"use server"

import { oracleKnex } from '@/lib/oracle-db/db'

// SSLVW_PUR_INQ_REQ 테이블 데이터 타입 (실제 테이블 구조에 맞게 조정 필요)
export interface SSLVWPurInqReq {
  [key: string]: string | number | Date | null | undefined
}

// 테스트 환경용 폴백 데이터
const FALLBACK_TEST_DATA: SSLVWPurInqReq[] = [
  {
    REG_NO: '1030',
    INQ_TP: 'OC',
    INQ_TP_DSC: '해외계약',
    TIT: 'Contrack of Sale',
    REQ_DGR: '2',
    REQR_NM: '김원식',
    REQ_DT: '20130829',
    REVIEW_TERM_DT: '20130902',
    RVWR_NM: '김미정',
    CNFMR_NM: '안한진',
    APPR_NM: '염정훈',
    PRGS_STAT: 'E',
    PRGS_STAT_DSC: '검토중이라고',
    REGR_DPTCD: 'D602058000',
    REGR_DEPTNM: '구매1팀(사외계약)'
  },
  {
    REG_NO: '1076',
    INQ_TP: 'IC',
    INQ_TP_DSC: '국내계약',
    TIT: 'CAISSON PIPE 복관 계약서 검토 요청件',
    REQ_DGR: '1',
    REQR_NM: '서권환',
    REQ_DT: '20130821',
    REVIEW_TERM_DT: '20130826',
    RVWR_NM: '이택준',
    CNFMR_NM: '이택준',
    APPR_NM: '전상용',
    PRGS_STAT: 'E',
    PRGS_STAT_DSC: '완료',
    REGR_DPTCD: 'D602058000',
    REGR_DEPTNM: '구매1팀(사외계약)'
  },
  {
    REG_NO: '1100',
    INQ_TP: 'IC',
    INQ_TP_DSC: '국내계약',
    TIT: '(7102) HVAC 작업계약',
    REQ_DGR: '1',
    REQR_NM: '신동동',
    REQ_DT: '20130826',
    REVIEW_TERM_DT: '20130829',
    RVWR_NM: '이두리',
    CNFMR_NM: '이두리',
    APPR_NM: '전상용',
    PRGS_STAT: 'E',
    PRGS_STAT_DSC: '완료',
    REGR_DPTCD: 'D602058000',
    REGR_DEPTNM: '구매1팀(사외계약)'
  },
  {
    REG_NO: '1105',
    INQ_TP: 'IC',
    INQ_TP_DSC: '국내계약',
    TIT: 'Plate 가공계약서 검토 요청건',
    REQ_DGR: '1',
    REQR_NM: '서권환',
    REQ_DT: '20130826',
    REVIEW_TERM_DT: '20130829',
    RVWR_NM: '백영국',
    CNFMR_NM: '백영국',
    APPR_NM: '전상용',
    PRGS_STAT: 'E',
    PRGS_STAT_DSC: '완료',
    REGR_DPTCD: 'D602058000',
    REGR_DEPTNM: '구매1팀(사외계약)'
  },
  {
    REG_NO: '1106',
    INQ_TP: 'IC',
    INQ_TP_DSC: '국내계약',
    TIT: 'SHELL FLNG, V-BRACE 제작 계약서 검토件',
    REQ_DGR: '1',
    REQR_NM: '성기승',
    REQ_DT: '20130826',
    REVIEW_TERM_DT: '20130830',
    RVWR_NM: '이두리',
    CNFMR_NM: '이두리',
    APPR_NM: '전상용',
    PRGS_STAT: 'E',
    PRGS_STAT_DSC: '완료',
    REGR_DPTCD: 'D602058000',
    REGR_DEPTNM: '구매1팀(사외계약)'
  }
]

const normalizeOracleRows = (rows: Array<Record<string, unknown>>): SSLVWPurInqReq[] => {
  return rows.map((item) => {
    const convertedItem: SSLVWPurInqReq = {}
    for (const [key, value] of Object.entries(item)) {
      if (value instanceof Date) {
        convertedItem[key] = value
      } else if (value === null) {
        convertedItem[key] = null
      } else {
        convertedItem[key] = String(value)
      }
    }
    return convertedItem
  })
}

/**
 * SSLVW_PUR_INQ_REQ 테이블 전체 조회
 * @returns 테이블 데이터 배열
 */
export async function getSSLVWPurInqReqData(): Promise<{
  success: boolean
  data: SSLVWPurInqReq[]
  error?: string
  isUsingFallback?: boolean
}> {
  try {
    console.log('📋 [getSSLVWPurInqReqData] SSLVW_PUR_INQ_REQ 테이블 조회 시작...')

    const result = await oracleKnex.raw(`
      SELECT *
      FROM SSLVW_PUR_INQ_REQ
      WHERE ROWNUM < 100
      ORDER BY 1
    `)

    // Oracle raw query의 결과는 rows 배열에 들어있음
    const rows = (result.rows || result) as Array<Record<string, unknown>>

    console.log(`✅ [getSSLVWPurInqReqData] 조회 성공 - ${rows.length}건`)

    // 데이터 타입 변환 (필요에 따라 조정)
    const cleanedResult = normalizeOracleRows(rows)

    return {
      success: true,
      data: cleanedResult,
      isUsingFallback: false
    }
  } catch (error) {
    console.error('❌ [getSSLVWPurInqReqData] 오류:', error)
    console.log('🔄 [getSSLVWPurInqReqData] 폴백 테스트 데이터 사용')
    return {
      success: true,
      data: FALLBACK_TEST_DATA,
      isUsingFallback: true
    }
  }
}

export async function getSSLVWPurInqReqByRegNo(regNo: string): Promise<{
  success: boolean
  data?: SSLVWPurInqReq
  error?: string
  isUsingFallback?: boolean
}> {
  if (!regNo) {
    return {
      success: false,
      error: 'REG_NO는 필수입니다.'
    }
  }

  try {
    console.log(`[getSSLVWPurInqReqByRegNo] REG_NO=${regNo} 조회`)
    const result = await oracleKnex.raw(
      `
        SELECT *
        FROM SSLVW_PUR_INQ_REQ
        WHERE REG_NO = :regNo
      `,
      { regNo }
    )

    const rows = (result.rows || result) as Array<Record<string, unknown>>
    const cleanedResult = normalizeOracleRows(rows)

    if (cleanedResult.length === 0) {
      // 데이터가 없을 때 폴백 테스트 데이터에서 찾기
      console.log(`[getSSLVWPurInqReqByRegNo] 데이터 없음, 폴백 테스트 데이터에서 검색: REG_NO=${regNo}`)
      const fallbackData = FALLBACK_TEST_DATA.find(item => 
        String(item.REG_NO) === String(regNo)
      )
      
      if (fallbackData) {
        console.log(`[getSSLVWPurInqReqByRegNo] 폴백 테스트 데이터에서 찾음: REG_NO=${regNo}`)
        return {
          success: true,
          data: fallbackData,
          isUsingFallback: true
        }
      }
      
      return {
        success: false,
        error: '해당 REG_NO에 대한 데이터가 없습니다.'
      }
    }

    return {
      success: true,
      data: cleanedResult[0],
      isUsingFallback: false
    }
  } catch (error) {
    console.error('[getSSLVWPurInqReqByRegNo] 오류:', error)
    console.log(`[getSSLVWPurInqReqByRegNo] 폴백 테스트 데이터에서 검색: REG_NO=${regNo}`)
    
    // 오류 발생 시 폴백 테스트 데이터에서 찾기
    const fallbackData = FALLBACK_TEST_DATA.find(item => 
      String(item.REG_NO) === String(regNo)
    )
    
    if (fallbackData) {
      console.log(`[getSSLVWPurInqReqByRegNo] 폴백 테스트 데이터에서 찾음: REG_NO=${regNo}`)
      return {
        success: true,
        data: fallbackData,
        isUsingFallback: true
      }
    }
    
    return {
      success: false,
      error: error instanceof Error ? error.message : 'REG_NO 조회 중 오류가 발생했습니다.'
    }
  }
}