import { ipcMain } from 'electron'
import dgram from 'dgram'
import net from 'net'
import { IPC_EVENT } from '../renderer/src/common/ipcEvents.js'
import fs from 'fs'
const TIMEOUT = 10000 // 10秒超时
const END_SEQUENCE = '\n\n' // 消息结束标志
// 全局保存所有TCP连接和相关信息
const tcpClients = new Map()
// 保存待处理的请求，用于关联响应
const pendingRequests = new Map()

export function registerIpRouter() {
  ipcMain.on(IPC_EVENT.DEVICE_SEARCH, searchDevice)
  ipcMain.on(IPC_EVENT.DEVICE_CONNECT, connectDevice)
  ipcMain.on(IPC_EVENT.DEVICE_DISCONNECT, disconnectDevice)
  ipcMain.handle(IPC_EVENT.SENSORS_GET, sensorLoad) // 获取传感器
  ipcMain.handle(IPC_EVENT.SENSORS_SET, sensorSet) // 传感器设置处理
  ipcMain.handle(IPC_EVENT.IMAGE_SEND_TIME_GET, imageSendTimeGet)
  ipcMain.handle(IPC_EVENT.IMAGE_SEND_TIME_SET, imageSendTimeSet)
  // 其他基本参数GET处理
  ipcMain.handle(IPC_EVENT.ZERO_COUNT_GET, zeroCountGet)
  ipcMain.handle(IPC_EVENT.RESULT_COUNT_GET, resultCountGet)
  ipcMain.handle(IPC_EVENT.DATA_FPS_GET, dataFpsGet)
  ipcMain.handle(IPC_EVENT.VIDEO_FPS_GET, videoFpsGet)
  ipcMain.handle(IPC_EVENT.THRESHOLD_GET, thresholdGet)
  ipcMain.handle(IPC_EVENT.INVALID_DATA_COUNT_GET, invalidDataCountGet)
  // 其他基本参数SET处理
  ipcMain.handle(IPC_EVENT.ZERO_COUNT_SET, zeroCountSet)
  ipcMain.handle(IPC_EVENT.RESULT_COUNT_SET, resultCountSet)
  ipcMain.handle(IPC_EVENT.DATA_FPS_SET, dataFpsSet)
  ipcMain.handle(IPC_EVENT.VIDEO_FPS_SET, videoFpsSet)
  ipcMain.handle(IPC_EVENT.THRESHOLD_SET, thresholdSet)
  ipcMain.handle(IPC_EVENT.INVALID_DATA_COUNT_SET, invalidDataCountSet)
}

const searchDevice = (event) => {
  const message = Buffer.from(JSON.stringify({ command: 'name', type: 'get' }))
  const PORT = 2230
  const BROADCAST_ADDR = '255.255.255.255'
  const udpClient = dgram.createSocket('udp4')

  let timer = null
  const resultMap = new Map()

  udpClient.bind(() => {
    udpClient.setBroadcast(true)
    udpClient.send(message, 0, message.length, PORT, BROADCAST_ADDR, (err) => {
      if (err) {
        console.error('UDP send failed', err)
        udpClient.close()
      } else {
        console.log('UDP send successful')
      }
    })
  })

  udpClient.on('message', (msg, rinfo) => {
    try {
      resultMap.set(rinfo.address, {
        from: rinfo.address,
        data: msg.toString()
      })
    } catch (e) {
      console.error('parse UDP message failed:', e)
    }
    if (timer) clearTimeout(timer)
    timer = setTimeout(() => {
      udpClient.close()
      console.log('UDP socket closed after timeout')
      event.reply && event.reply(IPC_EVENT.DEVICE_SEARCH_REPLY, Array.from(resultMap.values()))
    }, 1000)
  })

  udpClient.on('error', (err) => {
    console.error('UDP error:', err)
    udpClient.close()
    event.reply && event.reply(IPC_EVENT.DEVICE_SEARCH_REPLY, Array.from(resultMap.values()))
  })
}

const connectDevice = (event, { ip, port }) => {
  if (!ip || !port) {
    event.reply(IPC_EVENT.DEVICE_CONNECT_REPLY, { success: false, error: '参数缺失' })
    return
  }
  if (tcpClients.has(ip)) {
    event.reply(IPC_EVENT.DEVICE_CONNECT_REPLY, { success: false, error: '已连接' })
    return
  }

  const client = new net.Socket()

  // 保存连接信息，包括event sender用于后续通信
  const connectionInfo = {
    client,
    eventSender: event.sender,
    ip,
    port
  }

  client.connect(Number(port), ip, () => {
    event.reply(IPC_EVENT.DEVICE_CONNECT_REPLY, { success: true, ip })
    tcpClients.set(ip, connectionInfo)
  })

  let buffer = ''

  client.on('data', (data) => {
    buffer += data.toString()
    let index
    while ((index = buffer.indexOf('\n')) !== -1) {
      const line = buffer.slice(0, index)
      buffer = buffer.slice(index + 1)
      if (!line.trim()) continue

      let msg
      try {
        msg = JSON.parse(line)
        console.log('Received command:', `${msg.command}:${msg.type}`)
      } catch (e) {
        console.error('TCP data parse error:', e)
        fs.appendFileSync('error_log.txt', line + '\n')
        continue
      }

      if (!msg || !msg.command) {
        console.log('invalid msg format:', msg)
        continue
      }

      // 处理TCP响应
      handleTcpResponse(ip, msg)
    }
  })

  client.on('error', (err) => {
    event.reply(IPC_EVENT.DEVICE_CONNECT_REPLY, { success: false, error: err.message })
    client.destroy()
    tcpClients.delete(ip)
    // 清理该IP的所有待处理请求
    clearPendingRequestsByIp(ip)
  })

  client.on('close', () => {
    tcpClients.delete(ip)
    clearPendingRequestsByIp(ip)
  })
}

const disconnectDevice = (event, { ip }) => {
  const connectionInfo = tcpClients.get(ip)
  if (connectionInfo) {
    connectionInfo.client.destroy()
    tcpClients.delete(ip)
    clearPendingRequestsByIp(ip)
    event.reply(IPC_EVENT.DEVICE_DISCONNECT_REPLY, { success: true })
  } else {
    event.reply(IPC_EVENT.DEVICE_DISCONNECT_REPLY, { success: false, error: '未连接' })
  }
}

// 处理TCP响应
const handleTcpResponse = async (ip, msg) => {
  const connectionInfo = tcpClients.get(ip)
  if (!connectionInfo) return

  switch (`${msg.command}:${msg.type}`) {
    case IPC_EVENT.RESULT_REPLY:
      connectionInfo.eventSender.send(IPC_EVENT.RESULT_REPLY, { ip, ...msg })
      break
    case IPC_EVENT.IMAGE_REPLY:
      connectionInfo.eventSender.send(IPC_EVENT.IMAGE_REPLY, { ip, ...msg })
      break
    case IPC_EVENT.SENSORS_GET:
      {
        const sensorRequest = pendingRequests.get(`${ip}${IPC_EVENT.SENSORS_GET}`)
        if (sensorRequest) {
          // 响应传感器加载请求
          await delay()
          sensorRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.SENSORS_GET}`)
        }
      }
      break
    case IPC_EVENT.SENSORS_SET:
      {
        const sensorSetRequest = pendingRequests.get(`${ip}${IPC_EVENT.SENSORS_SET}`)
        if (sensorSetRequest) {
          // 响应传感器设置请求
          await delay()
          sensorSetRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.SENSORS_SET}`)
        }
      }
      break
    case IPC_EVENT.IMAGE_SEND_TIME_GET:
      {
        const imageTimeRequest = pendingRequests.get(`${ip}${IPC_EVENT.IMAGE_SEND_TIME_GET}`)
        if (imageTimeRequest) {
          // 响应图像发送间隔获取请求
          await delay()
          console.log(msg)
          imageTimeRequest.resolve({ success: true, data: msg })

          pendingRequests.delete(`${ip}${IPC_EVENT.IMAGE_SEND_TIME_GET}`)
        }
      }
      break
    case IPC_EVENT.IMAGE_SEND_TIME_SET:
      {
        const imageTimeRequest = pendingRequests.get(`${ip}${IPC_EVENT.IMAGE_SEND_TIME_SET}`)
        if (imageTimeRequest) {
          // 响应图像发送间隔设置请求
          await delay()
          console.log(msg)
          imageTimeRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.IMAGE_SEND_TIME_SET}`)
        }
      }
      break
    // 其他基本参数GET响应处理
    case IPC_EVENT.ZERO_COUNT_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.ZERO_COUNT_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.ZERO_COUNT_GET}`)
        }
      }
      break
    case IPC_EVENT.RESULT_COUNT_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.RESULT_COUNT_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.RESULT_COUNT_GET}`)
        }
      }
      break
    case IPC_EVENT.DATA_FPS_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.DATA_FPS_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.DATA_FPS_GET}`)
        }
      }
      break
    case IPC_EVENT.VIDEO_FPS_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.VIDEO_FPS_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.VIDEO_FPS_GET}`)
        }
      }
      break
    case IPC_EVENT.THRESHOLD_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.THRESHOLD_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.THRESHOLD_GET}`)
        }
      }
      break
    case IPC_EVENT.INVALID_DATA_COUNT_GET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.INVALID_DATA_COUNT_GET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.INVALID_DATA_COUNT_GET}`)
        }
      }
      break
    // 其他基本参数SET响应处理
    case IPC_EVENT.ZERO_COUNT_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.ZERO_COUNT_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.ZERO_COUNT_SET}`)
        }
      }
      break
    case IPC_EVENT.RESULT_COUNT_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.RESULT_COUNT_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.RESULT_COUNT_SET}`)
        }
      }
      break
    case IPC_EVENT.DATA_FPS_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.DATA_FPS_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.DATA_FPS_SET}`)
        }
      }
      break
    case IPC_EVENT.VIDEO_FPS_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.VIDEO_FPS_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.VIDEO_FPS_SET}`)
        }
      }
      break
    case IPC_EVENT.THRESHOLD_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.THRESHOLD_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.THRESHOLD_SET}`)
        }
      }
      break
    case IPC_EVENT.INVALID_DATA_COUNT_SET:
      {
        const paramRequest = pendingRequests.get(`${ip}${IPC_EVENT.INVALID_DATA_COUNT_SET}`)
        if (paramRequest) {
          await delay()
          console.log(msg)
          paramRequest.resolve({ success: true, data: msg })
          pendingRequests.delete(`${ip}${IPC_EVENT.INVALID_DATA_COUNT_SET}`)
        }
      }
      break
    case IPC_EVENT.HEARTBEAT_REPLY:
      // 心跳处理
      break

    default:
      console.warn('unknown command:', `${msg.command}:${msg.type}`)
  }
}

// 传感器加载
const sensorLoad = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    // 生成请求ID并保存待处理请求
    const requestKey = `${ip}${IPC_EVENT.SENSORS_GET}`

    // 设置超时
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT) // 10秒超时

    // 保存请求信息
    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    // 发送传感器加载命令
    const command = { command: 'sensors', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}
// 传感器设置
const sensorSet = async (event, { ip, sensors }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    // 生成请求ID并保存待处理请求
    const requestKey = `${ip}${IPC_EVENT.SENSORS_SET}`

    // 设置超时
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT) // 10秒超时

    // 保存请求信息
    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    // 发送传感器设置命令
    const command = { command: 'sensors', type: 'set', values: sensors }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}
// 图像发送间隔获取
const imageSendTimeGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    // 生成请求ID并保存待处理请求
    const requestKey = `${ip}${IPC_EVENT.IMAGE_SEND_TIME_GET}`

    // 设置超时
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT) // 10秒超时

    // 保存请求信息
    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    // 发送图像发送间隔获取命令
    const command = { command: 'imageSendTime', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}
// 图像发送间隔设置
const imageSendTimeSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    // 生成请求ID并保存待处理请求
    const requestKey = `${ip}${IPC_EVENT.IMAGE_SEND_TIME_SET}`

    // 设置超时
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT) // 10秒超时

    // 保存请求信息
    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    // 发送图像发送间隔设置命令
    const command = { command: 'imageSendTime', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// zeroCount获取
const zeroCountGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.ZERO_COUNT_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'zeroCount', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// zeroCount设置
const zeroCountSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.ZERO_COUNT_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'zeroCount', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// resultCount获取
const resultCountGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.RESULT_COUNT_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'resultCount', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// resultCount设置
const resultCountSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.RESULT_COUNT_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'resultCount', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// dataFps获取
const dataFpsGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.DATA_FPS_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'dataFps', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// dataFps设置
const dataFpsSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.DATA_FPS_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'dataFps', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE
    console.log('Sending command:', message)
    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// videoFps获取
const videoFpsGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.VIDEO_FPS_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'videoFps', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// videoFps设置
const videoFpsSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.VIDEO_FPS_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'videoFps', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// threshold获取
const thresholdGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.THRESHOLD_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'threshold', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// threshold设置
const thresholdSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.THRESHOLD_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'threshold', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// invalidDataCount获取
const invalidDataCountGet = async (event, { ip }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.INVALID_DATA_COUNT_GET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'invalidDataCount', type: 'get', values: '' }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// invalidDataCount设置
const invalidDataCountSet = async (event, { ip, value }) => {
  return new Promise((resolve, reject) => {
    const connectionInfo = tcpClients.get(ip)
    if (!connectionInfo) {
      resolve({ success: false, error: '设备未连接' })
      return
    }

    const requestKey = `${ip}${IPC_EVENT.INVALID_DATA_COUNT_SET}`
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestKey)
      resolve({ success: false, error: '请求超时' })
    }, TIMEOUT)

    pendingRequests.set(requestKey, {
      resolve: (result) => {
        clearTimeout(timeout)
        resolve(result)
      },
      reject: (error) => {
        clearTimeout(timeout)
        reject(error)
      },
      timestamp: Date.now()
    })

    const command = { command: 'invalidDataCount', type: 'set', values: value }
    const message = JSON.stringify(command) + END_SEQUENCE

    connectionInfo.client.write(message, (err) => {
      if (err) {
        pendingRequests.delete(requestKey)
        clearTimeout(timeout)
        resolve({ success: false, error: err.message })
      }
    })
  })
}

// 清理指定IP的所有待处理请求
const clearPendingRequestsByIp = (ip) => {
  const keysToDelete = []
  for (const [key, request] of pendingRequests) {
    if (key.startsWith(`${ip}_`)) {
      request.resolve({ success: false, error: '连接已断开' })
      keysToDelete.push(key)
    }
  }
  keysToDelete.forEach((key) => pendingRequests.delete(key))
}

//模拟延迟函数
const delay = () => {
  return new Promise((resolve) => setTimeout(resolve, 1000))
}