const express = require('express');
const mysql = require('mysql2/promise');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const cors = require('cors');
const crypto = require('crypto');
const fs = require('fs');  // 使用同步版本的 fs
const fsPromises = require('fs').promises;  // 使用 promises 版本的 fs
const path = require('path');
require('dotenv').config({ path: path.join(__dirname, '.env') });
const CryptoJS = require('crypto-js');
const util = require('util');
const fileUpload = require('express-fileupload');

const app = express();

// 创建日志文件流
const logStream = fs.createWriteStream(path.join(__dirname, 'server.log'), { flags: 'a' });

// 创建管理员日志文件流
const adminLogStream = fs.createWriteStream(path.join(__dirname, 'admin.log'), { flags: 'a' });

// 自定义日志函数
function log(message) {
  const timestamp = new Date().toISOString();
  const logMessage = `${timestamp} - ${message}\n`;
  console.log(logMessage);
  logStream.write(logMessage);
}


// 允许所有源的 CORS 请求
app.use(cors());

app.use(express.json());
app.use(fileUpload({
  limits: { fileSize: 5 * 1024 * 1024 }, // 限制文件大小为5MB
  abortOnLimit: true
}));

// 创建数据库连接池
const pool = mysql.createPool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  charset: 'utf8mb4'
});

// 创建 SurveyKing 数据库连接池
const surveyKingPool = mysql.createPool({
  host: process.env.SurveyKing_DB_HOST,
  port: process.env.SurveyKing_DB_PORT,
  user: process.env.SurveyKing_DB_USER,
  password: process.env.SurveyKing_DB_PASSWORD,
  database: process.env.SurveyKing_DB_NAME,
  charset: 'utf8mb4'
});

// 在文件顶部的导入语句之后添加
pool.getConnection()
  .then(connection => {
    log('Successfully connected to the database.');
    connection.release();
  })
  .catch(err => {
    log(`Error connecting to the database: ${err}`);
  });

// 在文件顶部的导入语句之后添加
surveyKingPool.getConnection()
  .then(connection => {
    log('Successfully connected to the SurveyKing database.');
    connection.release();
  })
  .catch(err => {
    log(`Error connecting to the SurveyKing database: ${err}`);
  });


// 验证令牌的中间件
const authenticateToken = async (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) return res.sendStatus(401);

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [decoded.userId]);
    
    if (rows.length === 0 || new Date() > new Date(rows[0].expiration_date)) {
      return res.status(403).json({ error: '无效的令牌或账号已过期' });
    }

    // 检查token是否是最新的
    if (token !== rows[0].active_token) {
      return res.status(403).json({ error: '您的账号已在其他设备登录' });
    }

    req.user = rows[0];
    next();
  } catch (error) {
    return res.status(403).json({ error: '无效的令牌' });
  }
};

// 生成一个简单的密钥对
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

// 添加获取公钥的路由
app.get('/public-key', (req, res) => {
  res.json({ publicKey });
});


// 登录路由
app.post('/login', async (req, res) => {
  const { data, key, iv } = req.body;
  
  try {
    // 解密数据
    const decrypted = CryptoJS.AES.decrypt(
      data,
      CryptoJS.enc.Base64.parse(key),
      {
        iv: CryptoJS.enc.Base64.parse(iv),
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
      }
    );
    
    // 将解密后的数据转换为字符串
    const decryptedString = decrypted.toString(CryptoJS.enc.Utf8);
    
    // 解析 JSON 数据
    const { student_id_or_username, password } = JSON.parse(decryptedString);
    
    log(`Login attempt for: ${student_id_or_username}`);
    
    try {
      const [rows] = await pool.query('SELECT * FROM users WHERE username = ? OR student_id = ?', [student_id_or_username, student_id_or_username]);
      
      log(`Database query result: ${rows}`);
      
      if (rows.length === 0) {
        log('User not found');
        return res.status(401).json({ error: '用户名/邮箱或密码错误' });
      }
      
      const user = rows[0];
      
      if (new Date() > new Date(user.expiration_date)) {
        log(`Account expired for user: ${user.username}`);
        return res.status(403).json({ error: '账户已过期，请联系系统管理员xxx' });
      }
      
      const isPasswordValid = await bcrypt.compare(password, user.password);
      
      log(`Password validation result: ${isPasswordValid}`);
      
      if (!isPasswordValid) {
        log('Invalid password');
        return res.status(401).json({ error: '用户名/学号或密码错误' });
      }
      
      const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '24h' });
      
      // 更新用户的active_token
      await pool.query('UPDATE users SET active_token = ?, last_login = ? WHERE id = ?', [token, new Date(), user.id]);
      
      log(`Login successful for user: ${user.username}`);
      
      res.json({ 
        success: true, 
        username: user.username, 
        token,
        level: user.level,
        model:LICENSE_INFO.model
      });
    } catch (error) {
      log(`登录失败: ${error}`);
      res.status(500).json({ error: '登录失败', details: error.message });
    }
  } catch (error) {
    log(`登录解密失败: ${error}`);
    res.status(500).json({ 
      error: '登录失败',
      details: process.env.NODE_ENV === 'development' ? error.message : undefined 
    });
  }
});

// 登入路由
app.post('/logout', authenticateToken, (req, res) => {
  res.json({ success: true });
});

// 检认证状态
app.get('/check-auth', authenticateToken, async (req, res) => {
  try {
    const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [req.user.id]);
    if (rows.length === 0 || new Date() > new Date(rows[0].expiration_date)) {
      return res.status(403).json({ error: '账户已过期或无效' });
    }
    res.json({ isAuthenticated: true, username: req.user.username, level: req.user.level });
  } catch (error) {
    log(`检查认证状态失败: ${error}`);
    res.status(500).json({ error: '检查认证状态失败' });
  }
});

// 验证令牌
app.post('/verify-token', async (req, res) => {
  const { token } = req.body;

  if (!token) {
    return res.json({ valid: false });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [decoded.userId]);
    
    if (rows.length === 0 || new Date() > new Date(rows[0].expiration_date)) {
      return res.json({ valid: false });
    }

    res.json({ valid: true, username: rows[0].username, level: rows[0].level });
  } catch (error) {
    res.json({ valid: false });
  }
});

// 修改获取用户信息路由
app.get('/user-info', authenticateToken, async (req, res) => {
  try {
    const [rows] = await pool.query(
      'SELECT username, class_name, student_id, organization, created_at, last_login, level FROM users WHERE id = ?', 
      [req.user.id]
    );
    
    if (rows.length > 0) {
      res.json({
        class_name: rows[0].class_name,
        username: rows[0].username,
        student_id: rows[0].student_id,
        organization: LICENSE_INFO.user,
        created_at: rows[0].created_at,
        last_login: rows[0].last_login,
        level: rows[0].level,
        model:LICENSE_INFO.model
      });
    } else {
      res.status(404).json({ error: '用户不存在' });
    }
  } catch (error) {
    log(`获取用户信息失败: ${error}`);
    res.status(500).json({ error: '获取用户信息失败' });
  }
});

// 验证管理员权限
app.get('/verify-admin', authenticateToken, async (req, res) => {
  try {
    const [rows] = await pool.query('SELECT level FROM users WHERE id = ?', [req.user.id]);
    if (rows.length > 0 && rows[0].level >= 7) {
      res.json({ isAdmin: true });
    } else {
      res.json({ isAdmin: false });
    }
  } catch (error) {
    log(`验证管理员权限失败: ${error}`);
    res.status(500).json({ error: '验证管理员权限失败' });
  }
});

// 查询用户
app.get('/admin/users', authenticateToken, async (req, res) => {
  try {
    const [userRows] = await pool.query('SELECT level FROM users WHERE id = ?', [req.user.id]);
    if (userRows.length === 0 || userRows[0].level < 7) {
      return res.status(403).json({ error: '没有权限访问此资源' });
    }

    const [rows] = await pool.query(
      'SELECT id, username, student_id, class_name, organization, created_at, last_login, level FROM users'
    );
    res.json(rows);
  } catch (error) {
    log(`获取用户列表失败: ${error}`);
    res.status(500).json({ error: '获取用户列表失败' });
  }
});

// 批量创建用户
app.post('/admin/users', authenticateToken, async (req, res) => {
  try {
    // 权限校验：仅管理员(level >= 3)可执行
    const [adminCheck] = await pool.query('SELECT level FROM users WHERE id = ?', [req.user.id]);
    if (adminCheck.length === 0 || adminCheck[0].level < 7) {
      return res.status(403).json({ success: false, error: '没有权限执行此操作' });
    }

    const { class_name, student_ids } = req.body;
    if (!class_name || !student_ids) {
      return res.status(400).json({ success: false, error: '请提供班级和学号' });
    }

    // 支持多种分隔符：空格、英文逗号、中文逗号、换行
    const idList = student_ids
      .split(/[\s,，\n]+/)
      .map(id => id.trim())
      .filter(id => id.length > 0);

    if (idList.length === 0) {
      return res.status(400).json({ success: false, error: '未检测到有效学号' });
    }

    // 根据LICENSE_INFO.model确定最大用户数量
    let maxUsers = 0; // 默认值
    const licenseModel = LICENSE_INFO.model || '';
    
    if (licenseModel.includes('EST-05E')) {
      maxUsers = 10;
    } else if (licenseModel.includes('EST-10E')) {
      maxUsers = 60;
    } else if (licenseModel.includes('EST-100E')) {
      maxUsers = 100;
    } else if (licenseModel.includes('EST-05C')) {
      maxUsers = 10;
    } else if (licenseModel.includes('EST-10C')) {
      maxUsers = 60;
    } else if (licenseModel.includes('EST-100C')) {
      maxUsers = 100;
    } else if (licenseModel.includes('EST-10A')) {
      maxUsers = 60;
    } else if (licenseModel.includes('EST-100A')) {
      maxUsers = 100;
    }else if (licenseModel.includes('EST-100D')) {
      maxUsers = 100;
    }

    // 检查当前用户数量
    const [currentUsers] = await pool.query('SELECT COUNT(*) as count FROM users');
    const currentUserCount = currentUsers[0].count -1;
    
    // 计算可以创建的最大新用户数量
    const maxNewUsers = maxUsers - currentUserCount;
    
    // 如果新用户数量超过限制，返回错误
    if (idList.length > maxNewUsers) {
      return res.status(400).json({ 
        success: false, 
        error: `超出许可证用户数量限制，当前许可证(${licenseModel})最多允许${maxUsers}个用户，已有${currentUserCount}个用户，最多可创建${maxNewUsers}个新用户` 
      });
    }

    let createdCount = 0;
    let skipped = [];

    for (const sid of idList) {
      // 检查是否已存在
      const [exists] = await pool.query('SELECT id FROM users WHERE student_id = ?', [sid]);
      if (exists.length > 0) {
        skipped.push(sid);
        continue;
      }

      const plainPassword = sid;
      const password = await bcrypt.hash(plainPassword, 10); // saltRounds = 10

      const organization = LICENSE_INFO.user;
      const level = 0

      await pool.query(
        `INSERT INTO users (username, student_id, class_name, organization, level, password, created_at)
         VALUES (?, ?, ?, ?, ?, ?, NOW())`,
        [sid, sid, class_name, organization, level, password]
      );

      createdCount++;
    }

    res.json({
      success: true,
      createdCount,
      skipped,
      message: `成功创建 ${createdCount} 个用户，跳过 ${skipped.length} 个已存在的用户`,
      licenseInfo: {
        model: licenseModel,
        maxUsers: maxUsers,
        currentUsers: currentUserCount + createdCount,
        remainingSlots: maxUsers - (currentUserCount + createdCount)
      }
    });

  } catch (error) {
    console.error('批量创建用户失败:', error);
    res.status(500).json({ success: false, error: '批量创建用户失败', details: error.message });
  }
});

// 删除用户
app.delete('/admin/users/:student_id', authenticateToken, async (req, res) => {
  try {
    const [adminCheck] = await pool.query('SELECT level FROM users WHERE id = ?', [req.user.id]);
    if (adminCheck.length === 0 || adminCheck[0].level < 7) {
      return res.status(403).json({ success: false, error: '没有权限执行此操作' });
    }

    const studentId = req.params.student_id;
    const [result] = await pool.query('DELETE FROM users WHERE student_id = ?', [studentId]);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, error: '未找到该用户' });
    }

    res.json({ success: true, message: `已删除用户 ${studentId}` });
  } catch (error) {
    console.error('删除用户失败:', error);
    res.status(500).json({ success: false, error: '删除用户失败' });
  }
});


let onlineUsers = new Map();
let onlineHistory = [];

const ONLINE_DATA_FILE = path.join(__dirname, 'online_data.json');
const LONG_TERM_HISTORY_FILE = path.join(__dirname, 'long_term_history.json');

// 加载在线用户数据
async function loadOnlineData() {
  try {
    const data = await fsPromises.readFile(ONLINE_DATA_FILE, 'utf8');
    const parsedData = JSON.parse(data);
    onlineHistory = parsedData.history;
    onlineUsers = new Map(parsedData.users.map(([id, user]) => [parseInt(id), user]));
  } catch (error) {
    if (error.code !== 'ENOENT') {
      console.error('加载在线用户数据失败:', error);
    }
  }
}

// 保存在线用户数据
async function saveOnlineData() {
  try {
    const data = JSON.stringify({
      history: onlineHistory,
      users: Array.from(onlineUsers.entries())
    });
    await fsPromises.writeFile(ONLINE_DATA_FILE, data, 'utf8');
  } catch (error) {
    console.error('保存在线用户数据失败:', error);
  }
}


// 更新在线用户并记录历史
async function updateOnlineUsers() {
  const now = new Date();
  // 清理超时的用户（例如，15分钟无活动）
  for (const [userId, userData] of onlineUsers.entries()) {
    if (now - new Date(userData.lastActivity) > 5 * 60 * 1000) {
      onlineUsers.delete(userId);
    }
  }

  const currentOnlineUsers = {
    time: now.toISOString(),
    count: onlineUsers.size,
    users: Array.from(onlineUsers.values()).map(u => u.username)
  };

  onlineHistory.push(currentOnlineUsers);

  // 将超过24小时的记录移动到长期历史记录
  const oneDayAgo = new Date(now - 24 * 60 * 60 * 1000);
  const oldRecords = onlineHistory.filter(item => new Date(item.time) <= oneDayAgo);
  onlineHistory = onlineHistory.filter(item => new Date(item.time) > oneDayAgo);


  await saveOnlineData();
}

// 每10秒更新一次在线用户状态
setInterval(updateOnlineUsers, 10000);

// 在服务器启动时加载在线用户数据
loadOnlineData().then(() => {
  console.log('在线用户数据加载完成');
});

// 登录路由
app.post('/login', async (req, res) => {
  // ... 现有的登录逻辑 ...

  if (response.data.success) {
    // 添加用户到在线列表
    onlineUsers.set(user.id, {
      username: user.username,
      lastActivity: new Date().toISOString()
    });
    await saveOnlineData();
  }

  res.json({ success: true });
});

// 获取在线用户和历史记录
app.get('/online-users', authenticateToken, (req, res) => {
  res.json({
    currentOnline: {
      count: onlineUsers.size,
      users: Array.from(onlineUsers.values()).map(u => u.username)
    },
    history: onlineHistory
  });
});

// 更新用户活动时间
app.post('/update-activity', authenticateToken, async (req, res) => {
  if (onlineUsers.has(req.user.id)) {
    onlineUsers.get(req.user.id).lastActivity = new Date().toISOString();
  } else {
    onlineUsers.set(req.user.id, {
      username: req.user.username,
      lastActivity: new Date().toISOString()
    });
  }
  await saveOnlineData();
  res.sendStatus(200);
});

// 登出路由
app.post('/logout', authenticateToken, async (req, res) => {
  onlineUsers.delete(req.user.id);
  await saveOnlineData();
  res.json({ success: true });
});



// --------------------------LIC验证-------------------
// 全局许可证信息
const LICENSE_INFO = {
  isValid: false,
  model: "",
  user: "",
  serial: "",
  activation_code: "",
  activated_at: "",
  expires_at: "",
  gold_service_expires_at: "",
  issued_at: "",
  issuer: "",
  hardware_id: "" // 新增硬件码字段
};

// 获取系统硬件序列号
async function getHardwareSerial() {
  try {
    const hardwareSerial = await fsPromises.readFile('/hardware_serial', 'utf8');
    return hardwareSerial.trim();
  } catch (error) {
    log(`读取硬件序列号失败: ${error.message}`);
    throw error;
  }
}

// License 验证相关功能
// 获取目录下所有 .lic 文件
async function getLicenseFiles() {
  try {
    const licenseDir = path.join(__dirname, 'license');
    const files = await fsPromises.readdir(licenseDir);
    return files.filter(file => file.endsWith('.lic'));
  } catch (error) {
    if (error.code === 'ENOENT') {
      // 如果目录不存在，返回空数组
      return [];
    }
    log(`获取 License 文件失败: ${error.message}`);
    throw error;
  }
}

// 清空 LICENSE_INFO
function clearLicenseInfo() {
  Object.keys(LICENSE_INFO).forEach(key => {
    LICENSE_INFO[key] = typeof LICENSE_INFO[key] === 'boolean' ? false : "";
  });
}

// 读取公钥文件
async function readPublicKey() {
  try {
    const pubKeyPath = path.join(__dirname, 'pub.pem');
    const publicKeyData = await fsPromises.readFile(pubKeyPath, 'utf8');
    return publicKeyData;
  } catch (error) {
    log(`读取公钥文件失败: ${error.message}`);
    throw error;
  }
}

// 验证 License 文件
async function verifyLicense(licenseFile, publicKey) {
  try {
    const licenseDir = path.join(__dirname, 'license');
    const licenseData = await fsPromises.readFile(path.join(licenseDir, licenseFile), 'utf8');
    const license = JSON.parse(licenseData);
    
    // 解码 payload
    const payloadStr = Buffer.from(license.payload, 'base64').toString('utf8');
    const payload = JSON.parse(payloadStr);
    
    // 验证签名
    const verify = crypto.createVerify('SHA256');
    verify.update(payloadStr);
    const isValid = verify.verify(publicKey, license.signature, 'base64');

    // 验证硬件码匹配
    const hardwareSerial = await getHardwareSerial();
    const hardwareMatches = payload.hardware_id === hardwareSerial;
    
    // 只有在签名验证成功且硬件码匹配时才更新许可证信息
    if (isValid && hardwareMatches) {
      LICENSE_INFO.isValid = true;
      LICENSE_INFO.model = payload.model || "";
      LICENSE_INFO.user = payload.user || "";
      LICENSE_INFO.serial = payload.serial || "";
      LICENSE_INFO.activation_code = payload.activation_code || "";
      LICENSE_INFO.activated_at = payload.activated_at || "";
      LICENSE_INFO.expires_at = payload.expires_at || "";
      LICENSE_INFO.gold_service_expires_at = payload.gold_service_expires_at || "";
      LICENSE_INFO.issued_at = payload.issued_at || "";
      LICENSE_INFO.issuer = payload.issuer || "";
      LICENSE_INFO.hardware_id = payload.hardware_id || "";
    } else {
      clearLicenseInfo();
    }
    
    return {
      isValid,
      hardwareMatches,
      licenseFile,
      payload
    };
  } catch (error) {
    log(`验证 License 文件失败 (${licenseFile}): ${error.message}`);
    clearLicenseInfo();
    return {
      isValid: false,
      hardwareMatches: false,
      licenseFile,
      error: error.message
    };
  }
}

// 验证所有 License 文件
async function verifyAllLicenses() {
  try {
    const licenseFiles = await getLicenseFiles();
    if (licenseFiles.length === 0) {
      log('未找到任何 License 文件');
      clearLicenseInfo();
      return [];
    }
    
    // 只验证最新的 license 文件
    const latestLicenseFile = licenseFiles[licenseFiles.length - 1];
    log(`验证最新的 License 文件: ${latestLicenseFile}`);
    
    try {
      const publicKey = await readPublicKey();
      log('成功读取公钥文件 pub.pem');
      
      const result = await verifyLicense(latestLicenseFile, publicKey);
      
      // 输出验证结果
      if (result.isValid && result.hardwareMatches) {
        log(`License 验证成功: ${latestLicenseFile}`);
        log(`License 信息: ${JSON.stringify(result.payload, null, 2)}`);
      } else {
        log(`License 验证失败: ${latestLicenseFile}`);
        if (!result.isValid) {
          log('签名验证失败');
        }
        if (!result.hardwareMatches) {
          log('硬件码不匹配');
        }
        if (result.error) {
          log(`错误信息: ${result.error}`);
        }
        clearLicenseInfo();
      }
      
      return [result];
    } catch (error) {
      log(`读取公钥失败: ${error.message}`);
      clearLicenseInfo();
      return [{
        isValid: false,
        hardwareMatches: false,
        licenseFile: latestLicenseFile,
        error: '无法读取公钥文件'
      }];
    }
  } catch (error) {
    log(`验证所有 License 文件失败: ${error.message}`);
    clearLicenseInfo();
    throw error;
  }
}

// 获取许可证信息
function getLicenseInfo() {
  return LICENSE_INFO;
}

// 添加获取许可证信息的API端点
app.get('/license-info', authenticateToken, (req, res) => {
  res.json({
    success: true,
    licenseInfo: LICENSE_INFO
  });
});

// 添加获取产品型号的API端点
app.get('/product-model', (req, res) => {
  res.json({
    success: true,
    isValid: LICENSE_INFO.isValid,
    model: LICENSE_INFO.model
  });
});

// 添加上传许可证文件的API端点
app.post('/upload-license', async (req, res) => {
  if (!req.files || Object.keys(req.files).length === 0) {
    return res.status(400).json({ success: false, error: '未上传文件' });
  }

  const licenseFile = req.files.license;
  
  // 验证文件扩展名
  if (!licenseFile.name.endsWith('.lic')) {
    return res.status(400).json({ success: false, error: '文件必须是.lic格式' });
  }

  try {
    // 验证硬件码匹配
    const hardwareSerial = await getHardwareSerial();
    
    // 读取并解析上传的 license 文件内容
    const licenseContent = licenseFile.data.toString('utf8');
    const license = JSON.parse(licenseContent);
    const payloadStr = Buffer.from(license.payload, 'base64').toString('utf8');
    const payload = JSON.parse(payloadStr);
    
    // 检查硬件码是否匹配
    if (payload.hardware_id !== hardwareSerial) {
      return res.status(400).json({ 
        success: false,
        error: '硬件码不匹配，无法使用此许可证' 
      });
    }

    // 确保 license 目录存在
    const licenseDir = path.join(__dirname, 'license');
    await fsPromises.mkdir(licenseDir, { recursive: true });
    
    // 删除现有的所有 license 文件
    const existingFiles = await getLicenseFiles();
    for (const file of existingFiles) {
      await fsPromises.unlink(path.join(licenseDir, file));
      log(`删除旧的许可证文件: ${file}`);
    }
    
    // 保存新的 license 文件
    await licenseFile.mv(path.join(licenseDir, licenseFile.name));
    log(`新的许可证文件 ${licenseFile.name} 上传成功到 license 目录`);
    
    // 重新验证许可证
    await verifyAllLicenses();
    
    res.json({
      success: true,
      message: '许可证文件上传并验证成功',
      licenseInfo: LICENSE_INFO
    });
  } catch (error) {
    log(`许可证文件上传失败: ${error.message}`);
    res.status(500).json({ success: false, error: '许可证文件上传失败' });
  }
});

// 检查许可证状态的API端点
app.get('/license-status', (req, res) => {
  res.json({
    success: true,
    isValid: LICENSE_INFO.isValid
  });
});

// 监视 license 目录变化
const licenseDir = path.join(__dirname, 'license');
fs.mkdir(licenseDir, { recursive: true }, (err) => {
  if (err) {
    log(`创建 license 目录失败: ${err.message}`);
    return;
  }
  
  fs.watch(licenseDir, async (eventType, filename) => {
    if (filename && filename.endsWith('.lic')) {
      log(`检测到 license 目录变化: ${eventType} - ${filename}`);
      try {
        await verifyAllLicenses();
      } catch (error) {
        log(`处理 license 目录变化时发生错误: ${error.message}`);
      }
    }
  });
});

// 在服务器启动时验证 License 文件
(async function checkLicensesOnStartup() {
  log('正在验证 License 文件...');
  try {
    await verifyAllLicenses();
    log('License 验证完成');
  } catch (error) {
    log(`License 验证过程中发生错误: ${error.message}`);
  }
})();

// ---------------------------------------------------------------

// -----------------添加查询 SurveyKing 答案数据的接口----------
app.get('/survey-answers', async (req, res) => {
  try {
    const { org } = req.query;
    
    if (!org) {
      return res.status(400).json({
        success: false,
        error: '请提供组织名称参数 (org)'
      });
    }

    // 基础查询
    const query = `
      SELECT 
        project_id,
        answer,
        exam_score,
        update_at
      FROM t_answer 
      WHERE 1=1
    `;

    // 执行查询
    const [rows] = await surveyKingPool.query(query);

    // 处理结果，解析 answer 列中的 JSON 数据并只返回匹配组织的数据
    const processedData = rows.map(row => {
      try {
        const answerData = JSON.parse(row.answer);
        
        // 查找包含 estorg 的键
        let organization = '';
        let username = '';
        
        // 遍历对象查找 estorg
        for (const key in answerData) {
          if (answerData[key].estorg) {
            organization = answerData[key].estorg;
          }
          if (answerData[key].estuser) {
            username = answerData[key].estuser;
          }
        }

        // 只返回匹配组织的数据
        if (organization && organization.toLowerCase() === org.toLowerCase()) {
          return {
            projectId: row.project_id,
            organization: organization,
            username: username,
            score: row.exam_score,
            submitTime: row.update_at
          };
        }
        return null;
      } catch (error) {
        console.error(`解析答案数据失败: ${error}`);
        return null;
      }
    }).filter(item => item !== null); // 移除不匹配的数据

    // 按提交时间降序排序
    processedData.sort((a, b) => new Date(b.submitTime) - new Date(a.submitTime));

    res.json({
      success: true,
      total: processedData.length,
      data: processedData
    });

  } catch (error) {
    console.error(`获取答案数据失败: ${error}`);
    res.status(500).json({ 
      success: false, 
      error: '获取答案数据失败',
      message: error.message 
    });
  }
});
// --------------------------------------------------

// -----------场景化功能切换API-----------------------
app.post('/admin/toggle-scenario', authenticateToken, async (req, res) => {
  try {
    // 验证管理员权限
    const [adminCheck] = await pool.query('SELECT level FROM users WHERE id = ?', [req.user.id]);
    if (adminCheck.length === 0 || adminCheck[0].level < 7) {
      return res.status(403).json({ 
        success: false, 
        message: '没有权限执行此操作' 
      });
    }

    const { student_id, new_level } = req.body;
    
    // 如果是要关闭场景化功能，直接执行
    if (new_level === 0) {
      const [updateResult] = await pool.query(
        'UPDATE users SET level = ? WHERE student_id = ?', 
        [0, student_id]
      );
      
      if (updateResult.affectedRows === 0) {
        return res.status(404).json({ 
          success: false, 
          message: '未找到该用户' 
        });
      }
      
      return res.json({ 
        success: true, 
        message: '已关闭场景化功能', 
        new_level: 0 
      });
    }
    
    // 如果是要开启场景化功能，需要检查许可证和当前已开启的用户数量
    // 根据LICENSE_INFO.model确定最大用户数
    let maxScenarioUsers = 0;
    const model = LICENSE_INFO.model;
    
    switch (model) {
      case 'EST-05E':
        maxScenarioUsers = 5;
        break;
      case 'EST-10E':
        maxScenarioUsers = 30;
        break;
      case 'EST-100E':
        maxScenarioUsers = 50;
        break;
      case 'EST-05C':
        maxScenarioUsers = 5;
        break;
      case 'EST-10C':
        maxScenarioUsers = 30;
        break;
      case 'EST-100C':
        maxScenarioUsers = 50;
        break;
      case 'EST-10A':
        maxScenarioUsers = 30;
        break;
      case 'EST-100A':
        maxScenarioUsers = 50;
        break;
      case 'EST-100D':
        maxScenarioUsers = 50;
        break;
      default:
        maxScenarioUsers = 0;
    }
    
    // 如果没有有效的许可证或型号不支持
    if (!LICENSE_INFO.isValid || maxScenarioUsers === 0) {
      return res.status(403).json({ 
        success: false, 
        message: '无有效许可证或当前型号不支持场景化功能' 
      });
    }
    
    // 查询当前已开启场景化功能的用户数量（level=1或level=4）
    const [countResult] = await pool.query(
      'SELECT COUNT(*) as count FROM users WHERE level = 1 OR level = 4'
    );
    
    const currentCount = countResult[0].count;
    
    // 如果当前数量已达到最大值，拒绝请求
    if (currentCount >= maxScenarioUsers) {
      return res.status(403).json({ 
        success: false, 
        message: `已达到最大场景化用户数量限制${maxScenarioUsers}位用户` 
      });
    }
    
    // 更新用户等级为1（开启场景化功能）
    const [updateResult] = await pool.query(
      'UPDATE users SET level = ? WHERE student_id = ?', 
      [1, student_id]
    );
    
    if (updateResult.affectedRows === 0) {
      return res.status(404).json({ 
        success: false, 
        message: '未找到该用户' 
      });
    }
    
    return res.json({ 
      success: true, 
      message: '已开启场景化功能', 
      new_level: 1 
    });
    
  } catch (error) {
    console.error('切换场景化功能失败:', error);
    res.status(500).json({ 
      success: false, 
      message: '操作失败，请稍后再试', 
      error: error.message 
    });
  }
});

// ---------------------------------------------------



// ---------------------宿主机网络配置----------------------------
// 网络配置相关 API
const NETWORK_CONFIG_FILE = path.join(__dirname, 'network');

// 读取网络配置
async function readNetworkConfig() {
  try {
    const config = await fsPromises.readFile(NETWORK_CONFIG_FILE, 'utf8');
    const configObj = {};
    config.split('\n').forEach(line => {
      const [key, value] = line.split('=').map(part => part.trim());
      if (key && value) {
        // 移除引号
        configObj[key] = value.replace(/^"(.*)"$/, '$1');
      }
    });
    return configObj;
  } catch (error) {
    log(`读取网络配置失败: ${error.message}`);
    throw error;
  }
}

// 写入网络配置
async function writeNetworkConfig(config) {
  try {
    let configContent = '';
    for (const [key, value] of Object.entries(config)) {
      // DNS 需要特殊处理，添加引号
      if (key === 'DNS') {
        configContent += `${key}="${value}"\n`;
      } else {
        configContent += `${key}=${value}\n`;
      }
    }
    await fsPromises.writeFile(NETWORK_CONFIG_FILE, configContent);
  } catch (error) {
    log(`写入网络配置失败: ${error.message}`);
    throw error;
  }
}

// 获取网络配置 API
app.get('/network-config', authenticateToken, async (req, res) => {
  try {
    const config = await readNetworkConfig();
    res.json({
      success: true,
      config
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: '获取网络配置失败'
    });
  }
});

// 更新网络配置 API
app.post('/network-config', authenticateToken, async (req, res) => {
  try {
    const { config } = req.body;
    
    // 基本验证
    if (!config || typeof config !== 'object') {
      return res.status(400).json({
        success: false,
        error: '无效的配置数据'
      });
    }

    if (!config.BOOTPROTO) {
      return res.status(400).json({
        success: false,
        error: '缺少必需字段: BOOTPROTO'
      });
    }
    // 限定 BOOTPROTO 的取值
    if (!['dhcp', 'static'].includes(config.BOOTPROTO)) {
      return res.status(400).json({
        success: false,
        error: 'BOOTPROTO 仅支持 dhcp 或 static'
      });
    }

    // 如果是静态 IP，验证额外字段
    if (config.BOOTPROTO === 'static') {
      const staticFields = ['IPADDR', 'NETMASK', 'GATEWAY', 'DNS'];
      for (const field of staticFields) {
        if (!config[field]) {
          return res.status(400).json({
            success: false,
            error: `静态 IP 配置缺少必需字段: ${field}`
          });
        }
      }
    }

    const existingConfig = await readNetworkConfig();
    const allowedUpdateKeys = ['BOOTPROTO', 'IPADDR', 'NETMASK', 'GATEWAY', 'DNS'];
    const updatedConfig = { ...existingConfig };
    for (const key of allowedUpdateKeys) {
      if (config[key] !== undefined) {
        updatedConfig[key] = config[key];
      }
    }

    if (config.BOOTPROTO === 'dhcp') {
      for (const key of ['IPADDR', 'NETMASK', 'GATEWAY', 'DNS']) {
        delete updatedConfig[key];
      }
    }

    await writeNetworkConfig(updatedConfig);
    res.json({
      success: true,
      message: '网络配置已更新'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: '更新网络配置失败'
    });
  }
});

// ------------------------------------------------------

// -------------------------API启动设置-----------------
const PORT = process.env.PORT || 3000;
// 如果作为主模块运行（独立启动），才开启监听；作为子服务被挂载时不监听端口
if (require.main === module) {
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    log(`Server running on port ${PORT}`);
  });
}

// 导出 Express 应用，供主入口统一挂载
module.exports = app;

// 在程序退出时关闭日志流
process.on('exit', () => {
  logStream.end();
});

// 捕获未捕获的异常并记录日志
process.on('uncaughtException', (error) => {
  log(`Uncaught Exception: ${error.message}`);
  process.exit(1);
});

// 捕获未处理的 Promise 拒绝并记录日志
process.on('unhandledRejection', (reason, promise) => {
  log(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
});