import type {
  CollectorOnlineStatus,
  CollectorStatus,
  DeviceCollectorRecord,
} from '@/stores/deviceCollectors'
import { request, type ApiResponse } from './request'
import { formatBusinessTime } from '@/utils/businessTime'
import type { DeviceRelatedTest } from '@/stores/deviceRelatedTests'

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

interface CollectorDto {
  collectorId: number
  adapterId: number | null
  collectorCode: string | null
  collectorName: string | null
  ipAddress: string | null
  macAddress: string | null
  manufacturer: string | null
  model: string | null
  channelCount: number | null
  onlineStatus: string | null
  relatedTests: DeviceRelatedTest[]
  status: string | null
  remark: string | null
  createTime: number | null
}

interface CollectorListResponse extends ApiResponse {
  total: number
  rows: CollectorDto[]
}

interface CollectorDetailResponse extends ApiResponse {
  data: CollectorDto
}

export interface DeviceCollectorInput {
  adapterId: number | null
  deviceCode: string
  ip: string
  mac: string
  name: string
  manufacturer: string
  model: string
  channelCount: number
  status: CollectorStatus
  remark: string
}

interface CollectorSaveDto {
  collectorId?: number
  adapterId: number | null
  collectorCode: string
  ipAddress: string
  macAddress: string
  collectorName: string
  manufacturer: string
  model: string
  channelCount: number
  status: string
  remark: string
}

export interface DeviceCollectorListResult {
  total: number
  rows: DeviceCollectorRecord[]
}

const onlineStatusMap: Record<string, CollectorOnlineStatus> = { '0': '离线', '1': '在线' }
const statusMap: Record<string, CollectorStatus> = { '0': '启用', '1': '禁用' }

function mapCollector(item: CollectorDto): DeviceCollectorRecord {
  return {
    id: item.collectorId,
    adapterId: item.adapterId ?? null,
    deviceCode: item.collectorCode || '-',
    ip: item.ipAddress || '-',
    mac: item.macAddress || '-',
    name: item.collectorName || '-',
    manufacturer: item.manufacturer || '',
    model: item.model || '',
    channelCount: item.channelCount ?? 0,
    remark: item.remark || '',
    onlineStatus: onlineStatusMap[item.onlineStatus || ''] || '离线',
    relatedTests: item.relatedTests || [],
    status: statusMap[item.status || ''] || '禁用',
    createdAt: formatBusinessTime(item.createTime),
  }
}

function toSaveDto(input: DeviceCollectorInput, collectorId?: number): CollectorSaveDto {
  return {
    collectorId,
    adapterId: input.adapterId,
    collectorCode: input.deviceCode.trim(),
    ipAddress: input.ip.trim(),
    macAddress: input.mac.trim(),
    collectorName: input.name.trim(),
    manufacturer: input.manufacturer.trim(),
    model: input.model.trim(),
    channelCount: input.channelCount,
    status: input.status === '启用' ? '0' : '1',
    remark: input.remark.trim(),
  }
}

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

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

export async function getDeviceCollector(collectorId: number): Promise<DeviceCollectorRecord> {
  const result = await request<CollectorDetailResponse>(`/system/collector/${collectorId}`)
  return mapCollector(result.data)
}

export function createDeviceCollector(input: DeviceCollectorInput): Promise<ApiResponse> {
  return request<ApiResponse>('/system/collector', {
    method: 'POST',
    body: JSON.stringify(toSaveDto(input)),
  })
}

export function updateDeviceCollector(collectorId: number, input: DeviceCollectorInput): Promise<ApiResponse> {
  return request<ApiResponse>('/system/collector', {
    method: 'PUT',
    body: JSON.stringify(toSaveDto(input, collectorId)),
  })
}

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

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