import httpClient from "../../../utils/http-client";
import Sortable from "sortablejs";

interface MultiImageConfig {
  // 初期画像データ配列
  initialImages?: Array<{ image: string; image_url: string; alt?: string }>;
  // 最大画像数（デフォルト: 5）
  maxImages?: number;
  // 配列名（name属性のプリフィックス）
  arrayName?: string;
  // カラム名（一意のIDとして使用）
  column?: string;
  // アップロード処理後のコールバック（オプション）
  onUploadComplete?: (
    images: Array<{ image: string; imageUrl: string; alt: string }>
  ) => void;
  // 削除処理後のコールバック（オプション）
  onImageRemove?: (images: Array<{ image: string; imageUrl: string; alt: string }>) => void;
  // 許可する拡張子（オプション、指定しない場合はすべての画像拡張子を許可）
  allowedExtensions?: string[];
  // 最大ファイルサイズ（バイト単位、オプション）
  maxFileSize?: number;
  // トリミング時のアスペクト比（0の場合は自由クロップ）
  cropAspectRatio?: number;
}

interface MultiImageUploaderData {
  images: Array<{ image: string; imageUrl: string; alt: string }>;
  isUploading: boolean;
  maxImages: number;
  canAddMore: boolean;
  showModal: boolean;
  modalImageUrl: string;
  sortableInstance: Sortable | null;
  arrayName: string;
  column: string;
  cropAspectRatio: number;
  handleFileChange(event: Event): void;
  handleFileDrop(event: DragEvent): void;
  uploadImage(file: File): Promise<void>;
  removeImage(index: number): void;
  validateFile(file: File): boolean;
  getFileExtension(filename: string): string;
  deleteOldTempFile(filepath: string): Promise<void>;
  updateCanAddMore(): void;
  initSortable(): void;
  destroySortable(): void;
  openModal(imageUrl: string): void;
  closeModal(): void;
  openCropper(index: number): void;
}

// システム全体で許可される画像拡張子（すべてのリスト）
const SYSTEM_ALLOWED_IMAGE_EXTENSIONS = [
  "jpg",
  "jpeg",
  "png",
  "gif",
  "svg",
  "webp",
];
// システム全体での最大ファイルサイズ上限 (10MB)
const SYSTEM_MAX_FILE_SIZE = 10 * 1024 * 1024;

/**
 * 複数画像アップローダーコンポーネント
 * @param config 設定オブジェクト
 */
export function multiImageUploader(
  config: MultiImageConfig = {}
): MultiImageUploaderData {
  // 設定値を展開し、デフォルト値を設定
  const {
    initialImages = [],
    maxImages = 5,
    arrayName = "images",
    column = "image",
    onUploadComplete,
    onImageRemove,
    allowedExtensions = SYSTEM_ALLOWED_IMAGE_EXTENSIONS,
    maxFileSize = SYSTEM_MAX_FILE_SIZE,
    cropAspectRatio = 0,
  } = config;

  // 許可拡張子をシステム上限でフィルタリング
  const validAllowedExtensions = allowedExtensions.filter((ext) =>
    SYSTEM_ALLOWED_IMAGE_EXTENSIONS.includes(ext.toLowerCase())
  );

  // 空の場合はシステムデフォルトを使用
  const effectiveAllowedExtensions =
    validAllowedExtensions.length > 0
      ? validAllowedExtensions
      : SYSTEM_ALLOWED_IMAGE_EXTENSIONS;

  // ファイルサイズをシステム上限内に制限
  const effectiveMaxFileSize = Math.min(maxFileSize, SYSTEM_MAX_FILE_SIZE);

  // 初期画像データの処理
  const processedInitialImages = initialImages.map((item) => {
    const isTemporaryImage = item.image.startsWith("temp_");
    const imageUrl = isTemporaryImage
      ? `/user_admin/access-temp-attachment/${item.image}`
      : item.image_url;

    return {
      image: item.image,
      imageUrl: imageUrl,
      alt: item.alt || '',
    };
  });

  return {
    images: processedInitialImages,
    isUploading: false,
    maxImages: maxImages,
    canAddMore: processedInitialImages.length < maxImages,
    showModal: false,
    modalImageUrl: "",
    sortableInstance: null,
    arrayName: arrayName,
    column: column,
    cropAspectRatio: cropAspectRatio,

    /**
     * ファイル選択時の処理
     */
    handleFileChange(event: Event): void {
      const input = event.target as HTMLInputElement;
      const files = input.files;

      if (files && files.length > 0) {
        this.uploadImage(files[0]);
      }

      // ファイル選択をリセット（同じファイルを再選択できるように）
      input.value = "";
    },

    /**
     * ドラッグ＆ドロップ時の処理（ファイルアップロード用）
     */
    handleFileDrop(event: DragEvent): void {
      event.preventDefault();
      const files = event.dataTransfer?.files;

      if (files && files.length > 0) {
        this.uploadImage(files[0]);
      }
    },

    /**
     * 画像アップロード処理
     */
    async uploadImage(file: File): Promise<void> {
      // 最大数チェック
      if (this.images.length >= this.maxImages) {
        alert(`画像は最大${this.maxImages}枚まで登録できます`);
        return;
      }

      // バリデーションチェック
      if (!this.validateFile(file)) {
        return;
      }

      // アップロード開始
      this.isUploading = true;

      try {
        // FormDataの作成
        const formData = new FormData();
        formData.append("image", file);

        // CSRFトークンを取得（LaravelのCSRF保護のため）
        const csrfToken =
          document
            .querySelector('meta[name="csrf-token"]')
            ?.getAttribute("content") || "";

        // アップロードリクエスト（httpClientを使用）
        const response = await httpClient.post(
          "/user_admin/upload-temp-image",
          formData,
          {
            headers: {
              "X-CSRF-TOKEN": csrfToken,
              "Content-Type": "multipart/form-data",
            },
          }
        );

        // レスポンスの検証
        if (!response.data || !response.data.filename) {
          throw new Error("サーバーからの応答が不正です");
        }

        // 新しい画像を配列に追加
        const newImage = {
          image: response.data.filename,
          imageUrl: `/user_admin/access-temp-attachment/${response.data.filename}`,
          alt: '',
        };
        this.images.push(newImage);

        // 追加可能フラグを更新
        this.updateCanAddMore();

        // SortableJSを再初期化
        setTimeout(() => {
          this.initSortable();
        }, 100);

        // コールバック関数があれば実行
        if (typeof onUploadComplete === "function") {
          onUploadComplete(this.images);
        }
      } catch (error) {
        let errorMessage = "画像のアップロードに失敗しました";

        console.error(errorMessage, error);
        alert(errorMessage);
      } finally {
        this.isUploading = false;
      }
    },

    /**
     * 画像の削除
     */
    removeImage(index: number): void {
      const removedImage = this.images[index];

      // 配列から削除
      this.images.splice(index, 1);

      // 一時ファイルを削除
      if (removedImage && removedImage.image.startsWith("temp_")) {
        this.deleteOldTempFile(removedImage.image).catch((error) => {
          console.error("一時ファイルの削除に失敗しました:", error);
        });
      }

      // 追加可能フラグを更新
      this.updateCanAddMore();

      // SortableJSを再初期化
      setTimeout(() => {
        this.initSortable();
      }, 100);

      // コールバック関数があれば実行
      if (typeof onImageRemove === "function") {
        onImageRemove(this.images);
      }
    },

    /**
     * ファイルバリデーション
     */
    validateFile(file: File): boolean {
      // ファイル拡張子のチェック
      const fileExtension = this.getFileExtension(file.name).toLowerCase();

      if (!effectiveAllowedExtensions.includes(fileExtension)) {
        alert(
          `対応していないファイル形式です。対応形式: ${effectiveAllowedExtensions.join(
            ", "
          )}`
        );
        return false;
      }

      // ファイルサイズのチェック
      if (file.size > effectiveMaxFileSize) {
        alert(
          `アップロード可能なファイルサイズの上限を超えています（最大${formatFileSize(
            effectiveMaxFileSize
          )}）`
        );
        return false;
      }

      return true;
    },

    /**
     * ファイル拡張子の取得
     */
    getFileExtension(filename: string): string {
      return filename.split(".").pop() || "";
    },

    /**
     * 古い一時ファイルの削除
     */
    async deleteOldTempFile(filepath: string): Promise<void> {
      try {
        const csrfToken =
          document
            .querySelector('meta[name="csrf-token"]')
            ?.getAttribute("content") || "";

        // httpClientを使用して削除リクエスト
        await httpClient.post(
          `/user_admin/delete-temp-attachment/${filepath}`,
          {},
          {
            headers: {
              "X-CSRF-TOKEN": csrfToken,
            },
          }
        );
      } catch (error) {
        console.error("一時ファイル削除エラー:", error);
      }
    },

    /**
     * 追加可能フラグの更新
     */
    updateCanAddMore(): void {
      this.canAddMore = this.images.length < this.maxImages;
    },

    /**
     * SortableJSの初期化
     */
    initSortable(): void {
      // 既存のインスタンスがあれば破棄
      this.destroySortable();

      // DOM更新後に初期化するため少し遅延
      setTimeout(() => {
        const gridElement = document.querySelector(
          `#sortable-grid-${arrayName}`
        ) as HTMLElement;
        if (gridElement && this.images.length > 1) {
          this.sortableInstance = Sortable.create(gridElement, {
            animation: 150,
            ghostClass: "sortable-ghost",
            chosenClass: "sortable-chosen",
            dragClass: "sortable-drag",
            handle: ".sortable-handle",
            filter: ".delete-button-overlay", // 削除ボタンをドラッグ対象から除外
            preventOnFilter: false, // フィルターされた要素でのイベントを許可
            forceFallback: false, // Alpineとの競合を避けるため
            swapThreshold: 0.65, // スワップの閾値を調整
            invertSwap: false, // スワップの反転を無効
            onStart: (evt) => {
              // ドラッグ開始時にAlpineのリアクティブを一時停止
              evt.item.style.pointerEvents = "none";
            },
            onEnd: (evt) => {
              // ドラッグ終了時にポインターイベントを復元
              if (evt.item) {
                evt.item.style.pointerEvents = "";
              }

              if (
                evt.oldIndex !== undefined &&
                evt.newIndex !== undefined &&
                evt.oldIndex !== evt.newIndex
              ) {
                // 配列の順序を更新
                const movedItem = this.images.splice(evt.oldIndex, 1)[0];
                this.images.splice(evt.newIndex, 0, movedItem);

                // Alpine.jsに変更を通知
                setTimeout(() => {
                  // 配列を新しい参照で更新してリアクティブシステムをトリガー
                  this.images = [...this.images];
                }, 10);
              }
            },
          });
        }
      }, 50);
    },

    /**
     * SortableJSの破棄
     */
    destroySortable(): void {
      if (this.sortableInstance) {
        this.sortableInstance.destroy();
        this.sortableInstance = null;
      }
    },

    /**
     * モーダルを開く
     */
    openModal(imageUrl: string): void {
      this.modalImageUrl = imageUrl;
      this.showModal = true;
      document.body.style.overflow = "hidden";
    },

    /**
     * モーダルを閉じる
     */
    closeModal(): void {
      this.showModal = false;
      this.modalImageUrl = "";
      document.body.style.overflow = "";
    },

    /**
     * トリミングモーダルを開く
     */
    openCropper(index: number): void {
      const imageData = this.images[index];
      if (!imageData || !imageData.imageUrl) {
        return;
      }

      const cropperEl = document.querySelector('[x-data="imageCropper"]') as HTMLElement;
      if (!cropperEl) {
        return;
      }

      const alpineInstance = (window as any).Alpine;
      if (!alpineInstance) {
        return;
      }

      const cropperData = alpineInstance.$data(cropperEl);
      if (!cropperData) {
        return;
      }

      const self = this;
      cropperData.openCropper(
        imageData.imageUrl,
        this.cropAspectRatio,
        (result: { image: string; imageUrl: string }) => {
          // 過去の一時ファイルがあれば削除
          if (imageData.image && imageData.image.startsWith("temp_")) {
            self.deleteOldTempFile(imageData.image).catch(() => {});
          }
          self.images[index] = {
            ...self.images[index],
            image: result.image,
            imageUrl: result.imageUrl,
          };
          // Alpine.jsに変更を通知
          self.images = [...self.images];
        }
      );
    },
  };
}

/**
 * ファイルサイズのフォーマット
 */
function formatFileSize(bytes: number): string {
  if (bytes === 0) return "0 B";

  const sizes = ["B", "KB", "MB", "GB"];
  const i = Math.floor(Math.log(bytes) / Math.log(1024));

  return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + " " + sizes[i];
}

// Alpine.js データオブジェクトとして登録
document.addEventListener("alpine:init", () => {
  (window as any).Alpine.data(
    "multiImageUploader",
    (config: MultiImageConfig = {}) => {
      return multiImageUploader(config);
    }
  );
});
