#!/home/python/ai/bin/python -u
import torch
import datetime
import torch.nn as nn
from torch.utils.data import DataLoader
import torch.optim as optim
from tqdm import tqdm
import autoencoder_classes
import simclr_classes
import byol_classes
import argparse

def autoencoder(directory: str, batch_size: int, training_epochs: int, embedding_dim: int, device: str, cpu_count: int):
  """
  AutoEncoder model training
  """
  dataset = autoencoder_classes.AutoencoderDataset(directory, transform = autoencoder_classes.preprocess)
  dataloader = DataLoader(dataset, batch_size = batch_size, shuffle=True, num_workers = cpu_count)
  model = autoencoder_classes.Autoencoder(embedding_dim = embedding_dim).to(device)
  criterion = nn.MSELoss()
  optimizer = optim.Adam(model.parameters(), lr=0.001)

  for epoch in range(training_epochs):
    running_loss = 0.0
    for images, _ in tqdm(dataloader, desc = f"Epoch {epoch+1}/{training_epochs}"):
      images = images.to(device)
      optimizer.zero_grad()
      outputs, _ = model(images)
      loss = criterion(outputs, images)
      loss.backward()
      optimizer.step()
      running_loss += loss.item()
    print(f"Epoch [{epoch+1}/{training_epochs}], Loss: {running_loss/len(dataloader):.4f}")
  return model

def simclr(directory: str, batch_size: int, training_epochs: int, embedding_dim: int, device: str, cpu_count: int):
  """
  SimCLR model training
  """
  dataset = simclr_classes.SimCLRDataset(directory, simclr_classes.preprocess_train, simclr_classes.preprocess, mode = 'train')
  dataloader = DataLoader(dataset, batch_size = batch_size, shuffle = True, num_workers = cpu_count)
  encoder = simclr_classes.SimpleCNNEncoder(embedding_dim = embedding_dim)
  model = simclr_classes.SimCLR(encoder, embedding_dim = embedding_dim, projection_dim = 64)
  optimizer = torch.optim.Adam(model.parameters(), lr = 1e-3)

  for epoch in range(training_epochs):
    for xi, xj in tqdm(dataloader, desc = f"Epoch {epoch+1}/{training_epochs}"):
      xi, xj = xi.to(device), xj.to(device)
      zi = model(xi)
      zj = model(xj)
      loss = simclr_classes.nt_xent_loss(zi, zj)
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()
    print(f"Epoch [{epoch+1}/{training_epochs}], Loss: {loss.item():.4f}")
  return model

def byol(directory: str, batch_size: int, training_epochs: int, embedding_dim: int, device: str, cpu_count: int, projection_dim = 64, hidden_dim = 256):
  """
  BYOL (Bootstrap Your Own Latent) model training
  """
  dataset = byol_classes.BYOLDataset(directory, byol_classes.preprocess_train, byol_classes.preprocess, mode = 'train')
  dataloader = DataLoader(dataset, batch_size = batch_size, shuffle = True, num_workers = cpu_count)

  encoder = byol_classes.SimpleCNNEncoder(embedding_dim = embedding_dim)
  model = byol_classes.BYOL(encoder, embedding_dim = embedding_dim, projection_dim = projection_dim, hidden_dim = hidden_dim).to(device)
  optimizer = torch.optim.Adam(model.parameters(), lr = 1e-3)

  for epoch in range(training_epochs):
    model.train()
    running_loss = 0.0
    for xi, xj in tqdm(dataloader, desc = f"Epoch {epoch+1}/{training_epochs}"):
      xi, xj = xi.to(device), xj.to(device)
      o1, t2, o2, t1 = model(xi, xj)
      loss = byol_classes.byol_loss_func(o1, t2) + byol_classes.byol_loss_func(o2, t1)
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()
      model._update_target()
      running_loss += loss.item() * xi.size(0)
    epoch_loss = running_loss / len(dataloader.dataset)
    print(f"Epoch [{epoch+1}/{training_epochs}], Loss: {epoch_loss:.4f}")
  return model
  
def main():
  DIRECTORY = '/img_align_celeba' # Where are your dataset images
  BATCH_SIZE = 32 # Adjust batch size to your available memory
  TRAINING_EPOCHS = 10 # Number of training epochs
  EMBEDDING_DIM = 1000 # Embedding dimension
  CPU_COUNT = 12 # Number of CPU cores, if you have a GPU you might tune differently

  # Create the parser
  parser = argparse.ArgumentParser(description="A simple example of using argparse.")

  # Add arguments
  valid_modes = {"autoencoder", "simclr", "byol"}
  parser.add_argument('-m', '--mode', type = str, help='Which method ({valid_modes}) ?', required=True)

  # Parse the arguments
  args = parser.parse_args()

  # Use the arguments
  if args.mode not in valid_modes:
    print(f"Invalid mode '{args.mode}'. Valid modes: {', '.join(sorted(valid_modes))}")
    exit(1)
  
  MODEL_FILE = args.mode + '.pt'

  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  print("Model training will be on " + str(device))

  start_process = datetime.datetime.now()
  print(f"Training {args.mode} model starts at {start_process}...")

  match args.mode:
    case "autoencoder":
      model = autoencoder(DIRECTORY, BATCH_SIZE, TRAINING_EPOCHS, EMBEDDING_DIM, device, CPU_COUNT)
    case "simclr":
      model = simclr(DIRECTORY, BATCH_SIZE, TRAINING_EPOCHS, EMBEDDING_DIM, device, CPU_COUNT)
    case "byol":
      model = byol(DIRECTORY, BATCH_SIZE, TRAINING_EPOCHS, EMBEDDING_DIM, device, CPU_COUNT)

  torch.save(model.state_dict(), MODEL_FILE)
  print(f"Model training completed and saved as {MODEL_FILE}")

  end_process = datetime.datetime.now()
  print(f"Model training ends at {end_process}")
  print(f"Model training duration: {end_process - start_process}")

if __name__ == "__main__":
  main()