XNSim/XNSimHtml/routes/DataMonitor.js

const express = require('express');
const router = express.Router();
const systemMonitor = require('../utils/xnCoreService');

// 存储连续注入状态
const continuousInjectStatus = new Map();

/**
 * @brief 启动数据监控
 * @route POST /api/data-monitor/start
 * @param {string} structName - 结构体名称
 * @returns {Object} 返回启动结果
 */
router.post('/start', async (req, res) => {
  try {
    const { structName } = req.body;
    if (!structName) {
      return res.status(400).json({ success: false, message: '结构体名称不能为空' });
    }

    const result = systemMonitor.startDataMonitor(structName);
    if (result.includes('失败')) {
      return res.status(500).json({ success: false, message: result });
    }
    res.json({ success: true, message: result });
  } catch (error) {
    res.status(500).json({ success: false, message: `启动数据监控失败: ${error.message}` });
  }
});

/**
 * @brief 停止数据监控
 * @route POST /api/data-monitor/stop
 * @param {string} structName - 结构体名称
 * @returns {Object} 返回停止结果
 */
router.post('/stop', async (req, res) => {
  try {
    const { structName } = req.body;
    if (!structName) {
      return res.status(400).json({ success: false, message: '结构体名称不能为空' });
    }

    const result = systemMonitor.stopDataMonitor(structName);
    if (result.includes('失败')) {
      return res.status(500).json({ success: false, message: result });
    }
    res.json({ success: true, message: result });
  } catch (error) {
    res.status(500).json({ success: false, message: `停止数据监控失败: ${error.message}` });
  }
});

/**
 * @brief 获取数据监控信息
 * @route GET /api/data-monitor/info
 * @param {string} structName - 结构体名称
 * @param {string} interfaceName - 接口名称
 * @param {number} [bufferSize=8192] - 数据缓冲区大小（可选）
 * @returns {Object} 返回监控信息，data字段包含解析后的JSON对象
 */
router.get('/info', async (req, res) => {
  try {
    const { structName, interfaceName, bufferSize } = req.query;
    if (!structName || !interfaceName) {
      return res.status(400).json({ 
        success: false, 
        message: '结构体名称和接口名称不能为空' 
      });
    }

    const result = systemMonitor.getDataMonitorInfo(
      structName, 
      interfaceName, 
      bufferSize ? parseInt(bufferSize) : undefined
    );
    if (typeof result === 'string' && result.includes('失败')) {
      return res.status(500).json({ success: false, message: result });
    }

    // 解析数据字符串为JSON对象
    let parsedData;
    try {
      parsedData = JSON.parse(result.data);
    } catch (parseError) {
      return res.status(500).json({ 
        success: false, 
        message: `数据解析失败: ${parseError.message}` 
      });
    }

    res.json({ 
      success: true, 
      data: parsedData,
      info: result.info 
    });
  } catch (error) {
    res.status(500).json({ success: false, message: `获取数据监控信息失败: ${error.message}` });
  }
});

/**
 * @brief 注入数据接口
 * @route POST /api/data-monitor/inject
 * @param {string} structName - 结构体名称
 * @param {string} interfaceNameAndData - 接口名称和数据JSON字符串
 * @returns {Object} 返回注入结果
 */
router.post('/inject', async (req, res) => {
  try {
    const { structName, interfaceNameAndData } = req.body;
    if (!structName || !interfaceNameAndData) {
      return res.status(400).json({ 
        success: false, 
        message: '结构体名称和接口数据不能为空' 
      });
    }

    const result = systemMonitor.injectDataInterface(structName, interfaceNameAndData);
    if (result.includes('失败')) {
      return res.status(500).json({ success: false, message: result });
    }
    res.json({ success: true, message: result });
  } catch (error) {
    res.status(500).json({ success: false, message: `注入数据接口失败: ${error.message}` });
  }
});

/**
 * @brief 启动持续注入数据
 * @route POST /api/data-monitor/start-continuous
 * @param {string} structName - 结构体名称
 * @param {string} interfaceNameAndData - 接口名称和数据JSON字符串
 * @param {number} frequency - 注入频率
 * @returns {Object} 返回启动结果
 */
router.post('/start-continuous', async (req, res) => {
  try {
    const { structName, interfaceNameAndData, frequency } = req.body;
    if (!structName || !interfaceNameAndData || frequency === undefined) {
      return res.status(400).json({ 
        success: false, 
        message: '结构体名称、接口数据和注入频率不能为空' 
      });
    }

    // 检查是否已存在该结构体的注入状态
    if (continuousInjectStatus.has(structName)) {
      const status = continuousInjectStatus.get(structName);
      
      // 检查频率是否相同
      if (status.frequency !== frequency) {
        return res.status(400).json({
          success: false,
          message: `该结构体已有其他接口以 ${status.frequency}ms 的频率进行注入，请使用相同的频率`
        });
      }

      // 合并接口数据
      try {
        const existingData = JSON.parse(status.interfaceNameAndData);
        const newData = JSON.parse(interfaceNameAndData);
        const mergedData = { ...existingData, ...newData };
        status.interfaceNameAndData = JSON.stringify(mergedData);
      } catch (error) {
        return res.status(400).json({
          success: false,
          message: '接口数据格式错误'
        });
      }

      // 启动注入
      const result = systemMonitor.startInjectContinuous(structName, status.interfaceNameAndData, frequency);
      if (result.includes('失败')) {
        continuousInjectStatus.delete(structName);
        return res.status(500).json({ success: false, message: result });
      }
    } else {
      // 创建新的注入状态
      continuousInjectStatus.set(structName, {
        interfaceNameAndData,
        frequency,
        isInjecting: false
      });

      // 启动注入
      const result = systemMonitor.startInjectContinuous(structName, interfaceNameAndData, frequency);
      if (result.includes('失败')) {
        continuousInjectStatus.delete(structName);
        return res.status(500).json({ success: false, message: result });
      }

      // 更新注入状态
      const status = continuousInjectStatus.get(structName);
      status.isInjecting = true;
    }

    res.json({ 
      success: true, 
      message: '启动持续注入成功',
      data: {
        structName,
        interfaceNameAndData: continuousInjectStatus.get(structName).interfaceNameAndData,
        frequency
      }
    });
  } catch (error) {
    res.status(500).json({ success: false, message: `启动持续注入数据失败: ${error.message}` });
  }
});

/**
 * @brief 停止持续注入数据
 * @route POST /api/data-monitor/stop-continuous
 * @param {string} structName - 结构体名称
 * @param {string} interfaceName - 要停止的接口名称
 * @returns {Object} 返回停止结果
 */
router.post('/stop-continuous', async (req, res) => {
  try {
    const { structName, interfaceName } = req.body;
    if (!structName || !interfaceName) {
      return res.status(400).json({ 
        success: false, 
        message: '结构体名称和接口名称不能为空' 
      });
    }

    // 检查是否存在该结构体的注入状态
    if (!continuousInjectStatus.has(structName)) {
      return res.status(400).json({
        success: false,
        message: '该结构体没有正在进行的注入'
      });
    }

    const status = continuousInjectStatus.get(structName);
    
    try {
      // 从接口数据中移除指定的接口
      const existingData = JSON.parse(status.interfaceNameAndData);
      delete existingData[interfaceName];
      
      // 如果还有其他接口在注入，更新状态
      if (Object.keys(existingData).length > 0) {
        status.interfaceNameAndData = JSON.stringify(existingData);
        const result = systemMonitor.startInjectContinuous(structName, status.interfaceNameAndData, status.frequency);
        if (result.includes('失败')) {
          return res.status(500).json({ success: false, message: result });
        }
        res.json({ 
          success: true, 
          message: '停止指定接口的注入成功',
          data: {
            structName,
            remainingInterfaces: Object.keys(existingData)
          }
        });
      } else {
        // 如果没有其他接口在注入，停止整个结构体的注入
        const result = systemMonitor.stopInjectContinuous(structName);
        if (result.includes('失败')) {
          return res.status(500).json({ success: false, message: result });
        }
        
        // 删除注入状态
        continuousInjectStatus.delete(structName);
        res.json({ 
          success: true, 
          message: '停止所有接口的注入成功'
        });
      }
    } catch (error) {
      return res.status(400).json({
        success: false,
        message: '接口数据格式错误'
      });
    }
  } catch (error) {
    res.status(500).json({ success: false, message: `停止持续注入数据失败: ${error.message}` });
  }
});

module.exports = router;