import { useState, useEffect, useMemo } from "react";
import { Card, CardContent, CardHeader, CardTitle } from "./ui/card";
import { Button } from "./ui/button";
import { Input } from "./ui/input";
import { Label } from "./ui/label";
import { Textarea } from "./ui/textarea";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./ui/select";
import { Separator } from "./ui/separator";
import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogFooter, DialogTrigger } from "./ui/dialog";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "./ui/table";
import { Badge } from "./ui/badge";
import { 
  Save,
  X,
  FileEdit,
  Calculator,
  Package,
  History,
  AlertCircle,
  RefreshCw,
  Plus,
  Search
} from "lucide-react";
import { PageLayout } from "./organisms/PageLayout";
import { PageHeader } from "./organisms/PageHeader";
import { FormActions } from "./organisms/FormActions";
import { useData } from "./contexts/DataContext";
import { AutoCalculationSimulator } from "./AutoCalculationSimulator";
import { AutoCalculationWithTabs } from "./AutoCalculationWithTabs";
import { QuoteDebugPanel, type DebugInfo } from "./QuoteDebugPanel";
import { toast } from "sonner@2.0.3";
import { ValidationHelpers, ValidationRule, validateForm } from "../utils/validation";
import { generateCompleteSampleQuoteData } from "../utils/sampleQuoteData_Complete";
import { addProductBoms } from "../utils/addProductBoms";

// 계산식 행 인터페이스
interface CalculationRow {
  id: string;
  distributionType: string;
  width: string;
  thickness: string;
  result: string;
  imageUrl: string;
  quantity: number;
  notes: string;
}

// 부품구성표(BOM) 계산 행
interface BOMCalculationRow {
  id: string;
  itemCode: string;
  itemName: string;
  baseQuantity: number;
  calculatedQuantity: number;
  unit: string;
  unitPrice: number;
  totalPrice: number;
  formula?: string;
  formulaSource?: string; // 수식 출처 (BOM템플릿, 제품BOM 등)
  formulaCategory?: string; // 수식 카테고리
  dataSource?: string; // 데이터 출처 (품목마스터, 단가관리 등)
  note?: string;
  deliveryDate?: string; // 품목별 납기일
}

// 견적 수정 이력
export interface QuoteRevision {
  revisionNumber: number;
  revisionDate: string;
  revisionBy: string;
  revisionReason?: string;
  previousData: any;
}

// 견적 데이터 인터페이스
export interface QuoteData {
  id: string;
  registrationDate: string;
  quoteNumber: string;
  type: string;
  productCode: string;
  quantity: number;
  amount: number;
  client: string;
  manager: string;
  contact: string;
  remarks: string;
  responseMethod: string;
  commitment: string;
  notes: string;
  
  // 수정 이력 관리
  currentRevision?: number;
  isFinal?: boolean;
  revisions?: QuoteRevision[];
  finalizedDate?: string;
  finalizedBy?: string;
  status?: 'draft' | 'sent' | 'approved' | 'rejected' | 'converted' | 'finalized';
  
  // 기존 필드 유지
  receiptDate: string;
  author: string;
  site: string;
  siteId?: string; // 현장 ID
  siteCode?: string; // 현장 코드
  memo: string;
  clientContact: string;
  contactPhone: string;
  completionDate: string;
  modelSelection: string;
  floors: string;
  code: string;
  powderType: string;
  installType: string;
  installLocation: string;
  openSizeWidth: string;
  openSizeHeight: string;
  selectedProducts: string[];
  calculationRows: CalculationRow[];
  createdAt: string;
  
  // 부품구성표(BOM) 관련 추가
  productCategory?: 'SCREEN' | 'STEEL';
  selectedProductId?: string;
  bomCalculations?: BOMCalculationRow[];
  
  // 자동 산출 설정 (수정 시 복원용)
  autoCalculationSettings?: {
    productId?: string;
    productName?: string;
    productCategory?: string;
    openSizeWidth?: number;
    openSizeHeight?: number;
    guideRailInstallType?: string;
    motorPower?: string;
    controller?: string;
    quantity?: number;
    edgeWingSize?: number;
    inspectionFee?: number;
  };
}

export function QuoteManagement3Write({ 
  onSave, 
  onCancel, 
  editingQuote,
  initialData: propsInitialData,
  isEditMode: propsIsEditMode
}: { 
  onSave: (data: QuoteData, isRevision?: boolean, revisionReason?: string) => void;
  onCancel: () => void;
  editingQuote?: QuoteData | null;
  initialData?: any;
  isEditMode?: boolean;
}) {
  const { itemMasters, sites, clients, quotes, addClient, addSite, currentUser, generateLotNumber, generateSampleQuoteData, addItemMaster, addPricing } = useData();
  const bomTemplates = []; // Placeholder until bomTemplates is added to DataContext
  const initialData = propsInitialData || editingQuote || undefined;
  const isEditMode = propsIsEditMode || !!editingQuote;
  
  const [isRevisionDialogOpen, setIsRevisionDialogOpen] = useState(false);
  const [revisionReason, setRevisionReason] = useState("");
  
  // 히스토리 뷰어 상태
  const [selectedRevisionNumber, setSelectedRevisionNumber] = useState<number | null>(null);
  const [isViewingHistory, setIsViewingHistory] = useState(false);
  
  // 디버깅 모드 상태
  const [debugInfo, setDebugInfo] = useState<DebugInfo | null>(null);
  const [showDebugPanel, setShowDebugPanel] = useState(false);
  
  // 필드 에러 상태 (벨리데이션용)
  const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});

  // 현재 표시할 데이터 결정 (히스토리 뷰잉 중이면 히스토리 데이터, 아니면 현재 데이터)
  const getCurrentData = () => {
    if (isViewingHistory && selectedRevisionNumber !== null && initialData?.revisions) {
      const revision = initialData.revisions.find(r => r.revisionNumber === selectedRevisionNumber);
      if (revision && revision.previousData) {
        return revision.previousData;
      }
    }
    return initialData;
  };

  const currentData = getCurrentData();

  // 기본 정보
  const [receiptDate, setReceiptDate] = useState(currentData?.receiptDate || new Date().toISOString().split('T')[0]);
  const [author, setAuthor] = useState(currentData?.author || currentUser?.name || "");
  const [client, setClient] = useState(currentData?.client || "");
  const [site, setSite] = useState(currentData?.site || "");
  const [siteId, setSiteId] = useState(currentData?.siteId || "");
  const [siteCode, setSiteCode] = useState(currentData?.siteCode || "");
  const [memo, setMemo] = useState(currentData?.memo || "");
  const [clientContact, setClientContact] = useState(currentData?.clientContact || "");
  const [contactPhone, setContactPhone] = useState(currentData?.contactPhone || "");
  const [completionDate, setCompletionDate] = useState(currentData?.completionDate || "");
  
  // 직접 입력 모드
  const [isDirectInputClient, setIsDirectInputClient] = useState(false);
  const [directClientName, setDirectClientName] = useState("");
  const [directClientContact, setDirectClientContact] = useState(""); // 담당자
  const [directClientPhone, setDirectClientPhone] = useState(""); // 연락처
  const [isDirectInputSite, setIsDirectInputSite] = useState(false);
  const [directSiteName, setDirectSiteName] = useState("");
  const [directSiteCode, setDirectSiteCode] = useState("");
  
  // 새로운 필드
  const [registrationDate, setRegistrationDate] = useState(currentData?.registrationDate || new Date().toISOString().split('T')[0]);
  const [quoteNumber, setQuoteNumber] = useState(currentData?.quoteNumber || "");
  const [manager, setManager] = useState(currentData?.manager || "");
  const [contact, setContact] = useState(currentData?.contact || "");
  const [remarks, setRemarks] = useState(currentData?.remarks || "");
  const [responseMethod, setResponseMethod] = useState(currentData?.responseMethod || "");
  const [commitment, setCommitment] = useState(currentData?.commitment || "");
  const [notes, setNotes] = useState(currentData?.notes || "");

  // 제품 선택 및 BOM 계산
  const [productCategory, setProductCategory] = useState<'SCREEN' | 'STEEL'>(
    (currentData?.productCategory as 'SCREEN' | 'STEEL') || 'SCREEN'
  );
  const [selectedProductId, setSelectedProductId] = useState(currentData?.selectedProductId || "");
  const [openSizeWidth, setOpenSizeWidth] = useState(currentData?.openSizeWidth || "");
  const [openSizeHeight, setOpenSizeHeight] = useState(currentData?.openSizeHeight || "");
  const [quantity, setQuantity] = useState(currentData?.quantity || 1);
  
  // 부호 및 층수
  const [unitSymbol, setUnitSymbol] = useState(currentData?.code || ""); // 부호
  const [floors, setFloors] = useState(currentData?.floors || ""); // 층수
  
  // 부품구성표(BOM) 계산 결과
  const [bomCalculations, setBomCalculations] = useState<BOMCalculationRow[]>(currentData?.bomCalculations || []);
  const [totalAmount, setTotalAmount] = useState(currentData?.amount || 0);
  
  // EditableBOMResults를 위한 state
  const [editableBOMItems, setEditableBOMItems] = useState<any[]>(currentData?.bomCalculations || []);
  
  // 자동 산출 설정 (수정 시 복원용)
  const [autoCalculationSettings, setAutoCalculationSettings] = useState<any>(currentData?.autoCalculationSettings || null);
  
  // 품목 추가 다이얼로그 필터/검색 상태
  const [itemDialogCategoryFilter, setItemDialogCategoryFilter] = useState<string>("all");
  const [itemDialogSearchTerm, setItemDialogSearchTerm] = useState<string>("");
  
  // 초기 로딩 완료 플래그 (수정 모드에서 저장된 BOM을 유지하기 위함)
  const [isInitialLoadComplete, setIsInitialLoadComplete] = useState(false);
  
  // Validation Rules를 useMemo로 메모이제이션
  const validationRules = useMemo(() => {
    const rules: ValidationRule[] = [];
    
    // 발주처 validation 제거 - 임시 저장 가능하도록 함
    // 실제 발송/확정 시에만 필수로 검증하도록 변경
    
    // 자동 견적 산출 섹션은 선택 사항으로 변경
    // 오픈사이즈나 제품이 입력되어 있으면 필수로 검증
    // 아무것도 입력되지 않았으면 검증하지 않음 (BOM 없이 저장 가능)
    
    return rules;
  }, [isDirectInputClient]);

  // formData를 useMemo로 메모이제이션
  const formData = useMemo(() => ({
    directClientName,
    manager,
    contact,
    directSiteName,
    client,
    productCategory,
    selectedProductId,
    quantity,
    openSizeWidth,
    openSizeHeight,
    unitSymbol,
    floors
  }), [directClientName, manager, contact, directSiteName, client, productCategory, selectedProductId, quantity, openSizeWidth, openSizeHeight, unitSymbol, floors]);
  
  // editingQuote가 변경될 때 폼 데이터 업데이트
  useEffect(() => {
    if (editingQuote) {
      console.log("📝 견적 수정 모드 - 기존 데이터 로드:", editingQuote);
      setReceiptDate(editingQuote.receiptDate || "");
      setAuthor(editingQuote.author || "");
      setClient(editingQuote.client || "");
      setSite(editingQuote.site || "");
      setSiteId(editingQuote.siteId || "");
      setSiteCode(editingQuote.siteCode || "");
      setMemo(editingQuote.memo || "");
      setClientContact(editingQuote.clientContact || "");
      setContactPhone(editingQuote.contactPhone || "");
      setCompletionDate(editingQuote.completionDate || "");
      setRegistrationDate(editingQuote.registrationDate || new Date().toISOString().split('T')[0]);
      setQuoteNumber(editingQuote.quoteNumber || "");
      setManager(editingQuote.manager || "");
      setContact(editingQuote.contact || "");
      setRemarks(editingQuote.remarks || "");
      setResponseMethod(editingQuote.responseMethod || "");
      setCommitment(editingQuote.commitment || "");
      setNotes(editingQuote.notes || "");
      setProductCategory((editingQuote.productCategory as 'SCREEN' | 'STEEL') || 'SCREEN');
      setSelectedProductId(editingQuote.selectedProductId || "");
      setOpenSizeWidth(editingQuote.openSizeWidth || "");
      setOpenSizeHeight(editingQuote.openSizeHeight || "");
      setQuantity(editingQuote.quantity || 1);
      setUnitSymbol(editingQuote.code || '');
      setFloors(editingQuote.floors || '');
      
      // BOM 데이터 로드
      if (editingQuote.bomCalculations && editingQuote.bomCalculations.length > 0) {
        console.log(`✅ BOM 데이터 로드: ${editingQuote.bomCalculations.length}개 항목`);
        setBomCalculations(editingQuote.bomCalculations);
        setEditableBOMItems(editingQuote.bomCalculations);
      }
      
      // 자동 산출 설정 로드
      if (editingQuote.autoCalculationSettings) {
        console.log('✅ 자동 산출 설정 로드:', editingQuote.autoCalculationSettings);
        setAutoCalculationSettings(editingQuote.autoCalculationSettings);
      }
      
      setTotalAmount(editingQuote.amount || 0);
      setIsInitialLoadComplete(true);
      
      toast.success("기존 견적 데이터를 불러왔습니다.", {
        description: `견적번호: ${editingQuote.quoteNumber || '미정'}`
      });
    }
  }, [editingQuote]);
  
  // 품목별 납기일 업데이트 함수
  const updateDeliveryDate = (bomId: string, deliveryDate: string) => {
    if (isViewingHistory) return; // 히스토리 뷰잉 중에는 수정 불가
    setBomCalculations(prev => 
      prev.map(bom => 
        bom.id === bomId ? { ...bom, deliveryDate } : bom
      )
    );
  };

  // BOM 수식 업데이트 함수
  const updateFormula = (bomId: string, newFormula: string) => {
    if (isViewingHistory) return; // 히스토리 뷰잉 중에는 수정 불가
    
    const W = parseFloat(openSizeWidth);
    const H = parseFloat(openSizeHeight);
    
    if (isNaN(W) || isNaN(H)) {
      toast.error("오픈사이즈(폭, 높이)를 먼저 입력해주세요.");
      return;
    }

    setBomCalculations(prev => 
      prev.map(bom => {
        if (bom.id === bomId) {
          // 수식이 비어있으면 기본수량 사용
          if (!newFormula.trim()) {
            return { 
              ...bom, 
              formula: '',
              calculatedQuantity: bom.baseQuantity,
              totalPrice: bom.baseQuantity * bom.unitPrice
            };
          }

          // 새로운 수식으로 수량 재계산
          const newCalculatedQty = calculateQuantity(newFormula, bom.baseQuantity, W, H);
          const newTotalPrice = newCalculatedQty * bom.unitPrice;

          return { 
            ...bom, 
            formula: newFormula,
            calculatedQuantity: newCalculatedQty,
            totalPrice: newTotalPrice
          };
        }
        return bom;
      })
    );
  };

  // 수식 검증 함수
  const validateFormula = (formula: string): { isValid: boolean; error?: string } => {
    if (!formula.trim()) return { isValid: true };

    try {
      const W = 1000;
      const H = 2000;
      const testExpression = formula.replace(/W/g, W.toString()).replace(/H/g, H.toString());
      const result = Function(`"use strict"; return (${testExpression})`)();
      
      if (typeof result !== 'number' || isNaN(result)) {
        return { isValid: false, error: '수식 결과가 숫자가 아닙니다' };
      }
      
      return { isValid: true };
    } catch (error) {
      return { isValid: false, error: '수식 구문 오류' };
    }
  };

  // 자동 산출 완료 핸들러
  const handleCalculationComplete = (results: any) => {
    console.log("🎯 견적 작성 - 자동 산출 완료:", results);
    
    // 다중 견적 형식인지 확인 (AutoCalculationSimulator의 새 형식)
    let quoteData = results;
    if (results.quotes && Array.isArray(results.quotes) && results.quotes.length > 0) {
      console.log("📦 다중 견적 형식 감지, 첫 번째 견적 사용:", results.quotes[0]);
      quoteData = results.quotes[0];  // 첫 번째 견적만 사용
    }
    
    if (quoteData.bomItems && Array.isArray(quoteData.bomItems)) {
      console.log(`✅ ${quoteData.bomItems.length}개 BOM 항목 생성`);
      
      // EditableBOMResults와 bomCalculations 모두 업데이트
      setEditableBOMItems(quoteData.bomItems);
      setBomCalculations(quoteData.bomItems);
      
      console.log("📦 자동 산출 결과:", quoteData);
      
      // 오픈사이즈 자동 설정
      if (quoteData.openSize?.width) {
        setOpenSizeWidth(quoteData.openSize.width.toString());
        console.log("✅ 오픈사이즈 폭 설정:", quoteData.openSize.width);
      }
      if (quoteData.openSize?.height) {
        setOpenSizeHeight(quoteData.openSize.height.toString());
        console.log("✅ 오픈사이즈 높이 설정:", quoteData.openSize.height);
      }
      
      // 제품 정보 자동 설정
      if (quoteData.productCategory) {
        setProductCategory(quoteData.productCategory);
        console.log("✅ 제품 카테고리 설정:", quoteData.productCategory);
      }
      if (quoteData.selectedProductId) {
        setSelectedProductId(quoteData.selectedProductId);
        console.log("✅ 제품 ID 설정:", quoteData.selectedProductId);
      }
      
      // 추가 입력값 설정 (층수, 부호 등)
      if (quoteData.floors) {
        setFloors(quoteData.floors);
        console.log("✅ 층수 설정:", quoteData.floors);
      }
      if (quoteData.sign) {
        setUnitSymbol(quoteData.sign);
        console.log("✅ 부호 설정:", quoteData.sign);
      }
      
      // 수량 설정
      if (quoteData.quantity) {
        setQuantity(quoteData.quantity);
        console.log("✅ 수량 설정:", quoteData.quantity);
      }
      
      // 총 금액 계산
      if (quoteData.totalAmount || quoteData.bomItems) {
        const materialCost = quoteData.bomItems.reduce((sum: number, item: any) => sum + (item.totalPrice || 0), 0);
        const total = materialCost * (quoteData.quantity || 1);
        setTotalAmount(total);
        console.log("✅ 총 금액 설정:", total);
      }
      
      // 자동 산출 설정 저장 (수정 시 복원용)
      const settings = {
        productId: quoteData.selectedProductId,
        productName: quoteData.productName,
        productCategory: quoteData.productCategory,
        openSizeWidth: quoteData.openSize?.width,
        openSizeHeight: quoteData.openSize?.height,
        guideRailInstallType: quoteData.guideRailInstallType,
        motorPower: quoteData.motorPower,
        controller: quoteData.controller,
        quantity: quoteData.quantity,
        edgeWingSize: quoteData.edgeWingSize,
        inspectionFee: quoteData.inspectionFee,
        floors: quoteData.floors,
        sign: quoteData.sign,
      };
      setAutoCalculationSettings(settings);
      console.log("✅ 자동 산출 설정 저장:", settings);
      
      // 상태가 제대로 업데이트되었는지 확인 (비동기로 확인)
      setTimeout(() => {
        console.log("🔍 상태 업데이트 확인 (비동기):", {
          floors,
          unitSymbol,
          openSizeWidth,
          openSizeHeight,
          quantity,
          totalAmount
        });
      }, 100);
      
      toast.success(`자동 산출 완료: ${quoteData.bomItems.length}개 BOM 항목이 생성되었습니다.`, {
        description: `오픈사이즈: ${quoteData.openSize?.width || '?'} × ${quoteData.openSize?.height || '?'}`
      });
    }
  };

  // BOM 항목 변경 핸들러
  const handleBOMItemsChange = (items: any[]) => {
    console.log("📝 BOM 항목 변경:", items.length, "개");
    console.log("📊 변경된 BOM 데이터:", items);
    setEditableBOMItems(items);
    setBomCalculations(items);
    
    // 총 금액 재계산
    const materialCost = items.reduce((sum, item) => sum + (item.totalPrice || 0), 0);
    const laborCost = selectedProduct?.laborCost || 0;
    const installCost = selectedProduct?.installCost || 0;
    const subtotal = materialCost + laborCost + installCost;
    const total = subtotal * quantity;
    setTotalAmount(total);
    console.log("💰 총 금액 재계산:", total);
  };
  
  // 새로운 샘플 데이터 생성 핸들러
  const handleGenerateCompleteSampleData = () => {
    try {
      // 1. 샘플 데이터 생성
      const { items: newItems, itemCount } = generateCompleteSampleQuoteData();
      
      // 2. 완제품 BOM 구조 추가
      const itemsWithBoms = addProductBoms(newItems);
      
      // 3. 품목 데이터 추가
      itemsWithBoms.forEach(item => {
        addItemMaster(item);
      });
      
      // 4. 단가 데이터 생성 및 추가
      const today = new Date().toISOString().split('T')[0];
      itemsWithBoms.forEach((item) => {
        addPricing({
          id: `PRICE-${item.id}`,
          itemId: item.id,
          itemCode: item.itemCode,
          itemName: item.itemName,
          itemType: item.itemType,
          specification: item.specification || '',
          unit: item.unit,
          effectiveDate: today,
          purchasePrice: item.purchasePrice || 0,
          processingCost: 0,
          loss: 0,
          roundingRule: 'round',
          roundingUnit: 1,
          marginRate: item.itemType === 'FG' ? 30 : 20,
          salesPrice: item.salesPrice || 0,
          supplier: item.itemType === 'FG' ? '자사 제조' : '협력업체',
          note: `${item.itemName} 샘플 단가`,
          currentRevision: 0,
          isFinal: false,
          status: 'active',
          createdAt: today,
          createdBy: '시스템'
        });
      });
      
      toast.success(`완벽한 샘플 데이터가 생성되었습니다!`, {
        description: `완제품 ${itemCount.screenProduct + itemCount.steelProduct + itemCount.bendingProduct}종(스크린 ${itemCount.screenProduct}, 철재 ${itemCount.steelProduct}, 절곡 ${itemCount.bendingProduct}), 반제품 ${itemCount.screenSemi + itemCount.steelSemi}종, 부자재 ${itemCount.subMaterial}종, 원자재 ${itemCount.rawMaterial}종 총 ${itemCount.total}개 품목 + 단가 데이터 생성 완료 ✓`
      });
      
      console.log('✅ 완벽한 샘플 데이터 생성 완료:', itemCount);
    } catch (error) {
      console.error('❌ 샘플 데이터 생성 실패:', error);
      toast.error('샘플 데이터 생성에 실패했습니다.', {
        description: error instanceof Error ? error.message : '알 수 없는 오류'
      });
    }
  };

  // 임시저장 핸들러
  const handleTempSave = () => {
    const tempData = {
      bomItems: editableBOMItems,
      productCategory,
      selectedProductId,
      openSizeWidth,
      openSizeHeight,
      quantity,
      client,
      site,
      timestamp: new Date().toISOString()
    };
    
    localStorage.setItem('quote-write-bom-temp', JSON.stringify(tempData));
    toast.success("BOM 항목이 임시저장되었습니다.");
  };

  // 히스토리 선택 핸들러
  const handleRevisionSelect = (value: string) => {
    if (value === 'current') {
      setIsViewingHistory(false);
      setSelectedRevisionNumber(null);
      // 현재 버전으로 돌아가기
      resetToCurrentData();
    } else {
      const revisionNumber = parseInt(value);
      setSelectedRevisionNumber(revisionNumber);
      setIsViewingHistory(true);
      // 선택된 히스토리 데이터로 폼 업데이트
      loadRevisionData(revisionNumber);
    }
  };

  // 현재 데이터로 리셋
  const resetToCurrentData = () => {
    if (!initialData) return;
    setReceiptDate(initialData.receiptDate || "");
    setAuthor(initialData.author || "");
    setClient(initialData.client || "");
    setSite(initialData.site || "");
    setSiteId(initialData.siteId || "");
    setSiteCode(initialData.siteCode || "");
    setMemo(initialData.memo || "");
    setClientContact(initialData.clientContact || "");
    setContactPhone(initialData.contactPhone || "");
    setCompletionDate(initialData.completionDate || "");
    setRegistrationDate(initialData.registrationDate || new Date().toISOString().split('T')[0]);
    setQuoteNumber(initialData.quoteNumber || "");
    setManager(initialData.manager || "");
    setContact(initialData.contact || "");
    setRemarks(initialData.remarks || "");
    setResponseMethod(initialData.responseMethod || "");
    setCommitment(initialData.commitment || "");
    setNotes(initialData.notes || "");
    setProductCategory((initialData.productCategory as 'SCREEN' | 'STEEL') || 'SCREEN');
    setSelectedProductId(initialData.selectedProductId || "");
    setOpenSizeWidth(initialData.openSizeWidth || "");
    setOpenSizeHeight(initialData.openSizeHeight || "");
    setQuantity(initialData.quantity || 1);
    setUnitSymbol(initialData.code || '');
    setFloors(initialData.floors || '');
    setBomCalculations(initialData.bomCalculations || []);
    setTotalAmount(initialData.amount || 0);
    // 현재 데이터로 리셋 시에도 초기 로딩 완료 표시
    setIsInitialLoadComplete(true);
  };

  // 히스토리 데이터 로드
  const loadRevisionData = (revisionNumber: number) => {
    if (!initialData?.revisions) return;
    const revision = initialData.revisions.find(r => r.revisionNumber === revisionNumber);
    if (!revision || !revision.previousData) return;

    const data = revision.previousData;
    setReceiptDate(data.receiptDate || "");
    setAuthor(data.author || "");
    setClient(data.client || "");
    setSite(data.site || "");
    setSiteId(data.siteId || "");
    setSiteCode(data.siteCode || "");
    setMemo(data.memo || "");
    setClientContact(data.clientContact || "");
    setContactPhone(data.contactPhone || "");
    setCompletionDate(data.completionDate || "");
    setRegistrationDate(data.registrationDate || "");
    setQuoteNumber(data.quoteNumber || "");
    setManager(data.manager || "");
    setContact(data.contact || "");
    setRemarks(data.remarks || "");
    setResponseMethod(data.responseMethod || "");
    setCommitment(data.commitment || "");
    setNotes(data.notes || "");
    setProductCategory((data.productCategory as 'SCREEN' | 'STEEL') || 'SCREEN');
    setSelectedProductId(data.selectedProductId || "");
    setOpenSizeWidth(data.openSizeWidth || "");
    setOpenSizeHeight(data.openSizeHeight || "");
    setQuantity(data.quantity || 1);
    setUnitSymbol(data.code || '');
    setFloors(data.floors || '');
    setBomCalculations(data.bomCalculations || []);
    setTotalAmount(data.amount || 0);
    // 히스토리 데이터 로드 시에도 초기 로딩 완료 표시
    setIsInitialLoadComplete(true);
  };

  // 제품 카테고리별 필터링된 제품 목록
  const filteredProducts = itemMasters.filter(item => {
    // 완제품(FG)이고 선택된 제품 카테고리와 일치하는 항목만 필터링
    const isFinishedGood = item.itemType === 'FG';
    const matchesCategory = item.productCategory === productCategory;
    
    return isFinishedGood && matchesCategory;
  });

  // 선택된 제품 정보
  const selectedProduct = itemMasters.find(item => item.id === selectedProductId);

  // 수량 계산 함수 (수식 파싱)
  const calculateQuantity = (formula: string | undefined, baseQty: number, W: number, H: number): number => {
    if (!formula) return baseQty;
    
    try {
      // W와 H를 실제 값으로 치환
      const expression = formula.replace(/W/g, W.toString()).replace(/H/g, H.toString());
      // 간단한 수식 계산 (eval 대신 안전한 방법)
      const result = Function(`"use strict"; return (${expression})`)();
      // 소수점 셋째 자리에서 반올림
      return Math.round(result * 100) / 100;
    } catch (error) {
      console.error('수식 계산 오류:', formula, error);
      return baseQty;
    }
  };

  // 디버그 정보 생성 함수
  const generateDebugInfo = (
    product: any,
    calculations: BOMCalculationRow[],
    W: number,
    H: number,
    materialCost: number,
    laborCost: number,
    installCost: number,
    subtotal: number,
    total: number
  ) => {
    const warnings: string[] = [];
    const errors: string[] = [];

    // 제품 판매단가 체크
    if (!product.salesPrice || product.salesPrice === 0) {
      warnings.push(`제품 "${product.itemName}"의 판매단가가 설정되지 않았습니다.`);
    }

    // BOM 항목 디버그 정보 생성
    const bomDebugItems = calculations.map(calc => {
      const item = itemMasters.find(im => im.itemCode === calc.itemCode);
      const itemWarnings: string[] = [];
      
      // 단가 체크
      let unitPriceSource: 'salesPrice' | 'purchasePrice' | 'default' = 'default';
      if (calc.unitPrice === 0) {
        itemWarnings.push('단가 미설정');
      } else if (item?.salesPrice === calc.unitPrice) {
        unitPriceSource = 'salesPrice';
      } else if (item?.purchasePrice === calc.unitPrice) {
        unitPriceSource = 'purchasePrice';
      }

      // 수식 평가
      let formulaEvaluation = '';
      if (calc.formula) {
        const expression = calc.formula.replace(/W/g, W.toString()).replace(/H/g, H.toString());
        formulaEvaluation = `${calc.formula} = ${expression} = ${calc.calculatedQuantity.toFixed(2)}`;
      }

      return {
        itemCode: calc.itemCode,
        itemName: calc.itemName,
        itemType: item?.itemType || 'Unknown',
        baseQuantity: calc.baseQuantity,
        calculatedQuantity: calc.calculatedQuantity,
        formula: calc.formula,
        formulaEvaluation,
        formulaSource: calc.formulaSource,
        formulaCategory: calc.formulaCategory,
        unit: calc.unit,
        unitPrice: calc.unitPrice,
        unitPriceSource,
        dataSource: calc.dataSource,
        totalPrice: calc.totalPrice,
        warnings: itemWarnings
      };
    });

    // 전체 경고 생성
    const zeroPriceItems = bomDebugItems.filter(item => item.unitPrice === 0);
    if (zeroPriceItems.length > 0) {
      warnings.push(`${zeroPriceItems.length}개 품목의 단가가 설정되지 않아 견적이 0원으로 계산됩니다.`);
    }

    const debugData: DebugInfo = {
      timestamp: new Date().toISOString(),
      productInfo: {
        id: product.id,
        code: product.itemCode,
        name: product.itemName,
        category: product.productCategory,
        salesPrice: product.salesPrice || 0,
        laborCost: product.laborCost || 0,
        installCost: product.installCost || 0,
      },
      openSize: {
        width: W,
        height: H,
      },
      bomItems: bomDebugItems,
      calculations: {
        materialCost,
        laborCost,
        installCost,
        subtotal,
        quantity,
        total,
      },
      warnings,
      errors,
    };

    setDebugInfo(debugData);
    
    // 경고가 있으면 디버그 패널 자동 표시
    if (warnings.length > 0 || errors.length > 0) {
      setShowDebugPanel(true);
    }
  };

  // 신규 작성 시 현재 로그인한 사용자 이름을 작성자로 자동 설정
  useEffect(() => {
    if (!editingQuote && currentUser) {
      setAuthor(currentUser.name);
    }
  }, [editingQuote, currentUser]);

  // editingQuote가 변경될 때 모든 state 초기화
  useEffect(() => {
    if (editingQuote) {
      // 기본 정보
      setReceiptDate(editingQuote.receiptDate || "");
      setAuthor(editingQuote.author || "");
      setClient(editingQuote.client || "");
      setSite(editingQuote.site || "");
      setSiteId(editingQuote.siteId || "");
      setSiteCode(editingQuote.siteCode || "");
      setMemo(editingQuote.memo || "");
      setClientContact(editingQuote.clientContact || "");
      setContactPhone(editingQuote.contactPhone || "");
      setCompletionDate(editingQuote.completionDate || "");
      
      // 새로운 필드
      setRegistrationDate(editingQuote.registrationDate || new Date().toISOString().split('T')[0]);
      setQuoteNumber(editingQuote.quoteNumber || "");
      setManager(editingQuote.manager || "");
      setContact(editingQuote.contact || "");
      setRemarks(editingQuote.remarks || "");
      setResponseMethod(editingQuote.responseMethod || "");
      setCommitment(editingQuote.commitment || "");
      setNotes(editingQuote.notes || "");

      // 제품 선택 및 BOM 계산
      const category = (editingQuote.productCategory as 'SCREEN' | 'STEEL') || 'SCREEN';
      setProductCategory(category);
      setSelectedProductId(editingQuote.selectedProductId || "");
      setOpenSizeWidth(editingQuote.openSizeWidth || "");
      setOpenSizeHeight(editingQuote.openSizeHeight || "");
      setQuantity(editingQuote.quantity || 1);
      
      // 부호 및 층수
      setUnitSymbol(editingQuote.code || "");
      setFloors(editingQuote.floors || "");
      
      // 부품구성표(BOM) 계산 결과
      setBomCalculations(editingQuote.bomCalculations || []);
      setEditableBOMItems(editingQuote.bomCalculations || []);
      setTotalAmount(editingQuote.amount || 0);
      
      // 초기 로딩 완료 표시 (약간의 지연을 두어 모든 state가 설정된 후 실행)
      setTimeout(() => {
        setIsInitialLoadComplete(true);
      }, 50);
    } else {
      // 신규 작성 모드
      setIsInitialLoadComplete(false);
    }
  }, [editingQuote]); // editingQuote 전체를 감시

  // 부품구성표(BOM) 기반 자동 계산
  useEffect(() => {
    // 수정 모드에서 초기 데이터 로딩 중에는 BOM 재계산 하지 않음
    if (editingQuote && bomCalculations.length > 0 && !isInitialLoadComplete) {
      return;
    }

    if (!selectedProduct || !openSizeWidth || !openSizeHeight) {
      // 신규 작성 모드이거나 사용자가 값을 지웠을 때만 초기화
      if (!editingQuote) {
        setBomCalculations([]);
        setTotalAmount(0);
      }
      return;
    }

    const W = parseFloat(openSizeWidth);
    const H = parseFloat(openSizeHeight);

    if (isNaN(W) || isNaN(H) || W <= 0 || H <= 0) {
      // 신규 작성 모드이거나 사용자가 값을 지웠을 때만 초기화
      if (!editingQuote) {
        setBomCalculations([]);
        setTotalAmount(0);
      }
      return;
    }

    // BOM 템플릿 우선 사용 (템플릿이 있으면 템플릿 사용, 없으면 제품의 BOM 사용)
    const matchingTemplate = bomTemplates?.find(template => 
      template.productType === productCategory && 
      template.status === 'active' &&
      (template.productModel === selectedProduct.itemName || 
       template.productModel === selectedProduct.itemCode ||
       !template.productModel)
    );

    let calculations: BOMCalculationRow[] = [];

    if (matchingTemplate && matchingTemplate.bomRules.length > 0) {
      // BOM 템플릿이 있는 경우 - 템플릿 사용
      console.log('🎯 BOM 템플릿 사용:', matchingTemplate.templateName);
      
      calculations = matchingTemplate.bomRules.map((rule, index) => {
        const existingCalc = bomCalculations.find(b => b.itemName === rule.partName);
        const formulaToUse = existingCalc?.formula !== undefined ? existingCalc.formula : rule.quantityFormula;
        
        // 수식 계산
        const calcQty = calculateQuantity(formulaToUse, 1, W, H);
        
        // 반올림 규칙 적용
        let finalQty = calcQty;
        if (rule.roundingRule === 'ceil') {
          finalQty = Math.ceil(calcQty);
        } else if (rule.roundingRule === 'floor') {
          finalQty = Math.floor(calcQty);
        } else if (rule.roundingRule === 'round') {
          finalQty = Math.round(calcQty);
        }
        
        // 최소/최대값 적용
        if (rule.minValue !== undefined && finalQty < rule.minValue) {
          finalQty = rule.minValue;
        }
        if (rule.maxValue !== undefined && finalQty > rule.maxValue) {
          finalQty = rule.maxValue;
        }
        
        // 부품 단가 조회
        const partItem = itemMasters.find(item => 
          item.itemName === rule.partName || 
          item.itemCode === rule.partCode
        );
        const unitPrice = partItem?.salesPrice || 0;
        const totalPrice = finalQty * unitPrice;

        return {
          id: `bom-calc-${rule.partCode || rule.partName}-${index}`,
          itemCode: rule.partCode || rule.partName,
          itemName: rule.partName,
          baseQuantity: 1,
          calculatedQuantity: finalQty,
          unit: rule.unit,
          unitPrice: unitPrice,
          totalPrice: totalPrice,
          formula: formulaToUse,
          formulaSource: `BOM템플릿: ${matchingTemplate.templateName}`,
          formulaCategory: rule.category || '미분류',
          dataSource: partItem ? `품목마스터 [${partItem.itemCode}]` : '품목 미등록',
          note: rule.description || '',
          deliveryDate: existingCalc?.deliveryDate || completionDate || ''
        };
      });
    } else if (selectedProduct.bom && selectedProduct.bom.length > 0) {
      // BOM 템플릿이 없는 경우 - 제품의 BOM 사용
      console.log('📋 제품 BOM 사용');
      
      calculations = selectedProduct.bom.map((bomLine, index) => {
        // 기존 계산 결과가 있으면 수정된 수식 유지, 없으면 BOM의 수식 사용
        const existingCalc = bomCalculations.find(b => b.itemCode === bomLine.childItemCode);
        const formulaToUse = existingCalc?.formula !== undefined ? existingCalc.formula : bomLine.quantityFormula;
        
        const calcQty = calculateQuantity(formulaToUse, bomLine.quantity, W, H);
        
        // 품목마스터에서 단가 조회
        const childItem = itemMasters.find(item => item.itemCode === bomLine.childItemCode);
        const unitPrice = childItem?.salesPrice || 0;
        const totalPrice = calcQty * unitPrice;

        return {
          id: `bom-calc-${bomLine.childItemCode}-${index}`,
          itemCode: bomLine.childItemCode,
          itemName: bomLine.childItemName,
          baseQuantity: bomLine.quantity,
          calculatedQuantity: calcQty,
          unit: bomLine.unit,
          unitPrice: unitPrice,
          totalPrice: totalPrice,
          formula: formulaToUse,
          formulaSource: `제품BOM: ${selectedProduct.itemName}`,
          formulaCategory: '제품구성',
          dataSource: childItem ? `품목마스터 [${childItem.itemCode}]` : '품목 미등록',
          note: bomLine.note,
          deliveryDate: existingCalc?.deliveryDate || completionDate || ''
        };
      });
    } else {
      // BOM 템플릿도 없고 제품 BOM도 없는 경우
      const basePrice = (selectedProduct.laborCost || 0) + (selectedProduct.installCost || 0);
      setTotalAmount(basePrice * quantity);
      setBomCalculations([]);
      return;
    }

    setBomCalculations(calculations);

    // 총 금액 계산
    const materialCost = calculations.reduce((sum, calc) => sum + calc.totalPrice, 0);
    const laborCost = selectedProduct.laborCost || 0;
    const installCost = selectedProduct.installCost || 0;
    const subtotal = materialCost + laborCost + installCost;
    const total = subtotal * quantity;

    setTotalAmount(total);
    
    // 디버그 정보 생성
    generateDebugInfo(selectedProduct, calculations, W, H, materialCost, laborCost, installCost, subtotal, total);
  }, [selectedProduct, openSizeWidth, openSizeHeight, quantity, isInitialLoadComplete]);

  // bomCalculations 변경 시 총 금액 재계산 및 디버그 정보 업데이트
  useEffect(() => {
    if (!selectedProduct || bomCalculations.length === 0) return;

    const materialCost = bomCalculations.reduce((sum, calc) => sum + calc.totalPrice, 0);
    const laborCost = selectedProduct.laborCost || 0;
    const installCost = selectedProduct.installCost || 0;
    const subtotal = materialCost + laborCost + installCost;
    const total = subtotal * quantity;

    setTotalAmount(total);
    
    // 디버그 정보 업데이트
    const W = parseFloat(openSizeWidth);
    const H = parseFloat(openSizeHeight);
    if (!isNaN(W) && !isNaN(H) && W > 0 && H > 0) {
      generateDebugInfo(selectedProduct, bomCalculations, W, H, materialCost, laborCost, installCost, subtotal, total);
    }
  }, [bomCalculations]);

  // 제품 카테고리 변경 시 선택 초기화 (신규 작성 모드에서만)
  useEffect(() => {
    // 초기 로딩 중이 아니고, 신규 작성이거나 초기 로딩이 완료된 경우에만 초기화
    if (isInitialLoadComplete && !editingQuote) {
      setSelectedProductId("");
      setBomCalculations([]);
      setTotalAmount(0);
    }
  }, [productCategory]);

  // 견적번호 자동 생성 함수 (LOT번호 규칙 사용)
  const generateQuoteNumber = (category: 'SCREEN' | 'STEEL') => {
    return generateLotNumber('quote');
  };

  // 제품 카테고리 변경 시 또는 신규 작성 시 견적번호 자동 생성
  useEffect(() => {
    // 신규 견적인 경우 또는 견적번호가 비어있거나 구 형식인 경우
    if (!editingQuote) {
      // 신규 작성 모드
      setQuoteNumber(generateQuoteNumber(productCategory));
    } else if (quoteNumber && (quoteNumber.includes('TEMP') || quoteNumber.includes('KQ#'))) {
      // 구 형식 견적번호는 새 형식으로 변환
      setQuoteNumber(generateQuoteNumber(productCategory));
    }
  }, [productCategory]);

  // 저장 버튼 클릭
  const handleSaveClick = () => {
    console.log("🔍 저장 벨리데이션 시작");
    console.log("📊 현재 상태:", {
      client,
      isDirectInputClient,
      directClientName,
      selectedProductId,
      openSizeWidth,
      openSizeHeight,
      editableBOMItems: editableBOMItems.length,
      bomCalculations: bomCalculations.length,
      formData
    });

    // 편집 모드 여부 확인
    const isEditMode = !!editingQuote;

    // validateForm을 사용하여 모든 필드 검증
    const validationResult = validateForm(formData, validationRules);
    
    console.log("🔍 벨리데이션 결과:", validationResult);
    console.log("🔍 벨리데이션 에러 상세:", validationResult.errors);
    console.log("🔍 필드별 에러:", validationResult.fieldErrors);
    
    if (!validationResult.isValid) {
      // 필드 에러 설정
      if (validationResult.fieldErrors) {
        setFieldErrors(validationResult.fieldErrors);
      }
      
      // 첫 번째 에러 메시지 표시
      if (validationResult.firstError) {
        console.error("❌ 검증 실패:", validationResult.firstError);
        toast.error(validationResult.firstError, {
          description: "필수 항목을 모두 입력해주세요."
        });
      }
      
      // 개발 모드에서만 검증 실패 로그 출력
      if (process.env.NODE_ENV === 'development') {
        console.log("검증 실패:", validationResult.errors);
      }
      return;
    }
    
    // 벨리데이션 통과 시 fieldErrors 초기화
    setFieldErrors({});

    // BOM 항목 검증
    // 편집 모드에서는 BOM이 없어도 저장 가능 (기존 데이터 유지)
    if (editableBOMItems.length === 0 && bomCalculations.length === 0) {
      if (!isEditMode && !editingQuote) {
        // 신규 작성 시에도 BOM 없이 저장 가능하도록 경고로만 표시
        toast.warning("BOM 항목이 없습니다.", {
          description: "자동 산출을 진행하지 않은 상태로 저장됩니다. 필요시 AutoCalculationSimulator에서 '자동 산출 시작'을 클릭하세요."
        });
        console.log("✅ 견적 저장: BOM 항목 없이 저장 (신규 작성 모드) - 정상 동작");
      } else {
        // 편집 모드에서는 경고만 표시
        console.log("✅ 견적 저장: BOM 항목이 없지만 편집 모드이므로 저장 진행 - 정상 동작");
      }
    }

    console.log("✅ 벨리데이션 통과");

    // 기존 견적을 수정하는 경우, 수정 사유 입력 다이얼로그 표시
    if (isEditMode) {
      setIsRevisionDialogOpen(true);
    } else {
      // 신규 등록
      handleSave(false);
    }
  };

  // 저장
  const handleSave = (isRevision: boolean = false) => {
    console.log("💾 저장 시작 - bomCalculations:", bomCalculations.length, "개");
    console.log("💾 저장 시작 - editableBOMItems:", editableBOMItems.length, "개");
    console.log("💾 저장할 BOM 상세:", editableBOMItems.length > 0 ? editableBOMItems : bomCalculations);
    console.log("💾 현재 상태 확인:", {
      floors,
      unitSymbol,
      openSizeWidth,
      openSizeHeight,
      quantity,
      totalAmount,
      selectedProductId,
      productCategory
    });
    
    // 직접 입력된 거래처 자동 등록
    let finalClientName = client;
    
    // 편집 모드에서 client가 비어있으면 기존 데이터 사용
    if (editingQuote && (!client || client.trim() === '')) {
      finalClientName = editingQuote.client || editingQuote.customerName || '';
      console.log("📝 편집 모드: 기존 발주처 사용", finalClientName);
    }
    
    if (isDirectInputClient && directClientName.trim()) {
      const newClient = {
        id: `CLI-${Date.now()}`,
        code: `C${Date.now().toString().slice(-6)}`,
        businessNumber: '',
        name: directClientName.trim(),
        type: '매출' as const,
        representative: '',
        address: '',
        businessType: '',
        businessCategory: '',
        phone: directClientPhone.trim(),
        mobile: directClientPhone.trim(),
        fax: '',
        email: '',
        managerName: directClientContact.trim(),
        managerTel: directClientPhone.trim(),
        memo: `견적 ${quoteNumber || '신규'} 작성 시 자동 등록`,
        status: '활성' as const,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };
      addClient(newClient);
      finalClientName = directClientName.trim();
      toast.success(`거래처 "${directClientName.trim()}"가 자동으로 등록되었습니다.`);
    }
    
    // 직접 입력된 현장 자동 등록
    let finalSiteId = siteId;
    let finalSiteName = site;
    let finalSiteCode = siteCode;
    if (isDirectInputSite && directSiteName.trim()) {
      const newSite = {
        id: `SITE-${Date.now()}`,
        siteCode: directSiteCode.trim() || `PJ-${new Date().getFullYear()}${String(Date.now()).slice(-6)}`,
        siteName: directSiteName.trim(),
        keyAddress: '',
        clientCode: finalClientName ? clients.find(c => c.name === finalClientName)?.code || '' : '',
        clientName: finalClientName || '',
        siteCategory: '기타' as any,
        contractStartDate: registrationDate,
        contractEndDate: completionDate || '',
        salesManager: manager || '',
        siteManager: '',
        accumulatedOrderAmount: totalAmount,
        totalCost: 0,
        status: '수주중' as any,
        specialNotes: `견적 ${quoteNumber || '신규'} 작성 시 자동 등록`,
        attachments: [],
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };
      addSite(newSite);
      finalSiteId = newSite.id;
      finalSiteName = directSiteName.trim();
      finalSiteCode = newSite.siteCode;
      toast.success(`현장 "${directSiteName.trim()}"이 자동으로 등록되었습니다.`);
    }
    
    // 견적번호 자동 생성 (미입력 시)
    // 형식: KD-PR-250717-02
    // KD = 고정 prefix
    // PR = 제품 타입 (PR: 철재제품, SC: 크린)
    // 250717 = 날짜 (YY년MM월DD일)
    // 02 = 당일 순번 (01부터 시작, 자동 증가)
    const generatedQuoteNumber = quoteNumber || generateQuoteNumber(productCategory);
    
    // BOM 데이터에서 제품 정보 추출 (selectedProduct가 없는 경우 대비)
    const bomData = editableBOMItems.length > 0 ? editableBOMItems : bomCalculations;
    const productInfo = selectedProduct || {
      itemCode: bomData[0]?.itemCode || '',
      itemName: bomData[0]?.itemName || ''
    };
    
    const quoteData: QuoteData = {
      id: initialData?.id || String(Date.now()),
      registrationDate,
      quoteNumber: generatedQuoteNumber,
      type: productCategory === 'SCREEN' ? '스크린' : '철재',
      productCode: productInfo?.itemCode || '',
      quantity,
      amount: totalAmount,
      client: finalClientName,
      manager,
      contact,
      remarks,
      responseMethod,
      commitment,
      notes,
      currentRevision: initialData?.currentRevision || 0,
      isFinal: initialData?.isFinal || false,
      revisions: initialData?.revisions || [],
      status: initialData?.status || 'draft',
      
      // 기존 필드
      receiptDate: receiptDate || new Date().toISOString().split('T')[0],
      author: author || currentUser?.name || '',
      site: finalSiteName,
      siteId: finalSiteId,
      siteCode: finalSiteCode,
      memo,
      clientContact,
      contactPhone,
      completionDate,
      modelSelection: productInfo?.itemName || '',
      floors: floors,
      code: unitSymbol,
      powderType: '',
      installType: '',
      installLocation: '',
      openSizeWidth,
      openSizeHeight,
      selectedProducts: selectedProduct ? [selectedProduct.itemName] : [],
      calculationRows: [],
      createdAt: initialData?.createdAt || new Date().toISOString(),
      
      // 부품구성표(BOM) 관련 - editableBOMItems 우선 사용
      productCategory,
      selectedProductId,
      bomCalculations: editableBOMItems.length > 0 ? editableBOMItems : bomCalculations,
      
      // 자동 산출 설정 (수정 시 복원용)
      autoCalculationSettings
    };
    
    console.log("✅ 저장할 견적 데이터:", quoteData);
    console.log("✅ BOM 항목 수:", quoteData.bomCalculations?.length);
    console.log("✅ 저장할 BOM 상세 데이터:", quoteData.bomCalculations);
    console.log("📊 저장할 입력값들:", {
      floors: quoteData.floors,
      code: quoteData.code,
      openSizeWidth: quoteData.openSizeWidth,
      openSizeHeight: quoteData.openSizeHeight,
      quantity: quoteData.quantity,
      amount: quoteData.amount
    });
    console.log("🔔 onSave 함수 호출 직전");
    
    if (isRevision) {
      console.log("🔄 수정 모드로 onSave 호출");
      onSave(quoteData, true, revisionReason);
    } else {
      console.log("✨ 신규 등록 모드로 onSave 호출");
      onSave(quoteData, false);
    }
    
    console.log("✅ onSave 함수 호출 완료");
    setIsRevisionDialogOpen(false);
    setRevisionReason("");
  };

  return (
    <PageLayout>
      {/* 헤더 */}
      <PageHeader 
        title="견적 등록"
        description="제품 유형과 오픈사이즈를 입력하면 부품구성표(BOM) 기반으로 자동 견적이 계산됩니다"
        icon={FileEdit}
        isEditMode={isEditMode}
        rightActions={
          !isViewingHistory && (
            <div className="hidden md:flex gap-2">
              <Button
                variant="outline"
                onClick={onCancel}
                className="gap-2"
              >
                <X className="h-4 w-4" />
                취소
              </Button>
              <Button 
                onClick={handleSaveClick}
                className="gap-2"
              >
                <Save className="h-4 w-4" />
                저장
              </Button>
            </div>
          )
        }
      />

      <div className="space-y-6">
        {/* 히스토리 뷰어 - 수정 이력이 있는 경우에만 표시 */}
        {editingQuote && editingQuote.revisions && editingQuote.revisions.length > 0 && (
          <Card className="border-purple-200 bg-purple-50">
            <CardHeader>
              <CardTitle className="flex items-center gap-2 text-purple-700">
                <History className="h-5 w-5" />
                견적 수정 이력
              </CardTitle>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="flex items-center gap-4">
                <Label className="text-purple-700">버전 선택</Label>
                <Select 
                  value={isViewingHistory && selectedRevisionNumber !== null ? String(selectedRevisionNumber) : 'current'}
                  onValueChange={handleRevisionSelect}
                >
                  <SelectTrigger className="w-[300px] bg-white">
                    <SelectValue />
                  </SelectTrigger>
                  <SelectContent>
                    <SelectItem value="current">
                      <div className="flex items-center gap-2">
                        <Badge variant="default">현재</Badge>
                        <span>현재 버전 (최신)</span>
                      </div>
                    </SelectItem>
                    {editingQuote.revisions
                      .sort((a, b) => b.revisionNumber - a.revisionNumber)
                      .map((revision) => (
                        <SelectItem key={revision.revisionNumber} value={String(revision.revisionNumber)}>
                          <div className="flex items-center gap-2">
                            <Badge variant="outline">{revision.revisionNumber}차</Badge>
                            <span>{revision.revisionDate} - {revision.revisionBy}</span>
                            {revision.revisionReason && (
                              <span className="text-xs text-muted-foreground">
                                ({revision.revisionReason})
                              </span>
                            )}
                          </div>
                        </SelectItem>
                      ))}
                  </SelectContent>
                </Select>
                
                {isViewingHistory && (
                  <Badge variant="secondary" className="ml-auto">
                    히스토리 보기 모드 (읽기 전용)
                  </Badge>
                )}
              </div>

              {isViewingHistory && selectedRevisionNumber !== null && (
                <div className="bg-white border border-purple-200 rounded-lg p-4">
                  <div className="text-sm space-y-2">
                    {editingQuote.revisions
                      .filter(r => r.revisionNumber === selectedRevisionNumber)
                      .map((revision) => (
                        <div key={revision.revisionNumber}>
                          <div className="flex items-center gap-2 mb-2">
                            <span className="font-semibold text-purple-700">{revision.revisionNumber}차 수정</span>
                            <span className="text-muted-foreground">•</span>
                            <span>{revision.revisionDate}</span>
                            <span className="text-muted-foreground">•</span>
                            <span>{revision.revisionBy}</span>
                          </div>
                          {revision.revisionReason && (
                            <div className="text-muted-foreground">
                              <span className="font-medium">수정 사유:</span> {revision.revisionReason}
                            </div>
                          )}
                          <div className="mt-2 p-2 bg-amber-50 border border-amber-200 rounded text-amber-700 text-xs">
                            ℹ️ 히스토리 보기 모드입니다. 현재 버전을 선택하면 수정이 가능합니다.
                          </div>
                        </div>
                      ))}
                  </div>
                </div>
              )}
            </CardContent>
          </Card>
        )}
        {/* 기본 정보 */}
        <Card>
          <CardHeader>
            <CardTitle className="font-bold">기본 정보</CardTitle>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-4">
              <div>
                <Label>등록일</Label>
                <Input
                  type="date"
                  value={registrationDate}
                  onChange={(e) => setRegistrationDate(e.target.value)}
                  disabled={true}
                  className="cursor-not-allowed"
                />
              </div>
              <div>
                <Label>작성자</Label>
                <Input
                  value={author}
                  onChange={(e) => setAuthor(e.target.value)}
                  placeholder="작성자명을 입력하세요"
                  disabled={true}
                  className="cursor-not-allowed"
                />
              </div>
              {/* 견적번호 필드 - 숨김 처리 (modules/QuoteNumberField.tsx로 이동됨) */}
              {/* <div>
                <Label>견적번호</Label>
                <div className="flex gap-2">
                  <Input
                    value={quoteNumber}
                    onChange={(e) => setQuoteNumber(e.target.value)}
                    placeholder="자동 생성 또는 직접 입력"
                    className="flex-1"
                  />
                  <Button
                    type="button"
                    variant="outline"
                    size="sm"
                    onClick={() => {
                      const newQuoteNumber = generateLotNumber('quote');
                      setQuoteNumber(newQuoteNumber);
                      toast.success(`견적번호가 생성되었습니다: ${newQuoteNumber}`);
                    }}
                    title="번호기준관리 규칙에 따라 자동 생성"
                  >
                    <RefreshCw className="w-4 h-4" />
                  </Button>
                </div>
                <p className="text-xs text-muted-foreground mt-1">
                  번호기준관리의 규칙에 따라 자동 생성되거나 직접 입력할 수 있습니다
                </p>
              </div> */}
              <div>
                <Label>발주처 선택 <span className="text-red-500">*</span></Label>
                <Select 
                  value={isDirectInputClient ? 'direct' : (client || undefined)} 
                  onValueChange={(value) => {
                    if (isViewingHistory) return;
                    if (value === 'direct') {
                      setIsDirectInputClient(true);
                      setClient('');
                      setDirectClientName('');
                      setManager('');
                      setContact('');
                      // 발주처 직접입력 시 현장명도 자동으로 직접입력 모드로 전환
                      setIsDirectInputSite(true);
                      setSiteId('');
                      setSite('');
                      setSiteCode('');
                      setDirectSiteName('');
                      setDirectSiteCode('');
                    } else {
                      setIsDirectInputClient(false);
                      const selectedClient = clients.find(c => c.name === value);
                      if (selectedClient) {
                        setClient(selectedClient.name);
                        setManager(selectedClient.managerName || '');
                        setContact(selectedClient.managerTel || '');
                      }
                    }
                    // 에러 클리어
                    setFieldErrors(prev => ({ ...prev, client: '', directClientName: '' }));
                  }}
                  disabled={isViewingHistory}
                >
                  <SelectTrigger className={fieldErrors.client ? 'border-red-500' : ''}>
                    <SelectValue placeholder="발주처를 선택하세요" />
                  </SelectTrigger>
                  <SelectContent>
                    <SelectItem value="direct">직접 입력</SelectItem>
                    {clients
                      .filter(c => c.type === '매출' || c.type === '매입매출')
                      .sort((a, b) => a.name.localeCompare(b.name, 'ko'))
                      .map(c => (
                        <SelectItem key={c.id} value={c.name}>
                          {c.name} {c.managerName && `· ${c.managerName}`}
                        </SelectItem>
                      ))}
                  </SelectContent>
                </Select>
                {fieldErrors.client && (
                  <p className="text-sm text-red-500 mt-1">{fieldErrors.client}</p>
                )}
                
                {isDirectInputClient && (
                  <>
                    <Input
                      value={directClientName}
                      onChange={(e) => {
                        setDirectClientName(e.target.value);
                        setFieldErrors(prev => ({ ...prev, directClientName: '' }));
                      }}
                      placeholder="발주처명을 직접 입력하세요"
                      disabled={isViewingHistory}
                      className={`mt-2 ${fieldErrors.directClientName ? 'border-red-500' : ''}`}
                    />
                    {fieldErrors.directClientName && (
                      <p className="text-sm text-red-500 mt-1">{fieldErrors.directClientName}</p>
                    )}
                  </>
                )}
              </div>
              
              <div>
                <Label>현장명 {isDirectInputClient && <span className="text-red-500">*</span>}</Label>
                <Select 
                  value={isDirectInputSite ? 'direct' : (siteId || '')} 
                  onValueChange={(value) => {
                    if (isViewingHistory) return;
                    if (value === 'direct') {
                      setIsDirectInputSite(true);
                      setSiteId('');
                      setSite('');
                      setSiteCode('');
                      setDirectSiteName('');
                      setDirectSiteCode('');
                    } else {
                      setIsDirectInputSite(false);
                      const selectedSite = sites.find(s => s.id === value);
                      if (selectedSite) {
                        setSiteId(selectedSite.id);
                        setSite(selectedSite.siteName);
                        setSiteCode(selectedSite.siteCode);
                      }
                    }
                    // 에러 클리어
                    setFieldErrors(prev => ({ ...prev, directSiteName: '' }));
                  }}
                  disabled={isViewingHistory || isDirectInputClient}
                >
                  <SelectTrigger>
                    <SelectValue placeholder={isDirectInputClient ? "직접 입력" : "현장을 선택하세요"} />
                  </SelectTrigger>
                  <SelectContent>
                    <SelectItem value="direct">직접 입력</SelectItem>
                    {(() => {
                      const filteredSites = client && !isDirectInputClient
                        ? sites.filter(s => s.clientName === client)
                        : sites;
                      
                      if (filteredSites.length === 0 && client && !isDirectInputClient) {
                        return null;
                      }
                      
                      return filteredSites.map(s => (
                        <SelectItem key={s.id} value={s.id}>
                          {s.siteName} ({s.siteCode})
                        </SelectItem>
                      ));
                    })()}
                  </SelectContent>
                </Select>
                
                {isDirectInputSite && (
                  <>
                    <Input
                      value={directSiteName}
                      onChange={(e) => {
                        setDirectSiteName(e.target.value);
                        setFieldErrors(prev => ({ ...prev, directSiteName: '' }));
                      }}
                      placeholder="현장명을 직접 입력하세요"
                      disabled={isViewingHistory}
                      className={`mt-2 ${fieldErrors.directSiteName ? 'border-red-500' : ''}`}
                    />
                    {fieldErrors.directSiteName && (
                      <p className="text-sm text-red-500 mt-1">{fieldErrors.directSiteName}</p>
                    )}
                  </>
                )}
              </div>
              <div>
                <Label>발주 담당자 {isDirectInputClient && <span className="text-red-500">*</span>}</Label>
                <Input
                  value={manager}
                  onChange={(e) => {
                    setManager(e.target.value);
                    setFieldErrors(prev => ({ ...prev, manager: '' }));
                  }}
                  placeholder={isDirectInputClient ? "담당자명을 입력하세요" : (client ? "거래처에서 자동 입력" : "담당자명을 입력하세요")}
                  disabled={isViewingHistory || (client && !isDirectInputClient)}
                  className={`${client && !isDirectInputClient ? "cursor-not-allowed" : ""} ${fieldErrors.manager ? 'border-red-500' : ''}`}
                />
                {fieldErrors.manager && (
                  <p className="text-sm text-red-500 mt-1">{fieldErrors.manager}</p>
                )}
              </div>
              <div>
                <Label>연락처 {isDirectInputClient && <span className="text-red-500">*</span>}</Label>
                <Input
                  value={contact}
                  onChange={(e) => {
                    setContact(e.target.value);
                    setFieldErrors(prev => ({ ...prev, contact: '' }));
                  }}
                  placeholder={isDirectInputClient ? "010-1234-5678" : (client ? "거래처에서 자동 입력" : "010-1234-5678")}
                  disabled={isViewingHistory || (client && !isDirectInputClient)}
                  className={`${client && !isDirectInputClient ? "cursor-not-allowed" : ""} ${fieldErrors.contact ? 'border-red-500' : ''}`}
                />
                {fieldErrors.contact && (
                  <p className="text-sm text-red-500 mt-1">{fieldErrors.contact}</p>
                )}
              </div>
              <div>
                <Label>납기일</Label>
                <Input
                  type="date"
                  value={completionDate}
                  onChange={(e) => setCompletionDate(e.target.value)}
                  disabled={isViewingHistory}
                />
              </div>
            </div>

            <div>
              <Label>비고</Label>
              <Textarea
                value={memo}
                onChange={(e) => setMemo(e.target.value)}
                placeholder="특이사항을 입력하세요"
                rows={2}
                disabled={isViewingHistory}
              />
            </div>
          </CardContent>
        </Card>

        {/* 자동 견적 산출 섹션 */}
        <div className="mt-8">
          <AutoCalculationWithTabs 
            showSampleButton={false} 
            showResults={true}
            onCalculationComplete={handleCalculationComplete} 
          />
        </div>


        
        {/* 디버그 패널 */}
        {debugInfo && (
          <QuoteDebugPanel 
            debugInfo={debugInfo} 
            isOpen={showDebugPanel}
          />
        )}
        
        {/* 샘플 데이터 생성 버튼 */}
        <Card className="border-blue-200 bg-blue-50">
          <CardContent className="p-6">
            <div className="flex items-start gap-4">
              <div className="flex-1">
                <h3 className="font-semibold text-blue-900 mb-2">견적 산출 샘플 데이터 (완전판)</h3>
                <p className="text-sm text-blue-700 mb-4">
                  자동 견적 산출 기능을 테스트하기 위한 완벽한 샘플 데이터를 생성합니다.
                  완제품 14종(스크린 5종, 철재 5종, 절곡 4종), 반제품 40종, 부자재 25종, 원자재 20종이 생성되며,
                  모든 제품에 실제 BOM 구조(2~3단계 계층)와 단가 정보가 포함되어 즉시 견적 산출이 가능합니다.
                </p>
                <div className="flex flex-wrap gap-2 text-xs text-blue-600">
                  <Badge variant="outline" className="bg-white">완제품 14종</Badge>
                  <Badge variant="outline" className="bg-white">반제품 40종</Badge>
                  <Badge variant="outline" className="bg-white">부자재 25종</Badge>
                  <Badge variant="outline" className="bg-white">원자재 20종</Badge>
                  <Badge variant="outline" className="bg-white">BOM 2~3단계 계층 ✓</Badge>
                  <Badge variant="outline" className="bg-white">단가 정보 포함 ✓</Badge>
                  <Badge variant="outline" className="bg-white">절곡 제품 포함 ✓</Badge>
                </div>
              </div>
              <Button
                onClick={handleGenerateCompleteSampleData}
                className="gap-2 bg-blue-600 hover:bg-blue-700"
              >
                <Package className="h-4 w-4" />
                완벽한 샘플 생성
              </Button>
            </div>
          </CardContent>
        </Card>
      </div>



      {/* 모바일 하단 CTA 버튼 */}
      {!isViewingHistory && (
        <div className="md:hidden fixed bottom-0 left-0 right-0 bg-white border-t border-gray-200 p-4 pb-[calc(1rem+env(safe-area-inset-bottom))] z-10">
          <div className="max-w-7xl mx-auto flex gap-2">
            <Button
              variant="outline"
              onClick={onCancel}
              className="gap-2 flex-1"
            >
              <X className="h-4 w-4" />
              취소
            </Button>
            <Button 
              onClick={handleSaveClick}
              className="gap-2 flex-1"
            >
              <Save className="h-4 w-4" />
              저장
            </Button>
          </div>
        </div>
      )}

      {/* 수정 사유 입력 다이얼로그 */}
      <Dialog open={isRevisionDialogOpen} onOpenChange={setIsRevisionDialogOpen}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>견적 수정 사유</DialogTitle>
            <DialogDescription>
              기존 견적을 수정하는 이유를 입력해주세요. 수정 이력으로 저장됩니다.
            </DialogDescription>
          </DialogHeader>
          <div className="py-4">
            <Label>수정 사유</Label>
            <Textarea
              value={revisionReason}
              onChange={(e) => setRevisionReason(e.target.value)}
              placeholder="예: 고객 요청으로 제품 사양 변경"
              rows={4}
            />
          </div>
          <DialogFooter>
            <Button variant="outline" onClick={() => setIsRevisionDialogOpen(false)}>
              취소
            </Button>
            <Button onClick={() => handleSave(true)} disabled={!revisionReason.trim()}>
              수정 사유 저장
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
    </PageLayout>
  );
}