from torchvision import transforms
import torch.nn as nn
from torch.utils.data import Dataset
from PIL import Image
import os

# Resize image to 178 x 178, standardizes each color channel (RGB) of your image and convert it to a Tensor
preprocess = transforms.Compose([
  # All images of my celebrity dataset are 178x218
  transforms.Resize(size = (178, 178)),
  transforms.ToTensor(),
  transforms.Normalize(mean = [0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225]),
])

class AutoencoderDataset(Dataset):
  """
  Class to read images from a folder without labels and apply to them a transformation (resize, normalize, ...).
  The parameters are:
  - image_folder: Directory with images.
  - transform: Optional transform to be applied on a sample.
  """
  def __init__(self, image_folder, transform = None):
    self.image_folder = image_folder
    self.transform = transform
    # self.images = [f for f in os.listdir(image_folder) if f.lower().endswith(('.jpg', '.jpeg', '.png'))][:10000]
    self.images = [f for f in os.listdir(image_folder) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]

  def __len__(self):
    return len(self.images)

  def __getitem__(self, idx):
    image_file = os.path.join(self.image_folder, self.images[idx])
    image = Image.open(image_file).convert('RGB')
    if self.transform:
      image = self.transform(image)
    return image, self.images[idx]  # Return filename for later use

class Autoencoder(nn.Module):
  """
  Simple convolutional autoencoder for image embeddings.
  The parameter is:
  - embedding_dim: Dimension of the output embedding.
  """
  def __init__(self, embedding_dim = 128):
    super(Autoencoder, self).__init__()
    # Encoder
    self.encoder = nn.Sequential(
      nn.Conv2d(in_channels = 3, out_channels = 32, kernel_size = 3, stride = 2, padding = 1), # torch.Size([1, 32, 89, 89])
      nn.ReLU(),
      nn.Conv2d(in_channels = 32, out_channels = 64, kernel_size = 3, stride = 2, padding = 1), # torch.Size([1, 64, 45, 45])
      nn.ReLU(),
      nn.Conv2d(in_channels = 64, out_channels = 128, kernel_size = 3, stride = 2, padding = 1), # torch.Size([1, 128, 23, 23])
      nn.ReLU(),
      nn.Conv2d(in_channels = 128, out_channels = 256, kernel_size = 3, stride = 2, padding = 1), # torch.Size([1, 256, 12, 12])
      nn.ReLU(),
      nn.Flatten(),
      nn.Linear(256 * 12 * 12, embedding_dim)
    )
    # Decoder
    self.decoder = nn.Sequential(
      nn.Linear(embedding_dim, 256 * 12 * 12),
      nn.Unflatten(1, (256, 12, 12)),
      nn.ConvTranspose2d(in_channels = 256, out_channels = 128, kernel_size = 3, stride = 2, padding = 1, output_padding = 0), # torch.Size([1, 128, 23, 23])
      nn.ReLU(),
      nn.ConvTranspose2d(in_channels = 128, out_channels = 64, kernel_size = 3, stride = 2, padding = 1, output_padding = 0), # torch.Size([1, 64, 45, 45])
      nn.ReLU(),
      nn.ConvTranspose2d(in_channels = 64, out_channels = 32, kernel_size = 3, stride = 2, padding = 1, output_padding = 0),  # torch.Size([1, 32, 89, 89])
      nn.ReLU(),
      nn.ConvTranspose2d(in_channels = 32, out_channels = 3, kernel_size = 3, stride = 2, padding = 1, output_padding = 1),  # torch.Size([1, 3, 178, 178])
      nn.Sigmoid()
    )

  def forward(self, x):
    embedding = self.encoder(x)
    reconstruction = self.decoder(embedding)
    return reconstruction, embedding
