// Gather every live number the dashboard shows and write dashboard/data.js.
//
// Two rules shape this file:
//  1. NO SOURCE MAY BREAK THE RENDER. Each source is fetched inside its own
//     try; a failure keeps the *previous* value and marks it stale rather than
//     blanking the panel. A dashboard that goes half-empty when the wifi blips
//     is worse than one that says "3h old".
//  2. The output is a .js file, not .json, because the page is loaded over
//     file:// where fetch() is blocked by CORS but <script src> is not.
import { readFileSync, writeFileSync, statfsSync } from "node:fs";
import { join } from "node:path";
import { homedir, totalmem, freemem, uptime, hostname, cpus } from "node:os";
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import { readAll, priceOf } from "../../shared-config/gemini-ledger.mjs";

const execFileP = promisify(execFile);
const HOME = homedir();
const HERE = decodeURIComponent(new URL(".", import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1");
const OUT = join(HERE, "data.js");
const LAYOUT = join(HERE, "layout.json");

// Coordinates and the analytics endpoint are redacted in this published copy.
const LAT = 0, LON = 0, PLACE = "Your Town";
const ANALYTICS = "https://example.com/analytics/hit.php";
const KEY_FILE = join(HOME, "code", "shared-config", "analytics-admin.key");
const SECRETS = join(HOME, "code", "shared-config", "secrets.env");

// Values stay in this process and go only to the API they belong to; nothing
// secret is ever written into data.js, which is world-readable on disk.
function secret(...names) {
  let txt = "";
  try { txt = readFileSync(SECRETS, "utf8"); } catch { return null; }
  for (const name of names) {
    const m = txt.match(new RegExp("^\s*" + name + "\s*=\s*(.+)$", "m"));
    if (m) {
      const v = m[1].trim().replace(/^["']|["']$/g, "");
      if (v) return v;
    }
  }
  return process.env[names[0]] || null;
}

const localDay = (d) => new Date(d.getTime() - d.getTimezoneOffset() * 6e4).toISOString().slice(0, 10);
const daysAgo = (n) => { const d = new Date(); d.setDate(d.getDate() - n); return localDay(d); };

// Keep the last good value for a source that just failed, so a transient
// network error degrades to "stale" instead of "empty".
function previous() {
  try {
    const t = readFileSync(OUT, "utf8");
    const i = t.indexOf("window.DASH=");
    return JSON.parse(t.slice(i + 12, t.lastIndexOf("}") + 1)).sources ?? {};
  } catch { return {}; }
}
const prev = previous();

async function source(name, fn) {
  try {
    return [name, { ok: true, at: new Date().toISOString(), ...(await fn()) }];
  } catch (e) {
    const old = prev[name];
    const err = String(e && e.message || e).slice(0, 120);
    if (old) return [name, { ...old, ok: false, stale: true, err }];
    return [name, { ok: false, err }];
  }
}

async function fetchJson(url, ms = 12000) {
  const ctl = new AbortController();
  const t = setTimeout(() => ctl.abort(), ms);
  try {
    const r = await fetch(url, { signal: ctl.signal });
    if (!r.ok) throw new Error("HTTP " + r.status);
    return await r.json();
  } finally { clearTimeout(t); }
}

// ---------------------------------------------------------------- weather
const WMO = {
  0: ["Clear", "sun"], 1: ["Mostly clear", "sun"], 2: ["Partly cloudy", "cloudsun"], 3: ["Overcast", "cloud"],
  45: ["Fog", "fog"], 48: ["Rime fog", "fog"], 51: ["Light drizzle", "drizzle"], 53: ["Drizzle", "drizzle"],
  55: ["Heavy drizzle", "drizzle"], 56: ["Freezing drizzle", "drizzle"], 57: ["Freezing drizzle", "drizzle"],
  61: ["Light rain", "rain"], 63: ["Rain", "rain"], 65: ["Heavy rain", "rain"],
  66: ["Freezing rain", "rain"], 67: ["Freezing rain", "rain"], 71: ["Light snow", "snow"], 73: ["Snow", "snow"],
  75: ["Heavy snow", "snow"], 77: ["Snow grains", "snow"], 80: ["Showers", "rain"], 81: ["Showers", "rain"],
  82: ["Violent showers", "rain"], 85: ["Snow showers", "snow"], 86: ["Snow showers", "snow"],
  95: ["Thunderstorm", "storm"], 96: ["Thunderstorm", "storm"], 99: ["Thunderstorm", "storm"],
};
const wmo = (c) => WMO[c] ?? WMO[3];

const weather = () => source("weather", async () => {
  const u = "https://api.open-meteo.com/v1/forecast?latitude=" + LAT + "&longitude=" + LON
    + "&current=temperature_2m,weather_code,wind_speed_10m,apparent_temperature"
    + "&hourly=temperature_2m,weather_code,precipitation_probability"
    + "&daily=temperature_2m_max,temperature_2m_min,weather_code,sunrise,sunset"
    + "&timezone=auto&forecast_days=3";
  const w = await fetchJson(u);
  const now = Date.now();
  const hours = w.hourly.time
    .map((t, i) => ({ t, temp: w.hourly.temperature_2m[i], code: w.hourly.weather_code[i], pop: w.hourly.precipitation_probability[i] }))
    .filter((h) => new Date(h.t).getTime() > now - 18e5)
    .slice(0, 7)
    .map((h) => ({ hour: h.t.slice(11, 13), temp: Math.round(h.temp), icon: wmo(h.code)[1], pop: h.pop ?? 0 }));
  const days = w.daily.time.map((t, i) => ({
    day: new Date(t + "T12:00").toLocaleDateString("en-GB", { weekday: "short" }),
    hi: Math.round(w.daily.temperature_2m_max[i]), lo: Math.round(w.daily.temperature_2m_min[i]),
    icon: wmo(w.daily.weather_code[i])[1],
  }));
  const cur = wmo(w.current.weather_code);
  return {
    place: PLACE, temp: Math.round(w.current.temperature_2m), feels: Math.round(w.current.apparent_temperature),
    wind: Math.round(w.current.wind_speed_10m), label: cur[0], icon: cur[1],
    hi: days[0].hi, lo: days[0].lo,
    sunrise: w.daily.sunrise[0].slice(11, 16), sunset: w.daily.sunset[0].slice(11, 16),
    hours, days,
  };
});

// ---------------------------------------------------------------- gemini spend
const spend = () => source("spend", async () => {
  const all = readAll({ from: daysAgo(29) });
  const today = localDay(new Date()), weekStart = daysAgo(6);
  const byDay = new Map(), byProject = new Map(), byModel = new Map();
  let todayUsd = 0, weekUsd = 0, monthUsd = 0, calls7 = 0, fails7 = 0;
  let priciest = null;                       // the single worst call today
  for (const e of all) {
    const d = localDay(new Date(e.ts));
    const usd = priceOf(e);
    monthUsd += usd;
    byDay.set(d, (byDay.get(d) ?? 0) + usd);
    if (d === today) {
      todayUsd += usd;
      if (!priciest || usd > priciest.usd) priciest = { usd, project: e.project, model: e.model, at: e.ts };
    }
    if (d >= weekStart) {
      weekUsd += usd; calls7++;
      if (e.ok === false) fails7++;
      const p = byProject.get(e.project) ?? { usd: 0, calls: 0 };
      p.usd += usd; p.calls++; byProject.set(e.project, p);
      // A model is often the real reason a day got expensive - one pro-tier or
      // per-image model can outweigh thousands of flash calls - so it gets its
      // own breakdown rather than hiding inside the project total.
      const m = byModel.get(e.model) ?? { usd: 0, calls: 0, fails: 0 };
      m.usd += usd; m.calls++; if (e.ok === false) m.fails++; byModel.set(e.model, m);
    }
  }
  const days = [];
  for (let i = 13; i >= 0; i--) { const d = daysAgo(i); days.push({ d, usd: byDay.get(d) ?? 0 }); }

  // Early warning. Two independent triggers, because they catch different
  // failures: the cap catches a big day, the ratio catches a day that is small
  // in absolute terms but running far hotter than normal - a loop that only
  // started an hour ago. Prior days exclude today so today cannot dilute its
  // own baseline.
  const cap = Number(JSON.parse(readFileSync(LAYOUT, "utf8"))._budget?.dailyUsd) || 0;
  const prior = days.slice(0, -1).filter((d) => d.usd > 0);
  const normalUsd = prior.length ? prior.reduce((a, d) => a + d.usd, 0) / prior.length : 0;
  const ratio = normalUsd > 0 ? todayUsd / normalUsd : null;
  const capPct = cap ? (todayUsd / cap) * 100 : null;
  const level = (capPct != null && capPct >= 100) || (ratio != null && ratio >= 3 && todayUsd > 1) ? "critical"
    : (capPct != null && capPct >= 70) || (ratio != null && ratio >= 2 && todayUsd > 0.5) ? "warning"
      : "good";

  return {
    todayUsd, weekUsd, monthUsd, calls7, fails7, days, priciest,
    cap, capPct, normalUsd, ratio, level,
    projects: [...byProject].map(([name, v]) => ({ name, usd: v.usd, calls: v.calls }))
      .sort((a, b) => b.usd - a.usd).slice(0, 6),
    models: [...byModel].map(([name, v]) => ({ name, usd: v.usd, calls: v.calls, fails: v.fails }))
      .sort((a, b) => b.usd - a.usd).slice(0, 6),
  };
});

// ---------------------------------------------------------------- analytics
const traffic = () => source("traffic", async () => {
  const key = readFileSync(KEY_FILE, "utf8").trim();
  const s = (await fetchJson(ANALYTICS + "?stats=" + key)).sites ?? {};
  const window7 = Array.from({ length: 7 }, (_, i) => daysAgo(6 - i));
  const perDay = Object.fromEntries(window7.map((d) => [d, 0]));
  const sites = [];
  for (const [slug, v] of Object.entries(s)) {
    let v7 = 0;
    const spark = window7.map((d) => { const n = (v.days && v.days[d] && v.days[d].v) || 0; v7 += n; perDay[d] += n; return n; });
    sites.push({ slug, v7, total: (v.totals && v.totals.v) || 0, uniq: (v.totals && v.totals.u) || 0, last: v.last, spark });
  }
  sites.sort((a, b) => b.v7 - a.v7 || b.total - a.total);
  return {
    sites: sites.slice(0, 9),
    days: window7.map((d) => ({ d, v: perDay[d] })),
    views7: Object.values(perDay).reduce((a, b) => a + b, 0),
    totalAll: sites.reduce((a, x) => a + x.total, 0),
    siteCount: sites.length,
  };
});

// ---------------------------------------------------------------- work journal
// One row per project, not per moment. Every `said` line in the journal is
// already a summary of one turn, so the project line is a summary OF those
// summaries: the most recent few outcomes joined. This replaces the old
// "recently touched" panel too - directory mtimes said the same thing worse.
const journal = () => source("journal", async () => {
  const lines = readFileSync(join(HOME, ".claude", "journal.jsonl"), "utf8").trim().split(/\r?\n/).slice(-3000);
  const rows = [];
  for (const l of lines) { try { rows.push(JSON.parse(l)); } catch { /* partial line */ } }

  const since = Date.now() - 14 * 864e5;
  const recent = rows.filter((r) => r.project && new Date(r.t).getTime() >= since);
  const byProject = new Map();
  for (const r of recent) {
    let g = byProject.get(r.project);
    if (!g) { g = { project: r.project, moments: 0, sessions: new Set(), last: 0, said: [], asked: [] }; byProject.set(r.project, g); }
    g.moments++;
    if (r.session) g.sessions.add(r.session);
    const ts = new Date(r.t).getTime();
    if (ts > g.last) g.last = ts;
    const txt = String(r.text ?? "").replace(/\s+/g, " ").trim();
    if (txt) (r.kind === "said" ? g.said : g.asked).push({ ts, txt });
  }

  const projects = [...byProject.values()].map((g) => {
    g.said.sort((a, b) => b.ts - a.ts);
    g.asked.sort((a, b) => b.ts - a.ts);
    // Outcomes ("said") beat requests ("asked"): what got done is the story.
    const src = g.said.length ? g.said : g.asked;
    const seen = new Set(), parts = [];
    for (const x of src) {
      const k = x.txt.slice(0, 30).toLowerCase();
      if (seen.has(k)) continue;
      seen.add(k);
      parts.push(x.txt);
      if (parts.length >= 3) break;
    }
    return {
      project: g.project, moments: g.moments, sessions: g.sessions.size,
      last: new Date(g.last).toISOString(), kind: g.said.length ? "did" : "asked",
      summary: parts.join(" &middot; ").slice(0, 300),
    };
  }).sort((a, b) => new Date(b.last) - new Date(a.last));

  const since7 = Date.now() - 7 * 864e5;
  const r7 = recent.filter((r) => new Date(r.t).getTime() >= since7);
  return {
    projects: projects.slice(0, 8),
    projects14: projects.length,
    projects7: new Set(r7.map((r) => r.project)).size,
    moments7: r7.length,
  };
});

// ---------------------------------------------------------------- machine
// One PowerShell spawn for everything Node cannot see (battery, network, power
// plan, CPU load); spawning four would cost more than the whole render. It lives
// in its own .ps1 rather than a -Command string so quoting stays sane.
const machine = () => source("machine", async () => {
  let ps = {};
  try {
    const { stdout } = await execFileP("powershell",
      ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", join(HERE, "machine.ps1")],
      { timeout: 25000, windowsHide: true });
    ps = JSON.parse(stdout.trim());
  } catch { /* the local numbers below are still worth showing without it */ }

  const disks = [];
  for (const letter of ["C:", "D:", "E:"]) {
    try {
      const s = statfsSync(letter + "\\");
      const total = s.blocks * s.bsize, free = s.bavail * s.bsize;
      if (total > 0) disks.push({ letter, freeGb: free / 1e9, totalGb: total / 1e9, pct: (1 - free / total) * 100 });
    } catch { /* drive not present */ }
  }
  const tm = totalmem(), fm = freemem();
  return {
    host: hostname(), plan: ps.plan || null, net: ps.net || null, netKind: ps.netKind || null,
    online: ps.online ?? null,
    cpuLoad: ps.cpuLoad ?? null,
    cpuName: String(ps.cpuName || (cpus()[0] && cpus()[0].model) || "").replace(/\(R\)|\(TM\)|CPU|Processor/g, "").replace(/\s+/g, " ").trim(),
    cores: cpus().length,
    battery: ps.batteryPct == null ? null : { pct: ps.batteryPct, charging: !!ps.charging, onAc: !!ps.onAc, mins: ps.batteryMins ?? null },
    ram: { usedGb: (tm - fm) / 1e9, totalGb: tm / 1e9, pct: ((tm - fm) / tm) * 100 },
    disks, uptimeH: uptime() / 3600,
  };
});

// ---------------------------------------------------------------- stripe
// Rolling 30 days across the whole account, since one Stripe account serves
// every project. Balance transactions are the right source rather than charges:
// they already carry Stripe's fee and the net that actually lands, and refunds
// appear as their own negative rows instead of having to be reconciled.
const revenue = () => source("revenue", async () => {
  const key = secret("STRIPE_API_KEY", "STRIPE_SECRET_KEY", "STRIPE_RESTRICTED_KEY");
  if (!key) throw new Error("no STRIPE_API_KEY in shared-config/secrets.env");

  const since = Math.floor((Date.now() - 30 * 864e5) / 1000);
  const rows = [];
  let after = null;
  // Bounded: 5 pages is 500 transactions in 30 days. If that is ever not
  // enough the totals would silently undercount, so it is reported.
  let truncated = false;
  for (let page = 0; page < 5; page++) {
    const u = "https://api.stripe.com/v1/balance_transactions?limit=100&created[gte]=" + since
      + (after ? "&starting_after=" + after : "");
    const ctl = new AbortController();
    const t = setTimeout(() => ctl.abort(), 15000);
    let j;
    try {
      const r = await fetch(u, { headers: { Authorization: "Bearer " + key }, signal: ctl.signal });
      if (!r.ok) {
        const body = await r.text().catch(() => "");
        throw new Error("Stripe HTTP " + r.status + (r.status === 401 ? " (key rejected)" : "")
          + " " + body.slice(0, 80));
      }
      j = await r.json();
    } finally { clearTimeout(t); }
    rows.push(...j.data);
    if (!j.has_more) { after = null; break; }
    after = j.data[j.data.length - 1].id;
    truncated = page === 4;
  }

  const EARN = new Set(["charge", "payment"]);
  const BACK = new Set(["refund", "payment_refund", "payment_failure_refund"]);
  const byDay = new Map();
  let gross = 0, net = 0, fees = 0, refunded = 0, payments = 0, refunds = 0;
  let currency = "eur";
  for (const t of rows) {
    if (t.currency) currency = t.currency;
    const day = localDay(new Date(t.created * 1000));
    if (EARN.has(t.type)) {
      gross += t.amount; net += t.net; fees += t.fee; payments++;
      byDay.set(day, (byDay.get(day) ?? 0) + t.amount);
    } else if (BACK.has(t.type)) {
      refunded += Math.abs(t.amount); net += t.net; refunds++;
      byDay.set(day, (byDay.get(day) ?? 0) + t.amount);
    }
  }
  const days = [];
  for (let i = 29; i >= 0; i--) { const d = daysAgo(i); days.push({ d, amt: (byDay.get(d) ?? 0) / 100 }); }
  const best = days.reduce((a, b) => (b.amt > a.amt ? b : a), days[0]);
  return {
    currency: currency.toUpperCase(), truncated,
    gross: gross / 100, net: net / 100, fees: fees / 100, refunded: refunded / 100,
    payments, refunds, days,
    best: best.amt > 0 ? best : null,
    last7: days.slice(-7).reduce((a, d) => a + d.amt, 0),
  };
});

// ---------------------------------------------------------------- cpu / throttle
// The per-minute ring buffer written by sample.ps1. "Throttled" means the clock
// sat at or below the nameplate base while the CPU was actually busy - the one
// throttle signal this machine exposes without admin (see sample.ps1).
const cpu = () => source("cpu", async () => {
  const raw = readFileSync(join(HERE, "state", "cpu.jsonl"), "utf8").replace(/^/, "");
  const rows = [];
  for (const l of raw.trim().split("\n")) { try { rows.push(JSON.parse(l)); } catch { /* partial line */ } }
  const cutoff = Date.now() - 31 * 6e4;
  const win = rows.filter((r) => new Date(r.t).getTime() >= cutoff).slice(-30);
  if (!win.length) throw new Error("no samples yet");

  const base = win[win.length - 1].base || 0;
  const withMhz = win.filter((r) => r.mhz != null);
  const last = win[win.length - 1];
  const peak = withMhz.length ? Math.max(...withMhz.map((r) => r.mhz)) : null;
  const avg = withMhz.length ? withMhz.reduce((a, r) => a + r.mhz, 0) / withMhz.length : null;
  // The chart keeps its 30-minute window because that is where a throttle
  // becomes visible as a shape; the headline average matches the refresh
  // interval, so it describes the picture you are actually looking at.
  const cut5 = Date.now() - 5.5 * 6e4;
  const w5 = withMhz.filter((r) => new Date(r.t).getTime() >= cut5);
  const avg5 = w5.length ? w5.reduce((a, r) => a + r.mhz, 0) / w5.length : null;
  const busy5 = w5.length ? w5.reduce((a, r) => a + (r.busy ?? 0), 0) / w5.length : null;
  // Only samples where the CPU was doing real work can testify about throttling;
  // a low clock on an idle machine is power saving, not a limit.
  const busy = withMhz.filter((r) => (r.busy ?? 0) >= 25);
  const throttled = busy.filter((r) => r.mhz <= base * 1.02);
  return {
    base, samples: win.length,
    now: last.mhz ?? null, nowBusy: last.busy ?? null, nowUtil: last.util ?? null,
    peak, avg, avg5, busy5, mins5: w5.length,
    series: win.map((r) => ({ t: r.t.slice(11, 16), mhz: r.mhz, busy: r.busy ?? 0 })),
    busyMins: busy.length,
    throttledMins: throttled.length,
    throttleNow: last.mhz != null && (last.busy ?? 0) >= 25 && last.mhz <= base * 1.02,
    spanMins: Math.round((new Date(last.t) - new Date(win[0].t)) / 6e4) + 1,
  };
});

// ---------------------------------------------------------------- write
const sources = Object.fromEntries(await Promise.all([weather(), spend(), traffic(), journal(), machine(), revenue(), cpu()]));
const now = new Date();
const jan0 = new Date(now.getFullYear(), 0, 0);
const payload = {
  generatedAt: now.toISOString(),
  life: (() => {
    const cfg = JSON.parse(readFileSync(LAYOUT, "utf8"))._life ?? {};
    const total = cfg.totalWeeks || 4000;
    const born = new Date(cfg.born || "1990-11-01");
    const lived = Math.floor((now - born) / (7 * 864e5));
    const ageY = (now - born) / (365.2425 * 864e5);
    return {
      total, lived, left: total - lived, pct: (lived / total) * 100,
      born: born.toLocaleDateString("en-GB", { month: "short", year: "numeric" }),
      age: Math.floor(ageY) + "y " + Math.round((ageY % 1) * 12) + "m",
    };
  })(),
  clock: {
    time: now.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" }),
    weekday: now.toLocaleDateString("en-GB", { weekday: "long" }),
    day: now.getDate(),
    month: now.toLocaleDateString("en-GB", { month: "long" }),
    year: now.getFullYear(),
    dayOfYear: Math.floor((now - jan0) / 864e5),
    week: (() => {
      const d = new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()));
      d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
      return Math.ceil(((d - Date.UTC(d.getUTCFullYear(), 0, 1)) / 864e5 + 1) / 7);
    })(),
    minutesIntoDay: now.getHours() * 60 + now.getMinutes(),
  },
  sources,
};

writeFileSync(OUT, "window.LAYOUT=" + readFileSync(LAYOUT, "utf8").trim() + ";\nwindow.DASH=" + JSON.stringify(payload) + ";\n");

const names = Object.keys(sources);
const bad = Object.entries(sources).filter(([, v]) => !v.ok);
console.log("data.js written - " + (names.length - bad.length) + "/" + names.length + " sources ok"
  + (bad.length ? "; degraded: " + bad.map(([k, v]) => k + " (" + (v.stale ? "stale" : "no data") + ": " + v.err + ")").join(", ") : ""));