import { getEnums } from '@/api/index.js'
import { getCurrentLanguage } from '@/utils/i18n'

const ENUMS_CACHE_KEY = 'mini_enums_cache_v1'

let enumsMap = {}
let enumsLanguage = ''
let fetchPromise = null

function normalizeEnumMap(data) {
  const map = {}
  if (Array.isArray(data)) {
    data.forEach((item) => {
      if (item && item.code) {
        map[item.code] = Array.isArray(item.data) ? item.data : []
      }
    })
  }
  return map
}

function getNormalizedLanguage(language = '') {
  return String(language || getCurrentLanguage() || 'zh').trim().toLowerCase() === 'en' ? 'en' : 'zh'
}

function readEnumsCache(language) {
  const cacheLanguage = getNormalizedLanguage(language)
  try {
    const cached = uni.getStorageSync(ENUMS_CACHE_KEY)
    if (!cached) return {}
    const resolveLanguageBucket = (payload) => {
      if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
        return {}
      }
      if (payload.en || payload.zh) {
        const bucket = payload[cacheLanguage]
        return bucket && typeof bucket === 'object' ? bucket : {}
      }
      return payload
    }
    if (typeof cached === 'string') {
      const parsed = JSON.parse(cached)
      return resolveLanguageBucket(parsed)
    }
    return resolveLanguageBucket(cached)
  } catch (error) {
    console.error('Failed to read enums cache', error)
    return {}
  }
}

function writeEnumsCache(map, language) {
  const cacheLanguage = getNormalizedLanguage(language)
  try {
    const cached = uni.getStorageSync(ENUMS_CACHE_KEY)
    let nextCache = {}
    if (cached && typeof cached === 'object' && !Array.isArray(cached)) {
      nextCache = { ...cached }
    } else if (typeof cached === 'string') {
      try {
        const parsed = JSON.parse(cached)
        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
          nextCache = { ...parsed }
        }
      } catch (error) {
        nextCache = {}
      }
    }
    nextCache[cacheLanguage] = map
    uni.setStorageSync(ENUMS_CACHE_KEY, nextCache)
  } catch (error) {
    console.error('Failed to write enums cache', error)
  }
}

export function initEnumsFromCache(language) {
  const currentLanguage = getNormalizedLanguage(language)
  if (Object.keys(enumsMap).length && enumsLanguage === currentLanguage) return enumsMap
  enumsMap = readEnumsCache(currentLanguage)
  enumsLanguage = currentLanguage
  return enumsMap
}

export async function fetchEnums(force = false, language) {
  const currentLanguage = getNormalizedLanguage(language)
  if (!force && Object.keys(enumsMap).length && enumsLanguage === currentLanguage) return enumsMap
  if (fetchPromise) return fetchPromise

  fetchPromise = (async () => {
    if (!force && (!Object.keys(enumsMap).length || enumsLanguage !== currentLanguage)) {
      initEnumsFromCache(currentLanguage)
      if (Object.keys(enumsMap).length) return enumsMap
    }

    try {
      const res = await getEnums({}, currentLanguage)
      const data = res && res.data ? res.data : res
      const map = normalizeEnumMap(data)
      if (Object.keys(map).length) {
        enumsMap = map
        enumsLanguage = currentLanguage
        writeEnumsCache(map, currentLanguage)
      }
      return enumsMap
    } catch (error) {
      console.error('Failed to fetch enums', error)
      return enumsMap
    } finally {
      fetchPromise = null
    }
  })()

  return fetchPromise
}

export function getEnumOptions(code, language) {
  initEnumsFromCache(language)
  return enumsMap[code] || []
}

export function getEnumLabel(code, key, fallback = '', language) {
  const options = getEnumOptions(code, language)
  const matched = options.find(item => String(item.key) === String(key))
  if (matched) return matched.value
  return fallback || key
}

export function getApprovalStatusLabel(status, fallback = '', language) {
  return getEnumLabel('ApprovalStatusEnum', status, fallback, language)
}

export function getGenderLabel(gender, fallback = '', language) {
  return getEnumLabel('GenderEnum', gender, fallback, language)
}

export const ACCOUNT_BILL_STATUS = {
  ACTIVE: 10,
  FINISHED: 99
}

export const ACCOUNT_BILL_PAYMENT_STATUS = {
  UNPAID: 0,
  PARTIAL: 1,
  PAID: 2
}

export const ACCOUNT_BILL_REFUND_STATUS = {
  NONE: 0,
  PARTIAL: 10,
  REFUNDED: 99
}

export function getAccountBillStatusLabel(status, fallback = '', language) {
  return getEnumLabel('AccountBillStatusEnum', status, fallback, language)
}

export function getAccountBillPaymentStatusLabel(status, fallback = '', language) {
  return getEnumLabel('AccountBillPaymentStatusEnum', status, fallback, language)
}

export function getAccountBillRefundStatusLabel(status, fallback = '', language) {
  return getEnumLabel('AccountBillRefundStatusEnum', status, fallback, language)
}

export function getAccountReferenceTypeLabel(type, fallback = '', language) {
  return getEnumLabel('AccountReferenceTypeEnum', type, fallback, language)
}