"use client"

import { z } from "zod"
import { createOffshoreTopItem, getMaxOffshoreTopIMCode } from "../../service"
import { splitItemCodes, createErrorExcelFile, ExtendedProcessResult, processEmptyItemCodes } from "../../utils/import-utils"

// 해양 TOP 기능(공종) 유형 enum
const TOP_WORK_TYPES = ["TM", "TS", "TE", "TP", "TA"] as const;

// 아이템 데이터 검증을 위한 Zod 스키마
const itemSchema = z.object({
  itemCode: z.string().optional(),
  workType: z.enum(TOP_WORK_TYPES, {
    required_error: "기능(공종)은 필수입니다",
  }),
  itemList: z.string().nullable().optional(),
  subItemList: z.string().nullable().optional(),
});

/**
 * Excel 파일에서 가져온 해양 TOP 아이템 데이터 처리하는 함수
 */
export async function processTopFileImport(
  jsonData: Record<string, unknown>[],
  progressCallback?: (current: number, total: number) => void
): Promise<ExtendedProcessResult> {
  // 결과 카운터 초기화
  let successCount = 0;
  let errorCount = 0;
  const errors: Array<{ 
    row: number; 
    message: string; 
    itemCode?: string; 
    workType?: string;
    originalData?: Record<string, any>;
  }> = [];
  const processedItemCodes: string[] = [];
  const duplicateItemCodes: string[] = [];
  
  // 빈 행 등 필터링
  const dataRows = jsonData.filter(row => {
    // 빈 행 건너뛰기
    if (Object.values(row).every(val => !val)) {
      return false;
    }
    return true;
  });
  
  // 데이터 행이 없으면 빈 결과 반환
  if (dataRows.length === 0) {
    return { 
      successCount: 0, 
      errorCount: 0, 
      errors: [],
      processedItemCodes: [],
      duplicateItemCodes: []
    };
  }
  
  // 기존 IM 코드의 최대 번호 조회
  const maxIMCode = await getMaxOffshoreTopIMCode();
  let nextIMNumber = maxIMCode + 1;
  
  // 각 행에 대해 처리
  for (let i = 0; i < dataRows.length; i++) {
    const row = dataRows[i];
    const rowIndex = i + 1; // 사용자에게 표시할 행 번호는 1부터 시작
    
    // 진행 상황 콜백 호출
    if (progressCallback) {
      progressCallback(i + 1, dataRows.length);
    }
    
    try {
      // 필드 매핑 (한글/영문 필드명 모두 지원)
      const itemCode = row["자재 그룹"] || row["itemCode"] || "";
      const workType = row["기능(공종)"] || row["workType"] || "";
      const itemList = row["자재명"] || row["itemList"] || null;
      const subItemList = row["자재명(상세)"] || row["subItemList"] || null;
      
      // 데이터 정제
      const cleanedRow = {
        itemCode: typeof itemCode === 'string' ? itemCode.trim() : String(itemCode).trim(),
        workType: typeof workType === 'string' ? workType.trim() : String(workType).trim(),
        itemList: itemList ? (typeof itemList === 'string' ? itemList : String(itemList)) : null,
        subItemList: subItemList ? (typeof subItemList === 'string' ? subItemList : String(subItemList)) : null,
      };
      
      // 데이터 유효성 검사
      const validationResult = itemSchema.safeParse(cleanedRow);
      
      if (!validationResult.success) {
        const errorMessage = validationResult.error.errors.map(
          err => `${err.path.join('.')}: ${err.message}`
        ).join(', ');
        
        errors.push({ 
          row: rowIndex, 
          message: errorMessage,
          originalData: cleanedRow
        });
        errorCount++;
        continue;
      }

      // itemCode 분할 처리
      const rawItemCodes = splitItemCodes(cleanedRow.itemCode);
      
      // 빈 itemCode 처리 (임시 코드 생성)
      const { codes: itemCodes, nextNumber } = processEmptyItemCodes(rawItemCodes, nextIMNumber);
      nextIMNumber = nextNumber;

      // 각 itemCode에 대해 개별 처리
      let rowSuccessCount = 0;
      let rowErrorCount = 0;
      
      for (const singleItemCode of itemCodes) {
        try {
          // 해양 TOP 아이템 생성
          const result = await createOffshoreTopItem({
            itemCode: singleItemCode,
            workType: cleanedRow.workType as "TM" | "TS" | "TE" | "TP" | "TA",
            itemList: cleanedRow.itemList,
            subItemList: cleanedRow.subItemList,
          });
          
          if (result.success) {
            rowSuccessCount++;
            processedItemCodes.push(singleItemCode);
          } else {
            rowErrorCount++;
            if (result.message?.includes('중복') || result.error?.includes('중복')) {
              duplicateItemCodes.push(singleItemCode);
            }
            
            errors.push({
              row: rowIndex,
              message: `${singleItemCode}: ${result.message || result.error || "알 수 없는 오류"}`,
              itemCode: singleItemCode,
              workType: cleanedRow.workType,
              originalData: cleanedRow
            });
          }
        } catch (error) {
          rowErrorCount++;
          console.error(`${rowIndex}행 ${singleItemCode} 처리 오류:`, error);
          errors.push({
            row: rowIndex,
            message: `${singleItemCode}: ${error instanceof Error ? error.message : "알 수 없는 오류"}`,
            itemCode: singleItemCode,
            workType: cleanedRow.workType,
            originalData: cleanedRow
          });
        }
      }
      
      // 행별 성공/실패 카운트 업데이트
      successCount += rowSuccessCount;
      errorCount += rowErrorCount;
      
    } catch (error) {
      console.error(`${rowIndex}행 처리 오류:`, error);
      errors.push({
        row: rowIndex,
        message: error instanceof Error ? error.message : "알 수 없는 오류",
        originalData: row as Record<string, any>
      });
      errorCount++;
    }
    
    // 비동기 작업 쓰로틀링
    if (i % 5 === 0) {
      await new Promise(resolve => setTimeout(resolve, 10));
    }
  }
  
  // 에러가 있으면 Excel 파일 생성
  if (errors.length > 0) {
    await createErrorExcelFile(errors, 'top');
  }
  
  // 처리 결과 반환
  return {
    successCount,
    errorCount,
    errors,
    processedItemCodes,
    duplicateItemCodes
  };
}