export type ImageInputToBase64FunctionReturn = {
    imageBase64?: string;
    imageBase64Full?: string;
    imageName?: string;
    imageType?: string;
};

export type ImageInputToBase64FunctioParam = {
    imageInput?: HTMLInputElement;
    maxWidth?: number;
    mimeType?: string;
    file?: File;
};

export default async function imageInputToBase64({
    imageInput,
    maxWidth,
    mimeType,
    file,
}: ImageInputToBase64FunctioParam): Promise<ImageInputToBase64FunctionReturn> {
    try {
        const finalFile = file || imageInput?.files?.[0];

        if (!finalFile) {
            throw new Error("No Files found");
        }

        let imageName = finalFile.name.replace(/\..*/, "");

        let imageDataBase64: string | undefined;

        const MIME_TYPE = mimeType ? mimeType : finalFile.type;
        const QUALITY = 0.95;
        const MAX_WIDTH = maxWidth ? maxWidth : null;

        const blobURL = URL.createObjectURL(finalFile);
        const img = new Image();

        img.src = blobURL;

        imageDataBase64 = await new Promise((res, rej) => {
            img.onerror = function () {
                URL.revokeObjectURL(this.src);
                window.alert("Cannot load image!");
            };

            img.onload = function () {
                URL.revokeObjectURL(img.src);

                const canvas = document.createElement("canvas");

                if (MAX_WIDTH) {
                    const scaleSize = MAX_WIDTH / img.naturalWidth;

                    canvas.width =
                        img.naturalWidth < MAX_WIDTH
                            ? img.naturalWidth
                            : MAX_WIDTH;
                    canvas.height =
                        img.naturalWidth < MAX_WIDTH
                            ? img.naturalHeight
                            : img.naturalHeight * scaleSize;
                } else {
                    canvas.width = img.naturalWidth;
                    canvas.height = img.naturalHeight;
                }

                const ctx = canvas.getContext("2d");
                ctx?.drawImage(img, 0, 0, canvas.width, canvas.height);

                const srcEncoded = canvas.toDataURL(MIME_TYPE, QUALITY);

                res(srcEncoded);
            };
        });

        return {
            imageBase64: imageDataBase64?.replace(/.*?base64,/, ""),
            imageBase64Full: imageDataBase64,
            imageName: imageName,
            imageType: MIME_TYPE,
        };
    } catch (error: any) {
        console.log("Image Processing Error! =>", error.message);

        return {
            imageBase64: undefined,
            imageBase64Full: undefined,
            imageName: undefined,
        };
    }
}