import { contractDetail } from '@/api/index.js'

const contractNameCache = Object.create(null)
const contractDetailCache = Object.create(null)

function pickFirstText(...values) {
  for (let index = 0; index < values.length; index += 1) {
    const value = values[index]
    if (value === undefined || value === null) continue
    const text = String(value).trim()
    if (text) return text
  }
  return ''
}

function parseContractDetailResponse(response) {
  const payload = response && response.data ? response.data : response
  if (payload && payload.data && typeof payload.data === 'object' && !Array.isArray(payload.data)) {
    return payload.data
  }
  if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
    return payload
  }
  return {}
}

function resolveContractNameFromSource(source = {}) {
  return pickFirstText(
    source.contractDisplayName,
    source.contractName,
    source.contractTemplateName,
    source.contractTypeName,
    source.contractType,
    source.type,
    source.typeName,
    source.templateName,
    source.title
  )
}

function resolveContractNo(source = {}) {
  return pickFirstText(source.no, source.contractNo)
}

export function getContractDisplayName(source = {}, fallbackText = '') {
  const directName = resolveContractNameFromSource(source)
  if (directName) return directName

  const contractNo = resolveContractNo(source)
  if (contractNo && contractNameCache[contractNo]) return contractNameCache[contractNo]

  return fallbackText || ''
}

export async function fetchContractDisplayInfo(contractNo = '', language) {
  const normalizedContractNo = String(contractNo || '').trim()
  if (!normalizedContractNo) {
    return {
      contractDisplayName: '',
      detail: {}
    }
  }

  if (contractDetailCache[normalizedContractNo]) {
    const cachedDetail = contractDetailCache[normalizedContractNo]
    return {
      contractDisplayName: resolveContractNameFromSource(cachedDetail) || contractNameCache[normalizedContractNo] || '',
      detail: cachedDetail
    }
  }

  const response = await contractDetail({ contractNo: normalizedContractNo }, language)
  const detail = parseContractDetailResponse(response)
  const contractDisplayName = resolveContractNameFromSource(detail)

  contractDetailCache[normalizedContractNo] = detail
  contractNameCache[normalizedContractNo] = contractDisplayName

  return {
    contractDisplayName,
    detail
  }
}

export async function enrichContractDisplayNames(list = [], language) {
  const sourceList = Array.isArray(list) ? list : []
  const pendingNos = [...new Set(
    sourceList
      .filter(item => !resolveContractNameFromSource(item))
      .map(item => resolveContractNo(item))
      .filter(Boolean)
  )]

  await Promise.all(
    pendingNos.map((contractNo) =>
      fetchContractDisplayInfo(contractNo, language).catch(() => ({
        contractDisplayName: '',
        detail: {}
      }))
    )
  )

  return sourceList.map((item) => {
    const contractNo = resolveContractNo(item)
    return {
      ...item,
      contractDisplayName: getContractDisplayName(item, '')
        || (contractNo ? contractNameCache[contractNo] : '')
        || ''
    }
  })
}