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

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

import { debugLog, debugSuccess, debugError } from '@/lib/debug-utils';
import db from '@/db/db';
import {
  biddings,
  prItemsForBidding,
  prDocuments,
} from '@/db/schema/bidding';
import {
  PR_INFORMATION_T_BID_HEADER,
  PR_INFORMATION_T_BID_ITEM,
} from '@/db/schema/ECC/ecc';
import { inArray, max, sql, eq, like } from 'drizzle-orm';
import { users } from '@/db/schema/users';
import {
  findUserInfoByEKGRP,
  findProjectInfoByPSPID,
  findProjectIdByPSPID,
  findMaterialNameByMATNR,
  parseSAPDateTime,
  parseSAPDateToString,
  findSpecificationByMATNR,
} from './common-mapper-utils';
import { updateBiddingAmounts } from '@/lib/bidding/service';
// Note: POS 파일은 온디맨드 방식으로 다운로드됩니다.
// 자동 동기화 관련 import는 제거되었습니다.

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

// 비즈니스 테이블 데이터 타입 정의
export type BiddingData = typeof biddings.$inferInsert;
export type PrItemForBiddingData = typeof prItemsForBidding.$inferInsert;

// Note: syncBiddingPosFiles 함수는 제거되었습니다.
// POS 파일은 온디맨드 방식으로 사용자가 필요할 때 다운로드됩니다.


/**
 * Bidding 코드 생성 함수 (배치 처리용)
 * 형식: E/F/G{담당자코드3자리}{년도2자리}{시퀀스4자리}-01
 * 기존 ANFNR은 기존 biddingNumber 사용, 새로운 ANFNR만 새 코드 생성
 */
async function generateBiddingCodes(eccHeaders: ECCBidHeader[]): Promise<Map<string, string>> {
  try {
    debugLog('Bidding 코드 배치 생성 시작', { headerCount: eccHeaders.length });

    const biddingCodeMap = new Map<string, string>();

    // 1) 먼저 기존 ANFNR들의 biddingNumber 조회
    const anfnrList = eccHeaders.map(h => h.ANFNR).filter(Boolean);
    if (anfnrList.length > 0) {
      const existingResult = await db
        .select({
          ANFNR: biddings.ANFNR,
          biddingNumber: biddings.biddingNumber
        })
        .from(biddings)
        .where(inArray(biddings.ANFNR, anfnrList));

      // 기존 ANFNR들의 biddingNumber 매핑
      for (const row of existingResult) {
        if (row.ANFNR && row.biddingNumber) {
          biddingCodeMap.set(row.ANFNR, row.biddingNumber);
        }
      }
    }

    // 2) 새로운 ANFNR들만 필터링 (기존에 없는 것들)
    const newHeaders = eccHeaders.filter(header =>
      header.ANFNR && !biddingCodeMap.has(header.ANFNR)
    );

    if (newHeaders.length === 0) {
      debugSuccess('모든 ANFNR이 기존에 존재함', {
        totalCodes: biddingCodeMap.size
      });
      return biddingCodeMap;
    }

    // 3) 새로운 ANFNR들을 담당자별로 그룹핑 (EKGRP 기반)
    const managerGroups = new Map<string, ECCBidHeader[]>();
    for (const header of newHeaders) {
      // EKGRP를 직접 사용하여 3자리 담당자 코드 생성
      let managerCode = '000';
      const ekgrp = header.EKGRP || '';

      if (ekgrp.length >= 3) {
        managerCode = ekgrp.substring(0, 3).toUpperCase();
      } else if (ekgrp.length > 0) {
        managerCode = ekgrp.padEnd(3, '0').toUpperCase();
      }

      if (!managerGroups.has(managerCode)) {
        managerGroups.set(managerCode, []);
      }
      managerGroups.get(managerCode)!.push(header);
    }

    // 계약 타입별 접두사 설정 (ECC에서는 기본적으로 일반계약으로 가정)
    const contractType = 'general';
    const typePrefix = {
      'general': 'E', // 일반계약
      'unit_price': 'F', // 단가계약
      'sale': 'G', // 매각계약
    };
    const prefix = typePrefix[contractType as keyof typeof typePrefix] || 'E';

    // 현재 년도 2자리
    const currentYear = new Date().getFullYear().toString().slice(-2);

    // 4) 담당자별로 새 코드 생성
    for (const [managerCode, headers] of managerGroups) {
      const yearPrefix = `${prefix}${managerCode}${currentYear}`;

      // 해당 담당자의 현재 최대 시퀀스 조회
      const prefixLength = yearPrefix.length + 4;
      const result = await db
        .select({
          maxNumber: sql<string>`MAX(LEFT(${biddings.biddingNumber}, ${prefixLength}))`
        })
        .from(biddings)
        .where(like(biddings.biddingNumber, `${yearPrefix}%`));

      // 시퀀스 생성 헬퍼 함수
      const generateNextSequence = (lastSequence: string | null): string => {
        if (!lastSequence) return '0001';
        const seqNum = parseInt(lastSequence, 10) || 0;
        return (seqNum + 1).toString().padStart(4, '0');
      };

      const nextSequence = generateNextSequence(result[0]?.maxNumber?.slice(-4) || null);

      // 동일 담당자 내에서 순차적으로 새 코드 생성
      for (const header of headers) {
        const biddingNumber = `${yearPrefix}${nextSequence}-01`;

        // 중복 확인 및 재시도 (동시성 문제 방지)
        let finalBiddingNumber = biddingNumber;
        let attempts = 0;
        const maxRetries = 5;

        while (attempts < maxRetries) {
          const existing = await db
            .select({ id: biddings.id })
            .from(biddings)
            .where(eq(biddings.biddingNumber, finalBiddingNumber))
            .limit(1);

          if (existing.length === 0) {
            break; // 중복 없음
          }

          // 중복이 발견되면 시퀀스 증가
          const currentSeq = parseInt(finalBiddingNumber.slice(-6, -3), 10);
          const newSeq = (currentSeq + 1).toString().padStart(4, '0');
          finalBiddingNumber = `${yearPrefix}${newSeq}-01`;
          attempts++;

          if (attempts >= maxRetries) {
            throw new Error(`Failed to generate unique bidding number after ${maxRetries} attempts`);
          }
        }

        biddingCodeMap.set(header.ANFNR || '', finalBiddingNumber);
      }
    }

    debugSuccess('Bidding 코드 배치 생성 완료', {
      totalCodes: biddingCodeMap.size,
      newCodes: newHeaders.length,
      existingCodes: eccHeaders.length - newHeaders.length
    });
    return biddingCodeMap;
  } catch (error) {
    debugError('Bidding 코드 배치 생성 중 오류 발생', { error });

    // 오류 발생시 폴백: 기본 형식으로 코드 생성
    const fallbackMap = new Map<string, string>();
    const currentYear = new Date().getFullYear().toString().slice(-2);

    eccHeaders.forEach((header, index) => {
      const seqString = (index + 1).toString().padStart(4, '0');
      const ekgrp = header.EKGRP || '000';
      fallbackMap.set(header.ANFNR, `E${ekgrp.substring(0, 3).toUpperCase()}${currentYear}${seqString}-01`);
    });
    return fallbackMap;
  }
}



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

/**
 * ECC Bidding 헤더 데이터를 biddings 테이블로 매핑
 */
export async function mapECCBiddingHeaderToBidding(
  eccHeader: ECCBidHeader,
  eccItems: ECCBidItem[],
  biddingNumber: string
): Promise<BiddingData> {
  debugLog('ECC Bidding 헤더 매핑 시작', { anfnr: eccHeader.ANFNR, biddingNumber });

  // 첫번째 PR Item 가져오기 (관련 아이템들 중 첫번째)
  const firstItem = eccItems.find(item => item.ANFNR === eccHeader.ANFNR);

  // 대표 PR Item 찾기 (ZCON_NO_PO와 BANFN이 같은 아이템 - RFQ 매퍼 로직 반영)
  const representativeItem = eccItems.find(item =>
    item.ANFNR === eccHeader.ANFNR &&
    item.ZCON_NO_PO &&
    item.ZCON_NO_PO.trim() &&
    item.BANFN === item.ZCON_NO_PO.trim()
  );

  // 타겟 아이템 설정 (대표 아이템 우선, 없으면 첫번째 아이템)
  const targetItem = representativeItem || firstItem;
  
  // 날짜 파싱 (실패시 현재 Date 들어감)
  const createdAt = parseSAPDateTime(eccHeader.ZRFQ_TRS_DT || null, eccHeader.ZRFQ_TRS_TM || null);

  // 담당자 찾기
  const inChargeUserInfo = await findUserInfoByEKGRP(eccHeader.EKGRP || null);

  // 타겟 PR Item 기반으로 projectName, itemName 설정
  let projectName: string | null = null;
  let itemName: string | null = null;
  let prNumber: string | null = null;
  
  if (targetItem) {
    // projectName: 타겟 PR Item의 PSPID와 projects.code 매칭
    const projectInfo = await findProjectInfoByPSPID(targetItem.PSPID || null);
    if (projectInfo) {
      projectName = projectInfo.name;
    }
    
    // itemName: 타겟 PR Item의 TXZ01(내역) 우선 사용, 없으면 MATNR로 조회
    if (targetItem.TXZ01) {
      itemName = targetItem.TXZ01;
    } else {
      itemName = await findMaterialNameByMATNR(targetItem.MATNR || null);
    }
    
    // prNumber: 대표 PR의 BANFN 또는 타겟 PR의 ZREQ_FN 값
    prNumber = representativeItem?.BANFN || targetItem.ZREQ_FN || null;
  }
  
  // 원입찰번호(originalBiddingNumber)에 생성된 biddingNumber에서 '-'로 split해서 앞부분을 사용
  const originalBiddingNumber = biddingNumber ? biddingNumber.split('-')[0] : (eccHeader.ANFNR || null);

  // 매핑
  const mappedData: BiddingData = {
    biddingNumber, // 생성된 Bidding 코드
    originalBiddingNumber, // 원입찰번호에 생성된 biddingnumber split 결과 사용
    revision: 0, // 기본 리비전 0 (I/F 해서 가져온 건 보낸 적 없으므로 0 고정)
    projectName, // 타겟 PR Item의 PSPID로 찾은 프로젝트 이름
    itemName, // 타겟 PR Item 정보로 조회한 자재명/내역
    title: `${targetItem?.PSPID || ''}${itemName || ''}입찰`, // PSPID+자재명+입찰
    description: null,
    
    // 계약 정보 - ECC에서 제공되지 않으므로 기본값 설정
    contractType: 'general', // 일반계약 기본값 (notNull)
    biddingType: 'equipment', // 입찰유형 기본값 (notNull)
    awardCount: 'single', // 낙찰업체 수 기본값 (notNull)
    contractStartDate: null, // ECC에서 제공 X
    contractEndDate: null, // ECC에서 제공 X
    
    // 일정 관리 - ECC에서 제공되지 않음
    preQuoteDate: null,
    biddingRegistrationDate: new Date().toISOString(), // 입찰등록일 I/F 시점 등록(1120 이시원 프로 요청)
    submissionStartDate: null,
    submissionEndDate: null,
    
    // 사양설명회
    hasSpecificationMeeting: false, // 기본값 처리하고, 입찰관리상세에서 사용자가 관리
    
    // 예산 및 가격 정보
    currency: targetItem?.WAERS1,
    budget: null,
    targetPrice: null,
    targetPriceCalculationCriteria: null,
    finalBidPrice: null,
    
    // PR 정보
    prNumber, // 첫번째 PR의 ZREQ_FN 값
    hasPrDocument: false, // PR문서는 POS를 말하는 것으로 보임.
    
    // 상태 및 설정
    status: 'bidding_generated', // 입찰생성 상태
    isPublic: false,
    
    // 담당자 정보 - EKGRP 기반으로 설정 (입찰담당자로 매핑)
    bidPicId: inChargeUserInfo?.userId || null,
    bidPicName: inChargeUserInfo?.userName || null,
    bidPicCode: eccHeader.EKGRP || null,
    
    // 메타 정보
    remarks: `ECC ANFNR: ${eccHeader.ANFNR}`,
    createdBy: inChargeUserInfo?.userId?.toString() || '1',
    createdAt,
    updatedAt: createdAt,
    updatedBy: inChargeUserInfo?.userId?.toString() || '1',
    ANFNR: eccHeader.ANFNR, // 원본 ANFNR 추적용
  };

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

/**
 * ECC Bidding 아이템 데이터를 prItemsForBidding 테이블로 매핑
 */
export async function mapECCBiddingItemToPrItemForBidding(
  eccItem: ECCBidItem,
  biddingId: number
): Promise<PrItemForBiddingData> {
  debugLog('ECC Bidding 아이템 매핑 시작', {
    anfnr: eccItem.ANFNR,
    anfps: eccItem.ANFPS,
  });

  // 날짜 파싱 (YYYY-MM-DD 형식의 문자열로 변환)
  const requestedDeliveryDate = parseSAPDateToString(eccItem.LFDAT || null);

  // PSPID(Project Code)로 프로젝트 ID 조회
  const projectId = await findProjectIdByPSPID(eccItem.PSPID || null);

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

  const mappedData: PrItemForBiddingData = {
    biddingId, // 부모 Bidding ID
    itemNumber: eccItem.ANFPS || null, // 아이템 번호
    projectId, // PSSID로 조회한 프로젝트 ID
    projectInfo: eccItem.PSPID || null, // 프로젝트 정보 (PSPID)
    itemInfo: eccItem.TXZ01 || null, // 품목정보 (자재 설명)
    shi: null, // ECC에서 제공되지 않음
    
    // 자재 그룹 정보
    materialGroupNumber: eccItem.MATKL || null, // 자재그룹번호 (Material Group Code)
    materialGroupInfo: null, // ECC에서 제공되지 않음
    
    // 자재 정보
    materialNumber: eccItem.MATNR || null, // 자재번호 (Material Number)
    materialInfo: eccItem.TXZ01 || null, // 자재정보 (Material Description)
    
    requestedDeliveryDate, // 납품요청일
    annualUnitPrice: null, // ECC에서 제공되지 않음
    currency: eccItem.WAERS1 || null, // 기본 통화
    quantity: eccItem.MENGE || null, // 수량
    quantityUnit: eccItem.MEINS || null, // 수량단위
    totalWeight: eccItem.BRGEW || null, // 총중량
    weightUnit: eccItem.GEWEI || null, // 중량단위
    
    // WBS 정보
    wbsCode: eccItem.POSID || null, // WBS No
    wbsName: null, // ECC에서 제공되지 않음
    
    // Cost Center 정보
    costCenterCode: eccItem.KOSTL || null, // Cost Center
    costCenterName: null, // ECC에서 제공되지 않음
    
    // GL Account 정보
    glAccountCode: eccItem.SAKTO || null, // G/L Account Number
    glAccountName: null, // ECC에서 제공되지 않음
    
    prNumber: eccItem.BANFN || null, // PR번호
    hasSpecDocument: false, // 기본값 false
    specification, // MATNR로 조회한 Specification
  };

  debugSuccess('ECC Bidding 아이템 매핑 완료', {
    itemNumber: eccItem.ANFPS,
    prNumber: eccItem.BANFN,
    projectId,
    specification,
  });
  return mappedData;
}

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

  // ANFNR이 없는 헤더들 필터링
  const validHeaders = eccHeaders.filter(header => {
    if (!header.ANFNR) {
      debugError('ANFNR이 없는 헤더 스킵', { header });
      return false;
    }
    return true;
  });

  if (validHeaders.length === 0) {
    debugError('처리할 유효한 헤더가 없음');
    return {
      success: false,
      message: '처리할 유효한 ANFNR이 있는 헤더가 없습니다.',
      processedCount: 0,
    };
  }

  try {
    const result = await db.transaction(async (tx) => {
      // 1) Bidding 코드 배치 생성 (중복 방지) - 유효한 헤더만 사용
      const biddingCodeMap = await generateBiddingCodes(validHeaders);
      
      // 2) 헤더별 관련 아이템 그룹핑 + 헤더 매핑을 병렬로 수행 - 유효한 헤더만 사용
      const biddingGroups = await Promise.all(
        validHeaders.map(async (eccHeader) => {
          // 아이템 필터링 및 정렬 (ANFPS 오름차순)
          const relatedItems = eccItems
            .filter((item) => item.ANFNR === eccHeader.ANFNR)
            .sort((a, b) => {
              const anfpsA = parseInt(a.ANFPS || '0', 10);
              const anfpsB = parseInt(b.ANFPS || '0', 10);
              return anfpsA - anfpsB;
            });
          
          const biddingNumber = biddingCodeMap.get(eccHeader.ANFNR) || `BID${eccHeader.EKGRP || 'UNKNOWN'}00001`;
          // 헤더 매핑 시 아이템 정보와 생성된 Bidding 코드 전달
          const biddingData = await mapECCBiddingHeaderToBidding(eccHeader, relatedItems, biddingNumber);
          return { biddingNumber: biddingData.biddingNumber, biddingData, relatedItems };
        })
      );

      const biddingRecords = biddingGroups.map((g) => g.biddingData);

      // 3) Bidding 다건 삽입
      const inserted = await tx
        .insert(biddings)
        .values(biddingRecords)
        .returning({ 
          id: biddings.id, 
          biddingNumber: biddings.biddingNumber,
          ANFNR: biddings.ANFNR,
          createdBy: biddings.createdBy
        });

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

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

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

        // 각 아이템을 병렬로 매핑 (async 함수로 변경되었으므로)
        const itemsData = await Promise.all(
          group.relatedItems.map(eccItem => 
            mapECCBiddingItemToPrItemForBidding(eccItem, biddingId)
          )
        );
        allItemsToInsert.push(...itemsData);
      }

      // 6) 아이템 일괄 삽입 (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(prItemsForBidding).values(chunk);
      }

      return { 
        processedCount: biddingRecords.length,
        insertedBiddings: inserted as Array<{ id: number; biddingNumber: string; ANFNR: string | null; createdBy: string | null }>,
        allEccItems: eccItems // POS 동기화를 위해 필요
      };
    });

    // 새로 생성된 Bidding들에 대해 금액 집계 업데이트 (PR 아이템의 금액 정보를 Bidding 헤더에 반영)
    if (result.insertedBiddings && result.insertedBiddings.length > 0) {
      debugLog('Bidding 금액 집계 업데이트 시작', { count: result.insertedBiddings.length });
      await Promise.all(
        result.insertedBiddings.map(async (bidding) => {
          try {
            await updateBiddingAmounts(bidding.id);
          } catch (err) {
            debugError(`Bidding ${bidding.biddingNumber} 금액 업데이트 실패`, err);
          }
        })
      );
    }

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

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

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

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

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

  // 아이템 데이터 검증
  for (const item of eccItems) {
    if (!item.ANFNR) {
      errors.push(
        `필수 필드 누락: ANFNR (Bidding 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 Bidding 데이터를 삭제 (biddings/prItemsForBidding 테이블에서 삭제)
 */
export async function deleteECCBiddingData(
  eccHeaders: ECCBidHeader[]
): Promise<{ success: boolean; message: string; deletedCount: number }> {
  debugLog('ECC Bidding 데이터 삭제 시작', {
    headerCount: eccHeaders.length,
  });

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

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

        // 1) 해당 ANFNR의 Bidding 찾기
        const existingBidding = await tx
          .select({ id: biddings.id, biddingNumber: biddings.biddingNumber })
          .from(biddings)
          .where(eq(biddings.ANFNR, anfnr))
          .limit(1);

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

        const biddingId = existingBidding[0].id;
        const biddingNumber = existingBidding[0].biddingNumber;

        // 2) prItemsForBidding 삭제
        const deletedItems = await tx
          .delete(prItemsForBidding)
          .where(eq(prItemsForBidding.biddingId, biddingId));

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

        // 3) prDocuments 삭제 (POS 파일 관련 문서)
        const deletedDocuments = await tx
          .delete(prDocuments)
          .where(eq(prDocuments.biddingId, biddingId));

        debugLog(`Bidding ${biddingNumber}의 문서 ${deletedDocuments.rowCount}개 삭제 완료`);

        // 4) biddings 삭제
        await tx
          .delete(biddings)
          .where(eq(biddings.id, biddingId));

        deletedBiddings.push(biddingNumber);
        debugLog(`Bidding ${biddingNumber} 삭제 완료`);
      }

      return { deletedBiddings };
    });

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

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