'use client';

import { useState, useEffect } from 'react';
import { deleteItemFile, ItemFileType } from '@/lib/api/items';
import { downloadFileById } from '@/lib/utils/fileDownload';
import { BendingDetail } from '@/types/item';
import { ItemType } from '@/types/item';
import { toast } from 'sonner';

/**
 * 파일 정보 타입 (API 응답)
 */
interface FileInfo {
  id: number;
  file_id?: number;
  file_name: string;
  file_path: string;
}

/**
 * files 객체 타입 (initialData에서 추출)
 */
interface FilesObject {
  bending_diagram?: FileInfo[];
  specification_file?: FileInfo[];
  certification_file?: FileInfo[];
}

/**
 * useFileHandling 훅 입력 파라미터
 */
export interface UseFileHandlingParams {
  /** 폼 모드 (create/edit) */
  mode: 'create' | 'edit';
  /** 초기 데이터 (edit 모드에서 사용) */
  initialData?: Record<string, unknown>;
  /** 품목 ID (edit 모드에서 파일 삭제 시 필요) */
  propItemId?: number;
  /** 현재 선택된 품목 유형 */
  selectedItemType: ItemType | '';
}

/**
 * useFileHandling 훅 반환 타입
 */
export interface FileHandlingResult {
  // 기존 파일 상태 (edit 모드)
  existingBendingDiagram: string;
  existingBendingDiagramFileId: number | null;
  existingSpecificationFile: string;
  existingSpecificationFileName: string;
  existingSpecificationFileId: number | null;
  existingCertificationFile: string;
  existingCertificationFileName: string;
  existingCertificationFileId: number | null;

  // 삭제 중 상태
  isDeletingFile: string | null;

  // 상태 설정 함수 (전개도 삭제 후 상태 초기화용)
  setExistingBendingDiagram: (value: string) => void;
  setExistingBendingDiagramFileId: (value: number | null) => void;

  // 핸들러 함수
  handleFileDownload: (fileId: number | null, fileName?: string) => Promise<void>;
  handleDeleteFile: (
    fileType: ItemFileType,
    callbacks?: {
      onBendingDiagramDeleted?: () => void;
    }
  ) => Promise<void>;

  // 절곡 상세 정보 (edit 모드에서 로드)
  loadedBendingDetails: BendingDetail[];
  loadedWidthSum: string;
}

/**
 * 파일 처리 커스텀 훅
 *
 * edit 모드에서 기존 파일 정보를 로드하고,
 * 파일 다운로드/삭제 기능을 제공합니다.
 *
 * @param params - 훅 입력 파라미터
 * @returns 파일 처리 관련 상태 및 핸들러
 */
export function useFileHandling({
  mode,
  initialData,
  propItemId,
  selectedItemType,
}: UseFileHandlingParams): FileHandlingResult {
  // 기존 파일 URL 상태 (edit 모드에서 사용)
  const [existingBendingDiagram, setExistingBendingDiagram] = useState<string>('');
  const [existingBendingDiagramFileId, setExistingBendingDiagramFileId] = useState<number | null>(null);
  const [existingSpecificationFile, setExistingSpecificationFile] = useState<string>('');
  const [existingSpecificationFileName, setExistingSpecificationFileName] = useState<string>('');
  const [existingSpecificationFileId, setExistingSpecificationFileId] = useState<number | null>(null);
  const [existingCertificationFile, setExistingCertificationFile] = useState<string>('');
  const [existingCertificationFileName, setExistingCertificationFileName] = useState<string>('');
  const [existingCertificationFileId, setExistingCertificationFileId] = useState<number | null>(null);
  const [isDeletingFile, setIsDeletingFile] = useState<string | null>(null);

  // 절곡 상세 정보 (edit 모드에서 로드)
  const [loadedBendingDetails, setLoadedBendingDetails] = useState<BendingDetail[]>([]);
  const [loadedWidthSum, setLoadedWidthSum] = useState<string>('');

  // initialData에서 기존 파일 정보 및 전개도 상세 데이터 로드 (edit 모드)
  useEffect(() => {
    if (mode === 'edit' && initialData) {
      // files 객체에서 파일 정보 추출 (단수: specification_file, certification_file)
      // 2025-12-15: files가 JSON 문자열로 올 수 있으므로 파싱 처리
      let filesRaw = initialData.files;

      // JSON 문자열인 경우 파싱
      if (typeof filesRaw === 'string') {
        try {
          filesRaw = JSON.parse(filesRaw);
        } catch (e) {
          console.error('[useFileHandling] files JSON 파싱 실패:', e);
          filesRaw = undefined;
        }
      }

      const files = filesRaw as FilesObject | undefined;

      // 2025-12-15: 파일 로드 디버깅

      // 전개도 파일 (배열의 마지막 파일 = 최신 파일을 가져옴)
      const bendingFileArr = files?.bending_diagram;
      const bendingFile = bendingFileArr && bendingFileArr.length > 0
        ? bendingFileArr[bendingFileArr.length - 1]
        : undefined;
      if (bendingFile) {
        setExistingBendingDiagram(bendingFile.file_path);
        // API에서 id 또는 file_id로 올 수 있음
        const bendingFileId = bendingFile.id || bendingFile.file_id;
        setExistingBendingDiagramFileId(bendingFileId as number);
      } else if (initialData.bending_diagram) {
        setExistingBendingDiagram(initialData.bending_diagram as string);
      }

      // 시방서 파일 (배열의 마지막 파일 = 최신 파일을 가져옴)
      const specFileArr = files?.specification_file;
      const specFile = specFileArr && specFileArr.length > 0
        ? specFileArr[specFileArr.length - 1]
        : undefined;
      if (specFile?.file_path) {
        setExistingSpecificationFile(specFile.file_path);
        setExistingSpecificationFileName(specFile.file_name || '시방서');
        // API에서 id 또는 file_id로 올 수 있음
        const specFileId = specFile.id || specFile.file_id;
        setExistingSpecificationFileId(specFileId as number || null);
      } else {
        // 파일이 없으면 상태 초기화 (이전 값 제거)
        setExistingSpecificationFile('');
        setExistingSpecificationFileName('');
        setExistingSpecificationFileId(null);
      }

      // 인정서 파일 (배열의 마지막 파일 = 최신 파일을 가져옴)
      const certFileArr = files?.certification_file;
      const certFile = certFileArr && certFileArr.length > 0
        ? certFileArr[certFileArr.length - 1]
        : undefined;
      if (certFile?.file_path) {
        setExistingCertificationFile(certFile.file_path);
        setExistingCertificationFileName(certFile.file_name || '인정서');
        // API에서 id 또는 file_id로 올 수 있음
        const certFileId = certFile.id || certFile.file_id;
        setExistingCertificationFileId(certFileId as number || null);
      } else {
        // 파일이 없으면 상태 초기화 (이전 값 제거)
        setExistingCertificationFile('');
        setExistingCertificationFileName('');
        setExistingCertificationFileId(null);
      }

      // 전개도 상세 데이터 로드 (bending_details)
      if (initialData.bending_details) {
        const details = Array.isArray(initialData.bending_details)
          ? initialData.bending_details
          : (typeof initialData.bending_details === 'string'
              ? JSON.parse(initialData.bending_details as string)
              : []);

        if (details.length > 0) {
          // BendingDetail 형식으로 변환
          // 2025-12-16: 명시적 Number() 변환 추가 - TypeScript 타입 캐스팅은 런타임 변환을 하지 않음
          // 백엔드에서 문자열로 올 수 있으므로 명시적 숫자 변환 필수
          const mappedDetails: BendingDetail[] = details.map((d: Record<string, unknown>, index: number) => ({
            id: (d.id as string) || `detail-${Date.now()}-${index}`,
            no: Number(d.no) || index + 1,
            input: Number(d.input) || 0,
            // elongation은 0이 유효한 값이므로 NaN 체크 필요
            elongation: !isNaN(Number(d.elongation)) ? Number(d.elongation) : -1,
            calculated: Number(d.calculated) || 0,
            sum: Number(d.sum) || 0,
            shaded: Boolean(d.shaded),
            aAngle: d.aAngle !== undefined ? Number(d.aAngle) : undefined,
          }));
          setLoadedBendingDetails(mappedDetails);

          // 폭 합계도 계산하여 설정
          const totalSum = mappedDetails.reduce((acc, detail) => {
            return acc + detail.input + detail.elongation;
          }, 0);
          setLoadedWidthSum(totalSum.toString());
        }
      }
    }
  }, [mode, initialData]);

  // 파일 다운로드 핸들러 (Blob 방식)
  const handleFileDownload = async (fileId: number | null, fileName?: string) => {
    if (!fileId) return;
    try {
      await downloadFileById(fileId, fileName);
    } catch (error) {
      console.error('[useFileHandling] 다운로드 실패:', error);
      toast.error('파일 다운로드에 실패했습니다.');
    }
  };

  // 파일 삭제 핸들러
  const handleDeleteFile = async (
    fileType: ItemFileType,
    callbacks?: {
      onBendingDiagramDeleted?: () => void;
    }
  ) => {

    if (!propItemId) {
      console.error('[useFileHandling] propItemId가 없습니다');
      return;
    }

    // 파일 ID 가져오기
    let fileId: number | null = null;
    if (fileType === 'bending_diagram') {
      fileId = existingBendingDiagramFileId;
    } else if (fileType === 'specification') {
      fileId = existingSpecificationFileId;
    } else if (fileType === 'certification') {
      fileId = existingCertificationFileId;
    }


    if (!fileId) {
      console.error('[useFileHandling] 파일 ID를 찾을 수 없습니다:', fileType);
      toast.error('파일 ID를 찾을 수 없습니다.');
      return;
    }

    const confirmMessage = fileType === 'bending_diagram' ? '전개도 이미지를' :
                          fileType === 'specification' ? '시방서 파일을' : '인정서 파일을';

    if (!confirm(`${confirmMessage} 삭제하시겠습니까?`)) return;

    try {
      setIsDeletingFile(fileType);
      await deleteItemFile(propItemId, fileId, selectedItemType || 'FG');

      // 상태 업데이트
      if (fileType === 'bending_diagram') {
        setExistingBendingDiagram('');
        setExistingBendingDiagramFileId(null);
        // 콜백 호출 (부모 컴포넌트에서 bendingDiagram 상태 초기화)
        callbacks?.onBendingDiagramDeleted?.();
      } else if (fileType === 'specification') {
        setExistingSpecificationFile('');
        setExistingSpecificationFileName('');
        setExistingSpecificationFileId(null);
      } else if (fileType === 'certification') {
        setExistingCertificationFile('');
        setExistingCertificationFileName('');
        setExistingCertificationFileId(null);
      }

      toast.success('파일이 삭제되었습니다.');
    } catch (error) {
      console.error('[useFileHandling] 파일 삭제 실패:', error);
      toast.error('파일 삭제에 실패했습니다.');
    } finally {
      setIsDeletingFile(null);
    }
  };

  return {
    existingBendingDiagram,
    existingBendingDiagramFileId,
    existingSpecificationFile,
    existingSpecificationFileName,
    existingSpecificationFileId,
    existingCertificationFile,
    existingCertificationFileName,
    existingCertificationFileId,
    isDeletingFile,
    setExistingBendingDiagram,
    setExistingBendingDiagramFileId,
    handleFileDownload,
    handleDeleteFile,
    loadedBendingDetails,
    loadedWidthSum,
  };
}