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

interface FileConfig {
    // ファイルパスを保持する値（初期値）
    initialFile?: string;
    // ファイル名を保持する値（初期値）
    initialFileName?: string;
    // ファイルサイズを保持する値（初期値、バイト単位）
    initialFileSize?: number;
    // ファイル拡張子を保持する値（初期値）
    initialFileExtension?: string;
    // アップロード処理後のコールバック（オプション）
    onUploadComplete?: (fileData: {
        file: string;
        fileName: string;
        fileSize: number;
        fileExtension: string;
    }) => void;
    // 削除処理後のコールバック（オプション）
    onFileClear?: () => void;
    // 許可する拡張子（オプション、指定しない場合はすべての許可された拡張子を許可）
    allowedExtensions?: string[];
    // 最大ファイルサイズ（バイト単位、オプション）
    maxFileSize?: number;
}

interface FileUploaderData {
    file: string;
    fileName: string;
    fileSize: number;
    fileExtension: string;
    fileUrl: string;
    isUploading: boolean;
    handleFileChange(event: Event): void;
    handleFileDrop(event: DragEvent): void;
    uploadFile(file: File): Promise<void>;
    clearFile(): void;
    validateFile(file: File): boolean;
    getFileExtension(filename: string): string;
    getFileName(filename: string): string;
    formatFileSize(bytes: number): string;
    deleteOldTempFile(filepath: string): Promise<void>;
}

// システム全体で許可されるファイル拡張子（すべてのリスト）
const SYSTEM_ALLOWED_FILE_EXTENSIONS = [
    "pdf",
    "doc",
    "docx",
    "xls",
    "xlsx",
    "ppt",
    "pptx",
    "txt",
    "csv",
    "zip",
];
// システム全体での最大ファイルサイズ上限 (10MB)
const SYSTEM_MAX_FILE_SIZE = 10 * 1024 * 1024;

/**
 * ファイルアップローダーコンポーネント
 * @param config 設定オブジェクト
 */
export function fileUploader(config: FileConfig = {}): FileUploaderData {
    // 設定値を展開し、デフォルト値を設定
    const {
        initialFile = "",
        initialFileName = "",
        initialFileSize = 0,
        initialFileExtension = "",
        onUploadComplete,
        onFileClear,
        allowedExtensions = SYSTEM_ALLOWED_FILE_EXTENSIONS,
        maxFileSize = SYSTEM_MAX_FILE_SIZE,
    } = config;

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

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

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

    // 一時的なファイルかチェックしてURLを構築
    const isTemporaryFile = initialFile.startsWith("temp_");
    const fileUrl = isTemporaryFile
        ? `/user_admin/access-temp-attachment/${initialFile}`
        : initialFile;

    return {
        file: initialFile,
        fileName: initialFileName,
        fileSize: initialFileSize,
        fileExtension: initialFileExtension,
        fileUrl: fileUrl,
        isUploading: false,

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

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

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

        /**
         * ドラッグ＆ドロップ時の処理
         */
        handleFileDrop(event: DragEvent): void {
            const files = event.dataTransfer?.files;

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

        /**
         * ファイルアップロード処理
         */
        async uploadFile(file: File): Promise<void> {
            // バリデーションチェック
            if (!this.validateFile(file)) {
                return;
            }

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

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

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

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

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

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

                // ファイル情報を更新
                this.file = response.data.filename;
                this.fileName = this.getFileName(file.name);
                this.fileExtension = this.getFileExtension(file.name);
                this.fileSize = file.size;
                this.fileUrl = `/user_admin/access-temp-attachment/${response.data.filename}`;

                // コールバック関数があれば実行
                if (typeof onUploadComplete === "function") {
                    onUploadComplete({
                        file: this.file,
                        fileName: this.fileName,
                        fileSize: this.fileSize,
                        fileExtension: this.fileExtension,
                    });
                }
            } catch (error) {
                let errorMessage = "ファイルのアップロードに失敗しました";

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

        /**
         * ファイルのクリア
         */
        clearFile(): void {
            const oldFile = this.file;

            // ファイル情報をクリア
            this.file = "";
            this.fileName = "";
            this.fileSize = 0;
            this.fileExtension = "";
            this.fileUrl = "";

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

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

        /**
         * ファイルバリデーション
         */
        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(
                    `アップロード可能なファイルサイズの上限を超えています（最大${this.formatFileSize(
                        effectiveMaxFileSize
                    )}）`
                );
                return false;
            }

            return true;
        },

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

        /**
         * ファイル名の取得（拡張子を除く）
         */
        getFileName(filename: string): string {
            const extension = this.getFileExtension(filename);
            return filename.replace(`.${extension}`, "");
        },

        /**
         * ファイルサイズのフォーマット
         */
        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]
            );
        },

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

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