/**
 * Public /status 24h uptime.
 *
 * The figure was `(uptimeMs / WINDOW_MS) * 100` — the age of the current Bun
 * worker as a fraction of 24 hours. A deploy is not an outage, so every deploy
 * reset the public status page to a near-zero number. Observed live on
 * 2026-07-28, minutes after a routine deploy:
 *
 *   <div class="status-hero-stat-num">0.0%</div>
 *   <div class="status-hero-stat-label">24h uptime</div>
 *
 * directly beside "All systems operational" and a service table where every
 * row read 100.0%. With the 60s auto-deploy timer this was the page's normal
 * state, not an edge case — anyone checking the status page during a deploy
 * saw 0% uptime on a healthy system.
 *
 * It now derives from recorded incidents.
 */

import { describe, expect, it } from "bun:test";
import { uptimePctFromIncidents, UPTIME_WINDOW_MS } from "../routes/status";

const NOW = new Date("2026-07-28T12:00:00.000Z").getTime();
const HOUR = 3_600_000;

describe("no incidents means full uptime", () => {
  it("reports 100 with an empty incident list", () => {
    // The core regression: a freshly-restarted process with a clean incident
    // log must read 100%, not "how long have I been alive".
    expect(uptimePctFromIncidents([], NOW)).toBe(100);
  });

  it("ignores incidents that ended before the window", () => {
    const old = [
      {
        startedAt: new Date(NOW - 40 * HOUR),
        resolvedAt: new Date(NOW - 30 * HOUR),
      },
    ];
    expect(uptimePctFromIncidents(old, NOW)).toBe(100);
  });
});

describe("downtime is subtracted accurately", () => {
  it("a 1h resolved incident costs 1/24th", () => {
    const rows = [
      { startedAt: new Date(NOW - 5 * HOUR), resolvedAt: new Date(NOW - 4 * HOUR) },
    ];
    const pct = uptimePctFromIncidents(rows, NOW);
    expect(pct).toBeCloseTo((23 / 24) * 100, 5);
  });

  it("an unresolved incident counts as ongoing up to now", () => {
    const rows = [{ startedAt: new Date(NOW - 2 * HOUR), resolvedAt: null }];
    expect(uptimePctFromIncidents(rows, NOW)).toBeCloseTo((22 / 24) * 100, 5);
  });

  it("clamps an incident that began before the window to the window edge", () => {
    // Started 30h ago, resolved 20h ago → only 4h falls inside the window.
    const rows = [
      { startedAt: new Date(NOW - 30 * HOUR), resolvedAt: new Date(NOW - 20 * HOUR) },
    ];
    expect(uptimePctFromIncidents(rows, NOW)).toBeCloseTo((20 / 24) * 100, 5);
  });
});

describe("overlapping incidents are merged, not double-counted", () => {
  it("two fully overlapping incidents count once", () => {
    const rows = [
      { startedAt: new Date(NOW - 6 * HOUR), resolvedAt: new Date(NOW - 4 * HOUR) },
      { startedAt: new Date(NOW - 5 * HOUR), resolvedAt: new Date(NOW - 4 * HOUR) },
    ];
    // 2h of real downtime, not 3h.
    expect(uptimePctFromIncidents(rows, NOW)).toBeCloseTo((22 / 24) * 100, 5);
  });

  it("partially overlapping incidents merge into one span", () => {
    const rows = [
      { startedAt: new Date(NOW - 6 * HOUR), resolvedAt: new Date(NOW - 4 * HOUR) },
      { startedAt: new Date(NOW - 5 * HOUR), resolvedAt: new Date(NOW - 3 * HOUR) },
    ];
    // Union is 6h ago → 3h ago = 3h.
    expect(uptimePctFromIncidents(rows, NOW)).toBeCloseTo((21 / 24) * 100, 5);
  });

  it("never goes below 0 even if incidents blanket the window many times over", () => {
    const rows = Array.from({ length: 10 }, () => ({
      startedAt: new Date(NOW - 48 * HOUR),
      resolvedAt: null,
    }));
    expect(uptimePctFromIncidents(rows, NOW)).toBe(0);
  });

  it("is order-independent", () => {
    const a = { startedAt: new Date(NOW - 3 * HOUR), resolvedAt: new Date(NOW - 2 * HOUR) };
    const b = { startedAt: new Date(NOW - 9 * HOUR), resolvedAt: new Date(NOW - 8 * HOUR) };
    expect(uptimePctFromIncidents([a, b], NOW)).toBeCloseTo(
      uptimePctFromIncidents([b, a], NOW),
      10
    );
  });
});

describe("malformed rows do not corrupt the figure", () => {
  it("skips unparseable timestamps rather than producing NaN", () => {
    const rows = [
      { startedAt: "not-a-date", resolvedAt: null },
      { startedAt: new Date(NOW - 2 * HOUR), resolvedAt: new Date(NOW - 1 * HOUR) },
    ];
    const pct = uptimePctFromIncidents(rows, NOW);
    expect(Number.isFinite(pct)).toBe(true);
    expect(pct).toBeCloseTo((23 / 24) * 100, 5);
  });

  it("skips a resolvedAt earlier than its startedAt", () => {
    const rows = [
      { startedAt: new Date(NOW - 1 * HOUR), resolvedAt: new Date(NOW - 5 * HOUR) },
    ];
    expect(uptimePctFromIncidents(rows, NOW)).toBe(100);
  });
});

describe("window constant", () => {
  it("is 24 hours", () => {
    expect(UPTIME_WINDOW_MS).toBe(24 * 60 * 60 * 1000);
  });
});