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

interface ImageConfig {
    // 画像を保持する値（初期値）
    initialImage?: string;
    // 画像URLを保持する値（初期値）
    initialImageUrl?: string;
    // アップロード処理後のコールバック（オプション）
    onUploadComplete?: (image: string) => void;
    // 削除処理後のコールバック（オプション）
    onImageClear?: () => void;
    // 許可する拡張子（オプション、指定しない場合はすべての画像拡張子を許可）
    allowedExtensions?: string[];
    // 最大ファイルサイズ（バイト単位、オプション）
    maxFileSize?: number;
    // トリミング時のアスペクト比（0の場合は自由クロップ）
    cropAspectRatio?: number;
}

interface ImageUploaderData {
    image: string;
    imageUrl: string;
    isUploading: boolean;
    cropAspectRatio: number;
    handleFileChange(event: Event): void;
    handleFileDrop(event: DragEvent): void;
    uploadImage(file: File): Promise<void>;
    clearImage(): void;
    validateFile(file: File): boolean;
    getFileExtension(filename: string): string;
    deleteOldTempFile(filepath: string): Promise<void>;
    openCropper(): 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 imageUploader(config: ImageConfig = {}): ImageUploaderData {
    // 設定値を展開し、デフォルト値を設定
    const {
        initialImage = "",
        initialImageUrl = "",
        onUploadComplete,
        onImageClear,
        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);

    // 一時的な画像ファイルであれは、画像URLを取得
    const isTemporaryImage = initialImage.startsWith("temp_");
    const imageUrl = isTemporaryImage
        ? `/user_admin/access-temp-attachment/${initialImage}`
        : initialImageUrl;

    return {
        image: initialImage,
        imageUrl: imageUrl,
        isUploading: false,
        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 {
            const files = event.dataTransfer?.files;

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

        /**
         * 画像アップロード処理
         */
        async uploadImage(file: File): Promise<void> {
            // バリデーションチェック
            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("サーバーからの応答が不正です");
                }

                // 過去の一時ファイルがあれば削除
                if (this.image && this.image.startsWith("temp_")) {
                    await this.deleteOldTempFile(this.image);
                }

                // 画像を更新
                this.image = response.data.filename;
                this.imageUrl = `/user_admin/access-temp-attachment/${response.data.filename}`;

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

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

        /**
         * 画像のクリア
         */
        clearImage(): void {
            const oldImage = this.image;

            // 画像をクリア
            this.image = "";

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

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

        /**
         * ファイルバリデーション
         */
        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() || "";
        },

        /**
         * トリミングモーダルを開く
         */
        openCropper(): void {
            if (!this.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(
                this.imageUrl,
                this.cropAspectRatio,
                (result: { image: string; imageUrl: string }) => {
                    // 過去の一時ファイルがあれば削除
                    if (self.image && self.image.startsWith("temp_")) {
                        self.deleteOldTempFile(self.image).catch(() => {});
                    }
                    self.image = result.image;
                    self.imageUrl = result.imageUrl;
                }
            );
        },

        /**
         * 古い一時ファイルの削除
         */
        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);
            }
        },
    };
}

/**
 * ファイルサイズのフォーマット
 */
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", () => {
    Alpine.data("imageUploader", (config: ImageConfig = {}) => {
        return imageUploader(config);
    });
});
