"use client";

import { API_BASE_URL } from "@/lib/api/config";
import { useLanguageStore } from "@/store/languageStore";
import type { Area } from "react-easy-crop";

export const loadImageWithCORS = async (imageUrl: string): Promise<string> => {
  const tryWithProxy = async (): Promise<string> => {
    const proxyUrl = `${API_BASE_URL}/proxy-image/?url=${encodeURIComponent(imageUrl)}`;
    console.debug('Attempting to load image via proxy:', proxyUrl);

    const language = useLanguageStore.getState().language || 'en';

    const response = await fetch(proxyUrl, {
      method: 'GET',
      credentials: 'omit',
      headers: { 'x-lang': language, 'Accept-Language': language },
    });

    if (!response.ok) {
      throw new Error(`Proxy fetch failed: ${response.status}`);
    }

    const blob = await response.blob();
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onloadend = () => resolve(reader.result as string);
      reader.onerror = reject;
      reader.readAsDataURL(blob);
    });
  };

  const tryWithCrossOrigin = (): Promise<string> => {
    return new Promise((resolve, reject) => {
      const img = new Image();
      img.crossOrigin = 'anonymous';

      img.onload = () => {
        try {
          const canvas = document.createElement('canvas');
          canvas.width = img.naturalWidth;
          canvas.height = img.naturalHeight;
          const ctx = canvas.getContext('2d');

          if (!ctx) {
            reject(new Error('Failed to get canvas context'));
            return;
          }

          ctx.drawImage(img, 0, 0);
          const dataUrl = canvas.toDataURL('image/jpeg', 0.9);
          resolve(dataUrl);
        } catch (err) {
          reject(err);
        }
      };

      img.onerror = () => reject(new Error('Image load failed with crossOrigin'));
      img.src = imageUrl;
    });
  };

  try {
    return await tryWithProxy();
  } catch (err1) {
    console.warn('Proxy strategy failed, trying direct crossOrigin...', err1);
    try {
      return await tryWithCrossOrigin();
    } catch (err2) {
      console.error('All image loading strategies failed', err2);
      throw new Error('Unable to load image. Please try re-uploading the image.');
    }
  }
};

export const createCroppedImage = async (
  imageSrc: string,
  /* `react-easy-crop`'s own `Area`: the crop rectangle in source-image pixels,
     which is the unit `drawImage` below needs. The percentage variant the
     library also reports would silently produce a 0×0 canvas. */
  pixelCrop: Area,
  fileName: string
): Promise<File> => {
  const image = new Image();
  image.crossOrigin = "anonymous";

  return new Promise((resolve, reject) => {
    image.onload = () => {
      try {
        console.debug("createCroppedImage: image loaded", imageSrc);
        const canvas = document.createElement("canvas");
        const ctx = canvas.getContext("2d");

        if (!ctx) {
          console.error("createCroppedImage: 2D context unavailable", imageSrc);
          return reject(new Error("2D context unavailable"));
        }

        canvas.width = pixelCrop.width;
        canvas.height = pixelCrop.height;

        ctx.fillStyle = "white";
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        ctx.drawImage(
          image,
          pixelCrop.x,
          pixelCrop.y,
          pixelCrop.width,
          pixelCrop.height,
          0,
          0,
          pixelCrop.width,
          pixelCrop.height
        );

        canvas.toBlob((blob) => {
          if (blob) {
            const file = new File([blob], fileName, { type: "image/jpeg" });
            console.debug("createCroppedImage: blob created", fileName);
            resolve(file);
          } else {
            console.error("createCroppedImage: toBlob returned null", imageSrc);
            reject(new Error("toBlob returned null"));
          }
        }, "image/jpeg", 0.9);
      } catch (err) {
        console.error("createCroppedImage: unexpected error", err);
        reject(err);
      }
    };

    image.onerror = (err) => {
      console.error("createCroppedImage: failed to load image", imageSrc, err);
      reject(new Error("Failed to load image"));
    };

    image.src = imageSrc;
  });
};
