path: root/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts

/**
 * SAP ECC에서 PR을 묶어 RFQ를 생성한 경우 SOAP으로 수신하여 처리하는 매퍼
 * 
 * ZBSART = AN (RFQ)인 경우 이 파일에서 처리하여 rfqsLast, rfqPrItems 테이블에 매핑합니다.
 * ZBSART = AB (Bidding)인 경우는 bidding-and-pr-mapper.ts 파일에서 매핑합니다.
 * 
 * 주요 변경사항:
 * - POS 파일 자동 다운로드 로직 제거됨 (온디맨드 방식으로 변경)
 * - 사용자가 필요할 때만 POS 파일을 다운로드하도록 개선
 */

import { debugLog, debugSuccess, debugError } from '@/lib/debug-utils';
import db from '@/db/db';
import {
  rfqsLast,
  rfqPrItems,
} from '@/db/schema/rfqLast';
import {
  PR_INFORMATION_T_BID_HEADER,
  PR_INFORMATION_T_BID_ITEM,
} from '@/db/schema/ECC/ecc';
import { eq, max } from 'drizzle-orm';
import {
  findUserInfoByEKGRP,
  findProjectInfoByPSPID,
  parseSAPDateTime,
  findUserInfoByPERNR,
  findSpecificationByMATNR,
} from './common-mapper-utils';

// ECC 데이터 타입 정의
export type ECCBidHeader = typeof PR_INFORMATION_T_BID_HEADER.$inferInsert;
export type ECCBidItem = typeof PR_INFORMATION_T_BID_ITEM.$inferInsert;

// 비즈니스 테이블 데이터 타입 정의
export type RfqLastData = typeof rfqsLast.$inferInsert;
export type RfqPrItemData = typeof rfqPrItems.$inferInsert;

/**
 * 시리즈 판단: 관련 PR 아이템들의 PSPID를 기반으로 결정
 * - 아이템이 1개 이하: null
 * - 아이템이 2개 이상이고 PSPID가 모두 동일: "||"
 * - 아이템이 2개 이상이고 PSPID가 서로 다름: "SS"
 */
function computeSeriesFromItems(items: ECCBidItem[]): string | null {
  if (items.length <= 1) return null;

  const normalize = (v: unknown): string | null => {
    if (typeof v !== 'string') return null;
    const trimmed = v.trim();
    return trimmed.length > 0 ? trimmed : null;
  };

  const uniquePspids = new Set<string | null>(
    items.map((it) => normalize(it.PSPID as string | null | undefined))
  );

  return uniquePspids.size === 1 ? '||' : 'SS';
}


/**
 * RFQ 코드 생성 함수 (배치 처리용)
 * 형식: RFQ{EKGRP}{00001}
 * 동일한 EKGRP의 여러 RFQ가 동시에 처리될 때 중복 방지
 */
async function generateRfqCodes(eccHeaders: ECCBidHeader[]): Promise<Map<string, string>> {
  try {
    debugLog('RFQ 코드 배치 생성 시작', { headerCount: eccHeaders.length });
    
    const rfqCodeMap = new Map<string, string>();
    
    // EKGRP별로 그룹핑
    const ekgrpGroups = new Map<string, ECCBidHeader[]>();
    for (const header of eccHeaders) {
      const ekgrp = header.EKGRP || 'UNKNOWN';
      if (!ekgrpGroups.has(ekgrp)) {
        ekgrpGroups.set(ekgrp, []);
      }
      ekgrpGroups.get(ekgrp)!.push(header);
    }
    
    // EKGRP별로 순차 처리
    for (const [ekgrp, headers] of ekgrpGroups) {
      // 해당 EKGRP의 현재 최대 시퀀스 조회
      const maxResult = await db
        .select({ 
          maxRfqCode: max(rfqsLast.rfqCode)
        })
        .from(rfqsLast)
        .where(eq(rfqsLast.picCode, ekgrp));

      let nextSeq = 1;
      if (maxResult[0]?.maxRfqCode) {
        const prefix = `RFQ${ekgrp}`;
        const currentCode = maxResult[0].maxRfqCode;
        if (currentCode.startsWith(prefix)) {
          const seqPart = currentCode.substring(prefix.length);
          const currentSeq = parseInt(seqPart, 10);
          if (!isNaN(currentSeq)) {
            nextSeq = currentSeq + 1;
          }
        }
      }
      
      // 동일 EKGRP 내에서 순차적으로 코드 생성
      for (const header of headers) {
        const seqString = nextSeq.toString().padStart(5, '0');
        const rfqCode = `RFQ${ekgrp}${seqString}`;
        rfqCodeMap.set(header.ANFNR || '', rfqCode);
        nextSeq++; // 다음 시퀀스로 증가
      }
    }
    
    debugSuccess('RFQ 코드 배치 생성 완료', { 
      totalCodes: rfqCodeMap.size,
      ekgrpCount: ekgrpGroups.size 
    });
    return rfqCodeMap;
  } catch (error) {
    debugError('RFQ 코드 배치 생성 중 오류 발생', { error });
    
    // 오류 발생시 폴백: ANFNR 기반 코드 생성
    const fallbackMap = new Map<string, string>();
    eccHeaders.forEach((header, index) => {
      const ekgrp = header.EKGRP || 'UNKNOWN';
      const seqString = (index + 1).toString().padStart(5, '0');
      fallbackMap.set(header.ANFNR || '', `RFQ${ekgrp}${seqString}`);
    });
    return fallbackMap;
  }
}



// *****************************mapping functions*********************************

/**
 * ECC RFQ 헤더 데이터를 rfqsLast 테이블로 매핑
 * 매핑 규칙에 따라 첫번째 PR Item 정보로 헤더 필드들을 채움
 */
export async function mapECCRfqHeaderToRfqLast(
  eccHeader: ECCBidHeader,
  eccItems: ECCBidItem[],
  rfqCode: string
): Promise<RfqLastData> {
  debugLog('ECC RFQ 헤더 매핑 시작', { anfnr: eccHeader.ANFNR, rfqCode });

  // 첫번째 PR Item 가져오기 (관련 아이템들 중 첫번째)
  const firstItem = eccItems.find(item => item.ANFNR === eccHeader.ANFNR);
  
  // 날짜 파싱 (실패시 현재 Date 들어감)
  const interfacedAt = parseSAPDateTime(eccHeader.ZRFQ_TRS_DT || null, eccHeader.ZRFQ_TRS_TM || null);

  // 담당자 찾기
  const inChargeUserInfo = await findUserInfoByEKGRP(eccHeader.EKGRP || null);
  const inChargeUserId = inChargeUserInfo?.userId || null;
  const inChargeUserName = inChargeUserInfo?.userName || null; // 담당자명 추가
  
  // 대표 PR Item 기반으로 projectId, itemCode, itemName, 설계담당자 설정 (없으면 첫번째 PR Item 사용)
  let projectId: number | null = null;
  let itemCode: string | null = null;
  let itemName: string | null = null;
  let prNumber: string | null = null;
  let engPicName: string | null = null;
  let engPicEmployeeNumber: string | null = null;
  let representativeItem: ECCBidItem | undefined;

  if (firstItem) {
    // 대표 PR Item 찾기 (ZCON_NO_PO와 BANFN이 같은 아이템)
    representativeItem = eccItems.find(item =>
      item.ANFNR === eccHeader.ANFNR &&
      item.ZCON_NO_PO &&
      item.ZCON_NO_PO.trim() &&
      item.BANFN === item.ZCON_NO_PO.trim()
    );

    // 대표 PR Item이 없으면 첫번째 PR Item 사용
    const targetItem = representativeItem || firstItem;

    // projectId: 대표 PR Item의 PSPID와 projects.code 매칭
    const projectInfo = await findProjectInfoByPSPID(targetItem.PSPID || null);
    projectId = projectInfo?.id || null;

    // itemCode: 대표 PR Item의 MATNR
    itemCode = targetItem.MATNR || null;

    // itemName: 대표 PR Item의 TXZ01 (Short Text)
    itemName = targetItem.TXZ01 || null;

    // prNumber: 대표 PR의 BANFN 또는 첫번째 PR의 ZREQ_FN 값
    prNumber = representativeItem?.BANFN || firstItem.ZREQ_FN || null;

    // 설계담당자 정보: 대표 PR Item의 PERNR로 조회
    if (targetItem.PERNR) {
      const engPicInfo = await findUserInfoByPERNR(targetItem.PERNR);
      if (engPicInfo) {
        engPicName = engPicInfo.userName;
        engPicEmployeeNumber = engPicInfo.employeeNumber;
      }
    }
  }

  // 매핑
  const mappedData: RfqLastData = {
    rfqCode, // 생성된 RFQ 코드
    ANFNR: eccHeader.ANFNR,
    projectId, // 첫번째 PR Item의 PSPID로 찾은 프로젝트 ID
    series: null, // PR 아이템 처리 후 업데이트 
    itemCode, // 첫번째 PR Item의 MATKL
    itemName, // 첫번째 PR Item의 MATNR로 조회한 자재명
    dueDate: null, // ECC에서 제공되지 않음
    rfqSendDate: null, // ECC에서 제공되지 않음
    status: 'RFQ 생성', // 한글 상태로 변경
    rfqSealedYn: false,
    EngPicName: engPicName, // 대표 PR Item의 PERNR로 조회한 설계담당자명
    EngPicEmployeeNumber: engPicEmployeeNumber, // 대표 PR Item의 PERNR(사번)
    packageNo: null, // ECC에서 제공되지 않음
    packageName: null, // ECC에서 제공되지 않음
    remark: null,
    pic: inChargeUserId, // 담당자 ID
    picCode: eccHeader.EKGRP || null, // 구매그룹코드
    picName: inChargeUserName, // 담당자명 (EKGRP로 조회)
    sentBy: null,
    createdBy: inChargeUserId || 1,
    updatedBy: inChargeUserId,
    createdAt: interfacedAt,
    // 새 필드들
    rfqType: 'ECC', // ECC에서 온 데이터임을 표시
    rfqTitle: null,
    projectCompany: null,
    projectFlag: null,
    projectSite: null,
    smCode: null,
    prNumber, // 첫번째 PR의 ZREQ_FN 값
    prIssueDate: interfacedAt, // 수신시점의 날짜
  };

  debugSuccess('ECC RFQ 헤더 매핑 완료', { anfnr: eccHeader.ANFNR, rfqCode });
  return mappedData;
}

/**
 * ECC RFQ 아이템 데이터를 rfqPrItems 테이블로 매핑
 */
export async function mapECCRfqItemToRfqPrItem(
  eccItem: ECCBidItem,
  rfqId: number,
  isMajor: boolean = false
): Promise<RfqPrItemData> {
  debugLog('ECC RFQ 아이템 매핑 시작', {
    anfnr: eccItem.ANFNR,
    anfps: eccItem.ANFPS,
  });

  // 날짜 파싱
  let deliveryDate: Date | null = null;
  if (eccItem.LFDAT && eccItem.LFDAT.length === 8) {
    try {
      // YYYYMMDD 형식을 YYYY-MM-DD로 변환 후 한국 시간 기준으로 설정
      const year = eccItem.LFDAT.substring(0, 4);
      const month = eccItem.LFDAT.substring(4, 6);
      const day = eccItem.LFDAT.substring(6, 8);
      // 한국 시간(KST, UTC+9) 기준으로 날짜 생성
      deliveryDate = new Date(`${year}-${month}-${day}T00:00:00+09:00`);
    } catch (error) {
      debugError('SAP 날짜 파싱 오류', {
        lfdat: eccItem.LFDAT,
        error,
      });
    }
  }

  // Specification 조회 (MATNR 기반)
  const specification = await findSpecificationByMATNR(eccItem.MATNR || null);

  const mappedData: RfqPrItemData = {
    rfqsLastId: rfqId, // 부모 RFQ ID
    rfqItem: eccItem.ANFPS || null, // RFQ Item 번호
    prItem: eccItem.BANPO || null, // PR Item 번호
    prNo: eccItem.BANFN || null, // PR 번호
    materialCode: eccItem.MATNR || null, // 자재코드
    materialCategory: eccItem.MATKL || null, // 자재그룹
    acc: eccItem.SAKTO || null, // G/L 계정
    materialDescription: eccItem.TXZ01 || null, // 자재 설명
    size: null, // ECC에서 제공되지 않음
    deliveryDate, // 납기일
    quantity: eccItem.MENGE ? Number(eccItem.MENGE) : null, // 수량
    uom: eccItem.MEINS || null, // 단위
    grossWeight: eccItem.BRGEW ? Number(eccItem.BRGEW) : null, // 총중량
    gwUom: eccItem.GEWEI || null, // 중량단위
    specNo: null, // ECC에서 제공되지 않음
    specUrl: null, // ECC에서 제공되지 않음
    specification, // MATNR로 조회한 Specification
    trackingNo: null, // ECC에서 제공되지 않음
    majorYn: isMajor, // ZCON_NO_PO와 BANFN이 같은 경우 true
    projectDef: eccItem.PSPID || null, // 프로젝트 정의
    projectSc: null, // ECC에서 제공되지 않음
    projectKl: null, // ECC에서 제공되지 않음
    projectLc: null, // ECC에서 제공되지 않음
    projectDl: null, // ECC에서 제공되지 않음
    remark: null,
  };

  debugSuccess('ECC RFQ 아이템 매핑 완료', {
    rfqItem: eccItem.ANFPS,
    materialCode: eccItem.MATNR,
    specification,
  });
  return mappedData;
}

/**
 * ECC 데이터를 rfqsLast/rfqPrItems 테이블로 일괄 매핑 및 저장
 */
/**
 * 기존 함수명 호환성 유지 - 새 테이블로 리다이렉트
 */
export async function mapAndSaveECCRfqData(
  eccHeaders: ECCBidHeader[],
  eccItems: ECCBidItem[]
): Promise<{ success: boolean; message: string; processedCount: number }> {
  return mapAndSaveECCRfqDataToRfqLast(eccHeaders, eccItems);
}

/**
 * ECC 데이터를 rfqsLast/rfqPrItems 테이블로 일괄 매핑 및 저장
 */
export async function mapAndSaveECCRfqDataToRfqLast(
  eccHeaders: ECCBidHeader[],
  eccItems: ECCBidItem[]
): Promise<{ success: boolean; message: string; processedCount: number }> {
  debugLog('ECC 데이터 일괄 매핑 및 저장 시작 (rfqsLast)', {
    headerCount: eccHeaders.length,
    itemCount: eccItems.length,
  });

  try {
    const result = await db.transaction(async (tx) => {
      // 1) RFQ 코드 배치 생성 (중복 방지)
      const rfqCodeMap = await generateRfqCodes(eccHeaders);
      
      // 2) 헤더별 관련 아이템 그룹핑 + 시리즈 계산 + 헤더 매핑을 병렬로 수행
      const rfqGroups = await Promise.all(
        eccHeaders.map(async (eccHeader) => {
          const relatedItems = eccItems.filter((item) => item.ANFNR === eccHeader.ANFNR);
          const series = computeSeriesFromItems(relatedItems);
          const rfqCode = rfqCodeMap.get(eccHeader.ANFNR) || `RFQ${eccHeader.EKGRP || 'UNKNOWN'}00001`;
          // 헤더 매핑 시 아이템 정보와 생성된 RFQ 코드 전달
          const rfqData = await mapECCRfqHeaderToRfqLast(eccHeader, relatedItems, rfqCode);
          rfqData.series = series;
          return { rfqCode: rfqData.rfqCode, rfqData, relatedItems };
        })
      );

      const rfqRecords = rfqGroups.map((g) => g.rfqData);

      // 3) RFQ 다건 삽입
      const inserted = await tx
        .insert(rfqsLast)
        .values(rfqRecords)
        .returning({ id: rfqsLast.id, rfqCode: rfqsLast.rfqCode });

      const rfqCodeToId = new Map<string, number>();
      for (const row of inserted) {
        if (row.rfqCode) {
          rfqCodeToId.set(row.rfqCode, row.id);
        }
      }

      // 4) 모든 새로 삽입된 레코드의 ID 매핑은 이미 완료됨

      // 5) 모든 아이템을 한 번에 생성할 데이터로 변환 (async 함수로 병렬 처리)
      const allItemsToInsert: RfqPrItemData[] = [];
      for (const group of rfqGroups) {
        const rfqCode = group.rfqCode;
        if (!rfqCode) continue;
        const rfqId = rfqCodeToId.get(rfqCode);
        if (!rfqId) {
          debugError('RFQ ID 매핑 누락', { rfqCode });
          throw new Error(`RFQ ID를 찾을 수 없습니다: ${rfqCode}`);
        }

        // 각 아이템을 병렬로 매핑 (async 함수로 변경되었으므로)
        const itemsData = await Promise.all(
          group.relatedItems.map(async eccItem => {
            // ZCON_NO_PO와 BANFN이 같은 경우 majorYn을 true로 설정
            const isMajor: boolean = !!(eccItem.ZCON_NO_PO &&
                                       eccItem.ZCON_NO_PO.trim() &&
                                       eccItem.BANFN === eccItem.ZCON_NO_PO.trim());

            return await mapECCRfqItemToRfqPrItem(eccItem, rfqId, isMajor);
          })
        );
        allItemsToInsert.push(...itemsData);
      }

      // 5) 아이템 일괄 삽입 (chunk 처리로 파라미터 제한 회피)
      const ITEM_CHUNK_SIZE = 1000;
      for (let i = 0; i < allItemsToInsert.length; i += ITEM_CHUNK_SIZE) {
        const chunk = allItemsToInsert.slice(i, i + ITEM_CHUNK_SIZE);
        await tx.insert(rfqPrItems).values(chunk);
      }

      return { 
        processedCount: rfqRecords.length,
        insertedRfqs: inserted  // POS 동기화를 위해 inserted 데이터 반환
      };
    });

    debugSuccess('ECC 데이터 일괄 처리 완료 (rfqsLast)', {
      processedCount: result.processedCount,
    });

    // Note: POS 파일은 온디맨드 방식으로 사용자가 필요할 때 다운로드됩니다.
    // 자동 다운로드는 더 이상 수행하지 않습니다.

    return {
      success: true,
      message: `${result.processedCount}개의 RFQ 데이터가 성공적으로 처리되었습니다.`,
      processedCount: result.processedCount,
    };
  } catch (error) {
    debugError('ECC 데이터 처리 중 오류 발생', error);
    return {
      success: false,
      message:
        error instanceof Error
          ? error.message
          : '알 수 없는 오류가 발생했습니다.',
      processedCount: 0,
    };
  }
}

/**
 * ECC 데이터 유효성 검증
 */
export function validateECCRfqData(
  eccHeaders: ECCBidHeader[],
  eccItems: ECCBidItem[]
): { isValid: boolean; errors: string[] } {
  const errors: string[] = [];

  // 헤더 데이터 검증
  for (const header of eccHeaders) {
    if (!header.ANFNR) {
      errors.push(`필수 필드 누락: ANFNR (Bidding/RFQ Number)`);
    }
    if (!header.ZBSART) {
      errors.push(
        `필수 필드 누락: ZBSART (Bidding Type) - ANFNR: ${header.ANFNR}`
      );
    }
  }

  // 아이템 데이터 검증
  for (const item of eccItems) {
    if (!item.ANFNR) {
      errors.push(
        `필수 필드 누락: ANFNR (Bidding/RFQ Number) - Item: ${item.ANFPS}`
      );
    }
    if (!item.ANFPS) {
      errors.push(`필수 필드 누락: ANFPS (Item Number) - ANFNR: ${item.ANFNR}`);
    }
    if (!item.BANFN) {
      errors.push(
        `필수 필드 누락: BANFN (Purchase Requisition Number) - ANFNR: ${item.ANFNR}, ANFPS: ${item.ANFPS}`
      );
    }
    if (!item.BANPO) {
      errors.push(
        `필수 필드 누락: BANPO (Item Number of Purchase Requisition) - ANFNR: ${item.ANFNR}, ANFPS: ${item.ANFPS}`
      );
    }
  }

  // 헤더와 아이템 간의 관계 검증
  const headerAnfnrs = new Set(eccHeaders.map((h) => h.ANFNR));
  const itemAnfnrs = new Set(eccItems.map((i) => i.ANFNR));

  for (const anfnr of itemAnfnrs) {
    if (!headerAnfnrs.has(anfnr)) {
      errors.push(`아이템의 ANFNR이 헤더에 존재하지 않음: ${anfnr}`);
    }
  }

  return {
    isValid: errors.length === 0,
    errors,
  };
}

/**
 * ECC RFQ 데이터를 삭제 (rfqsLast/rfqPrItems 테이블에서 삭제)
 */
export async function deleteECCRfqData(
  eccHeaders: ECCBidHeader[]
): Promise<{ success: boolean; message: string; deletedCount: number }> {
  debugLog('ECC RFQ 데이터 삭제 시작', {
    headerCount: eccHeaders.length,
  });

  try {
    const result = await db.transaction(async (tx) => {
      const deletedRfqs: (string | null)[] = [];

      for (const eccHeader of eccHeaders) {
        const anfnr = eccHeader.ANFNR;
        if (!anfnr) {
          debugError('삭제할 ANFNR이 없음', { eccHeader });
          continue;
        }

        // 1) 해당 ANFNR의 RFQ 찾기
        const existingRfq = await tx
          .select({ id: rfqsLast.id, rfqCode: rfqsLast.rfqCode })
          .from(rfqsLast)
          .where(eq(rfqsLast.ANFNR, anfnr))
          .limit(1);

        if (existingRfq.length === 0) {
          debugLog(`ANFNR ${anfnr}에 해당하는 RFQ가 존재하지 않음`);
          continue;
        }

        const rfqId = existingRfq[0].id;
        const rfqCode = existingRfq[0].rfqCode;

        if (!rfqCode) {
          debugError('RFQ 코드가 없는 데이터는 건너뜀', { rfqId });
          continue;
        }

        // 2) rfqPrItems 삭제
        const deletedItems = await tx
          .delete(rfqPrItems)
          .where(eq(rfqPrItems.rfqsLastId, rfqId));

        debugLog(`RFQ ${rfqCode}의 PR 아이템 ${deletedItems.rowCount}개 삭제 완료`);

        // 3) rfqsLast 삭제
        await tx
          .delete(rfqsLast)
          .where(eq(rfqsLast.id, rfqId));

        deletedRfqs.push(rfqCode);
        debugLog(`RFQ ${rfqCode} 삭제 완료`);
      }

      return { deletedRfqs };
    });

    debugSuccess('ECC RFQ 데이터 삭제 완료', {
      deletedCount: result.deletedRfqs.length,
      deletedRfqs: result.deletedRfqs,
    });

    return {
      success: true,
      message: `${result.deletedRfqs.length}개의 RFQ 데이터가 성공적으로 삭제되었습니다.`,
      deletedCount: result.deletedRfqs.length,
    };
  } catch (error) {
    debugError('ECC RFQ 데이터 삭제 중 오류 발생', error);
    return {
      success: false,
      message:
        error instanceof Error
          ? error.message
          : '알 수 없는 오류가 발생했습니다.',
      deletedCount: 0,
    };
  }
}