import { useState, useEffect } from "react";
import { toast } from "sonner@2.0.3";
import { useData, ItemMaster } from "./contexts/DataContext";
import { PricingManagementList } from "./PricingManagementList";
import { PricingWrite, PricingData } from "./PricingWrite";

export function PricingManagement() {
  const { itemMasters, updateItemMaster, pricing, addPricing, updatePricing, revisePricing } = useData();
  const [currentView, setCurrentView] = useState<'list' | 'write'>('list');
  const [selectedItem, setSelectedItem] = useState<ItemMaster | null>(null);
  const [editingPricing, setEditingPricing] = useState<PricingData | null>(null);
  
  // DataContext의 pricing 사용 (로컬 상태 제거)
  const pricings = pricing || [];

  // 품목 마스터 데이터를 기반으로 단가 데이터 초기화
  useEffect(() => {
    if (itemMasters.length > 0 && pricings.length === 0) {
      const initialPricings: PricingData[] = [];
      
      itemMasters.forEach(item => {
        // 단가 정보가 있는 품목만 처리
        if (item.purchasePrice || item.processingCost || item.salesPrice) {
          const basePrice = (item.purchasePrice || 0) + (item.processingCost || 0);
          const calculatedSalesPrice = item.salesPrice || (basePrice > 0 && item.marginRate ? Math.floor(basePrice * (1 + item.marginRate / 100)) : 0);
          
          const pricingData: PricingData = {
            id: `pricing-${item.id}`,
            itemId: item.id,
            itemCode: item.itemCode,
            itemName: item.itemName,
            itemType: item.itemType,
            specification: item.specification,
            unit: item.unit,
            purchasePrice: item.purchasePrice || 0,
            processingCost: item.processingCost || 0,
            marginRate: item.marginRate || 0,
            salesPrice: calculatedSalesPrice,
            effectiveDate: new Date().toISOString().split('T')[0],
            status: 'active',
            isFinal: false,
            currentRevision: 0,
            revisions: [],
            createdAt: item.createdAt || new Date().toISOString(),
            createdBy: '시스템',
            note: '품목 마스터 데이터 기반 자동 생성'
          };
          
          initialPricings.push(pricingData);
        }
      });
      
      if (initialPricings.length > 0) {
        initialPricings.forEach(p => addPricing(p));
        console.log(`${initialPricings.length}개 품목의 단가 데이터가 초기화되었습니다.`);
      }
    }
  }, [itemMasters]);

  // 신규 단가 등록
  const handleNewPricing = (item: ItemMaster) => {
    setSelectedItem(item);
    setEditingPricing(null);
    setCurrentView('write');
  };

  // 단가 수정
  const handleEditPricing = (pricing: PricingData) => {
    setEditingPricing(pricing);
    setSelectedItem(null);
    setCurrentView('write');
  };

  // 단가 저장
  const handleSavePricing = (data: PricingData, isRevision?: boolean, revisionReason?: string) => {
    if (isRevision && editingPricing) {
      // 수정 이력 관리 - revisePricing 사용
      revisePricing(editingPricing.id, data, revisionReason, '관리자');
      toast.success(`단가가 수정되었습니다. (수정 ${(editingPricing.currentRevision || 0) + 1}차)`);
    } else {
      // 신규 등록 또는 일반 저장
      const existingIndex = pricings.findIndex(p => p.id === data.id);
      
      if (existingIndex >= 0) {
        // 기존 데이터 업데이트
        updatePricing(data.id, data);
        toast.success("단가 정보가 업데이트되었습니다.");
      } else {
        // 신규 등록
        addPricing(data);
        toast.success("단가가 등록되었습니다.");
      }

      // 품목 마스터에도 단가 정보 업데이트
      if (data.itemId) {
        updateItemMaster(data.itemId, {
          purchasePrice: data.purchasePrice,
          processingCost: data.processingCost,
          marginRate: data.marginRate,
          salesPrice: data.salesPrice
        });
      }
    }

    // 목록으로 돌아가기
    setCurrentView('list');
    setSelectedItem(null);
    setEditingPricing(null);
  };

  // 취소
  const handleCancel = () => {
    setCurrentView('list');
    setSelectedItem(null);
    setEditingPricing(null);
  };

  // 품목 마스터 데이터로부터 단가 데이터 동기화
  const handleSyncFromItemMaster = () => {
    if (!confirm('품목 마스터 데이터를 기반으로 단가 데이터를 동기화하시겠습니까?\n기존 단가 데이터는 모두 삭제되고 품목 마스터 데이터로 대체됩니다.')) {
      return;
    }

    const syncedPricings: PricingData[] = [];
    let syncedCount = 0;

    itemMasters.forEach(item => {
      // 단가 정보가 있는 품목만 처리
      if (item.purchasePrice || item.processingCost || item.salesPrice) {
        const basePrice = (item.purchasePrice || 0) + (item.processingCost || 0);
        const calculatedSalesPrice = item.salesPrice || (basePrice > 0 && item.marginRate ? Math.floor(basePrice * (1 + item.marginRate / 100)) : 0);
        
        const pricingData: PricingData = {
          id: `pricing-${item.id}`,
          itemId: item.id,
          itemCode: item.itemCode,
          itemName: item.itemName,
          itemType: item.itemType,
          specification: item.specification,
          unit: item.unit,
          purchasePrice: item.purchasePrice || 0,
          processingCost: item.processingCost || 0,
          marginRate: item.marginRate || 0,
          salesPrice: calculatedSalesPrice,
          effectiveDate: new Date().toISOString().split('T')[0],
          status: 'active',
          isFinal: false,
          currentRevision: 0,
          revisions: [],
          createdAt: item.createdAt || new Date().toISOString(),
          createdBy: '시스템',
          note: '품목 마스터 데이터로부터 동기화'
        };
        
        syncedPricings.push(pricingData);
        syncedCount++;
      }
    });

    if (syncedPricings.length > 0) {
      syncedPricings.forEach(p => addPricing(p));
      toast.success(`${syncedCount}개 품목의 단가 데이터가 동기화되었습니다.`);
    } else {
      toast.warning('단가 정보가 있는 품목이 없습니다.');
    }
  };

  // 모든 품목에 랜덤 단가 생성
  const handleGenerateRandomPricing = () => {
    if (!confirm('모든 품목에 랜덤 단가를 생성하시겠습니까?\n기존에 등록된 단가는 유지되며, 미등록 품목에만 단가가 생성됩니다.')) {
      return;
    }

    const newPricings: PricingData[] = [];
    let addedCount = 0;

    itemMasters.forEach(item => {
      // 이미 단가가 등록된 품목은 건너뛰기
      const existingPricing = pricings.find(p => p.itemId === item.id || p.itemCode === item.itemCode);
      if (existingPricing) {
        return;
      }

      // 품목 유형에 따라 다른 가격 범위 설정
      let purchasePrice = 0;
      let processingCost = 0;
      let marginRate = 0;

      switch (item.itemType) {
        case 'RM': // 원자재
          purchasePrice = Math.floor(Math.random() * 50000) + 10000; // 10,000 ~ 60,000
          processingCost = 0;
          marginRate = Math.floor(Math.random() * 15) + 10; // 10% ~ 25%
          break;
        case 'PT': // 부품
          purchasePrice = Math.floor(Math.random() * 30000) + 5000; // 5,000 ~ 35,000
          processingCost = Math.floor(Math.random() * 20000) + 3000; // 3,000 ~ 23,000
          marginRate = Math.floor(Math.random() * 20) + 15; // 15% ~ 35%
          break;
        case 'FG': // 제품
          purchasePrice = 0;
          processingCost = Math.floor(Math.random() * 100000) + 50000; // 50,000 ~ 150,000
          marginRate = Math.floor(Math.random() * 25) + 20; // 20% ~ 45%
          break;
        case 'SM': // 부자재
          purchasePrice = Math.floor(Math.random() * 20000) + 2000; // 2,000 ~ 22,000
          processingCost = 0;
          marginRate = Math.floor(Math.random() * 15) + 10; // 10% ~ 25%
          break;
        case 'CS': // 소모품
          purchasePrice = Math.floor(Math.random() * 10000) + 1000; // 1,000 ~ 11,000
          processingCost = 0;
          marginRate = Math.floor(Math.random() * 20) + 15; // 15% ~ 35%
          break;
        default:
          purchasePrice = Math.floor(Math.random() * 30000) + 5000;
          processingCost = Math.floor(Math.random() * 10000) + 2000;
          marginRate = Math.floor(Math.random() * 20) + 15;
      }

      const basePrice = purchasePrice + processingCost;
      const salesPrice = Math.floor(basePrice * (1 + marginRate / 100));

      const pricingData: PricingData = {
        id: `pricing-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
        itemId: item.id,
        itemCode: item.itemCode,
        itemName: item.itemName,
        itemType: item.itemType,
        specification: item.specification,
        unit: item.unit,
        purchasePrice,
        processingCost,
        marginRate,
        salesPrice,
        effectiveDate: new Date().toISOString().split('T')[0],
        status: 'active',
        isFinal: false,
        currentRevision: 0,
        revisions: [],
        createdAt: new Date().toISOString(),
        createdBy: '시스템 자동 생성',
        note: '랜덤 생성된 단가입니다. 실제 단가로 수정이 필요합니다.'
      };

      newPricings.push(pricingData);

      // 품목 마스터에도 단가 정보 업데이트
      updateItemMaster(item.id, {
        purchasePrice,
        processingCost,
        marginRate,
        salesPrice
      });

      addedCount++;
    });

    if (newPricings.length > 0) {
      newPricings.forEach(p => addPricing(p));
      toast.success(`${addedCount}개 품목에 랜덤 단가가 생성되었습니다.`);
    } else {
      toast.info('모든 품목에 이미 단가가 등록되어 있습니다.');
    }
  };

  return (
    <>
      {currentView === 'list' ? (
        <PricingManagementList
          onNewPricing={handleNewPricing}
          onEditPricing={handleEditPricing}
          onSyncFromItemMaster={handleSyncFromItemMaster}
          pricings={pricings}
        />
      ) : (
        <PricingWrite
          onSave={handleSavePricing}
          onCancel={handleCancel}
          editingPricing={editingPricing}
          itemData={selectedItem ? {
            id: selectedItem.id,
            itemCode: selectedItem.itemCode,
            itemName: selectedItem.itemName,
            itemType: selectedItem.itemType,
            specification: selectedItem.specification,
            unit: selectedItem.unit
          } : undefined}
        />
      )}
    </>
  );
}