/**
 * 连接配置 API - 支持动态分组
 */

// 模拟延迟
const delay = (min = 300, max = 600) => {
  const time = Math.random() * (max - min) + min
  return new Promise(resolve => setTimeout(resolve, time))
}

// 模拟分组数据
const mockGroups = [
  { key: 'ip', name: 'IP配置' },
  { key: 'hardware', name: '硬件接口' },
  { key: 'proxy', name: '网络代理' },
  { key: 'advanced', name: '高级设置' },
  { key: 'security', name: '安全设置' },
  { key: 'performance', name: '性能优化' },
  { key: 'logging', name: '日志配置' },
  { key: 'monitoring', name: '监控告警' }
]

// 模拟各分组的参数数据
const mockParamsByGroup = {
  ip: [
    {
      key: 'serverIp',
      label: '服务器IP',
      value: '192.168.1.100',
      desc: '请输入服务器IP地址'
    },
    {
      key: 'mqttBrokerWeb',
      label: 'MQTT代理地址（网页）',
      value: 'ws://broker.hivemq.com:8000',
      desc: '网页端MQTT连接地址'
    },
    {
      key: 'mqttBrokerNav',
      label: 'MQTT代理地址（导航）',
      value: 'mqtt://broker.hivemq.com:1883',
      desc: '导航端MQTT连接地址'
    },
    {
      key: 'mqttProductId',
      label: 'MQTT产品ID',
      value: 'smart_driving_v2',
      desc: '请输入产品ID'
    },
    {
      key: 'httpBase',
      label: 'HTTP服务地址',
      value: 'https://api.smartdriving.com',
      desc: 'HTTP API基础地址'
    }
  ],
  hardware: [
    {
      key: 'lidarNic',
      label: '激光网卡',
      value: 'enp0s31f6',
      desc: '激光雷达网络接口名称'
    },
    {
      key: 'packetFilterEnabled',
      label: '网络包过滤使能',
      value: 'true',
      desc: '是否启用网络包过滤功能'
    },
    {
      key: 'packetFilterRule',
      label: '网络包过滤规则',
      value: 'tcp and (port 80 or port 443)\nudp and port 53\nicmp',
      desc: '请输入过滤规则，每行一条'
    }
  ],
  proxy: [
    {
      key: 'netProxyEnabled',
      label: '开启网络代理',
      value: 'false',
      desc: '是否启用网络代理服务'
    },
    {
      key: 'netProxyAddr',
      label: '代理服务地址',
      value: 'proxy.company.com:8080',
      desc: '代理服务器地址和端口'
    },
    {
      key: 'map8086',
      label: '8086映射参数',
      value: 'localhost:8086',
      desc: '8086端口映射配置'
    },
    {
      key: 'map8088',
      label: '8088映射参数',
      value: 'localhost:8088',
      desc: '8088端口映射配置'
    }
  ],
  advanced: [
    {
      key: 'debugMode',
      label: '调试模式',
      value: 'false',
      desc: '是否启用调试模式'
    },
    {
      key: 'logLevel',
      label: '日志级别',
      value: 'INFO',
      desc: '系统日志记录级别'
    },
    {
      key: 'maxConnections',
      label: '最大连接数',
      value: '100',
      desc: '系统允许的最大并发连接数'
    }
  ],
  security: [
    {
      key: 'enableHttps',
      label: '启用HTTPS',
      value: 'true',
      desc: '是否强制使用HTTPS协议'
    },
    {
      key: 'authTimeout',
      label: '认证超时时间',
      value: '3600',
      desc: '用户认证会话超时时间（秒）'
    }
  ],
  performance: [
    {
      key: 'cacheEnabled',
      label: '启用缓存',
      value: 'true',
      desc: '是否启用数据缓存'
    },
    {
      key: 'threadPoolSize',
      label: '线程池大小',
      value: '20',
      desc: '系统线程池大小'
    }
  ],
  logging: [
    {
      key: 'logPath',
      label: '日志路径',
      value: '/var/log/system.log',
      desc: '系统日志文件存储路径'
    }
  ],
  monitoring: [
    {
      key: 'alertEnabled',
      label: '启用告警',
      value: 'true',
      desc: '是否启用系统监控告警'
    }
  ]
}

// 存储当前配置（模拟数据库）
let currentParamsByGroup = JSON.parse(JSON.stringify(mockParamsByGroup))

/**
 * 获取分组列表
 */
export const getGroups = async () => {
  await delay()
  
  return {
    code: 200,
    message: '获取分组成功',
    data: [...mockGroups]
  }
}

/**
 * 获取指定分组的参数
 * @param {Object} params - 参数对象
 * @param {string} params.group - 分组key
 */
export const getGroupParams = async ({ group }) => {
  await delay()
  
  // 模拟错误场景（3% 概率）
  if (Math.random() < 0.03) {
    throw new Error('获取参数失败，请重试')
  }
  
  if (!group || !currentParamsByGroup[group]) {
    throw new Error(`未知的分组: ${group}`)
  }
  
  return {
    code: 200,
    message: '获取参数成功',
    data: [...currentParamsByGroup[group]]
  }
}

/**
 * 更新单个配置参数
 * @param {Object} params - 参数对象
 * @param {string} params.group - 分组key
 * @param {string} params.key - 配置键名
 * @param {any} params.value - 配置值
 */
export const updateParam = async ({ group, key, value }) => {
  await delay()
  
  // 模拟错误场景（5% 概率）
  if (Math.random() < 0.05) {
    throw new Error('网络错误，请重试')
  }
  
  // 验证参数
  if (!group || !key) {
    throw new Error('分组和参数键名不能为空')
  }
  
  if (!currentParamsByGroup[group]) {
    throw new Error(`未知的分组: ${group}`)
  }
  
  const paramIndex = currentParamsByGroup[group].findIndex(p => p.key === key)
  if (paramIndex === -1) {
    throw new Error(`分组 ${group} 中未找到参数: ${key}`)
  }
  
  // 更新配置
  currentParamsByGroup[group][paramIndex].value = value
  
  return {
    code: 200,
    message: '参数更新成功',
    data: {
      group,
      key,
      value,
      timestamp: Date.now()
    }
  }
}

/**
 * 批量更新分组配置
 * @param {Object} params - 参数对象
 * @param {string} params.group - 分组key
 * @param {Array} params.params - 参数数组
 */
export const updateGroupParams = async ({ group, params }) => {
  await delay(500, 800)
  
  // 模拟错误场景
  if (Math.random() < 0.03) {
    throw new Error('服务器内部错误')
  }
  
  if (!group || !currentParamsByGroup[group]) {
    throw new Error(`未知的分组: ${group}`)
  }
  
  const updates = {}
  
  for (const param of params) {
    const paramIndex = currentParamsByGroup[group].findIndex(p => p.key === param.key)
    if (paramIndex !== -1) {
      currentParamsByGroup[group][paramIndex].value = param.value
      updates[param.key] = param.value
    }
  }
  
  return {
    code: 200,
    message: `成功更新 ${Object.keys(updates).length} 个配置项`,
    data: {
      group,
      updates,
      timestamp: Date.now()
    }
  }
}

/**
 * 重置分组配置到默认值
 * @param {Object} params - 参数对象
 * @param {string} params.group - 分组key
 */
export const resetGroupParams = async ({ group }) => {
  await delay(400, 700)
  
  if (!group || !mockParamsByGroup[group]) {
    throw new Error(`未知的分组: ${group}`)
  }
  
  currentParamsByGroup[group] = JSON.parse(JSON.stringify(mockParamsByGroup[group]))
  
  return {
    code: 200,
    message: '配置已重置到默认值',
    data: [...currentParamsByGroup[group]]
  }
}

/**
 * 测试分组连接
 * @param {Object} params - 参数对象
 * @param {string} params.group - 分组key
 * @param {Object} params.config - 相关配置
 */
export const testGroupConnection = async ({ group, config }) => {
  await delay(1000, 2000)
  
  // 模拟测试结果
  const testResults = {
    ip: {
      success: Math.random() > 0.2, // 80% 成功率
      message: Math.random() > 0.2 ? 'IP连接测试通过' : 'IP地址无法访问'
    },
    hardware: {
      success: Math.random() > 0.25, // 75% 成功率
      message: Math.random() > 0.25 ? '硬件接口检测正常' : '激光网卡未检测到'
    },
    proxy: {
      success: Math.random() > 0.4, // 60% 成功率
      message: Math.random() > 0.4 ? '代理连接测试通过' : '代理服务器无响应'
    },
    advanced: {
      success: Math.random() > 0.1, // 90% 成功率
      message: Math.random() > 0.1 ? '高级设置验证通过' : '配置参数有误'
    }
  }
  
  const result = testResults[group] || { success: false, message: '未知测试类型' }
  
  return {
    code: 200,
    message: '测试完成',
    data: {
      group,
      success: result.success,
      message: result.message,
      timestamp: Date.now()
    }
  }
}

export default {
  getGroups,
  getGroupParams,
  updateParam,
  updateGroupParams,
  resetGroupParams,
  testGroupConnection
}
