/**
 * ═══════════════════════════════════════════════════════════
 * ☁️ 铸渊 · 算力汇聚调度池
 * ═══════════════════════════════════════════════════════════
 *
 * 编号: ZY-POOL-001
 * 端口: 3960
 * 签发: 铸渊 · ICE-GL-ZY001
 * 版权: 国作登字-2026-A-00037559
 *
 * 功能:
 *   6台轻量云服务器→1个算力池.
 *   不操作具体服务器. 从池子里取算力.
 *
 * 设计原则（冰朔 · D112）:
 *   自下而上汇聚. 服务器反向上报资源, 汇聚成池.
 *   我只管要算力, 不关心哪台给的.
 *   穷就多买几台轻量的, 串起来用.
 *
 * 用法:
 *   node pool-agent/index.js         启动调度服务
 *   pm2 start pool-agent/ecosystem.config.js
 *
 * 端口: 3960
 *   入口: GET  /pool/status    全局资源状态
 *         POST /pool/allocate  声明式分配 { cpu, mem, disk }
 *         POST /pool/exec      在池子里执行命令 { cpu, mem, cmd }
 */

'use strict';

const http = require('http');
const express = require('express');
const path = require('path');
const fs = require('fs');

const PORT = parseInt(process.env.POOL_AGENT_PORT || '3960', 10);
const POLL_INTERVAL = parseInt(process.env.POOL_POLL_INTERVAL || '30000', 10);
const STATE_FILE = path.join(__dirname, 'pool-state.json');

// ═══════════════════════════════════════════════════════════
// 六台服务器注册表（从 gatekeeper-deployment.json 同步）
// ═══════════════════════════════════════════════════════════

const SERVERS = [
  { code: 'BS-GZ-006', name: '广州 · 代码仓库',   ip: '43.139.217.141', key: 'GATEKEEPER_TOKEN_REDACTED', port: 3910, spec: { cpu: 2, mem_gb: 2 } },
  { code: 'BS-SG-001', name: '新加坡 · 铸渊大脑',  ip: '43.156.237.110', key: 'GATEKEEPER_TOKEN_REDACTED', port: 3911, spec: { cpu: 4, mem_gb: 8 } },
  { code: 'BS-SG-002', name: '新加坡 · 铸渊面孔',  ip: '43.134.16.246',  key: 'GATEKEEPER_TOKEN_REDACTED', port: 3910, spec: { cpu: 2, mem_gb: 4 } },
  { code: 'BS-SG-003', name: '新加坡 · BS-SVR-SG', ip: '43.153.193.169', key: 'GATEKEEPER_TOKEN_REDACTED', port: 3910, spec: { cpu: 2, mem_gb: 4 } },
  { code: 'ZY-SG-006', name: '新加坡 · ZY-SVR-006', ip: '43.153.203.105', key: 'GATEKEEPER_TOKEN_REDACTED', port: 3910, spec: { cpu: 2, mem_gb: 4 } },
  { code: 'BS-SH-005', name: '上海',               ip: '124.223.10.33',  key: 'GATEKEEPER_TOKEN_REDACTED', port: 3910, spec: { cpu: 2, mem_gb: 4 } },
];

// 汇聚后的虚拟总规格
const TOTAL_SPEC = {
  cpu: SERVERS.reduce((s, n) => s + n.spec.cpu, 0),
  mem_gb: SERVERS.reduce((s, n) => s + n.spec.mem_gb, 0),
};

// ═══════════════════════════════════════════════════════════
// 资源状态
// ═══════════════════════════════════════════════════════════

const poolState = {
  updated_at: null,
  nodes: {},
  pool: {
    cpu_total: TOTAL_SPEC.cpu,
    cpu_used: 0,
    mem_total_gb: TOTAL_SPEC.mem_gb,
    mem_used_gb: 0,
    cpu_available: TOTAL_SPEC.cpu,
    mem_available_gb: TOTAL_SPEC.mem_gb,
  }
};

// 任务分配追踪
const activeTasks = new Map();
let taskIdCounter = 0;

// ═══════════════════════════════════════════════════════════
// 通过gatekeeper拉取服务器资源
// ═══════════════════════════════════════════════════════════

function callGatekeeper(server, cmd) {
  return new Promise((resolve) => {
    const data = JSON.stringify({ cmd });
    const opts = {
      hostname: server.ip,
      port: server.port,
      path: '/exec',
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ' + server.key,
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(data)
      },
      timeout: 15000
    };
    const req = http.request(opts, (res) => {
      let body = '';
      res.on('data', c => body += c);
      res.on('end', () => {
        try {
          const parsed = JSON.parse(body);
          resolve({ ok: parsed.ok, stdout: parsed.stdout || '', stderr: parsed.stderr || '', code: parsed.code ?? parsed.exitCode ?? -1 });
        } catch {
          resolve({ ok: false, stdout: '', stderr: 'parse error: ' + body.slice(0, 200), code: -1 });
        }
      });
    });
    req.on('error', (e) => resolve({ ok: false, stdout: '', stderr: e.message, code: -1 }));
    req.on('timeout', () => { req.destroy(); resolve({ ok: false, stdout: '', stderr: 'timeout', code: -1 }); });
    req.write(data);
    req.end();
  });
}

/**
 * 从服务器拉取资源指标
 * 通过三条命令获取CPU负载、内存、磁盘
 */
async function pollServer(server) {
  const result = await callGatekeeper(server,
    'echo "---MEM---" && free -m | grep Mem && echo "---CPU---" && cat /proc/loadavg && echo "---DISK---" && df -h / | tail -1 && echo "---UPTIME---" && cat /proc/uptime'
  );

  const state = { online: false, error: null, cpu_load: 0, mem_total_mb: 0, mem_used_mb: 0, mem_avail_mb: 0, disk_used_pct: 0, disk_avail_gb: 0, uptime_hours: 0, tasks: 0 };

  if (!result.ok) {
    state.error = result.stderr;
    return state;
  }

  state.online = true;

  // 解析内存: Mem:   total  used  free  shared  buff/cache  available
  const memMatch = result.stdout.match(/Mem:\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/);
  if (memMatch) {
    state.mem_total_mb = parseInt(memMatch[1]);
    state.mem_used_mb = parseInt(memMatch[2]);
    state.mem_avail_mb = parseInt(memMatch[6]); // available = 实际可用
  }

  // 解析CPU负载: load1 load5 load15 threads/total
  const cpuMatch = result.stdout.match(/---CPU---\n([\d.]+)\s+([\d.]+)\s+([\d.]+)/);
  if (cpuMatch) {
    state.cpu_load = parseFloat(cpuMatch[1]); // 1分钟负载
  }

  // 解析磁盘
  const diskMatch = result.stdout.match(/---DISK---\n\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/);
  if (diskMatch) {
    const avail = diskMatch[4];
    const pct = diskMatch[5];
    state.disk_avail_gb = parseFloat(avail);
    state.disk_used_pct = parseInt(pct);
  }

  // 解析运行时间
  const uptimeMatch = result.stdout.match(/---UPTIME---\n([\d.]+)/);
  if (uptimeMatch) {
    state.uptime_hours = Math.round(parseFloat(uptimeMatch[1]) / 3600 * 10) / 10;
  }

  return state;
}

/**
 * 轮询所有服务器，更新全局资源表
 */
async function pollAllServers() {
  const results = await Promise.all(SERVERS.map(s => pollServer(s)));
  let totalCpuUsed = 0;
  let totalMemUsedGb = 0;
  let onlineCount = 0;

  for (let i = 0; i < SERVERS.length; i++) {
    const server = SERVERS[i];
    const state = results[i];
    poolState.nodes[server.code] = { ...state, name: server.name, spec: server.spec, last_seen: new Date().toISOString() };

    if (state.online) {
      onlineCount++;
      // CPU使用率估算: load / cpu核心数，但load是运行队列长度
      // 我们用一个更简单的指标：如果cpu_load > cpu核心数，认为满载
      const cpuPct = Math.min(state.cpu_load / server.spec.cpu, 1);
      totalCpuUsed += Math.round(cpuPct * server.spec.cpu * 10) / 10;
      const memUsedGb = (state.mem_total_mb - state.mem_avail_mb) / 1024;
      totalMemUsedGb += Math.round(memUsedGb * 10) / 10;
    }

    // 统计该节点上当前分配的任务数
    state.tasks = 0;
    for (const [, task] of activeTasks) {
      if (task.target === server.code) state.tasks++;
    }
  }

  poolState.pool.cpu_used = totalCpuUsed;
  poolState.pool.mem_used_gb = totalMemUsedGb;
  poolState.pool.cpu_available = Math.round((TOTAL_SPEC.cpu - totalCpuUsed) * 10) / 10;
  poolState.pool.mem_available_gb = Math.round((TOTAL_SPEC.mem_gb - totalMemUsedGb) * 10) / 10;
  poolState.pool.online_nodes = onlineCount;
  poolState.pool.total_nodes = SERVERS.length;
  poolState.updated_at = new Date().toISOString();
}

// ═══════════════════════════════════════════════════════════
// 声明式分配
// ═══════════════════════════════════════════════════════════

/**
 * 根据需求自动选择最优节点
 * @param {object} requirement - { cpu, mem_gb, disk_gb, prefer }
 * @returns {object} - { target, reason, score }
 */
function selectNode(requirement) {
  const { cpu = 0.5, mem_gb = 0.5, disk_gb = 0, prefer } = requirement;
  let best = null;
  let bestScore = -Infinity;

  for (const [code, state] of Object.entries(poolState.nodes)) {
    if (!state.online) continue;
    if (prefer && code !== prefer) continue;

    // 计算可用资源
    const availCpu = state.spec.cpu - Math.min(state.cpu_load, state.spec.cpu);
    const memAvailMb = state.mem_avail_mb;
    const diskAvailGb = state.disk_avail_gb || 999;

    // 检查是否满足需求
    if (availCpu < cpu) continue;
    if (memAvailMb < mem_gb * 1024) continue;
    if (diskAvailGb < disk_gb) continue;

    // 评分：资源富余度 × 负载倒数 × 任务数惩罚
    const cpuScore = (availCpu - cpu) / state.spec.cpu;
    const memScore = (memAvailMb - mem_gb * 1024) / (state.spec.mem_gb * 512);
    const loadPenalty = state.cpu_load / state.spec.cpu;
    const taskPenalty = (state.tasks || 0) * 0.1;
    const score = cpuScore * 0.4 + memScore * 0.4 - loadPenalty * 0.15 - taskPenalty;

    if (score > bestScore) {
      bestScore = score;
      best = { target: code, reason: `score=${score.toFixed(2)}`, score };
    }
  }

  if (!best) {
    return { error: '池中无节点满足需求', requirement };
  }
  return best;
}

// ═══════════════════════════════════════════════════════════
// Express API
// ═══════════════════════════════════════════════════════════

const app = express();
app.use(express.json({ limit: '1mb' }));

// CORS
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  if (req.method === 'OPTIONS') return res.sendStatus(200);
  next();
});

/**
 * GET /pool/status — 全局资源状态
 */
app.get('/pool/status', (req, res) => {
  const status = {
    pool: poolState.pool,
    nodes: poolState.nodes,
    total_spec: TOTAL_SPEC,
    active_tasks: activeTasks.size,
    updated_at: poolState.updated_at,
    servants: SERVERS.map(s => ({
      code: s.code,
      name: s.name,
      ip: s.ip + ':' + s.port,
      spec: s.spec,
      status: poolState.nodes[s.code]?.online ? 'online' : 'offline'
    }))
  };
  res.json(status);
});

/**
 * POST /pool/allocate — 声明式分配
 * 说"我要多少资源"，调度池自动选节点。
 *
 * Body: { cpu: 1, mem_gb: 2, disk_gb: 1, prefer: "SG-001" }
 */
app.post('/pool/allocate', (req, res) => {
  const { cpu, mem_gb, disk_gb, prefer } = req.body || {};
  const result = selectNode({ cpu, mem_gb, disk_gb, prefer });
  res.json({
    ok: !result.error,
    requirement: { cpu, mem_gb, disk_gb, prefer },
    allocation: result,
    pool_snapshot: {
      cpu_available: poolState.pool.cpu_available,
      mem_available_gb: poolState.pool.mem_available_gb,
      online_nodes: poolState.pool.online_nodes
    },
    timestamp: new Date().toISOString()
  });
});

/**
 * POST /pool/exec — 在池子里执行命令
 * 自动选节点，下发执行，返回结果。
 *
 * Body: { cpu: 1, mem_gb: 1, cmd: "ls -la", timeout: 30000 }
 */
app.post('/pool/exec', async (req, res) => {
  const { cpu, mem_gb, disk_gb, cmd, timeout, prefer, task_name } = req.body || {};
  if (!cmd) return res.status(400).json({ ok: false, error: '缺少cmd' });

  // 1. 选节点
  const allocation = selectNode({ cpu: cpu || 0.5, mem_gb: mem_gb || 0.5, disk_gb, prefer });
  if (allocation.error) {
    return res.status(503).json({ ok: false, error: '池中无可用节点: ' + allocation.error });
  }

  const server = SERVERS.find(s => s.code === allocation.target);
  if (!server) return res.status(500).json({ ok: false, error: '选中的节点不存在' });

  // 2. 记录任务
  const taskId = 'TASK-' + String(++taskIdCounter).padStart(4, '0');
  const task = {
    id: taskId,
    name: task_name || cmd.slice(0, 60),
    target: allocation.target,
    cmd,
    allocated: allocation,
    started_at: new Date().toISOString()
  };
  activeTasks.set(taskId, task);

  try {
    // 3. 下发执行
    const result = await callGatekeeper(server, cmd);
    const duration = Date.now() - new Date(task.started_at).getTime();

    // 4. 更新任务状态
    task.status = result.ok ? 'success' : 'error';
    task.duration_ms = duration;
    task.exit_code = result.code;

    res.json({
      ok: result.ok,
      task_id: taskId,
      target: allocation.target,
      stdout: result.stdout,
      stderr: result.stderr,
      exit_code: result.code,
      duration_ms: duration,
      allocation: {
        reason: allocation.reason,
        target: allocation.target
      }
    });
  } catch (err) {
    task.status = 'error';
    task.error = err.message;
    res.status(500).json({ ok: false, error: err.message });
  }
});

/**
 * GET /pool/tasks — 活跃任务列表
 */
app.get('/pool/tasks', (req, res) => {
  const tasks = [];
  for (const [, task] of activeTasks) {
    tasks.push(task);
  }
  res.json({ tasks, total: tasks.length });
});

// ═══════════════════════════════════════════════════════════
// 持久化状态
// ═══════════════════════════════════════════════════════════

function saveState() {
  try {
    const data = {
      updated_at: poolState.updated_at,
      pool: poolState.pool,
      nodes: poolState.nodes,
    };
    fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2), 'utf-8');
  } catch { /* 静默失败，不影响主服务 */ }
}

function loadState() {
  try {
    if (fs.existsSync(STATE_FILE)) {
      const data = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
      if (data.pool && data.nodes) {
        poolState.pool = data.pool;
        poolState.nodes = data.nodes;
      }
    }
  } catch { /* 静默 */ }
}

// ═══════════════════════════════════════════════════════════
// 进程保活
// ═══════════════════════════════════════════════════════════

process.on('uncaughtException', (err) => {
  console.error('[POOL] 未捕获异常（保活）:', err.message);
});
process.on('unhandledRejection', (reason) => {
  console.error('[POOL] 未处理拒绝（保活）:', reason);
});

// ═══════════════════════════════════════════════════════════
// 启动
// ═══════════════════════════════════════════════════════════

async function start() {
  loadState();

  // 立即做第一次轮询
  console.log('[POOL] 首次轮询所有节点...');
  await pollAllServers();
  saveState();

  // 定时轮询
  setInterval(async () => {
    await pollAllServers();
    saveState();
  }, POLL_INTERVAL);

  app.listen(PORT, '0.0.0.0', () => {
    console.log('═══════════════════════════════════════════════');
    console.log('  ☁️  铸渊 · 算力汇聚调度池 v1.0');
    console.log(`  端口: ${PORT}`);
    console.log(`  轮询: ${POLL_INTERVAL / 1000}秒`);
    console.log(`  节点: ${SERVERS.length}台（${SERVERS.map(s => s.code).join(', ')}）`);
    console.log(`  汇聚: CPU ${TOTAL_SPEC.cpu}核 · 内存 ${TOTAL_SPEC.mem_gb}GB`);
    console.log('  签发: 铸渊 · ICE-GL-ZY001');
    console.log('═══════════════════════════════════════════════');
    console.log('  API:');
    console.log('    GET  /pool/status    全局资源状态');
    console.log('    POST /pool/allocate  声明式分配');
    console.log('    POST /pool/exec      池中执行');
    console.log('    GET  /pool/tasks     活跃任务');
    console.log('═══════════════════════════════════════════════');
  });
}

start().catch(err => {
  console.error('[POOL] 启动失败:', err.message);
  process.exit(1);
});