// MQTT数据管理器
import { createMqtt, closeMqtt, getConnectionStatus } from './sendMqtt.js'

class MqttDataManager {
  constructor() {
    this.listeners = new Map()
    this.isConnected = false
    this.lastData = {
      temperature: null,
      humidity: null,
      pm25: null,
      timestamp: null,
      // 扩展数据结构支持更多设备类型
      deviceType: null,
      rawData: null,
      // 空调设备数据
      acTemperature: null,
      // 其他设备数据可在此扩展
      otherDeviceData: {}
    }
    this.init()
  }

  // 初始化MQTT连接
  init() {
    try {
      console.log('🚀 MQTT数据管理器开始初始化...')
      
      // 监听MQTT数据
      uni.$on('mqttData', this.handleMqttData.bind(this))
      // console.log('✅ MQTT数据监听器已注册')
      
      // 立即创建MQTT连接，不使用延迟
      // console.log('🔧 立即创建MQTT连接...')
      createMqtt()
      
      // 定期检查连接状态
      this.statusCheckInterval = setInterval(() => {
        const wasConnected = this.isConnected
        this.isConnected = getConnectionStatus()
        
        // 如果连接状态发生变化，通知监听器
        if (wasConnected !== this.isConnected) {
          // console.log('🔄 MQTT连接状态变化:', {
          //   wasConnected,
          //   isConnected: this.isConnected
          // })
          this.notifyListeners('connectionStatus', { 
            isConnected: this.isConnected,
            lastUpdate: this.lastData.timestamp ? new Date(this.lastData.timestamp * 1000).toLocaleString('zh-CN') : null
          })
        }
      }, 3000) // 改为3秒检查一次
      
      // console.log('✅ MQTT数据管理器初始化完成')
    } catch (error) {
      console.error('❌ MQTT数据管理器初始化失败:', error)
    }
  }

  // 处理MQTT数据
  handleMqttData(data) {
    try {
      // console.log('📨 收到MQTT数据:', data)
      
      // 更新连接状态
      this.isConnected = true
      
      // 检查数据是否为数组
      if (Array.isArray(data)) {
        // console.log('📋 收到数组数据，长度:', data.length)
        // 遍历数组中的每个设备数据
        data.forEach((deviceData, index) => {
          // console.log(`📦 处理设备数据[${index}]:`, deviceData)
          this.processDeviceData(deviceData)
        })
      } else {
        // 单个设备数据
        // console.log('📦 处理单个设备数据:', data)
        this.processDeviceData(data)
      }
    } catch (error) {
      console.error('❌ 处理MQTT数据失败:', error)
    }
  }

  // 处理单个设备数据
  processDeviceData(deviceData) {
    try {
      // 检查数据结构
      if (!deviceData || !deviceData.Device || !deviceData.Data) {
        console.warn('⚠️ 设备数据格式不符合预期:', deviceData)
        return
      }
      
      const deviceType = deviceData.Device
      const deviceDataContent = deviceData.Data
      const timestamp = deviceData.timestamp || Math.floor(Date.now() / 1000)
      // 处理所有设备类型的数据
      // console.log(`✅ 处理设备类型: ${deviceType}`)
      this.processAllDeviceData(deviceType, deviceDataContent, timestamp)
    } catch (error) {
      console.error('❌ 处理设备数据失败:', error)
    }
  }

  // 处理所有设备类型的数据
  processAllDeviceData(deviceType, data, timestamp) {
    try {
      // 构建基础解析数据
      const parsedData = {
        deviceType,
        timestamp,
        time: new Date(timestamp * 1000).toLocaleString('zh-CN'),
        rawData: data // 保存原始数据供页面特殊处理
      }
      
      // 根据设备类型解析特定数据
      switch (deviceType) {
        case 'WSD': // 温湿度传感器
          if (data.WD !== undefined) {
            parsedData.temperature = parseFloat(data.WD)
          }
          if (data.SD !== undefined) {
            parsedData.humidity = parseFloat(data.SD)
          }
          break
          
        case 'AC': // 空调设备
          if (data.BSQWD !== undefined) {
            parsedData.acTemperature = parseFloat(data.BSQWD)
          }

          if (data.SD !== undefined) {
            parsedData.acHumidity = parseFloat(data.SD)
          }

          if (data.status !== undefined) {
            parsedData.acStatus = data.status
          }
          // 可以添加其他空调参数
          break
          
        case 'PM25': // PM2.5传感器
          if (data.PM25 !== undefined) {
            parsedData.pm25 = parseFloat(data.PM25)
          }
          break
          
        default:
          // 其他设备类型，保存到otherDeviceData中
          console.log(`📦 处理未知设备类型 ${deviceType}，保存原始数据`)
          // parsedData.otherDeviceData = data
          break
      }
      
      // 更新最新数据
      this.updateLastData(parsedData)
      
      // 通知所有监听器
      this.notifyListeners('dataUpdate', parsedData)
      
      console.log(`✅ ${deviceType}数据处理完成:`, parsedData)
    } catch (error) {
      console.error(`❌ 处理${deviceType}数据失败:`, error)
    }
  }

  // 解析设备数据
  parseDeviceData(rawData) {
    try {
      // 如果是数组，取第一个元素
      if (Array.isArray(rawData) && rawData.length > 0) {
        rawData = rawData[0]
      }
      
      // 检查数据结构
      if (!rawData || !rawData.Device || !rawData.Data) {
        // console.warn('⚠️ 数据格式不符合预期:', rawData)
        return null
      }
      
      const deviceType = rawData.Device
      const deviceData = rawData.Data
      const timestamp = rawData.timestamp || Math.floor(Date.now() / 1000)
      
      // 根据设备类型解析数据
      let parsedData = {
        deviceType,
        timestamp,
        time: new Date(timestamp * 1000).toLocaleString('zh-CN')
      }
      
      switch (deviceType) {
        case 'WSD': // 温湿度传感器
          deviceData.Temperature && (parsedData.temperature = parseFloat(deviceData.Temperature))
          deviceData.Humidity && (parsedData.humidity = parseFloat(deviceData.Humidity))
          break
          
        case 'AC': // 空调设备
          deviceData.Temperature && (parsedData.temperature = parseFloat(deviceData.Temperature))
          deviceData.Humidity && (parsedData.humidity = parseFloat(deviceData.Humidity))
          break
          
        case 'PM': // PM2.5传感器
          deviceData.PM25 && (parsedData.pm25 = parseFloat(deviceData.PM25))
          break
          
        default:
          console.warn('⚠️ 未知设备类型:', deviceType)
          return null
      }
      
      return parsedData
    } catch (error) {
      console.error('❌ 解析设备数据失败:', error)
      return null
    }
  }

  // 更新最新数据
  updateLastData(parsedData) {
    // 直接合并数据，只更新有值的字段
    Object.keys(parsedData).forEach(key => {
      if (parsedData[key] !== undefined) {
        if (key === 'otherDeviceData' && this.lastData.otherDeviceData) {
          // 对于 otherDeviceData，进行深度合并
          this.lastData.otherDeviceData = { ...this.lastData.otherDeviceData, ...parsedData.otherDeviceData }
        } else {
          // 其他字段直接赋值
          this.lastData[key] = parsedData[key]
        }
      }
    })
  }

  // 添加数据监听器
  addListener(key, callback) {
    if (!this.listeners.has(key)) {
      this.listeners.set(key, [])
    }
    this.listeners.get(key).push(callback)
    
    // 立即发送当前数据
    if (key === 'dataUpdate' && this.lastData.timestamp) {
      callback(this.lastData)
    }
  }

  // 移除数据监听器
  removeListener(key, callback) {
    if (this.listeners.has(key)) {
      const callbacks = this.listeners.get(key)
      const index = callbacks.indexOf(callback)
      if (index > -1) {
        callbacks.splice(index, 1)
      }
    }
  }

  // 通知监听器
  notifyListeners(key, data) {
    if (this.listeners.has(key)) {
      this.listeners.get(key).forEach(callback => {
        try {
          callback(data)
        } catch (error) {
          console.error('❌ 监听器回调执行失败:', error)
        }
      })
    }
  }

  // 获取最新数据
  getLastData() {
    return { ...this.lastData }
  }

  // 获取连接状态
  getConnectionStatus() {
    return {
      isConnected: this.isConnected,
      lastUpdate: this.lastData.timestamp ? new Date(this.lastData.timestamp * 1000).toLocaleString('zh-CN') : null
    }
  }

  // 销毁管理器
  destroy() {
    uni.$off('mqttData', this.handleMqttData.bind(this))
    closeMqtt()
    
    if (this.statusCheckInterval) {
      clearInterval(this.statusCheckInterval)
    }
    
    this.listeners.clear()
    console.log('🔌 MQTT数据管理器已销毁')
  }
}

// 创建全局实例
const mqttDataManager = new MqttDataManager()

export default mqttDataManager