'use client';

import { useState, useEffect, useRef } from 'react';
import { toast } from 'sonner';
import { useItemMaster } from '@/contexts/ItemMasterContext';
import type { ItemPage } from '@/contexts/ItemMasterContext';
import { ApiError, getErrorMessage } from '@/lib/api/error-handler';
import { pageService } from '../services';

export interface UsePageManagementReturn {
  // 상태
  selectedPageId: number | null;
  setSelectedPageId: (id: number | null) => void;
  selectedPage: ItemPage | undefined;
  editingPageId: number | null;
  setEditingPageId: (id: number | null) => void;
  editingPageName: string;
  setEditingPageName: (name: string) => void;
  isPageDialogOpen: boolean;
  setIsPageDialogOpen: (open: boolean) => void;
  newPageName: string;
  setNewPageName: (name: string) => void;
  newPageItemType: 'FG' | 'PT' | 'SM' | 'RM' | 'CS';
  setNewPageItemType: (type: 'FG' | 'PT' | 'SM' | 'RM' | 'CS') => void;
  editingPathPageId: number | null;
  setEditingPathPageId: (id: number | null) => void;
  editingAbsolutePath: string;
  setEditingAbsolutePath: (path: string) => void;
  isLoading: boolean;

  // 핸들러
  handleAddPage: () => Promise<void>;
  handleDuplicatePage: (pageId: number) => Promise<void>;
  handleDeletePage: (pageId: number) => void;
  handleUpdatePageName: (pageId: number, newName: string) => Promise<void>;
  handleUpdateAbsolutePath: (pageId: number, newPath: string) => Promise<void>;
}

export function usePageManagement(): UsePageManagementReturn {
  const {
    itemPages,
    addItemPage,
    updateItemPage,
    deleteItemPage,
  } = useItemMaster();

  // 상태
  const [selectedPageId, setSelectedPageId] = useState<number | null>(itemPages[0]?.id || null);
  const [editingPageId, setEditingPageId] = useState<number | null>(null);
  const [editingPageName, setEditingPageName] = useState('');
  const [isPageDialogOpen, setIsPageDialogOpen] = useState(false);
  const [newPageName, setNewPageName] = useState('');
  const [newPageItemType, setNewPageItemType] = useState<'FG' | 'PT' | 'SM' | 'RM' | 'CS'>('FG');
  const [editingPathPageId, setEditingPathPageId] = useState<number | null>(null);
  const [editingAbsolutePath, setEditingAbsolutePath] = useState('');
  const [isLoading, setIsLoading] = useState(false);

  // 선택된 페이지
  const selectedPage = itemPages.find(p => p.id === selectedPageId);

  // 마이그레이션 완료 추적용 ref
  const migrationDoneRef = useRef<Set<number>>(new Set());

  // 기존 페이지들에 절대경로 자동 생성 (마이그레이션)
  useEffect(() => {
    // itemPages가 비어있으면 스킵
    if (itemPages.length === 0) return;

    const pagesToMigrate = itemPages.filter(
      page => !page.absolute_path && !migrationDoneRef.current.has(page.id)
    );

    // 마이그레이션할 페이지가 없으면 스킵
    if (pagesToMigrate.length === 0) return;

    // 마이그레이션 실행 (한 번에 처리)
    pagesToMigrate.forEach(page => {
      const absolutePath = pageService.generateAbsolutePath(page.item_type as 'FG' | 'PT' | 'SM' | 'RM' | 'CS', page.page_name);
      updateItemPage(page.id, { absolute_path: absolutePath });
      migrationDoneRef.current.add(page.id);
    });

   
  }, [itemPages.length]); // itemPages 길이가 변경될 때만 체크

  // 페이지 추가
  const handleAddPage = async () => {
    if (!newPageName.trim()) {
      toast.error('섹션명을 입력해주세요');
      return;
    }

    try {
      setIsLoading(true);
      const absolutePath = pageService.generateAbsolutePath(newPageItemType, newPageName);

      const newPage = await addItemPage({
        page_name: newPageName,
        item_type: newPageItemType,
        absolute_path: absolutePath,
        is_active: true,
        sections: [],
        order_no: 0,
      });

      // 새로 생성된 페이지를 선택
      setSelectedPageId(newPage.id);

      // 폼 초기화
      setNewPageName('');
      setNewPageItemType('FG');
      setIsPageDialogOpen(false);

      toast.success('페이지가 추가되었습니다');
    } catch (err) {
      if (err instanceof ApiError && err.errors) {
        const errorMessages = Object.entries(err.errors)
          .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
          .join('\n');
        toast.error(errorMessages);
      } else {
        const errorMessage = getErrorMessage(err);
        toast.error(errorMessage);
      }
      console.error('❌ Failed to create page:', err);
    } finally {
      setIsLoading(false);
    }
  };

  // 페이지 복제
  const handleDuplicatePage = async (pageId: number) => {
    const originalPage = itemPages.find(p => p.id === pageId);
    if (!originalPage) {
      toast.error('페이지를 찾을 수 없습니다');
      return;
    }

    try {
      setIsLoading(true);

      const duplicatedPageName = `${originalPage.page_name} (복제)`;
      const absolutePath = pageService.generateAbsolutePath(originalPage.item_type as 'FG' | 'PT' | 'SM' | 'RM' | 'CS', duplicatedPageName);

      const newPage = await addItemPage({
        page_name: duplicatedPageName,
        item_type: originalPage.item_type,
        sections: [], // 섹션은 별도 API로 복제해야 함
        is_active: true,
        absolute_path: absolutePath,
        order_no: 0,
      });

      setSelectedPageId(newPage.id);
      toast.success('페이지가 복제되었습니다');

      // TODO: 원본 페이지의 섹션들도 복제 필요 (별도 API 호출)
    } catch (err) {
      const errorMessage = getErrorMessage(err);
      toast.error(errorMessage);
      console.error('❌ Failed to duplicate page:', err);
    } finally {
      setIsLoading(false);
    }
  };

  // 페이지 삭제
  // 2025-12-01: 페이지 삭제 시 섹션들은 독립 섹션으로 이동 (필드 연결 유지)
  const handleDeletePage = (pageId: number) => {
    const pageToDelete = itemPages.find(p => p.id === pageId);
    const _sectionCount = pageToDelete?.sections.length || 0;
    const _fieldCount = pageToDelete?.sections.flatMap(s => s.fields || []).length || 0;

    deleteItemPage(pageId);

    // 삭제된 페이지가 선택된 페이지였다면 다른 페이지 선택
    if (selectedPageId === pageId) {
      const remainingPages = itemPages.filter(p => p.id !== pageId);
      setSelectedPageId(remainingPages[0]?.id || null);
    }

  };

  // 페이지명 수정
  const handleUpdatePageName = async (pageId: number, newName: string) => {
    if (!newName.trim()) {
      toast.error('페이지명을 입력해주세요');
      return;
    }

    try {
      setIsLoading(true);
      await updateItemPage(pageId, { page_name: newName });
      setEditingPageId(null);
      setEditingPageName('');
      toast.success('페이지명이 수정되었습니다');
    } catch (err) {
      const errorMessage = getErrorMessage(err);
      toast.error(errorMessage);
    } finally {
      setIsLoading(false);
    }
  };

  // 절대경로 수정
  const handleUpdateAbsolutePath = async (pageId: number, newPath: string) => {
    if (!newPath.trim()) {
      toast.error('절대경로를 입력해주세요');
      return;
    }

    try {
      setIsLoading(true);
      await updateItemPage(pageId, { absolute_path: newPath });
      setEditingPathPageId(null);
      setEditingAbsolutePath('');
      toast.success('절대경로가 수정되었습니다');
    } catch (err) {
      const errorMessage = getErrorMessage(err);
      toast.error(errorMessage);
    } finally {
      setIsLoading(false);
    }
  };

  return {
    // 상태
    selectedPageId,
    setSelectedPageId,
    selectedPage,
    editingPageId,
    setEditingPageId,
    editingPageName,
    setEditingPageName,
    isPageDialogOpen,
    setIsPageDialogOpen,
    newPageName,
    setNewPageName,
    newPageItemType,
    setNewPageItemType,
    editingPathPageId,
    setEditingPathPageId,
    editingAbsolutePath,
    setEditingAbsolutePath,
    isLoading,

    // 핸들러
    handleAddPage,
    handleDuplicatePage,
    handleDeletePage,
    handleUpdatePageName,
    handleUpdateAbsolutePath,
  };
}