"use server"

import { fileUploadSchema } from "@/schemas/artworks/imageSchema";
import "dotenv/config";
import { z } from "zod/v4";
import { createImageFromFile } from "./createImageFromFile";

export async function createImage(values: z.infer<typeof fileUploadSchema>) {
  const imageFile = values.file[0];
  return createImageFromFile(imageFile);
}

/*
export async function createImage(values: z.infer<typeof fileUploadSchema>) {
  const imageFile = values.file[0];

  if (!(imageFile instanceof File)) {
    console.log("No image or invalid type");
    return null;
  }

  const fileName = imageFile.name;
  const fileType = imageFile.type;
  const fileSize = imageFile.size;
  const lastModified = new Date(imageFile.lastModified);

  const fileKey = uuidv4();

  const arrayBuffer = await imageFile.arrayBuffer();
  const buffer = Buffer.from(arrayBuffer);

  const realFileType = fileType.split("/")[1];
  const originalKey = `original/${fileKey}.${realFileType}`;
  const modifiedKey = `modified/${fileKey}.webp`;
  const resizedKey = `resized/${fileKey}.webp`;
  const thumbnailKey = `thumbnail/${fileKey}.webp`;

  const sharpData = sharp(buffer);
  const metadata = await sharpData.metadata();
  
  //--- Original file
  await s3.send(
    new PutObjectCommand({
      Bucket: `${process.env.BUCKET_NAME}`,
      Key: originalKey,
      Body: buffer,
      ContentType: "image/" + metadata.format,
    })
  );
  //--- Modified file
  const modifiedBuffer = await sharp(buffer)
    .toFormat('webp')
    .toBuffer()
  const modifiedMetadata = await sharp(modifiedBuffer).metadata();
  await s3.send(
    new PutObjectCommand({
      Bucket: `${process.env.BUCKET_NAME}`,
      Key: modifiedKey,
      Body: modifiedBuffer,
      ContentType: "image/" + modifiedMetadata.format,
    })
  );
  //--- Resized file
  const { width, height } = modifiedMetadata;
  const targetSize = 400;
  let resizeOptions;
  if (width && height) {
    if (height < width) {
      resizeOptions = { height: targetSize };
    } else {
      resizeOptions = { width: targetSize };
    }
  } else {
    resizeOptions = { height: targetSize };
  }
  const resizedBuffer = await sharp(modifiedBuffer)
    .resize({ ...resizeOptions, withoutEnlargement: true })
    .toFormat('webp')
    .toBuffer();
  const resizedMetadata = await sharp(resizedBuffer).metadata();
  await s3.send(
    new PutObjectCommand({
      Bucket: `${process.env.BUCKET_NAME}`,
      Key: resizedKey,
      Body: resizedBuffer,
      ContentType: "image/" + resizedMetadata.format,
    })
  );
  //--- Thumbnail file
  const thumbnailTargetSize = 160;
  let thumbnailOptions;
  if (width && height) {
    if (height < width) {
      thumbnailOptions = { height: thumbnailTargetSize };
    } else {
      thumbnailOptions = { width: thumbnailTargetSize };
    }
  } else {
    thumbnailOptions = { height: thumbnailTargetSize };
  }
  const thumbnailBuffer = await sharp(modifiedBuffer)
    .resize({ ...thumbnailOptions, withoutEnlargement: true })
    .toFormat('webp')
    .toBuffer();
  const thumbnailMetadata = await sharp(thumbnailBuffer).metadata();
  await s3.send(
    new PutObjectCommand({
      Bucket: `${process.env.BUCKET_NAME}`,
      Key: thumbnailKey,
      Body: thumbnailBuffer,
      ContentType: "image/" + thumbnailMetadata.format,
    })
  );

  const fileRecord = await prisma.fileData.create({
    data: {
      name: fileName,
      fileKey,
      originalFile: fileName,
      uploadDate: lastModified,
      fileType: realFileType,
      fileSize: fileSize,
    },
  });

  const artworkSlug = fileName.toLowerCase().replace(/\s+/g, "-");
  const artworkRecord = await prisma.artwork.create({
    data: {
      name: fileName,
      slug: artworkSlug,
      creationDate: lastModified,
      fileId: fileRecord.id,
    },
  });

  await prisma.artworkMetadata.create({
    data: {
      artworkId: artworkRecord.id,
      format: metadata.format || "unknown",
      width: metadata.width || 0,
      height: metadata.height || 0,
      space: metadata.space || "unknown",
      channels: metadata.channels || 0,
      depth: metadata.depth || "unknown",
      density: metadata.density ?? undefined,
      bitsPerSample: metadata.bitsPerSample ?? undefined,
      isProgressive: metadata.isProgressive ?? undefined,
      isPalette: metadata.isPalette ?? undefined,
      hasProfile: metadata.hasProfile ?? undefined,
      hasAlpha: metadata.hasAlpha ?? undefined,
      autoOrientW: metadata.autoOrient?.width ?? undefined,
      autoOrientH: metadata.autoOrient?.height ?? undefined,
    },
  });

  await prisma.fileVariant.createMany({
    data: [
      {
        s3Key: originalKey,
        type: "original",
        height: metadata.height,
        width: metadata.width,
        fileExtension: metadata.format,
        mimeType: "image/" + metadata.format,
        sizeBytes: metadata.size,
        artworkId: artworkRecord.id
      },
      {
        s3Key: modifiedKey,
        type: "modified",
        height: modifiedMetadata.height,
        width: modifiedMetadata.width,
        fileExtension: modifiedMetadata.format,
        mimeType: "image/" + modifiedMetadata.format,
        sizeBytes: modifiedMetadata.size,
        artworkId: artworkRecord.id
      },
      {
        s3Key: resizedKey,
        type: "resized",
        height: resizedMetadata.height,
        width: resizedMetadata.width,
        fileExtension: resizedMetadata.format,
        mimeType: "image/" + resizedMetadata.format,
        sizeBytes: resizedMetadata.size,
        artworkId: artworkRecord.id
      },
      {
        s3Key: thumbnailKey,
        type: "thumbnail",
        height: thumbnailMetadata.height,
        width: thumbnailMetadata.width,
        fileExtension: thumbnailMetadata.format,
        mimeType: "image/" + thumbnailMetadata.format,
        sizeBytes: thumbnailMetadata.size,
        artworkId: artworkRecord.id
      }
    ],
  });

  return artworkRecord
}
  */