/**
 * 자동 산출 BOM 품목 단가 계산 헬퍼
 */

import { calculateItemPrice } from './priceCalculator';
import type { ItemDebugInfo } from '../BomCalculationResults';

interface CalculationVariables {
  W0: number;
  H0: number;
  W1: number;
  H1: number;
  M: number;
  K: number;
  UP?: number;
}

interface AutoBomItem {
  itemCode: string;
  itemName: string;
  quantity: number;
  quantityFormula?: string; // 수량 계산 수식
  specification?: string;
  unit?: string;
  unitPrice?: number;
  totalPrice?: number;
  pricingSource?: string;
  formulaUsed?: string;
  itemCategory?: string;
  debugInfo?: ItemDebugInfo;
  [key: string]: any;
}

interface ItemMaster {
  id: string;
  itemCode: string;
  itemName: string;
  itemCategory?: string;
  sellingPrice?: number;
  [key: string]: any;
}

interface PriceMappingItem {
  id: string;
  mappingType: 'individual' | 'categoryGroup';
  itemCode?: string;
  categoryGroupId?: string;
  priceFormulaId: string;
  quantityFormula?: string;
  enabled: boolean;
  priority?: number;
}

/**
 * 자동 산출 BOM 품목들에 단가 정보와 디버깅 정보를 추가합니다.
 */
export function addPricesToAutoBomItems(
  autoBomItems: AutoBomItem[],
  itemMasters: ItemMaster[],
  calculationVariables: CalculationVariables,
  formulas: any[],
  categoryGroups: any[],
  pricings: any[],
  priceMappings?: PriceMappingItem[]
): AutoBomItem[] {
  
  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
  console.log('📊 [자동 산출 BOM 단가 계산 시작]');
  console.log(`  품목 수: ${autoBomItems.length}개`);
  console.log(`  변수: W0=${calculationVariables.W0}, H0=${calculationVariables.H0}`);
  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
  
  return autoBomItems.map((bomItem, index) => {
    console.log(`\n[${index + 1}/${autoBomItems.length}] ${bomItem.itemCode} - ${bomItem.itemName}`);
    
    // 품목 마스터에서 상세 정보 찾기
    const itemMaster = itemMasters.find(item => item.itemCode === bomItem.itemCode);
    
    if (!itemMaster) {
      console.warn(`⚠️  품목 마스터를 찾을 수 없음: ${bomItem.itemCode}`);
      return {
        ...bomItem,
        unitPrice: 0,
        totalPrice: 0,
        pricingSource: '품목 마스터 없음'
      };
    }
    
    // customPrice가 있으면 우선 사용 (검사비 등)
    if (bomItem.customPrice !== undefined) {
      console.log(`  💎 사용자 지정 단가 사용: ${bomItem.customPrice}원`);
      return {
        ...bomItem,
        unitPrice: bomItem.customPrice,
        totalPrice: bomItem.quantity * bomItem.customPrice,
        pricingSource: '사용자 지정 단가'
      };
    }
    
    // 단가 계산
    const priceResult = calculateItemPrice(
      itemMaster,
      calculationVariables,
      formulas,
      categoryGroups,
      pricings,
      priceMappings
    );
    
    const unitPrice = priceResult.unitPrice;
    const totalPrice = bomItem.quantity * unitPrice;
    
    // 디버깅 정보 생성
    const debugInfo: ItemDebugInfo = createDebugInfo(
      bomItem,
      itemMaster,
      calculationVariables,
      priceResult,
      unitPrice,
      totalPrice
    );
    
    console.log(`  ✅ 단가: ${unitPrice.toLocaleString()}원, 수량: ${bomItem.quantity}, 금액: ${totalPrice.toLocaleString()}원`);
    
    return {
      ...bomItem,
      itemCategory: itemMaster.itemCategory,
      unitPrice: unitPrice,
      totalPrice: totalPrice,
      pricingSource: priceResult.source,
      formulaUsed: priceResult.formulaUsed,
      debugInfo: debugInfo
    };
  });
}

/**
 * 디버깅 정보 생성
 */
function createDebugInfo(
  bomItem: AutoBomItem,
  itemMaster: ItemMaster,
  variables: CalculationVariables,
  priceResult: any,
  unitPrice: number,
  totalPrice: number
): ItemDebugInfo {
  
  // Step 1: 사용된 수식
  const step1_formula = bomItem.quantityFormula || '직접 입력된 수량';
  
  // Step 2: 대입된 변수 값
  const step2_variables: Record<string, number> = {
    W0: variables.W0,
    H0: variables.H0,
    W1: variables.W1,
    H1: variables.H1,
    M: variables.M,
    K: variables.K
  };
  
  if (variables.UP) {
    step2_variables.UP = variables.UP;
  }
  
  // Step 3: 수량 계산 과정
  let step3_quantityCalc = '직접 입력';
  if (bomItem.quantityFormula) {
    let expr = bomItem.quantityFormula;
    Object.keys(step2_variables).forEach(key => {
      expr = expr.replace(new RegExp(`\\b${key}\\b`, 'g'), step2_variables[key].toString());
    });
    step3_quantityCalc = `${bomItem.quantityFormula} = ${expr}`;
  }
  
  // Step 4: 계산된 수량
  const step4_quantity = bomItem.quantity;
  
  // Step 5: 단가 출처
  const step5_priceSource = priceResult.source || '품목 판매단가';
  
  // Step 6: 기본 단가
  const step6_basePrice = itemMaster.sellingPrice || 0;
  
  // Step 7: 분류별 변수 곱셈 (맵핑에서 수식 사용 시)
  let step7_categoryMultiplier: string | undefined;
  if (priceResult.debugInfo?.formulaExpression) {
    const steps = priceResult.debugInfo.calculationSteps || [];
    step7_categoryMultiplier = steps.join(' → ');
  }
  
  // Step 8: 최종 단가
  const step8_finalPrice = unitPrice;
  
  // Step 9: 금액 계산 과정
  const step9_totalCalc = `${step4_quantity.toFixed(2)} × ${step8_finalPrice.toLocaleString()}`;
  
  // Step 10: 최종 금액
  const step10_total = totalPrice;
  
  return {
    step1_formula,
    step2_variables,
    step3_quantityCalc,
    step4_quantity,
    step5_priceSource,
    step6_basePrice,
    step7_categoryMultiplier,
    step8_finalPrice,
    step9_totalCalc,
    step10_total
  };
}

/**
 * 여러 자동 산출 결과 배열들을 하나로 통합하고 단가를 추가합니다.
 */
export function consolidateAndPriceAutoBomResults(
  results: {
    windingShaftResults?: AutoBomItem[];
    guideRailResults?: AutoBomItem[];
    baseResults?: AutoBomItem[];
    smokeBarrierResults?: AutoBomItem[];
    caseItemResults?: AutoBomItem[];
    motorResults?: AutoBomItem[];
    controllerResults?: AutoBomItem[];
    edgeWingResults?: AutoBomItem[];
    inspectionResults?: AutoBomItem[];
  },
  itemMasters: ItemMaster[],
  calculationVariables: CalculationVariables,
  formulas: any[],
  categoryGroups: any[],
  pricings: any[],
  priceMappings?: PriceMappingItem[]
): AutoBomItem[] {
  
  const allItems: AutoBomItem[] = [
    ...(results.windingShaftResults || []),
    ...(results.guideRailResults || []),
    ...(results.baseResults || []),
    ...(results.smokeBarrierResults || []),
    ...(results.caseItemResults || []),
    ...(results.motorResults || []),
    ...(results.controllerResults || []),
    ...(results.edgeWingResults || []),
    ...(results.inspectionResults || [])
  ];
  
  return addPricesToAutoBomItems(
    allItems,
    itemMasters,
    calculationVariables,
    formulas,
    categoryGroups,
    pricings,
    priceMappings
  );
}
