import { $t } from '@/locales'

export const BAS_STATION_AREA_REPORT_STYLE = {
  titleAlign: 'center',
  titleLevel: 'strong',
  orientation: 'portrait',
  density: 'compact',
  showSequence: true
}

function getStatusMeta(status, t = $t) {
  if (status === true || Number(status) === 1) {
    return { text: t('common.status.normal'), type: 'success', bool: true }
  }
  if (status === false || Number(status) === 0) {
    return { text: t('common.status.frozen'), type: 'danger', bool: false }
  }
  return { text: t('common.status.unknown'), type: 'info', bool: false }
}

function normalizeText(value) {
  return String(value ?? '').trim()
}

function normalizeNumber(value, fallback = void 0) {
  if (value === '' || value === null || value === undefined) {
    return fallback
  }
  const parsed = Number(value)
  return Number.isNaN(parsed) ? fallback : parsed
}

function normalizeBooleanText(value, t = $t) {
  if (value === 1 || value === '1' || value === true || value === t('common.status.yes')) {
    return t('common.status.yes')
  }
  if (value === 0 || value === '0' || value === false || value === t('common.status.no')) {
    return t('common.status.no')
  }
  return normalizeText(value) || t('common.placeholder.empty')
}

function normalizeIdArray(values = []) {
  if (Array.isArray(values)) {
    return values
      .map((item) => normalizeNumber(item, void 0))
      .filter((item) => item !== void 0 && item !== null)
  }

  if (typeof values === 'string' && values.trim()) {
    return values
      .split(',')
      .map((item) => normalizeNumber(item, void 0))
      .filter((item) => item !== void 0 && item !== null)
  }

  return []
}

function normalizeStringArray(values = []) {
  if (Array.isArray(values)) {
    return values.map((item) => normalizeText(item)).filter(Boolean)
  }

  if (typeof values === 'string' && values.trim()) {
    return values
      .split(',')
      .map((item) => normalizeText(item))
      .filter(Boolean)
  }

  return []
}

function buildJoinedText(values = [], resolver) {
  const labels = values
    .map((value) => {
      if (typeof resolver === 'function') {
        return normalizeText(resolver(value))
      }
      return normalizeText(value)
    })
    .filter(Boolean)

  return labels.length ? labels.join($t('common.listSeparator')) : $t('common.placeholder.empty')
}

export function createBasStationAreaSearchState() {
  return {
    condition: '',
    timeStart: '',
    timeEnd: '',
    stationAreaName: '',
    stationAreaId: '',
    type: '',
    inAble: '',
    outAble: '',
    useStatus: '',
    area: '',
    isCrossZone: '',
    crossZoneArea: '',
    isWcs: '',
    wcsData: '',
    containerType: '',
    barcode: '',
    autoTransfer: '',
    stationAlias: '',
    memo: '',
    status: ''
  }
}

export function createBasStationAreaFormState() {
  return {
    id: void 0,
    stationAreaName: '',
    stationAreaId: '',
    type: void 0,
    inAble: 0,
    outAble: 0,
    useStatus: '',
    area: void 0,
    isCrossZone: 0,
    crossZoneArea: [],
    isWcs: 0,
    wcsData: '',
    containerType: [],
    barcode: '',
    autoTransfer: 0,
    stationAlias: [],
    status: 1,
    memo: ''
  }
}

export function getBasStationAreaPaginationKey() {
  return {
    current: 'current',
    size: 'pageSize'
  }
}

export function getBasStationAreaReportTitle(t = $t) {
  return t('pages.basicInfo.basStationArea.reportTitle')
}

export function getBasStationAreaTypeOptions(t = $t) {
  return [
    { label: t('pages.basicInfo.basStationArea.type.smart'), value: 0 },
    { label: t('pages.basicInfo.basStationArea.type.normal'), value: 1 }
  ]
}

export function getBasStationAreaBinaryOptions(t = $t) {
  return [
    { label: t('common.status.no'), value: 0 },
    { label: t('common.status.yes'), value: 1 }
  ]
}

export function getBasStationAreaStatusOptions(t = $t) {
  return [
    { label: t('common.status.normal'), value: 1 },
    { label: t('common.status.frozen'), value: 0 }
  ]
}

export function resolveBasStationAreaWarehouseAreaOptions(records = []) {
  if (!Array.isArray(records)) {
    return []
  }

  return records
    .map((item) => {
      if (!item || typeof item !== 'object') {
        return null
      }
      const value = item.id ?? item.areaId ?? item.value
      if (value === void 0 || value === null || value === '') {
        return null
      }
      return {
        value: Number(value),
        label: normalizeText(item.name || item.areaName || item.code || item.areaCode || `${$t('menu.warehouseAreas')} ${value}`)
      }
    })
    .filter(Boolean)
}

export function resolveBasStationAreaStationOptions(records = []) {
  if (!Array.isArray(records)) {
    return []
  }

  return records
    .map((item) => {
      if (!item || typeof item !== 'object') {
        return null
      }
      const value = item.id ?? item.stationId ?? item.value
      if (value === void 0 || value === null || value === '') {
        return null
      }
      return {
        value: Number(value),
        label: normalizeText(item.stationName || item.stationId || item.name || `${$t('menu.basStation')} ${value}`)
      }
    })
    .filter(Boolean)
}

export function resolveBasStationAreaContainerTypeOptions(records = []) {
  if (!Array.isArray(records)) {
    return []
  }

  return records
    .map((item) => {
      if (!item || typeof item !== 'object') {
        return null
      }
      const value = item.value ?? item.id ?? item.dictValue
      if (value === void 0 || value === null || value === '') {
        return null
      }
      return {
        value: Number(value),
        label: normalizeText(item.label || item.name || item.dictLabel || item.value || '')
      }
    })
    .filter(Boolean)
}

export function resolveBasStationAreaUseStatusOptions(records = []) {
  if (!Array.isArray(records)) {
    return []
  }

  return records
    .map((item) => {
      if (!item || typeof item !== 'object') {
        return null
      }
      const value = item.value ?? item.id ?? item.dictValue
      if (value === void 0 || value === null || value === '') {
        return null
      }
      return {
        value: normalizeText(item.value ?? value),
        label: normalizeText(item.label || item.name || item.dictLabel || item.value || '')
      }
    })
    .filter(Boolean)
}

export function buildBasStationAreaSearchParams(params = {}) {
  const searchParams = {
    condition: normalizeText(params.condition),
    timeStart: normalizeText(params.timeStart),
    timeEnd: normalizeText(params.timeEnd),
    stationAreaName: normalizeText(params.stationAreaName),
    stationAreaId: normalizeText(params.stationAreaId),
    type:
      params.type !== undefined && params.type !== null && params.type !== ''
        ? Number(params.type)
        : void 0,
    inAble:
      params.inAble !== undefined && params.inAble !== null && params.inAble !== ''
        ? Number(params.inAble)
        : void 0,
    outAble:
      params.outAble !== undefined && params.outAble !== null && params.outAble !== ''
        ? Number(params.outAble)
        : void 0,
    useStatus: normalizeText(params.useStatus),
    area:
      params.area !== undefined && params.area !== null && params.area !== ''
        ? Number(params.area)
        : void 0,
    isCrossZone:
      params.isCrossZone !== undefined && params.isCrossZone !== null && params.isCrossZone !== ''
        ? Number(params.isCrossZone)
        : void 0,
    crossZoneArea: normalizeText(params.crossZoneArea),
    isWcs:
      params.isWcs !== undefined && params.isWcs !== null && params.isWcs !== ''
        ? Number(params.isWcs)
        : void 0,
    wcsData: normalizeText(params.wcsData),
    containerType: normalizeText(params.containerType),
    barcode: normalizeText(params.barcode),
    autoTransfer:
      params.autoTransfer !== undefined && params.autoTransfer !== null && params.autoTransfer !== ''
        ? Number(params.autoTransfer)
        : void 0,
    stationAlias: normalizeText(params.stationAlias),
    memo: normalizeText(params.memo),
    status:
      params.status !== undefined && params.status !== null && params.status !== ''
        ? Number(params.status)
        : void 0
  }

  return Object.fromEntries(
    Object.entries(searchParams).filter(([, value]) => value !== '' && value !== void 0 && value !== null)
  )
}

export function buildBasStationAreaPageQueryParams(params = {}) {
  return {
    current: params.current || 1,
    pageSize: params.pageSize || params.size || 20,
    ...buildBasStationAreaSearchParams(params)
  }
}

function normalizeIdValue(value) {
  if (value === '' || value === null || value === undefined) {
    return void 0
  }
  const numberValue = Number(value)
  return Number.isNaN(numberValue) ? void 0 : numberValue
}

function resolveOptionText(ids = [], resolver, fallback = []) {
  const fallbackList = normalizeStringArray(fallback)
  const resolvedList = normalizeIdArray(ids).map((id, index) => {
    if (typeof resolver === 'function') {
      const text = normalizeText(resolver(id))
      if (text) {
        return text
      }
    }
    return fallbackList[index] || normalizeText(id)
  })
  return buildJoinedText(resolvedList)
}

export function buildBasStationAreaSavePayload(formData = {}) {
  return {
    ...(formData.id !== void 0 && formData.id !== null && formData.id !== ''
      ? { id: Number(formData.id) }
      : {}),
    stationAreaName: normalizeText(formData.stationAreaName) || '',
    stationAreaId: normalizeText(formData.stationAreaId) || '',
    ...(formData.type !== void 0 && formData.type !== null && formData.type !== ''
      ? { type: Number(formData.type) }
      : {}),
    ...(formData.inAble !== void 0 && formData.inAble !== null && formData.inAble !== ''
      ? { inAble: Number(formData.inAble) }
      : {}),
    ...(formData.outAble !== void 0 && formData.outAble !== null && formData.outAble !== ''
      ? { outAble: Number(formData.outAble) }
      : {}),
    useStatus: normalizeText(formData.useStatus) || '',
    ...(formData.area !== void 0 && formData.area !== null && formData.area !== ''
      ? { area: Number(formData.area) }
      : {}),
    ...(formData.isCrossZone !== void 0 && formData.isCrossZone !== null && formData.isCrossZone !== ''
      ? { isCrossZone: Number(formData.isCrossZone) }
      : {}),
    ...(Array.isArray(formData.crossZoneArea) && formData.crossZoneArea.length
      ? { crossZoneArea: normalizeIdArray(formData.crossZoneArea) }
      : {}),
    ...(formData.isWcs !== void 0 && formData.isWcs !== null && formData.isWcs !== ''
      ? { isWcs: Number(formData.isWcs) }
      : {}),
    wcsData: normalizeText(formData.wcsData) || '',
    ...(Array.isArray(formData.containerType) && formData.containerType.length
      ? { containerType: normalizeIdArray(formData.containerType) }
      : {}),
    barcode: normalizeText(formData.barcode) || '',
    ...(formData.autoTransfer !== void 0 && formData.autoTransfer !== null && formData.autoTransfer !== ''
      ? { autoTransfer: Number(formData.autoTransfer) }
      : {}),
    ...(Array.isArray(formData.stationAlias) && formData.stationAlias.length
      ? { stationAlias: normalizeIdArray(formData.stationAlias).map((item) => String(item)) }
      : {}),
    status:
      formData.status !== void 0 && formData.status !== null && formData.status !== ''
        ? Number(formData.status)
        : 1,
    memo: normalizeText(formData.memo) || ''
  }
}

export function buildBasStationAreaDialogModel(record = {}, resolvers = {}) {
  return {
    ...createBasStationAreaFormState(),
    ...(record.id !== void 0 && record.id !== null && record.id !== '' ? { id: Number(record.id) } : {}),
    stationAreaName: normalizeText(record.stationAreaName || ''),
    stationAreaId: normalizeText(record.stationAreaId || ''),
    type: normalizeIdValue(record.type),
    inAble: record.inAble !== void 0 && record.inAble !== null ? Number(record.inAble) : 0,
    outAble: record.outAble !== void 0 && record.outAble !== null ? Number(record.outAble) : 0,
    useStatus: normalizeText(record.useStatus || ''),
    area: normalizeIdValue(record.area),
    isCrossZone: record.isCrossZone !== void 0 && record.isCrossZone !== null ? Number(record.isCrossZone) : 0,
    crossZoneArea: normalizeIdArray(record.crossZoneArea),
    isWcs: record.isWcs !== void 0 && record.isWcs !== null ? Number(record.isWcs) : 0,
    wcsData: normalizeText(record.wcsData || ''),
    containerType: normalizeIdArray(record.containerType ?? record.containerTypes),
    barcode: normalizeText(record.barcode || ''),
    autoTransfer: record.autoTransfer !== void 0 && record.autoTransfer !== null ? Number(record.autoTransfer) : 0,
    stationAlias: normalizeIdArray(record.stationAlias),
    status: record.status !== void 0 && record.status !== null ? Number(record.status) : 1,
    memo: normalizeText(record.memo || '')
  }
}

export function normalizeBasStationAreaDetailRecord(record = {}, resolvers = {}) {
  const t = resolvers.t || $t
  const statusMeta = getStatusMeta(record.statusBool ?? record.status, t)
  const typeValue = record.type$ ?? record.type
  const areaId = record.area ?? record.areaId ?? record.area$
  const crossZoneAreaIds = normalizeIdArray(record.crossZoneArea)
  const containerTypeIds = normalizeIdArray(record.containerType ?? record.containerTypes)
  const stationAliasIds = normalizeStringArray(record.stationAlias)
  const stationAliasNames = normalizeStringArray(record.stationAliasStaNo)

  return {
    ...record,
    id: normalizeIdValue(record.id),
    stationAreaName: normalizeText(record.stationAreaName) || t('common.placeholder.empty'),
    stationAreaId: normalizeText(record.stationAreaId) || t('common.placeholder.empty'),
    type: normalizeIdValue(record.type),
    typeText: normalizeText(
      record.type$ || record.typeText || resolvers.resolveTypeLabel?.(typeValue) || typeValue
    ) || t('common.placeholder.empty'),
    inAble: normalizeIdValue(record.inAble),
    inAbleText: normalizeBooleanText(record.inAble, t),
    outAble: normalizeIdValue(record.outAble),
    outAbleText: normalizeBooleanText(record.outAble, t),
    useStatus: normalizeText(record.useStatus),
    useStatusText:
      normalizeText(record.useStatus$ || record.useStatusText || resolvers.resolveUseStatusLabel?.(record.useStatus) || record.useStatus) ||
      t('common.placeholder.empty'),
    area: normalizeIdValue(areaId),
    areaText: normalizeText(record.area$ || record.areaText || resolvers.resolveAreaLabel?.(areaId) || '') || t('common.placeholder.empty'),
    isCrossZone: normalizeIdValue(record.isCrossZone),
    isCrossZoneText: normalizeBooleanText(record.isCrossZone, t),
    crossZoneArea: crossZoneAreaIds,
    crossZoneAreaText:
      resolveOptionText(crossZoneAreaIds, resolvers.resolveCrossZoneAreaLabel, record.crossZoneAreaText || []) ||
      t('common.placeholder.empty'),
    isWcs: normalizeIdValue(record.isWcs),
    isWcsText: normalizeBooleanText(record.isWcs, t),
    wcsData: normalizeText(record.wcsData) || t('common.placeholder.empty'),
    containerType: containerTypeIds,
    containerTypeText:
      resolveOptionText(containerTypeIds, resolvers.resolveContainerTypeLabel, record.containerTypesText || []) ||
      t('common.placeholder.empty'),
    barcode: normalizeText(record.barcode) || t('common.placeholder.empty'),
    autoTransfer: normalizeIdValue(record.autoTransfer),
    autoTransferText: normalizeBooleanText(record.autoTransfer, t),
    stationAlias: stationAliasIds,
    stationAliasText:
      resolveOptionText(
        stationAliasIds,
        resolvers.resolveStationAliasLabel,
        stationAliasNames.length ? stationAliasNames : record.stationAliasText || []
      ) || t('common.placeholder.empty'),
    status: normalizeIdValue(record.status),
    statusText: statusMeta.text,
    statusType: statusMeta.type,
    statusBool: record.statusBool !== void 0 ? Boolean(record.statusBool) : statusMeta.bool,
    memo: normalizeText(record.memo) || t('common.placeholder.empty'),
    createByText: normalizeText(record.createBy$ || record.createByText || '') || t('common.placeholder.empty'),
    createTimeText: normalizeText(record.createTime$ || record.createTime || '') || t('common.placeholder.empty'),
    updateByText: normalizeText(record.updateBy$ || record.updateByText || '') || t('common.placeholder.empty'),
    updateTimeText: normalizeText(record.updateTime$ || record.updateTime || '') || t('common.placeholder.empty')
  }
}

export function normalizeBasStationAreaListRow(record = {}, resolvers = {}) {
  return normalizeBasStationAreaDetailRecord(record, resolvers)
}

export function buildBasStationAreaPrintRows(records = [], resolvers = {}) {
  if (!Array.isArray(records)) {
    return []
  }
  return records.map((record) => normalizeBasStationAreaListRow(record, resolvers))
}

export function buildBasStationAreaReportMeta({
  previewMeta = {},
  count = 0,
  orientation = BAS_STATION_AREA_REPORT_STYLE.orientation,
  t = $t
} = {}) {
  return {
    reportTitle: getBasStationAreaReportTitle(t),
    reportDate: previewMeta.reportDate,
    printedAt: previewMeta.printedAt,
    operator: previewMeta.operator,
    count,
    reportStyle: {
      ...BAS_STATION_AREA_REPORT_STYLE,
      orientation
    }
  }
}