import type {
  CabinetOnlineStatus,
  CabinetPayload,
  CabinetStatus,
  CabinetTestStatus,
  DeviceCabinetRecord,
} from '@/stores/deviceCabinets'
import { request, type ApiResponse } from './request'

export interface DeviceCabinetListParams {
  pageNum: number
  pageSize: number
  device?: string
  beginCreateTime?: string
  endCreateTime?: string
  onlineStatus?: string
  testStatus?: string
  status?: string
}

interface DetectionCabinetDto {
  cabinetId: number
  cabinetCode: string | null
  cabinetName: string | null
  ipAddress: string | null
  macAddress: string | null
  manufacturer: string | null
  model: string | null
  capacity: number | string | null
  channelCount: number | null
  onlineStatus: string | null
  testStatus: string | null
  currentTest: string | null
  status: string | null
  remark: string | null
  createTime: string | null
}

interface DetectionCabinetListResponse extends ApiResponse {
  total: number
  rows: DetectionCabinetDto[]
}

interface DetectionCabinetDetailResponse extends ApiResponse {
  data: DetectionCabinetDto
}

interface DetectionCabinetPayload {
  cabinetId?: number
  cabinetCode: string
  cabinetName: string
  ipAddress: string
  macAddress: string
  manufacturer: string
  model: string
  capacity: number
  channelCount: number
  onlineStatus: string
  testStatus: string
  currentTest: string
  status: string
  remark: string
}

export interface DeviceCabinetListResult {
  total: number
  rows: DeviceCabinetRecord[]
}

export interface DiscoveredCabinet {
  deviceCode: string
  ip: string
  mac: string
  onlineStatus: CabinetOnlineStatus
  testStatus: CabinetTestStatus
  currentTest: string
}

export interface DiscoveredCabinetListResult {
  total: number
  rows: DiscoveredCabinet[]
}

interface DiscoveredCabinetListResponse extends ApiResponse {
  total: number
  rows: DiscoveredCabinet[]
}

const onlineStatusMap: Record<string, CabinetOnlineStatus> = { '0': '在线', '1': '离线' }
const testStatusMap: Record<string, CabinetTestStatus> = { '0': '空闲', '1': '测试中' }
const statusMap: Record<string, CabinetStatus> = { '0': '启用', '1': '禁用' }

function mapCabinet(item: DetectionCabinetDto): DeviceCabinetRecord {
  return {
    id: item.cabinetId,
    deviceCode: item.cabinetCode || '-',
    ip: item.ipAddress || '-',
    mac: item.macAddress || '-',
    name: item.cabinetName || '-',
    manufacturer: item.manufacturer || '-',
    model: item.model || '-',
    channelCount: item.channelCount ?? 0,
    specs: Number(item.capacity) || 0,
    remark: item.remark || '',
    onlineStatus: onlineStatusMap[item.onlineStatus || ''] || '离线',
    testStatus: testStatusMap[item.testStatus || ''] || '空闲',
    currentTest: item.currentTest || '',
    status: statusMap[item.status || ''] || '禁用',
    createdAt: item.createTime || '',
  }
}

function mapPayload(payload: CabinetPayload, cabinetId?: number): DetectionCabinetPayload {
  return {
    ...(cabinetId === undefined ? {} : { cabinetId }),
    cabinetCode: payload.deviceCode,
    cabinetName: payload.name,
    ipAddress: payload.ip,
    macAddress: payload.mac,
    manufacturer: payload.manufacturer,
    model: payload.model,
    capacity: payload.specs,
    channelCount: payload.channelCount,
    onlineStatus: payload.onlineStatus === '在线' ? '0' : '1',
    testStatus: payload.testStatus === '测试中' ? '1' : '0',
    currentTest: payload.currentTest,
    status: payload.status === '启用' ? '0' : '1',
    remark: payload.remark,
  }
}

export async function getDeviceCabinetList(params: DeviceCabinetListParams): Promise<DeviceCabinetListResult> {
  const searchParams = new URLSearchParams()
  Object.entries(params).forEach(([key, value]) => {
    if (value !== undefined && value !== '') searchParams.set(key, String(value))
  })

  const result = await request<DetectionCabinetListResponse>(`/system/detectionCabinet/list?${searchParams.toString()}`)
  return {
    total: Number(result.total) || 0,
    rows: (result.rows || []).map(mapCabinet),
  }
}

export async function getDiscoveredCabinetList(pageNum: number, pageSize: number): Promise<DiscoveredCabinetListResult> {
  const result = await request<DiscoveredCabinetListResponse>(
    `/system/detectionCabinet/discovered/list?pageNum=${pageNum}&pageSize=${pageSize}`,
  )
  return {
    total: Number(result.total) || 0,
    rows: result.rows || [],
  }
}

export async function getDeviceCabinetDetail(cabinetId: number): Promise<DeviceCabinetRecord> {
  const result = await request<DetectionCabinetDetailResponse>(`/system/detectionCabinet/${cabinetId}`)
  return mapCabinet(result.data)
}

export async function createDeviceCabinet(payload: CabinetPayload): Promise<void> {
  await request<ApiResponse>('/system/detectionCabinet', {
    method: 'POST',
    body: JSON.stringify(mapPayload(payload)),
  })
}

export async function updateDeviceCabinet(cabinetId: number, payload: CabinetPayload): Promise<void> {
  await request<ApiResponse>('/system/detectionCabinet', {
    method: 'PUT',
    body: JSON.stringify(mapPayload(payload, cabinetId)),
  })
}

export async function changeDeviceCabinetStatus(cabinetId: number, status: CabinetStatus): Promise<void> {
  await request<ApiResponse>('/system/detectionCabinet/changeStatus', {
    method: 'PUT',
    body: JSON.stringify({
      cabinetId,
      status: status === '启用' ? '0' : '1',
    }),
  })
}

export async function deleteDeviceCabinets(cabinetIds: number | number[]): Promise<void> {
  const ids = Array.isArray(cabinetIds) ? cabinetIds : [cabinetIds]
  await request<ApiResponse>(`/system/detectionCabinet/${ids.join(',')}`, {
    method: 'DELETE',
  })
}