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

def autoencoder(DIRECTORY: str, MODEL_FILE: str, EMBEDDING_DIM: int, device: str):
  model = autoencoder_classes.Autoencoder(embedding_dim = EMBEDDING_DIM).to(device)
  model.load_state_dict(torch.load(MODEL_FILE))
  model.eval().to(device)
  dataset = autoencoder_classes.AutoencoderDataset(DIRECTORY, transform = autoencoder_classes.preprocess)
  return model, dataset

def simclr(DIRECTORY: str, MODEL_FILE: str, EMBEDDING_DIM: int, device: str):
  encoder = simclr_classes.SimpleCNNEncoder(embedding_dim = EMBEDDING_DIM).to(device)
  model = simclr_classes.SimCLR(encoder = encoder, embedding_dim = EMBEDDING_DIM).to(device)
  model.load_state_dict(torch.load(MODEL_FILE))
  model.eval().to(device)
  dataset = simclr_classes.SimCLRDataset(DIRECTORY, transform_train = simclr_classes.preprocess_train, transform_infer = simclr_classes.preprocess, mode = 'inference')
  return model, dataset

def byol(DIRECTORY: str, MODEL_FILE: str, EMBEDDING_DIM: int, device: str):
  encoder = byol_classes.SimpleCNNEncoder(embedding_dim = EMBEDDING_DIM).to(device)
  model = byol_classes.BYOL(base_encoder = encoder, embedding_dim = EMBEDDING_DIM).to(device)
  model.load_state_dict(torch.load(MODEL_FILE))
  model.eval().to(device)
  dataset = byol_classes.BYOLDataset(DIRECTORY, transform_train=byol_classes.preprocess_train, transform_infer = byol_classes.preprocess, mode = 'inference')
  return model, dataset

def main():
  DIRECTORY = '/img_align_celeba' # Where are your dataset images
  TRUNCATE_TARGET_TABLE = 'yes' # Would you like to truncate the target table?
  BATCH_SIZE = 500 # Adjust batch size to your available memory, inference is consuming quite a lot... I have 32GB on my PC
  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'

  try:
    # Connection parameters
    connection_params= {"user" : "yjaquier", "password" : "secure_password", "host" : "server01.domain.com", "port": 3316, "database" : "test"}
    # Connect to an existing database
    connection= mariadb.connect(**connection_params)

    # Open a cursor to perform database operations
    cursor = connection.cursor()

    cursor.execute("select version()")
    row=cursor.fetchone()

    if not row:
      raise KeyError("No data found")

    print(row[0])

  except mariadb.Error as error:
    print("Error fetching data from MariaDB", error)
    exit(1)

  # Truncating destination table if requested
  if (TRUNCATE_TARGET_TABLE.lower() == "yes"):
    try:
      print("Truncating MariaDB vector table...")
      cursor.execute("truncate table pictures")
      connection.commit() # A commit for a truncate ? Yes....
    except mariadb.Error as error:
      print("Error truncating MariaDB vector table", error)
      exit(1)

  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  print("Vector Embeddings computation will be on " + str(device))

  print(f"Loading model from {MODEL_FILE}...")

  match args.mode:
    case "autoencoder":
      model, dataset = autoencoder(DIRECTORY, MODEL_FILE, EMBEDDING_DIM, device)
    case "simclr":
      model, dataset = simclr(DIRECTORY, MODEL_FILE, EMBEDDING_DIM, device)
    case "byol":
      model, dataset = byol(DIRECTORY, MODEL_FILE, EMBEDDING_DIM, device)

  # dataloader = DataLoader(dataset, batch_size = BATCH_SIZE, shuffle = True)

  start_process = datetime.datetime.now()
  print(f"Process starts at {start_process}")

  # filenames = [f for f in os.listdir(DIRECTORY) if f.endswith(('.jpg', '.jpeg', '.png'))][:10000]
  nb_filenames = len(dataset)
  print(f"Found {nb_filenames} images in {DIRECTORY}...")

  print(f"Preprocessing, computing and saving in MariaDB embedding vectors of images by batch of {BATCH_SIZE} images...")
  # filenames = [f for f in os.listdir(DIRECTORY) if f.endswith('.jpg')][:1]
  # When doing [x:y] note that the item in y position 5 is NOT included
  # images = []
  # embeddings = []
  # filenames = []
  sql = "insert into pictures (name, embedding) values (%s, Vec_FromText(%s))"

  # To avoid memory over consumption I compute embeddings and insert them directly in MariaDB by batch
  i = 1
  with torch.no_grad():
    for images, filenames in DataLoader(dataset, batch_size = BATCH_SIZE, num_workers = CPU_COUNT):
      images = images.to(device)
      if args.mode == "autoencoder":
        _, embeddings = model(images)
      elif args.mode == "simclr":
        embeddings = model.encoder(images)
      elif args.mode == "byol":
        embeddings = model.online_encoder(images)
      embeddings = embeddings.cpu().numpy()
      for filename, embedding in zip(filenames, embeddings):
        data = (filename, embedding.tolist())
        cursor.execute(sql, data)
      connection.commit()
      print(f"Preprocessed, computed and inserted into MariaDB embedding vectors {i * BATCH_SIZE}/{nb_filenames}...")
      i += 1

  print("Committing changes and closing MariaDB connection...")
  if connection:
    connection.commit()
    cursor.close()
    connection.close()
    print("MariaDB connection is closed \n")

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

if __name__ == "__main__":
  main()
