import { z } from 'zod'
import {
  DEVICE_STATUS,
  type DeviceStatus,
  EVENT_SEVERITY,
  fromMysqlBoolean,
  POWER_STATUS,
  type PowerStatus,
  SOH_THRESHOLDS,
} from './battery.constants'

export {
  BATTERY_LIST_SORT,
  BATTERY_LIST_SORT_VALUES,
  type BatteryListSort,
  DEVICE_STATUS,
  type DeviceStatus,
  EVENT_SEVERITY,
  type EventSeverity,
  fromMysqlBoolean,
  MYSQL_BOOLEAN,
  POWER_STATUS,
  POWER_STATUS_VALUES,
  type PowerStatus,
  SOH_THRESHOLDS,
  toMysqlBoolean,
} from './battery.constants'

export const powerStatusSchema = z.union([
  z.literal(POWER_STATUS.NOT_CHARGING),
  z.literal(POWER_STATUS.CHARGING),
  z.literal(POWER_STATUS.FULL),
])

export const deviceStatusSchema = z.union([
  z.literal(DEVICE_STATUS.HEALTHY),
  z.literal(DEVICE_STATUS.WATCH),
  z.literal(DEVICE_STATUS.WARNING),
])

export const batteryInfoSchema = z.object({
  id: z.number().int(),
  userId: z.number().int(),
  mac: z.string(),
  devModel: z.string(),
  devName: z.string(),
  isLowPower: z.boolean(),
  powerStatus: powerStatusSchema,
  power: z.number().int().min(0).max(100),
  createTime: z.string(),
  remark: z.string().nullable(),
})
export type BatteryInfo = z.infer<typeof batteryInfoSchema>

export const fleetUnitSchema = z.object({
  id: z.string(),
  displayName: z.string(),
  batch: z.string(),
  firmware: z.string(),
  cycles: z.number().int(),
  soh: z.number().nullable(),
  sohSource: z.union([z.literal('prediction'), z.literal('unavailable')]),
  soh30d: z.number().nullable(),
  soh60d: z.number().nullable(),
  soh90d: z.number().nullable(),
  temperature: z.number(),
  riskScore: z.number().int(),
  chargeEfficiency: z.number(),
  status: deviceStatusSchema,
  riskFactors: z.array(z.string()),
})
export type FleetUnit = z.infer<typeof fleetUnitSchema>

export const sohPointSchema = z.object({ month: z.string(), value: z.number() })
export const sohResponseSchema = z.object({
  history: z.array(sohPointSchema),
  forecast: z.array(sohPointSchema),
})

export const eventItemSchema = z.object({
  time: z.string(),
  title: z.string(),
  detail: z.string(),
  severity: z.union([z.literal(EVENT_SEVERITY.HIGH), z.literal(EVENT_SEVERITY.MEDIUM), z.literal(EVENT_SEVERITY.LOW)]),
})

export const strategyItemSchema = z.object({
  name: z.string(),
  impact: z.string(),
  scope: z.string(),
  eta: z.string(),
})

export const summaryResponseSchema = z.object({
  totalDevices: z.number().int(),
  avgSoh: z.number().nullable(),
  avgSoh30d: z.number().nullable(),
  avgSoh90d: z.number().nullable(),
  warningCount: z.number().int(),
  watchCount: z.number().int(),
  healthyCount: z.number().int(),
  batchPerformance: z.array(z.object({ batch: z.string(), avgSoh: z.number().nullable() })),
  riskFactorCounts: z.array(z.object({ factor: z.string(), count: z.number().int() })),
  firmwareHealth: z.array(z.object({ firmware: z.string(), avgSoh: z.number().nullable(), count: z.number().int() })),
  updatedAt: z.string(),
  executiveSummary: z.string(),
})

export const dashboardSnapshotSchema = z.object({
  devices: z.array(fleetUnitSchema),
  soh: sohResponseSchema,
  events: z.array(eventItemSchema),
  strategies: z.array(strategyItemSchema),
  summary: summaryResponseSchema,
})
export type DashboardSnapshot = z.infer<typeof dashboardSnapshotSchema>

export const batteriesResponseSchema = z.object({
  updatedAt: z.string(),
  total: z.number().int(),
  lowPower: z.number().int(),
  charging: z.number().int(),
  items: z.array(batteryInfoSchema),
  nextCursor: z.string().nullable(),
})
export type BatteriesResponse = z.infer<typeof batteriesResponseSchema>

export type BatteriesPageSummary = {
  total?: number
  lowPower?: number
  charging?: number
}

export type BatteryPrediction = {
  mac: string
  nowSoh: number
  monthSoh: number
  trmonthSoh: number
  riskScore: number | null
  riskLevel: string | null
  status: string | null
  modelName: string | null
  cyclesUsed: number | null
  updatedAt: string | null
}

const round1 = (value: number) => Math.round(value * 10) / 10

const clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value))

const pad2 = (value: number) => value.toString().padStart(2, '0')

const formatDateTime = (date: Date) =>
  `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`

export function getDeviceStatus(soh: number): DeviceStatus {
  if (soh <= SOH_THRESHOLDS.WARNING) return DEVICE_STATUS.WARNING
  if (soh <= SOH_THRESHOLDS.WATCH) return DEVICE_STATUS.WATCH
  return DEVICE_STATUS.HEALTHY
}

function getDeviceStatusByRisk(prediction: BatteryPrediction): DeviceStatus {
  const riskText = `${prediction.riskLevel ?? ''} ${prediction.status ?? ''}`.toLowerCase()

  if (
    riskText.includes('high') ||
    riskText.includes('danger') ||
    riskText.includes('危险') ||
    riskText.includes('高')
  ) {
    return DEVICE_STATUS.WARNING
  }
  if (
    riskText.includes('medium') ||
    riskText.includes('warning') ||
    riskText.includes('关注') ||
    riskText.includes('中')
  ) {
    return DEVICE_STATUS.WATCH
  }

  if (prediction.riskScore !== null) {
    if (prediction.riskScore >= SOH_THRESHOLDS.HIGH_RISK_SCORE) return DEVICE_STATUS.WARNING
    if (prediction.riskScore >= SOH_THRESHOLDS.WATCH_RISK_SCORE) return DEVICE_STATUS.WATCH
  }

  return getDeviceStatus(prediction.nowSoh)
}

export function normalizePowerStatus(value: number): PowerStatus {
  if (value === POWER_STATUS.CHARGING || value === POWER_STATUS.FULL) return value
  return POWER_STATUS.NOT_CHARGING
}

export function normalizeLowPower(value: string | boolean): boolean {
  return fromMysqlBoolean(value)
}

export type BatteryInfoSourceRow = {
  id: number
  userId: number
  mac: string
  devModel: string
  devName: string
  isLowPower: string | boolean
  powerStatus: number
  power: number
  createTime: Date | string
  remark: string | null
}

export function toBatteryInfo(row: BatteryInfoSourceRow): BatteryInfo {
  return {
    id: row.id,
    userId: row.userId,
    mac: row.mac,
    devModel: row.devModel,
    devName: row.devName,
    isLowPower: normalizeLowPower(row.isLowPower),
    powerStatus: normalizePowerStatus(row.powerStatus),
    power: row.power,
    createTime: row.createTime instanceof Date ? row.createTime.toISOString() : String(row.createTime),
    remark: row.remark,
  }
}

export function createBatteriesResponse(
  items: BatteryInfo[],
  now = new Date(),
  summary: BatteriesPageSummary = {},
  nextCursor: string | null = null,
): BatteriesResponse {
  return {
    updatedAt: now.toISOString(),
    total: summary.total ?? items.length,
    lowPower: summary.lowPower ?? items.filter((item) => item.isLowPower).length,
    charging: summary.charging ?? items.filter((item) => item.powerStatus === POWER_STATUS.CHARGING).length,
    items,
    nextCursor,
  }
}

function toFleetUnit(item: BatteryInfo, prediction?: BatteryPrediction): FleetUnit {
  const hasPrediction = Boolean(prediction)
  const soh = prediction ? round1(clamp(prediction.nowSoh, 0, 100)) : null
  const status = prediction
    ? getDeviceStatusByRisk(prediction)
    : item.isLowPower || item.power <= SOH_THRESHOLDS.LOW_POWER
      ? DEVICE_STATUS.WATCH
      : DEVICE_STATUS.HEALTHY
  const riskFactors: string[] = []

  if (item.isLowPower || item.power <= SOH_THRESHOLDS.LOW_POWER) riskFactors.push('低电量')
  if (item.powerStatus === POWER_STATUS.CHARGING) riskFactors.push('充电中')
  if (!hasPrediction) riskFactors.push('健康预测不可用')
  if (prediction && status === DEVICE_STATUS.WARNING) riskFactors.push('衰减加速')
  if (item.remark?.includes('v3.7')) riskFactors.push('旧固件')
  if (prediction?.riskLevel) riskFactors.push(`预测风险:${prediction.riskLevel}`)

  const soh30d = prediction ? round1(clamp(prediction.monthSoh, 0, 100)) : null
  const soh90d = prediction ? round1(clamp(prediction.trmonthSoh, 0, 100)) : null
  const soh60d = null
  const temperature = 0
  const chargeEfficiency = 0
  const fallbackRiskScore =
    (item.isLowPower || item.power <= SOH_THRESHOLDS.LOW_POWER ? 60 : 0) +
    (item.powerStatus === POWER_STATUS.CHARGING ? 20 : 0)
  const riskScore = Math.round(clamp(prediction?.riskScore ?? fallbackRiskScore, 0, 100))

  return {
    id: item.mac,
    displayName: item.devName || item.mac,
    batch: item.devModel,
    firmware: item.remark ?? '未提供',
    cycles: prediction?.cyclesUsed ?? 0,
    soh,
    sohSource: prediction ? 'prediction' : 'unavailable',
    soh30d,
    soh60d,
    soh90d,
    temperature,
    riskScore,
    chargeEfficiency,
    status,
    riskFactors,
  }
}

function createSohResponse(devices: FleetUnit[]) {
  const predictedDevices = devices.filter((unit) => unit.soh !== null)
  if (predictedDevices.length === 0) return { history: [], forecast: [] }

  const avgNow = averageNullable(predictedDevices.map((unit) => unit.soh))
  const avgMonth = averageNullable(predictedDevices.map((unit) => unit.soh30d))
  const avgTrmonth = averageNullable(predictedDevices.map((unit) => unit.soh90d))

  const forecast = [
    avgNow === null ? null : { month: '当前', value: round1(clamp(avgNow, 0, 100)) },
    avgMonth === null ? null : { month: '30天', value: round1(clamp(avgMonth, 0, 100)) },
    avgTrmonth === null ? null : { month: '90天', value: round1(clamp(avgTrmonth, 0, 100)) },
  ].filter((point): point is { month: string; value: number } => point !== null)

  return {
    history: [],
    forecast,
  }
}

function summarizeBy<T extends string>(items: FleetUnit[], getKey: (item: FleetUnit) => T) {
  return Object.entries(
    items.reduce<Record<string, { sum: number; valueCount: number; count: number }>>((acc, item) => {
      const key = getKey(item)
      const entry = acc[key] ?? { sum: 0, valueCount: 0, count: 0 }
      if (item.soh !== null) {
        entry.sum += item.soh
        entry.valueCount += 1
      }
      entry.count += 1
      acc[key] = entry
      return acc
    }, {}),
  )
}

function averageNullable(values: Array<number | null>) {
  const available = values.filter((value) => value !== null)

  if (available.length === 0) return null
  return available.reduce((sum, value) => sum + value, 0) / available.length
}

function createSummary(devices: FleetUnit[], now: Date) {
  const totalDevices = devices.length

  if (totalDevices === 0) {
    return {
      totalDevices,
      avgSoh: null,
      avgSoh30d: null,
      avgSoh90d: null,
      warningCount: 0,
      watchCount: 0,
      healthyCount: 0,
      batchPerformance: [],
      riskFactorCounts: [],
      firmwareHealth: [],
      updatedAt: formatDateTime(now),
      executiveSummary: '当前没有可用于电池健康分析的真实设备记录。',
    }
  }

  const avgSoh = averageNullable(devices.map((unit) => unit.soh))
  const avgSoh30d = averageNullable(devices.map((unit) => unit.soh30d))
  const avgSoh90d = averageNullable(devices.map((unit) => unit.soh90d))
  const warningCount = devices.filter((unit) => unit.status === DEVICE_STATUS.WARNING).length
  const watchCount = devices.filter((unit) => unit.status === DEVICE_STATUS.WATCH).length
  const healthyCount = devices.filter((unit) => unit.status === DEVICE_STATUS.HEALTHY).length
  const batchPerformance = summarizeBy(devices, (unit) => unit.batch)
    .map(([batch, data]) => ({ batch, avgSoh: data.valueCount > 0 ? round1(data.sum / data.valueCount) : null }))
    .sort((a, b) => (b.avgSoh ?? -1) - (a.avgSoh ?? -1))
  const firmwareHealth = summarizeBy(devices, (unit) => unit.firmware)
    .map(([firmware, data]) => ({
      firmware,
      avgSoh: data.valueCount > 0 ? round1(data.sum / data.valueCount) : null,
      count: data.count,
    }))
    .sort((a, b) => (b.avgSoh ?? -1) - (a.avgSoh ?? -1))
  const riskFactorCounts = Object.entries(
    devices.reduce<Record<string, number>>((acc, unit) => {
      for (const factor of unit.riskFactors) {
        acc[factor] = (acc[factor] ?? 0) + 1
      }
      return acc
    }, {}),
  )
    .map(([factor, count]) => ({ factor, count }))
    .sort((a, b) => b.count - a.count)
  const weakestModel = batchPerformance.at(-1)?.batch ?? '当前设备型号'
  const weakestRemark = firmwareHealth.at(-1)?.firmware ?? '未提供备注'
  const predictedDevices = devices.filter((unit) => unit.soh !== null).length
  const missingPredictionDevices = totalDevices - predictedDevices

  return {
    totalDevices,
    avgSoh: avgSoh === null ? null : round1(avgSoh),
    avgSoh30d: avgSoh30d === null ? null : round1(avgSoh30d),
    avgSoh90d: avgSoh90d === null ? null : round1(avgSoh90d),
    warningCount,
    watchCount,
    healthyCount,
    batchPerformance,
    riskFactorCounts,
    firmwareHealth,
    updatedAt: formatDateTime(now),
    executiveSummary:
      avgSoh === null
        ? '当前健康预测暂不可用，系统仍会展示设备电量、充电状态与低电量风险。请稍后复查或联系管理员。'
        : `当前共有 ${predictedDevices} 台设备具备健康预测，${missingPredictionDevices} 台设备暂无预测结果。建议重点关注 ${weakestModel} 型号与 ${weakestRemark} 备注设备，优先处理低电量和充电中的设备，并在下次同步后复查未来 30/90 天健康趋势。`,
  }
}

function createEvents(devices: FleetUnit[], now: Date) {
  if (devices.length === 0) return []

  const predictedDevices = devices.filter((unit) => unit.soh !== null)
  const warningDevices = devices.filter((unit) => unit.status === DEVICE_STATUS.WARNING)
  const missingPredictionDevices = devices.length - predictedDevices.length

  return [
    {
      time: formatDateTime(now),
      title: '风险快照',
      detail: `本次概览包含 ${devices.length} 台设备，其中 ${predictedDevices.length} 台具备健康预测，${warningDevices.length} 台处于预警状态。`,
      severity: warningDevices.length > 0 ? EVENT_SEVERITY.HIGH : EVENT_SEVERITY.LOW,
    },
    {
      time: formatDateTime(now),
      title: '预测可用性快照',
      detail:
        missingPredictionDevices > 0
          ? `当前有 ${missingPredictionDevices} 台设备暂无健康预测，相关趋势将暂不展示。`
          : '当前所有设备均已具备健康预测，可继续观察趋势变化。',
      severity: missingPredictionDevices > 0 ? EVENT_SEVERITY.MEDIUM : EVENT_SEVERITY.LOW,
    },
  ] satisfies DashboardSnapshot['events']
}

function createStrategies(devices: FleetUnit[]) {
  if (devices.length === 0) return []

  const warningDevices = devices.filter((unit) => unit.status === DEVICE_STATUS.WARNING)
  const powerAttentionDevices = devices.filter(
    (unit) => unit.riskFactors.includes('充电中') || unit.riskFactors.includes('低电量'),
  )
  const missingPredictionDevices = devices.filter((unit) => unit.soh === null)

  return [
    {
      name: '优先处理预警设备',
      impact: `当前有 ${warningDevices.length} 台设备处于预警状态，建议先复核供电、连接与预测结果。`,
      scope: warningDevices.length > 0 ? `${warningDevices.length} 台预警设备` : '当前设备',
      eta: '本次巡检周期内',
    },
    {
      name: '提升预测覆盖',
      impact:
        missingPredictionDevices.length > 0
          ? `当前有 ${missingPredictionDevices.length} 台设备暂无健康预测，建议在下次同步后复查。`
          : `当前已有 ${devices.length} 台设备具备预测结果，可继续观察健康变化。`,
      scope:
        powerAttentionDevices.length > 0
          ? `${powerAttentionDevices.length} 台充电中或低电量设备`
          : missingPredictionDevices.length > 0
            ? `${missingPredictionDevices.length} 台缺失预测设备`
            : '当前设备',
      eta: '下次同步后复查',
    },
  ] satisfies DashboardSnapshot['strategies']
}

export function createDashboardSnapshot(
  items: BatteryInfo[],
  now = new Date(),
  predictions: ReadonlyMap<string, BatteryPrediction> = new Map(),
): DashboardSnapshot {
  const devices = items.map((item) => toFleetUnit(item, predictions.get(item.mac)))

  return {
    devices,
    soh: createSohResponse(devices),
    events: createEvents(devices, now),
    strategies: createStrategies(devices),
    summary: createSummary(devices, now),
  }
}