/**
 * Polymarket multi-account monitor server
 *
 * Start: npx tsx monitor-server.ts
 * Open: http://localhost:8080
 *
 * Features:
 *   - Read the accounts.json list
 *   - Serve the monitor.html static page
 *   - Reverse-proxy /api/proxy?port=XXXX → http://localhost:XXXX/api/state?lite=1
 *   - Provide /api/accounts GET/PUT
 *   - Provide /api/tg/* config endpoints + long-polling responses for /status /d commands
 */
import { createServer } from "http";
import { readFileSync, writeFileSync, existsSync } from "fs";
import { resolve, dirname } from "path";
import { fileURLToPath } from "url";
import { loadTgConfig, saveTgConfig, autoDetectChatId, sendTgMessage, editTgMessage, deleteTgMessage, answerCallbackQuery, maskToken, TgPoller, type TgConfig, type CallbackContext } from "./tg-push.js";

const __dirname = dirname(fileURLToPath(import.meta.url));
const PORT = Number(process.env.MONITOR_PORT) || 8080;
const ACCOUNTS_FILE = resolve(__dirname, "accounts.json");
const HTML_FILE = resolve(__dirname, "monitor.html");
const HISTORY_FILE = resolve(__dirname, ".balance-history.json");

interface Account { name: string; port: number; enabled?: boolean }
function loadAccounts(includeDisabled = false): Account[] {
  try {
    const data = JSON.parse(readFileSync(ACCOUNTS_FILE, "utf-8"));
    if (Array.isArray(data)) {
      const valid: Account[] = data.filter(a => a && typeof a.name === "string" && typeof a.port === "number");
      if (includeDisabled) return valid;
      return valid.filter(a => a.enabled !== false);  // Enabled by default, only false disables
    }
  } catch (err) {
    console.warn("[monitor] Failed to read accounts.json:", err instanceof Error ? err.message : String(err));
  }
  return [];
}

// ── TG config (memory + file) ──
let tgConfig: TgConfig = loadTgConfig();
function tgConfigPublic(): Record<string, unknown> {
  return {
    enabled: tgConfig.enabled,
    botTokenSet: !!tgConfig.botToken,
    botTokenMasked: maskToken(tgConfig.botToken),
    chatId: tgConfig.chatId,
  };
}

// ── Fetch one machine's state (lite, ~5KB) ──
// On failure, return the cache if it's within 60s, marking it stale + age; TG push and the monitor page share this buffer
type FetchStateResult =
  | { ok: true; state: any; stale?: boolean; staleAgeMs?: number; error?: undefined }
  | { ok: false; state?: undefined; error: string };
const STATE_CACHE_MAX_MS = 60_000;
const _stateCache = new Map<number, { state: any; at: number }>();

async function fetchAccountState(port: number, timeoutMs = 8000): Promise<FetchStateResult> {
  try {
    const ctrl = new AbortController();
    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
    const r = await fetch(`http://localhost:${port}/api/state?lite=1`, { signal: ctrl.signal });
    clearTimeout(timer);
    if (!r.ok) return _fallbackFromCache(port, `HTTP ${r.status}`);
    const state = await r.json();
    _stateCache.set(port, { state, at: Date.now() });
    return { ok: true, state };
  } catch (e) {
    const raw = e instanceof Error ? e.message : String(e);
    const cause = (e as { cause?: { code?: string } })?.cause?.code || "";
    let err: string;
    if (cause === "ECONNREFUSED" || raw.includes("ECONNREFUSED")) err = "Connection closed";
    else if (cause === "ETIMEDOUT" || raw.includes("ETIMEDOUT")) err = "Connection timed out";
    else if (raw.includes("aborted") || raw.includes("AbortError")) err = "Request timed out";
    else if (cause === "ECONNRESET" || raw.includes("ECONNRESET")) err = "Connection closed";
    else if (raw === "fetch failed") err = "Connection closed";
    else err = raw.slice(0, 60);
    return _fallbackFromCache(port, err);
  }
}

function _fallbackFromCache(port: number, error: string): FetchStateResult {
  const cached = _stateCache.get(port);
  if (!cached) return { ok: false, error };
  const age = Date.now() - cached.at;
  if (age > STATE_CACHE_MAX_MS) return { ok: false, error };
  return { ok: true, state: cached.state, stale: true, staleAgeMs: age };
}

function fmtUsd(v: number | null | undefined): string {
  if (v == null || !Number.isFinite(v)) return "—";
  const sign = v >= 0 ? "" : "-";
  return `${sign}$${Math.abs(v).toFixed(2)}`;
}

// ── Balance history (record a total-balance snapshot once a day at CST 00:05) ──
interface BalanceSnapshot { total: number; online: number; offline: number; }
type BalanceHistory = Record<string, BalanceSnapshot>;  // key: YYYY-MM-DD (CST)

function loadBalanceHistory(): BalanceHistory {
  try {
    if (!existsSync(HISTORY_FILE)) return {};
    const data = JSON.parse(readFileSync(HISTORY_FILE, "utf-8"));
    return (data && typeof data === "object" && !Array.isArray(data)) ? data : {};
  } catch (err) {
    console.warn("[monitor] Failed to read .balance-history.json:", err instanceof Error ? err.message : String(err));
    return {};
  }
}
function saveBalanceHistory(h: BalanceHistory): void {
  try {
    writeFileSync(HISTORY_FILE, JSON.stringify(h, null, 2) + "\n", "utf-8");
  } catch (err) {
    console.warn("[monitor] Failed to write .balance-history.json:", err instanceof Error ? err.message : String(err));
  }
}

/** CST date string: 2026-05-09 */
function cstDateStr(d = new Date()): string {
  const cn = new Date(d.getTime() + 8 * 3600 * 1000);
  return cn.toISOString().slice(0, 10);
}

/** Fetch all account balances, tally the total + online/offline counts */
async function snapshotAllBalances(): Promise<BalanceSnapshot> {
  const accounts = loadAccounts();
  if (accounts.length === 0) return { total: 0, online: 0, offline: 0 };
  const results = await Promise.all(accounts.map(a => fetchAccountState(a.port)));
  let total = 0, online = 0, offline = 0;
  for (const r of results) {
    if (r.ok && typeof r.state.usdc === "number") {
      total += r.state.usdc;
      online++;
    } else {
      offline++;
    }
  }
  return { total: Math.round(total * 100) / 100, online, offline };
}

/** Record a snapshot (overwrite mode: multiple records on the same day use the latest value) */
async function recordBalanceSnapshot(reason: string): Promise<void> {
  const accounts = loadAccounts();
  if (accounts.length === 0) {
    console.log(`[balance] Skipping snapshot (no accounts), reason: ${reason}`);
    return;
  }
  const snap = await snapshotAllBalances();
  if (snap.online === 0) {
    console.log(`[balance] Skipping snapshot (all offline), reason: ${reason}`);
    return;
  }
  const dateKey = cstDateStr();
  const history = loadBalanceHistory();
  history[dateKey] = snap;
  saveBalanceHistory(history);
  console.log(`[balance] Snapshot saved ${dateKey}: total=$${snap.total.toFixed(2)} online=${snap.online} offline=${snap.offline} (${reason})`);
}

/** Schedule the daily CST 0:05 snapshot trigger */
function scheduleDailyBalanceSnapshot(): void {
  const now = new Date();
  const cnNow = now.getTime() + 8 * 3600 * 1000;
  const next = new Date(cnNow);
  next.setUTCHours(0, 5, 0, 0);
  // If today's 0:05 has already passed, schedule for tomorrow
  if (next.getTime() <= cnNow) next.setUTCDate(next.getUTCDate() + 1);
  const delayMs = next.getTime() - cnNow;
  setTimeout(() => {
    void recordBalanceSnapshot("CST 00:05 scheduled");
    scheduleDailyBalanceSnapshot();  // Schedule the next day
  }, Math.max(60_000, delayMs)).unref?.();
}

/** Backfill on startup: if today has no data yet → record one immediately (avoids losing the day's data after a server restart) */
async function bootstrapBalanceSnapshot(): Promise<void> {
  const dateKey = cstDateStr();
  const history = loadBalanceHistory();
  if (history[dateKey]) {
    console.log(`[balance] Today ${dateKey} already has a snapshot, skipping startup backfill`);
    return;
  }
  // Delay 30 seconds so all accounts can connect before recording
  setTimeout(() => { void recordBalanceSnapshot("startup backfill"); }, 30_000);
}

function fmtPnl(v: number | null | undefined): string {
  if (v == null || !Number.isFinite(v)) return "—";
  const sign = v >= 0 ? "+" : "-";
  return `${sign}$${Math.abs(v).toFixed(2)}`;
}

const STATUS_PAGE_SIZE = 10;

// ── Build overview text (tree layout + pagination, offline first) ──
async function buildStatusText(page: number = 1): Promise<{ text: string; page: number; totalPages: number }> {
  const accounts = loadAccounts();
  if (accounts.length === 0) return { text: "⚠ accounts.json is empty, configure accounts on the monitor page first", page: 1, totalPages: 1 };

  const results = await Promise.all(accounts.map(async a => ({
    account: a,
    result: await fetchAccountState(a.port),
  })));

  // Full aggregation (independent of pagination); stale still counts as online
  let online = 0, offline = 0, staleCount = 0;
  let totalUsdc = 0, totalPnl = 0, totalCount = 0, totalClosed = 0, totalWins = 0;
  for (const { result } of results) {
    if (!result.ok) { offline++; continue; }
    online++;
    if (result.stale) staleCount++;
    const s = result.state;
    if (typeof s.usdc === "number") totalUsdc += s.usdc;
    const p = s.pmPnl || {};
    if (typeof p.todayPnl === "number") totalPnl += p.todayPnl;
    if (typeof p.todayCount === "number") totalCount += p.todayCount;
    if (typeof p.todayClosedCount === "number") totalClosed += p.todayClosedCount;
    if (typeof p.todayWins === "number") totalWins += p.todayWins;
  }

  // Sort: offline first, the rest keep accounts.json's original order
  const sorted = [...results].sort((a, b) => {
    const aOff = a.result.ok ? 1 : 0;
    const bOff = b.result.ok ? 1 : 0;
    return aOff - bOff;
  });

  // Pagination
  const totalPages = Math.max(1, Math.ceil(sorted.length / STATUS_PAGE_SIZE));
  const safePage = Math.min(Math.max(1, page), totalPages);
  const start = (safePage - 1) * STATUS_PAGE_SIZE;
  const pageItems = sorted.slice(start, start + STATUS_PAGE_SIZE);

  const blocks: string[] = [];
  // Name format: account name takes priority (s.accountName), machine name (account.name) as a parenthesized subtitle
  const fmtName = (accName: string | null | undefined, machine: string): string => {
    if (accName && accName !== machine) return `${accName} (${machine})`;
    return machine;
  };
  for (const { account, result } of pageItems) {
    if (!result.ok) {
      blocks.push(`🔴 ${account.name}\n└ ${result.error}`);
      continue;
    }
    const s = result.state;
    const displayName = fmtName(typeof s.accountName === "string" ? s.accountName : null, account.name);
    const usdc = typeof s.usdc === "number" ? s.usdc : null;
    const p = s.pmPnl || {};
    const todayPnl = typeof p.todayPnl === "number" ? p.todayPnl : null;
    const todayCount = typeof p.todayCount === "number" ? p.todayCount : null;
    const todayClosed = typeof p.todayClosedCount === "number" ? p.todayClosedCount : null;
    const todayWins = typeof p.todayWins === "number" ? p.todayWins : null;

    const market = s.activeMarket?.displayName || "—";
    const cfg = s.strategyConfig || {};
    const fmtStratSize = (key: string): string | null => {
      const lk = String(key).toLowerCase();
      const isLimit = lk.startsWith("l");
      if (isLimit) {
        const sh = cfg.shares?.[lk];
        return typeof sh === "number" ? `${sh} shares` : null;
      }
      const am = cfg.amount?.[lk];
      return typeof am === "number" ? `$${am}` : null;
    };
    const enabledKeys = Object.keys(cfg.enabled || {}).filter(k => cfg.enabled[k]);
    let stratStr: string;
    if (!enabledKeys.length) {
      stratStr = "No strategy enabled";
    } else {
      stratStr = enabledKeys.map(k => {
        const sz = fmtStratSize(k);
        return sz ? `${k.toUpperCase()}(${sz})` : k.toUpperCase();
      }).join(" ");
    }
    const ws = s.wsStatus || {};
    const wsAllOk = ws.user && ws.market && ws.chainlink && ws.binance;
    // stale shows a yellow dot + appends the data age after the name
    const dot = result.stale ? "🟡" : (wsAllOk ? "🟢" : "🟡");
    let staleTag = "";
    if (result.stale) {
      const ageSec = Math.max(1, Math.round((result.staleAgeMs || 0) / 1000));
      staleTag = ageSec >= 60 ? ` ⏳${Math.round(ageSec / 60)}m ago` : ` ⏳${ageSec}s ago`;
    }

    const wrStr = todayClosed && todayClosed > 0
      ? `${Math.round((todayWins ?? 0) / todayClosed * 100)}%(${todayWins ?? 0}/${todayClosed})`
      : "—";

    blocks.push(
      `${dot} ${displayName}${staleTag} · ${market}\n` +
      `├ Balance ${fmtUsd(usdc)} · PnL ${fmtPnl(todayPnl)} · ${todayCount ?? 0} trades\n` +
      `└ Win rate ${wrStr} · Strategy ${stratStr}`
    );
  }

  const winRate = totalClosed > 0 ? `${Math.round((totalWins / totalClosed) * 100)}% (${totalWins}/${totalClosed})` : "—";
  const pageLine = totalPages > 1 ? `\n📄 Page ${safePage}/${totalPages}` : "";
  const head = [
    `📊 Monitor overview`,
    `🕒 ${new Date().toLocaleString("en-US", { hour12: false })}`,
    "",
    `📦 Machines ${accounts.length} (online ${online}${staleCount > 0 ? ` / cached ${staleCount}` : ""} / offline ${offline})`,
    "",
    `💰 Overview`,
    `├ Balance ${fmtUsd(totalUsdc)}`,
    `├ PnL ${fmtPnl(totalPnl)}`,
    `├ Trades ${totalCount}`,
    `└ Win rate ${winRate}`,
    "",
    `📋 Accounts${pageLine}`,
  ].join("\n");
  return { text: head + "\n" + blocks.join("\n\n"), page: safePage, totalPages };
}

/** Build the pagination + refresh inline keyboard */
function buildStatusKeyboard(page: number, totalPages: number): { text: string; callback_data: string }[][] {
  const buttons: { text: string; callback_data: string }[] = [];
  if (totalPages > 1) {
    if (page > 1) buttons.push({ text: "← Prev", callback_data: `status_page:${page - 1}` });
    buttons.push({ text: `${page}/${totalPages}`, callback_data: `noop` });
    if (page < totalPages) buttons.push({ text: "Next →", callback_data: `status_page:${page + 1}` });
  }
  buttons.push({ text: "🔄 Refresh", callback_data: `refresh:${page}` });
  return [buttons];
}

// ── Build single-account detail text ──
async function buildDetailText(name: string): Promise<string> {
  const accounts = loadAccounts();
  const target = accounts.find(a => a.name.toLowerCase() === name.toLowerCase());
  if (!target) {
    const list = accounts.map(a => a.name).join(", ") || "(empty)";
    return `⚠ Account "${name}" not found\n\nAvailable accounts: ${list}`;
  }
  const result = await fetchAccountState(target.port);
  if (!result.ok) return `${target.name} (port=${target.port})\nOffline: ${result.error}`;
  const s = result.state;
  const accName = s.accountName || target.name;
  const market = s.activeMarket?.displayName || "—";
  const usdc = typeof s.usdc === "number" ? s.usdc : null;
  const upPos = typeof s.upLocalSize === "number" ? s.upLocalSize : 0;
  const dnPos = typeof s.downLocalSize === "number" ? s.downLocalSize : 0;
  const lastTrade = s.lastTradeAt;
  const stratState = s.strategy?.state || "—";
  const stratActive = s.strategy?.activeStrategy;
  const enabledKeys = Object.keys(s.strategyConfig?.enabled || {}).filter(k => s.strategyConfig.enabled[k]).map(k => k.toUpperCase());
  const ws = s.wsStatus || {};
  const wsList = Object.entries(ws).map(([k, v]) => `${k}:${v ? "●" : "○"}`).join(" ");
  const p = s.pmPnl || {};

  const lines = [
    `📋 ${accName} (port=${target.port})`,
    `Market: ${market}`,
    `USDC: ${fmtUsd(usdc)}`,
    `Position: Up ${upPos.toFixed(2)} / Down ${dnPos.toFixed(2)}`,
    `Strategy: ${stratActive ? `${String(stratActive).toUpperCase()}·${stratState}` : `Enabled ${enabledKeys.join(" ") || "none"} · ${stratState}`}`,
    `Today: PnL ${fmtPnl(p.todayPnl)} | ${p.todayCount ?? 0} trades | Win rate ${p.todayClosedCount ? Math.round((p.todayWins ?? 0) / p.todayClosedCount * 100) + "%" : "—"} (${p.todayWins ?? 0}/${p.todayClosedCount ?? 0})`,
    `Last fill: ${lastTrade ? new Date(lastTrade).toLocaleString("en-US", { hour12: false }) : "—"}`,
    `WS: ${wsList}`,
  ];
  return lines.join("\n");
}

// ── Command dispatch ──
async function handleTgCommand(cmd: string, args: string, fromChatId: number): Promise<void> {
  // Security: only respond to the configured chatId (prevents strangers from sending commands)
  if (tgConfig.chatId && String(fromChatId) !== tgConfig.chatId) {
    console.warn(`[monitor.TG] Ignoring command from unauthorized chat_id: ${fromChatId}`);
    return;
  }
  if (cmd === "/start" || cmd === "/help") {
    const text = [
      "📊 Polymarket multi-account monitor",
      "",
      "Available commands:",
      "/status — Overview (all accounts)",
      "/d <account name> — Single-account details (e.g. /d T4-A)",
      "/help — Help",
    ].join("\n");
    await sendTgMessage({ ...tgConfig, chatId: String(fromChatId) }, text);
    return;
  }
  if (cmd === "/status" || cmd === "/s") {
    const r = await buildStatusText(1);
    await sendTgMessage({ ...tgConfig, chatId: String(fromChatId) }, r.text, {
      inlineKeyboard: buildStatusKeyboard(r.page, r.totalPages),
    });
    return;
  }
  if (cmd === "/d" || cmd === "/detail") {
    if (!args) {
      await sendTgMessage({ ...tgConfig, chatId: String(fromChatId) }, "Usage: /d <account name>\nExample: /d T4-A");
      return;
    }
    const text = await buildDetailText(args);
    await sendTgMessage({ ...tgConfig, chatId: String(fromChatId) }, text);
    return;
  }
  // Unknown commands are silently ignored
}

async function handleTgCallback(ctx: CallbackContext): Promise<void> {
  // Security: only respond to the authorized chat_id
  if (tgConfig.chatId && String(ctx.fromChatId) !== tgConfig.chatId) {
    await answerCallbackQuery(tgConfig, ctx.callbackQueryId, "Unauthorized");
    return;
  }
  // Compatible with the old refresh_status, plus the new formats status_page:N / refresh:N
  // Refresh (refresh:N): delete+send, triggers the animation, visibly signals a successful refresh
  // Page change (status_page:N): edit in place + top toast, doesn't jump to the bottom of the chat
  if (ctx.messageId && (ctx.data === "refresh_status" || ctx.data.startsWith("refresh:") || ctx.data.startsWith("status_page:"))) {
    const isRefresh = ctx.data === "refresh_status" || ctx.data.startsWith("refresh:");
    let page = 1;
    if (ctx.data.startsWith("refresh:")) {
      page = parseInt(ctx.data.slice("refresh:".length), 10) || 1;
    } else if (ctx.data.startsWith("status_page:")) {
      page = parseInt(ctx.data.slice("status_page:".length), 10) || 1;
    }
    const ackText = isRefresh ? "Refreshed" : `→ Page ${page}`;
    await answerCallbackQuery(tgConfig, ctx.callbackQueryId, ackText);
    const r = await buildStatusText(page);
    const keyboard = buildStatusKeyboard(r.page, r.totalPages);
    if (isRefresh) {
      const delRes = await deleteTgMessage(tgConfig, String(ctx.fromChatId), ctx.messageId);
      if (delRes.ok) {
        await sendTgMessage(tgConfig, r.text, { toChatId: String(ctx.fromChatId), inlineKeyboard: keyboard });
      } else {
        await editTgMessage(tgConfig, String(ctx.fromChatId), ctx.messageId, r.text, { inlineKeyboard: keyboard });
      }
    } else {
      await editTgMessage(tgConfig, String(ctx.fromChatId), ctx.messageId, r.text, { inlineKeyboard: keyboard });
    }
    return;
  }
  if (ctx.data === "noop") {
    await answerCallbackQuery(tgConfig, ctx.callbackQueryId);
    return;
  }
  await answerCallbackQuery(tgConfig, ctx.callbackQueryId);
}

const tgPoller = new TgPoller(() => tgConfig, handleTgCommand, handleTgCallback);
tgPoller.start();

// ── HTTP server ──
const server = createServer(async (req, res) => {
  const url = new URL(req.url || "/", `http://localhost:${PORT}`);
  const path = url.pathname;

  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Headers", "*");

  // ── /api/accounts ──
  if (path === "/api/accounts") {
    if (req.method === "GET") {
      // The management panel needs to see disabled accounts; add ?all=1 to return everything; by default only enabled accounts are returned
      const includeDisabled = url.searchParams.get("all") === "1";
      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify(loadAccounts(includeDisabled)));
      return;
    }
    if (req.method === "PUT") {
      try {
        const chunks: Buffer[] = [];
        for await (const c of req) chunks.push(c as Buffer);
        const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
        if (!Array.isArray(body)) throw new Error("body must be an array");
        const seen = new Set<number>();
        const cleaned: Account[] = [];
        for (const a of body) {
          if (!a || typeof a.name !== "string" || typeof a.port !== "number") {
            throw new Error("each item must contain name(string) and port(number)");
          }
          const name = a.name.trim();
          const port = Math.floor(a.port);
          if (!name) throw new Error("name cannot be empty");
          if (port < 1 || port > 65535) throw new Error(`port out of range: ${port}`);
          if (seen.has(port)) throw new Error(`duplicate port: ${port}`);
          seen.add(port);
          const item: Account = { name, port };
          if (a.enabled === false) item.enabled = false;  // Only write the field when explicitly disabled, keep enabled items clean
          cleaned.push(item);
        }
        writeFileSync(ACCOUNTS_FILE, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
        res.end(JSON.stringify(cleaned));
      } catch (e) {
        const msg = e instanceof Error ? e.message : String(e);
        res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
        res.end(JSON.stringify({ error: "Save failed", detail: msg }));
      }
      return;
    }
    res.writeHead(405, { "Content-Type": "text/plain; charset=utf-8" });
    res.end("Method Not Allowed");
    return;
  }

  // ── /api/proxy ──
  if (path === "/api/proxy") {
    const port = Number(url.searchParams.get("port"));
    if (!port || port < 1 || port > 65535) {
      res.writeHead(400, { "Content-Type": "application/json" });
      res.end(JSON.stringify({ error: "invalid port" }));
      return;
    }
    const result = await fetchAccountState(port);
    if (result.ok) {
      res.writeHead(200, {
        "Content-Type": "application/json; charset=utf-8",
        ...(result.stale ? { "X-State-Stale": "1", "X-State-Age-Ms": String(result.staleAgeMs || 0) } : {}),
      });
      res.end(JSON.stringify(result.state));
    } else {
      res.writeHead(503, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify({ error: "Upstream unreachable", detail: result.error }));
    }
    return;
  }

  // ── /api/tg/config GET / POST ──
  if (path === "/api/tg/config") {
    if (req.method === "GET") {
      res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify(tgConfigPublic()));
      return;
    }
    if (req.method === "POST") {
      try {
        const chunks: Buffer[] = [];
        for await (const c of req) chunks.push(c as Buffer);
        const body = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as Record<string, unknown>;
        if (typeof body.enabled === "boolean") tgConfig.enabled = body.enabled;
        // botToken containing *** means the frontend didn't modify it (mask echoed back), skip
        if (typeof body.botToken === "string" && !body.botToken.includes("***")) {
          const oldToken = tgConfig.botToken;
          tgConfig.botToken = body.botToken.trim();
          if (oldToken !== tgConfig.botToken) tgPoller.resetOnTokenChange();
        }
        if (typeof body.chatId === "string") tgConfig.chatId = body.chatId.trim();
        saveTgConfig(tgConfig);
        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
        res.end(JSON.stringify(tgConfigPublic()));
      } catch (e) {
        res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
        res.end(JSON.stringify({ error: "Save failed", detail: e instanceof Error ? e.message : String(e) }));
      }
      return;
    }
  }

  // ── /api/tg/auto-chat: fetch chat_id from getUpdates ──
  if (path === "/api/tg/auto-chat" && req.method === "POST") {
    try {
      const chunks: Buffer[] = [];
      for await (const c of req) chunks.push(c as Buffer);
      const body = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as Record<string, unknown>;
      // Prefer the token in the body (the frontend may have typed it and clicked fetch before saving)
      let token = typeof body.botToken === "string" && !body.botToken.includes("***") ? body.botToken.trim() : "";
      if (!token) token = tgConfig.botToken;
      if (!token) {
        res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
        res.end(JSON.stringify({ ok: false, error: "Bot Token not configured" }));
        return;
      }
      const r = await autoDetectChatId(token);
      res.writeHead(r.ok ? 200 : 400, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify(r));
    } catch (e) {
      res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : String(e) }));
    }
    return;
  }

  // ── /api/balance-history: return balance snapshots for all dates ──
  if (path === "/api/balance-history" && req.method === "GET") {
    const history = loadBalanceHistory();
    // Wrap once so the frontend can sort by date
    const items = Object.entries(history)
      .map(([date, snap]) => ({ date, ...snap }))
      .sort((a, b) => a.date.localeCompare(b.date));
    res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
    res.end(JSON.stringify(items));
    return;
  }

  // ── /api/balance-history/now: trigger a snapshot immediately (for debugging/manual backfill) ──
  if (path === "/api/balance-history/now" && req.method === "POST") {
    void recordBalanceSnapshot("manual trigger");
    res.writeHead(202, { "Content-Type": "application/json; charset=utf-8" });
    res.end(JSON.stringify({ ok: true, message: "Snapshot triggered, query /api/balance-history in 30 seconds" }));
    return;
  }

  // ── /api/balance-history?date=YYYY-MM-DD: delete the snapshot for the given date ──
  if (path === "/api/balance-history" && req.method === "DELETE") {
    const date = url.searchParams.get("date") || "";
    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
      res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify({ ok: false, error: "date parameter missing or malformed (need YYYY-MM-DD)" }));
      return;
    }
    const history = loadBalanceHistory();
    if (!(date in history)) {
      res.writeHead(404, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify({ ok: false, error: "No snapshot record for that date" }));
      return;
    }
    delete history[date];
    saveBalanceHistory(history);
    console.log(`[monitor] Deleted balance snapshot: ${date}`);
    res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
    res.end(JSON.stringify({ ok: true, date }));
    return;
  }

  // ── /api/tg/test: push an actual overview immediately (same as /status, with refresh button) ──
  if (path === "/api/tg/test" && req.method === "POST") {
    if (!tgConfig.botToken || !tgConfig.chatId) {
      res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
      res.end(JSON.stringify({ ok: false, error: "Bot Token or Chat ID not configured" }));
      return;
    }
    const status = await buildStatusText(1);
    const r = await sendTgMessage(tgConfig, status.text, {
      inlineKeyboard: buildStatusKeyboard(status.page, status.totalPages),
    });
    res.writeHead(r.ok ? 200 : 400, { "Content-Type": "application/json; charset=utf-8" });
    res.end(JSON.stringify(r));
    return;
  }

  // ── Static files ──
  if (path === "/" || path === "/monitor.html") {
    if (existsSync(HTML_FILE)) {
      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
      res.end(readFileSync(HTML_FILE));
    } else {
      res.writeHead(500, { "Content-Type": "text/plain" });
      res.end("monitor.html does not exist");
    }
    return;
  }

  res.writeHead(404, { "Content-Type": "text/plain" });
  res.end("Not Found");
});

server.listen(PORT, () => {
  const accounts = loadAccounts();
  console.log(`✓ Monitor server started`);
  console.log(`  URL: http://localhost:${PORT}`);
  console.log(`  Accounts: ${accounts.length}`);
  if (accounts.length > 0) {
    accounts.forEach(a => console.log(`    - ${a.name} (port=${a.port})`));
  } else {
    console.log(`  ⚠ accounts.json is empty or missing, please edit ${ACCOUNTS_FILE}`);
  }
  if (tgConfig.enabled && tgConfig.botToken) {
    console.log(`✓ TG bot started (chatId=${tgConfig.chatId || "not configured"})`);
  } else {
    console.log(`  TG bot not enabled (configure it in the top-right of the monitor page)`);
  }
  // Balance history collection: backfill today on startup + schedule tomorrow's auto snapshot at 0:05
  void bootstrapBalanceSnapshot();
  scheduleDailyBalanceSnapshot();
});

process.on("SIGINT", () => {
  console.log("\n[monitor] Received SIGINT, exiting");
  tgPoller.stop();
  server.close();
  process.exit(0);
});