/**
 * 견적 자동 산출
 * 
 * 분류별 단가 수식에 맞게 품목별 단가를 계산하는 방식
 * 
 * 작동 방식:
 * 1. 제품 선택 시 해당 제품의 분류 확인
 * 2. 분류에 맞는 품목 수식을 적용하여 필요한 BOM 구성
 * 3. 각 품목의 분류에 맞는 단가 수식을 적용하여 단가 계산
 * 4. 전체 품목 리스트 및 단가 표시
 */

import { useState, useMemo } from "react";
import { Calculator, Package, DollarSign, PlayCircle, FileText, AlertCircle } from "lucide-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 { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./ui/select";
import { Badge } from "./ui/badge";
import { Alert, AlertDescription } from "./ui/alert";
import { Separator } from "./ui/separator";
import { PageLayout } from "./organisms/PageLayout";
import { PageHeader } from "./organisms/PageHeader";
import { useData } from "./contexts/DataContext";
import { toast } from "sonner@2.0.3";

// BOM 품목 결과
interface BOMItem {
  itemCode: string;
  itemName: string;
  category: string;
  quantity: number;
  unitPrice: number;
  totalPrice: number;
  formula?: string; // 적용된 수량 수식
  priceFormula?: string; // 적용된 단가 수식
}

// 계산 결과
interface CalculationResult {
  productCode: string;
  productName: string;
  category: string;
  bomItems: BOMItem[];
  totalAmount: number;
  calculatedAt: string;
}

export function QuoteAutoCalculation() {
  const { 
    itemMasters, 
    categoryGroups, 
    formulaRules,
    pricing
  } = useData();

  // 입력 폼 상태
  const [selectedProductId, setSelectedProductId] = useState("");
  const [inputValues, setInputValues] = useState<Record<string, number>>({
    width: 1000,
    height: 2000,
    quantity: 1
  });

  // 계산 결과
  const [result, setResult] = useState<CalculationResult | null>(null);
  const [isCalculating, setIsCalculating] = useState(false);

  // 제품 목록 (제품 타입만 필터링)
  const products = useMemo(() => {
    return itemMasters.filter(item => item.itemType === 'FG');
  }, [itemMasters]);

  // 선택된 제품 정보
  const selectedProduct = useMemo(() => {
    return products.find(p => p.id === selectedProductId);
  }, [products, selectedProductId]);

  // 제품의 분류에 속한 카테고리 그룹 찾기
  const getCategoryGroupForProduct = (category: string) => {
    return categoryGroups.find(group => 
      group.categories.includes(category)
    );
  };

  // 품목 수식 적용 (BOM 구성)
  const applyItemFormulas = (product: any, inputs: Record<string, number>) => {
    const bomItems: BOMItem[] = [];
    const productCategory = product.itemCategory || product.category1 || "";
    
    console.log('🔍 제품 분류:', productCategory);
    
    // BOM 구성 규칙 찾기 (ruleName에 "수량"이 포함된 규칙)
    const bomRules = formulaRules.filter(rule => {
      const isBOMRule = rule.ruleName?.includes('수량') || 
                        rule.ruleCode?.includes('BOM') ||
                        rule.category === productCategory ||
                        rule.category === '공통';
      return isBOMRule && rule.status === 'active';
    });

    console.log('📋 적용 가능한 BOM 규칙:', bomRules.length, bomRules.map(r => r.ruleName));

    // 각 BOM 규칙에 대해 품목 찾기
    bomRules.forEach(rule => {
      try {
        // 규칙 이름에서 품목 카테고리 추출
        let itemCategory = '';
        if (rule.ruleName.includes('가이드레일')) itemCategory = '가이드레일';
        else if (rule.ruleName.includes('케이스')) itemCategory = '케이스';
        else if (rule.ruleName.includes('모터')) itemCategory = '모터';
        else if (rule.ruleName.includes('제어기')) itemCategory = '제어기';
        
        // 해당 카테고리의 품목 찾기
        const relatedItem = itemMasters.find(item => 
          item.itemCategory === itemCategory && item.itemType === 'PT'
        );

        if (relatedItem) {
          // 수식 계산
          let formulaStr = rule.outputFormula || rule.resultFormula || rule.formula || '1';
          
          // 변수 치환
          Object.entries(inputs).forEach(([key, value]) => {
            const regex = new RegExp(`\\b${key}\\b`, 'g');
            formulaStr = formulaStr.replace(regex, String(value));
          });

          // Math 함수 사용 가능하도록 처리
          let quantity = 1;
          try {
            quantity = eval(formulaStr);
          } catch (e) {
            console.warn('수식 계산 실패, 기본값 1 사용:', formulaStr);
            quantity = 1;
          }

          bomItems.push({
            itemCode: relatedItem.itemCode || "",
            itemName: relatedItem.itemName || "",
            category: relatedItem.itemCategory || "",
            quantity: Math.ceil(quantity), // 수량은 올림
            unitPrice: 0, // 나중에 단가 수식으로 계산
            totalPrice: 0,
            formula: rule.outputFormula || rule.resultFormula || rule.formula
          });
          
          console.log('✅ 품목 추가:', relatedItem.itemName, '수량:', Math.ceil(quantity));
        }
      } catch (error) {
        console.error('수식 계산 오류:', rule.ruleName, error);
      }
    });

    return bomItems;
  };

  // 단가 수식 적용 (분류별 단가 계산)
  const applyPriceFormulas = (bomItems: BOMItem[]) => {
    return bomItems.map(item => {
      // 1. 품목의 기본 단가를 pricing에서 찾기
      const pricingData = pricing.find(p => 
        p.itemCode === item.itemCode || 
        p.itemName === item.itemName
      );

      let unitPrice = pricingData?.unitPrice || 0;

      // 2. 품목의 분류에 맞는 단가 수식 찾기
      const categoryGroup = getCategoryGroupForProduct(item.category);
      
      if (categoryGroup) {
        // 분류 그룹에 맞는 단가 수식 규칙 찾기
        const priceRule = formulaRules.find(rule => 
          rule.category === '단가계산' && 
          rule.ruleName.includes(categoryGroup.name)
        );

        if (priceRule && priceRule.outputFormula) {
          try {
            // 단가 수식 적용 (basePrice를 변수로 사용)
            let priceFormulaStr = priceRule.outputFormula;
            priceFormulaStr = priceFormulaStr.replace(/basePrice/g, String(unitPrice));
            
            // 기타 변수들도 치환 가능
            Object.entries(inputValues).forEach(([key, value]) => {
              const regex = new RegExp(`\\b${key}\\b`, 'g');
              priceFormulaStr = priceFormulaStr.replace(regex, String(value));
            });

            unitPrice = eval(priceFormulaStr);
            item.priceFormula = priceRule.outputFormula;
          } catch (error) {
            console.error('단가 수식 계산 오류:', priceRule.ruleName, error);
          }
        }
      }

      // 3. 총 금액 계산
      const totalPrice = unitPrice * item.quantity;

      return {
        ...item,
        unitPrice: Math.round(unitPrice),
        totalPrice: Math.round(totalPrice)
      };
    });
  };

  // 견적 자동 산출 실행
  const handleCalculate = () => {
    if (!selectedProduct) {
      toast.error("제품을 선택해주세요");
      return;
    }

    setIsCalculating(true);

    try {
      // 1. 품목 수식 적용하여 BOM 구성
      let bomItems = applyItemFormulas(selectedProduct, inputValues);

      // 2. 단가 수식 적용하여 단가 계산
      bomItems = applyPriceFormulas(bomItems);

      // 3. 총 금액 계산
      const totalAmount = bomItems.reduce((sum, item) => sum + item.totalPrice, 0);

      // 4. 결과 설정
      const calculationResult: CalculationResult = {
        productCode: selectedProduct.itemCode || "",
        productName: selectedProduct.itemName || "",
        category: selectedProduct.itemCategory || "",
        bomItems,
        totalAmount,
        calculatedAt: new Date().toISOString()
      };

      setResult(calculationResult);
      toast.success("견적이 자동 산출되었습니다");
    } catch (error) {
      console.error('견적 산출 오류:', error);
      toast.error("견적 산출 중 오류가 발생했습니다");
    } finally {
      setIsCalculating(false);
    }
  };

  // 샘플 데이터 로드
  const loadSampleData = () => {
    const sampleProduct = products.find(p => p.itemCategory === '스크린');
    if (sampleProduct) {
      setSelectedProductId(sampleProduct.id);
      setInputValues({
        width: 1200,
        height: 2400,
        quantity: 10
      });
      toast.success("샘플 데이터가 로드되었습니다");
    } else {
      toast.error("샘플 제품이 없습니다");
    }
  };

  return (
    <PageLayout>
      <PageHeader
        title="견적 자동 산출"
        description="분류별 단가 수식에 맞게 품목별 단가를 자동으로 계산합니다"
        icon={Calculator}
      />

      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
        {/* 입력 폼 */}
        <Card>
          <CardHeader>
            <CardTitle className="flex items-center gap-2">
              <Package className="w-5 h-5" />
              제품 정보 입력
            </CardTitle>
          </CardHeader>
          <CardContent className="space-y-4">
            {/* 제품 선택 */}
            <div className="space-y-2">
              <Label>제품 선택</Label>
              <Select value={selectedProductId} onValueChange={setSelectedProductId}>
                <SelectTrigger>
                  <SelectValue placeholder="제품을 선택하세요" />
                </SelectTrigger>
                <SelectContent>
                  {products.map(product => (
                    <SelectItem key={product.id} value={product.id}>
                      {product.itemCode} - {product.itemName}
                      {product.itemCategory && (
                        <Badge variant="outline" className="ml-2">
                          {product.itemCategory}
                        </Badge>
                      )}
                    </SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>

            {selectedProduct && (
              <>
                <Separator />
                
                {/* 제품 정보 표시 */}
                <div className="p-3 bg-muted rounded-lg space-y-2">
                  <div className="flex justify-between">
                    <span className="text-muted-foreground">품목코드:</span>
                    <span>{selectedProduct.itemCode}</span>
                  </div>
                  <div className="flex justify-between">
                    <span className="text-muted-foreground">분류:</span>
                    <Badge>{selectedProduct.itemCategory || '미분류'}</Badge>
                  </div>
                </div>

                <Separator />

                {/* 입력 변수 */}
                <div className="space-y-2">
                  <Label>폭 (Width)</Label>
                  <Input
                    type="number"
                    value={inputValues.width}
                    onChange={e => setInputValues(prev => ({ ...prev, width: Number(e.target.value) }))}
                    placeholder="폭을 입력하세요"
                  />
                </div>

                <div className="space-y-2">
                  <Label>높이 (Height)</Label>
                  <Input
                    type="number"
                    value={inputValues.height}
                    onChange={e => setInputValues(prev => ({ ...prev, height: Number(e.target.value) }))}
                    placeholder="높이를 입력하세요"
                  />
                </div>

                <div className="space-y-2">
                  <Label>수량</Label>
                  <Input
                    type="number"
                    value={inputValues.quantity}
                    onChange={e => setInputValues(prev => ({ ...prev, quantity: Number(e.target.value) }))}
                    placeholder="수량을 입력하세요"
                  />
                </div>

                <Separator />

                {/* 버튼 */}
                <div className="flex gap-2">
                  <Button
                    onClick={handleCalculate}
                    disabled={isCalculating}
                    className="flex-1"
                  >
                    <PlayCircle className="w-4 h-4 mr-2" />
                    {isCalculating ? '계산 중...' : '견적 산출'}
                  </Button>
                  <Button
                    variant="outline"
                    onClick={loadSampleData}
                  >
                    샘플 데이터
                  </Button>
                </div>
              </>
            )}

            {!selectedProduct && (
              <Alert>
                <AlertCircle className="w-4 h-4" />
                <AlertDescription>
                  제품을 선택하거나 샘플 데이터를 로드하세요
                </AlertDescription>
              </Alert>
            )}
          </CardContent>
        </Card>

        {/* 계산 결과 */}
        <Card>
          <CardHeader>
            <CardTitle className="flex items-center gap-2">
              <FileText className="w-5 h-5" />
              견적 산출 결과
            </CardTitle>
          </CardHeader>
          <CardContent>
            {result ? (
              <div className="space-y-4">
                {/* 제품 정보 */}
                <div className="p-3 bg-primary/5 rounded-lg space-y-2">
                  <div className="flex justify-between">
                    <span className="text-muted-foreground">제품코드:</span>
                    <span>{result.productCode}</span>
                  </div>
                  <div className="flex justify-between">
                    <span className="text-muted-foreground">제품명:</span>
                    <span>{result.productName}</span>
                  </div>
                  <div className="flex justify-between">
                    <span className="text-muted-foreground">분류:</span>
                    <Badge>{result.category}</Badge>
                  </div>
                </div>

                <Separator />

                {/* BOM 품목 목록 */}
                <div className="space-y-2">
                  <div className="flex items-center gap-2 mb-2">
                    <DollarSign className="w-4 h-4" />
                    <h4>품목 목록 및 단가</h4>
                  </div>
                  
                  {result.bomItems.length > 0 ? (
                    <div className="space-y-2">
                      {result.bomItems.map((item, index) => (
                        <div key={index} className="p-3 border rounded-lg space-y-2">
                          <div className="flex justify-between items-start">
                            <div>
                              <div className="font-medium">{item.itemName}</div>
                              <div className="text-sm text-muted-foreground">{item.itemCode}</div>
                              {item.category && (
                                <Badge variant="outline" className="mt-1">
                                  {item.category}
                                </Badge>
                              )}
                            </div>
                            <Badge variant="secondary">
                              ₩{item.totalPrice.toLocaleString()}
                            </Badge>
                          </div>
                          
                          <div className="grid grid-cols-2 gap-2 text-sm">
                            <div>
                              <span className="text-muted-foreground">수량:</span>
                              <span className="ml-2">{item.quantity}</span>
                            </div>
                            <div>
                              <span className="text-muted-foreground">단가:</span>
                              <span className="ml-2">₩{item.unitPrice.toLocaleString()}</span>
                            </div>
                          </div>

                          {item.formula && (
                            <div className="text-xs text-muted-foreground">
                              수량 수식: {item.formula}
                            </div>
                          )}
                          {item.priceFormula && (
                            <div className="text-xs text-muted-foreground">
                              단가 수식: {item.priceFormula}
                            </div>
                          )}
                        </div>
                      ))}
                    </div>
                  ) : (
                    <Alert>
                      <AlertCircle className="w-4 h-4" />
                      <AlertDescription>
                        산출된 품목이 없습니다. 품목 수식과 단가 데이터를 확인해주세요.
                      </AlertDescription>
                    </Alert>
                  )}
                </div>

                <Separator />

                {/* 총 금액 */}
                <div className="p-4 bg-primary/10 rounded-lg">
                  <div className="flex justify-between items-center">
                    <span className="text-lg">총 금액</span>
                    <span className="text-2xl">
                      ₩{result.totalAmount.toLocaleString()}
                    </span>
                  </div>
                </div>

                <div className="text-xs text-muted-foreground text-right">
                  산출 시각: {new Date(result.calculatedAt).toLocaleString()}
                </div>
              </div>
            ) : (
              <Alert>
                <AlertCircle className="w-4 h-4" />
                <AlertDescription>
                  제품 정보를 입력하고 '견적 산출' 버튼을 클릭하세요
                </AlertDescription>
              </Alert>
            )}
          </CardContent>
        </Card>
      </div>

      {/* 시스템 정보 */}
      <Card className="mt-6">
        <CardHeader>
          <CardTitle>시스템 정보</CardTitle>
        </CardHeader>
        <CardContent>
          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
            <div>
              <div className="text-muted-foreground">등록된 제품</div>
              <div className="text-2xl">{products.length}</div>
            </div>
            <div>
              <div className="text-muted-foreground">분류 그룹</div>
              <div className="text-2xl">{categoryGroups.length}</div>
            </div>
            <div>
              <div className="text-muted-foreground">수식 규칙</div>
              <div className="text-2xl">{formulaRules.length}</div>
            </div>
            <div>
              <div className="text-muted-foreground">단가 데이터</div>
              <div className="text-2xl">{pricing.length}</div>
            </div>
          </div>
        </CardContent>
      </Card>
    </PageLayout>
  );
}