/**
 * 阿里云物联网客户端模块
 * 使用 alibabacloud-iot-device-sdk 实现设备接入和数据上传
 * 支持通过 API 动态获取设备三元组
 */

const { device } = require('alibabacloud-iot-device-sdk');
const axios = require('axios');
const Qs = require('qs');
const config = require('./config.json');
const appLogger = require('./loggerConfig');

// 获取阿里云配置
const aliyunConfig = config.aliyunIoT;

class AliyunIoTClient {
  constructor(deviceSerialNumber) {
    this.enabled = aliyunConfig.enabled;
    this.deviceSerialNumber = deviceSerialNumber;
    this.device = null;
    this.isConnected = false;
    this.deviceInfo = null;
    this.tripletInfo = null;
    
    if (!this.enabled) {
      return;
    }
  }

  /**
   * 通过 API 获取设备三元组
   * @returns {Promise<object>} 返回三元组信息 {deviceName, deviceSecret, productKey}
   */
  async fetchTripletFromAPI() {
    try {
      if (!aliyunConfig.apiConfig || !aliyunConfig.apiConfig.baseUrl) {
        appLogger.logWarn(`API 配置缺失，无法获取三元组`, {
          module: 'aliyun',
          device: this.deviceSerialNumber,
          hasApiConfig: !!aliyunConfig.apiConfig,
          hasBaseUrl: !!aliyunConfig.apiConfig?.baseUrl
        });
        console.warn(`⚠ API 配置不完整 [设备: ${this.deviceSerialNumber}]`);
        return null;
      }

      const apiConfig = aliyunConfig.apiConfig;
      const url = `${apiConfig.baseUrl}${apiConfig.secretUrl}`;
      const requestData = {
        isAutoRegister: 1,
        deviceName: this.deviceSerialNumber
      };

      // 记录 API 请求详情 - 使用 INFO 级别以确保记录
      appLogger.logInfo(`🔄 发起 API 请求获取三元组`, {
        module: 'aliyun',
        device: this.deviceSerialNumber,
        url: url,
        method: 'POST',
        params: requestData,
        timestamp: new Date().toISOString()
      });

      appLogger.logAliyunFetchingTriplet(this.deviceSerialNumber);
      console.log(`🔄 正在从 API 获取设备三元组 [设备: ${this.deviceSerialNumber}]...`);
      console.log(`   📡 请求地址: ${url}`);
      console.log(`   📤 请求参数: ${JSON.stringify(requestData)}`);

      const response = await axios({
        url: url,
        method: 'post',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        data: Qs.stringify(requestData),
        timeout: 10000
      });

      // 记录 API 响应详情
      appLogger.logInfo(`✓ API 请求成功，收到响应`, {
        module: 'aliyun',
        device: this.deviceSerialNumber,
        statusCode: response.status,
        statusText: response.statusText,
        dataLength: JSON.stringify(response.data).length,
        timestamp: new Date().toISOString()
      });

      console.log(`✓ API 请求成功 [状态码: ${response.status}]`);
      console.log(`   📥 响应数据大小: ${JSON.stringify(response.data).length} bytes`);

      if (response.data && response.data.data) {
        const tripletData = response.data.data;
        appLogger.logAliyunTripletFetched(this.deviceSerialNumber, {
          deviceName: tripletData.deviceName || this.deviceSerialNumber,
          deviceSecret: tripletData.deviceSecret,
          productKey: tripletData.productKey || aliyunConfig.productKey
        });
        
        // 记录成功的三元组获取
        appLogger.logInfo(`✓ 三元组获取成功`, {
          module: 'aliyun',
          device: this.deviceSerialNumber,
          deviceName: tripletData.deviceName || this.deviceSerialNumber,
          hasSecret: !!tripletData.deviceSecret,
          source: 'API',
          timestamp: new Date().toISOString()
        });
        
        console.log(`✓ 设备三元组获取成功 [设备: ${this.deviceSerialNumber}]`);
        console.log(`   ✔ 设备名称: ${tripletData.deviceName || this.deviceSerialNumber}`);
        console.log(`   ✔ 密钥已获取: ${!!tripletData.deviceSecret}`);
        
        return {
          deviceName: tripletData.deviceName || this.deviceSerialNumber,
          deviceSecret: tripletData.deviceSecret,
          productKey: tripletData.productKey || aliyunConfig.productKey
        };
      } else {
        console.error(`✗ API 返回数据格式错误:`, response.data);
        
        // 记录响应格式错误
        appLogger.logError(`✗ API 返回数据格式错误`, new Error('Invalid API response format'), {
          module: 'aliyun',
          device: this.deviceSerialNumber,
          statusCode: response.status,
          response: JSON.stringify(response.data),
          timestamp: new Date().toISOString()
        });
        
        appLogger.logAliyunTripletFetchError(this.deviceSerialNumber, new Error('Invalid API response format'));
        return null;
      }
    } catch (err) {
      console.error(`✗ 获取设备三元组失败 [${this.deviceSerialNumber}]: ${err.message}`);
      
      // 记录 API 请求错误详情 - 使用 ERROR 级别
      appLogger.logError(`✗ API 请求失败`, err, {
        module: 'aliyun',
        device: this.deviceSerialNumber,
        errorType: err.code || err.name,
        errorMessage: err.message,
        requestUrl: aliyunConfig.apiConfig?.baseUrl + aliyunConfig.apiConfig?.secretUrl,
        timeout: err.code === 'ECONNABORTED' ? '连接超时' : undefined,
        connectionRefused: err.code === 'ECONNREFUSED' ? '连接被拒绝' : undefined,
        timestamp: new Date().toISOString()
      });
      
      // 详细的错误日志输出
      console.error(`   ✗ 错误代码: ${err.code || err.name}`);
      console.error(`   ✗ 错误信息: ${err.message}`);
      if (err.response) {
        console.error(`   ✗ 响应状态: ${err.response.status}`);
        console.error(`   ✗ 响应数据: ${JSON.stringify(err.response.data)}`);
      }
      
      appLogger.logAliyunTripletFetchError(this.deviceSerialNumber, err);
      return null;
    }
  }

  /**
   * 获取设备三元组（优先从 API 获取，回退到配置文件）
   */
  async getTriplet() {
    // 首先尝试从 API 获取
    if (aliyunConfig.apiConfig && aliyunConfig.apiConfig.baseUrl) {
      appLogger.logInfo(`尝试从 API 获取三元组`, {
        module: 'aliyun',
        device: this.deviceSerialNumber,
        api: aliyunConfig.apiConfig.baseUrl + aliyunConfig.apiConfig.secretUrl
      });
      
      const triplet = await this.fetchTripletFromAPI();
      if (triplet) {
        return triplet;
      }
      
      appLogger.logWarn(`API 获取三元组失败，尝试本地配置`, {
        module: 'aliyun',
        device: this.deviceSerialNumber
      });
      console.warn(`⚠ API 获取失败，尝试从配置文件获取 [设备: ${this.deviceSerialNumber}]`);
    }

    // 回退到配置文件（如果有设备配置）
    if (aliyunConfig.devices && aliyunConfig.devices[this.deviceSerialNumber]) {
      this.deviceInfo = aliyunConfig.devices[this.deviceSerialNumber];
      
      appLogger.logInfo(`三元组获取成功`, {
        module: 'aliyun',
        device: this.deviceSerialNumber,
        deviceName: this.deviceInfo.deviceName,
        source: 'config'
      });
      
      return {
        deviceName: this.deviceInfo.deviceName,
        deviceSecret: this.deviceInfo.deviceSecret,
        productKey: aliyunConfig.productKey
      };
    }

    // 三元组获取完全失败
    appLogger.logError(`无法获取设备三元组`, new Error('Device not found'), {
      module: 'aliyun',
      device: this.deviceSerialNumber,
      apiEnabled: !!aliyunConfig.apiConfig?.baseUrl,
      hasLocalConfig: !!(aliyunConfig.devices && aliyunConfig.devices[this.deviceSerialNumber])
    });
    
    appLogger.logAliyunTripletFetchError(this.deviceSerialNumber, 'Device not found in config');
    console.warn(`⚠ 设备 ${this.deviceSerialNumber} 未在阿里云配置中注册，且无法从 API 获取`);
    return null;
  }

  /**
   * 连接到阿里云 IoT
   */
  async connect() {
    if (!this.enabled) {
      return Promise.resolve();
    }

    return new Promise(async (resolve, reject) => {
      try {
        // 获取三元组信息
        appLogger.logInfo(`开始获取设备三元组`, {
          module: 'aliyun',
          device: this.deviceSerialNumber,
          timestamp: new Date().toISOString()
        });
        
        const triplet = await this.getTriplet();
        if (!triplet || !triplet.deviceSecret) {
          appLogger.logError(`三元组验证失败`, new Error('Invalid triplet'), {
            module: 'aliyun',
            device: this.deviceSerialNumber,
            hasTriplet: !!triplet,
            hasSecret: !!(triplet && triplet.deviceSecret)
          });
          
          console.error(`✗ 无法获取有效的设备三元组 [${this.deviceSerialNumber}]`);
          reject(new Error('Invalid triplet information'));
          return;
        }

        const productKey = triplet.productKey || aliyunConfig.productKey;
        const regionId = aliyunConfig.regionId;
        const deviceName = triplet.deviceName;
        const deviceSecret = triplet.deviceSecret;

        // 记录即将创建的设备实例
        appLogger.logInfo(`准备创建阿里云设备实例`, {
          module: 'aliyun',
          device: this.deviceSerialNumber,
          deviceName: deviceName,
          productKey: productKey,
          regionId: regionId
        });

        // 构建设备配置
        const options = {
          productKey: productKey,
          deviceName: deviceName,
          deviceSecret: deviceSecret,
          regionId: regionId,
          keepalive: 60
        };

        console.log(`🔗 创建阿里云设备实例 [${deviceName}]...`);

        // 创建设备实例
        this.device = device(options);

        // 设置连接超时
        const connectTimeout = setTimeout(() => {
          appLogger.logError(`阿里云连接超时`, new Error('Connection timeout'), {
            module: 'aliyun',
            device: this.deviceSerialNumber,
            timeout: 15000,
            deviceName: deviceName
          });
          
          console.error(`✗ 阿里云 IoT 连接超时 [设备: ${this.deviceSerialNumber}]`);
          reject(new Error('Connection timeout'));
        }, 15000);

        // 监听连接事件
        this.device.on('connect', () => {
          clearTimeout(connectTimeout);
          this.isConnected = true;
          this.tripletInfo = triplet;
          
          appLogger.logInfo(`阿里云连接建立成功`, {
            module: 'aliyun',
            device: this.deviceSerialNumber,
            deviceName: deviceName,
            timestamp: new Date().toISOString()
          });
          
          appLogger.logAliyunConnected(this.deviceSerialNumber, deviceName);
          console.log(`✓ 阿里云 IoT 连接成功 [设备: ${this.deviceSerialNumber}] [${deviceName}]`);
          
          // 订阅主题
          this.subscribe();
          resolve();
        });

        // 监听错误事件
        this.device.on('error', (err) => {
          clearTimeout(connectTimeout);
          appLogger.logError(`阿里云连接错误`, err, {
            module: 'aliyun',
            device: this.deviceSerialNumber,
            deviceName: deviceName,
            errorType: err.code || err.name
          });
          
          appLogger.logAliyunConnectionError(this.deviceSerialNumber, err);
          console.error(`✗ 阿里云 IoT 错误 [设备: ${this.deviceSerialNumber}]:`, err.message);
          this.isConnected = false;
          if (!this.isConnected) {
            reject(err);
          }
        });

        // 监听离线事件
        this.device.on('offline', () => {
          this.isConnected = false;
          appLogger.logAliyunOffline(this.deviceSerialNumber);
          console.warn(`⚠ 阿里云 IoT 离线 [设备: ${this.deviceSerialNumber}]`);
        });

        // 监听重连事件
        this.device.on('reconnect', () => {
          appLogger.logInfo(`阿里云 IoT 重新连接中 [设备: ${this.deviceSerialNumber}]`, { module: 'aliyun', device: this.deviceSerialNumber });
          console.log(`⟳ 阿里云 IoT 重新连接中 [设备: ${this.deviceSerialNumber}]`);
        });

      } catch (err) {
        appLogger.logError(`创建设备实例失败`, err, { device: this.deviceSerialNumber });
        console.error(`创建设备实例失败:`, err);
        reject(err);
      }
    });
  }

  /**
   * 订阅主题
   */
  subscribe() {
    if (!this.enabled || !this.device) return;

    // 订阅属性设置命令
    this.device.subscribe('/a1/{productKey}/{deviceName}/thing/service/property/set');

    // 监听消息
    this.device.on('message', (topic, payload) => {
      console.log(`\n📩 收到阿里云下行消息 [${topic}]:`, payload);
    });
  }

  /**
   * 发布医疗数据属性
   * @param {object} keyData - 关键数据对象
   */
  publishProperties(keyData) {
    if (!this.enabled || !this.isConnected || !this.device) {
      if (this.enabled && !this.isConnected) {
        console.warn(`⚠ 设备 ${this.deviceSerialNumber} 未连接到阿里云 IoT`);
      }
      return;
    }

    // 构建属性数据
    const properties = {
      // 基本信息
      deviceModel: keyData.deviceModel,
      softwareVersion: keyData.softwareVersion,
      
      // 超滤参数
      ultraFiltrateTarget: parseFloat(keyData.ultraFiltrateTarget) || 0,
      ultraFiltrateTotal: parseFloat(keyData.ultraFiltrateTotal) || 0,
      ultrafiltrateRateSet: parseFloat(keyData.ultrafiltrateRateSet) || 0,
      
      // 透析液参数
      dialysisFluidFlow: parseFloat(keyData.dialysisFluidFlow) || 0,
      dialysisFluidActual: parseFloat(keyData.dialysisFluidActual) || 0,
      dialysisFluidTemp: parseFloat(keyData.dialysisFluidTemp) || 0,
      sodiumConc: parseFloat(keyData.sodiumConc) || 0,
      conductivity: parseFloat(keyData.conductivity) || 0,
      
      // 血液/血流参数
      bloodFlow: parseFloat(keyData.bloodFlow) || 0,
      effectiveBloodFlow: parseFloat(keyData.effectiveBloodFlow) || 0,
      dialysisBloodVolume: parseFloat(keyData.dialysisBloodVolume) || 0,
      returnedBloodVolume: parseFloat(keyData.returnedBloodVolume) || 0,
      plasmaNA: parseFloat(keyData.plasmaNA) || 0,
      clearanceRate: parseFloat(keyData.clearanceRate) || 0,
      
      // 质量指标
      instantKT: parseFloat(keyData.instantKT) || 0,
      ktvTarget: parseFloat(keyData.ktvTarget) || 0,
      
      // 电解质参数
      bicarbonate: parseFloat(keyData.bicarbonate) || 0,
      
      // 压力参数
      arterialPressure: parseFloat(keyData.arterialPressure) || 0,
      venousPressure: parseFloat(keyData.venousPressure) || 0,
      transmembranePressure: parseFloat(keyData.transmembranePressure) || 0,
      
      // 膜型参数
      dialysisMode: keyData.dialysisMode,
      
      // 状态参数
      runStatus: keyData.runStatus,
      alarmStatus: keyData.alarmStatus,
      treatmentDuration: parseFloat(keyData.treatmentDuration) || 0,
      
      // 置换参数
      replacementFluidTarget: parseFloat(keyData.replacementFluidTarget) || 0,
      replacementRate: parseFloat(keyData.replacementRate) || 0,
      replacementVolume: parseFloat(keyData.replacementVolume) || 0
    };

    try {
      const propertyStr = JSON.stringify(properties);
      appLogger.logAliyunPublishing(this.deviceSerialNumber, 'properties', propertyStr.length);
      this.device.postProperty(properties, (err, data) => {
        if (err) {
          appLogger.logAliyunPublishError(this.deviceSerialNumber, 'properties', err);
          console.error(`发布属性失败 [${this.deviceSerialNumber}]:`, err.message);
        }
      });
    } catch (err) {
      appLogger.logError(`发布属性异常`, err, { device: this.deviceSerialNumber, module: 'aliyun' });
      console.error(`发布属性异常:`, err.message);
    }
  }

  /**
   * 发布事件
   * @param {object} event - 事件对象
   */
  publishEvent(event) {
    if (!this.enabled || !this.isConnected || !this.device) {
      return;
    }

    const eventData = {
      eventType: event.type,
      description: event.description,
      severity: event.severity,
      timestamp: Date.now()
    };

    try {
      const eventStr = JSON.stringify(eventData);
      appLogger.logAliyunPublishing(this.deviceSerialNumber, 'event', eventStr.length);
      // 发布自定义事件
      this.device.postEvent('alert', eventData, (err, data) => {
        if (err) {
          appLogger.logAliyunPublishError(this.deviceSerialNumber, 'event', err);
          console.error(`发布事件失败:`, err.message);
        } else {
          appLogger.logInfo(`事件发布成功`, { module: 'aliyun', device: this.deviceSerialNumber, eventType: event.type, description: event.description });
          console.log(`✓ 事件发布成功 [${this.deviceSerialNumber}] - ${event.description}`);
        }
      });
    } catch (err) {
      appLogger.logError(`发布事件异常`, err, { device: this.deviceSerialNumber, module: 'aliyun' });
      console.error(`发布事件异常:`, err.message);
    }
  }

  /**
   * 断开连接
   */
  disconnect() {
    if (!this.enabled || !this.device) return;
    
    try {
      this.device.disconnect();
      this.isConnected = false;
      console.log(`✓ 阿里云 IoT 连接已关闭 [设备: ${this.deviceSerialNumber}]`);
    } catch (err) {
      console.error(`断开连接失败:`, err.message);
    }
  }

  /**
   * 获取连接状态
   */
  getConnectionStatus() {
    return {
      deviceSerialNumber: this.deviceSerialNumber,
      aliyunEnabled: this.enabled,
      isConnected: this.isConnected,
      deviceName: this.tripletInfo?.deviceName
    };
  }
}

module.exports = AliyunIoTClient;