import type {
  DesktopHostTelemetrySnapshot,
  ResourceMonitorProcessSample,
  ResourceMonitorSnapshotEvent,
  ResourceTelemetryHealth,
} from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Option from "effect/Option";

import {
  buildResourceTelemetryHistory,
  normalizeResourceTelemetryHistoryInput,
} from "./ResourceTelemetryHistory.ts";

const SERVER_PID = 100;
const ELECTRON_PID = 200;
const CHILD_PID = 300;
const STARTED_AT_MS = DateTime.toEpochMillis(DateTime.makeUnsafe("2026-06-17T12:00:00.000Z"));

function processSample(
  input: Partial<ResourceMonitorProcessSample> &
    Pick<ResourceMonitorProcessSample, "pid" | "ppid" | "startTimeMs">,
): ResourceMonitorProcessSample {
  return {
    runTimeMs: 1_000,
    name: `process-${input.pid}`,
    command: `process-${input.pid}`,
    status: "Running",
    cpuPercent: 0,
    cpuTimeMs: 0,
    residentBytes: 1_024,
    virtualBytes: 2_048,
    ioReadBytes: 0,
    ioWriteBytes: 0,
    ioSemantics: "storage",
    ...input,
  };
}

function snapshot(
  sequence: number,
  sampledAtUnixMs: number,
  childCpuTimeMs: number,
  childWriteBytes: number,
): ResourceMonitorSnapshotEvent {
  const processes = [
    processSample({ pid: SERVER_PID, ppid: 1, startTimeMs: 10 }),
    processSample({
      pid: ELECTRON_PID,
      ppid: 1,
      startTimeMs: 20,
      name: "electron",
      command: "electron",
    }),
    processSample({
      pid: CHILD_PID,
      ppid: SERVER_PID,
      startTimeMs: 30,
      name: "codex",
      command: "codex app-server",
      cpuTimeMs: childCpuTimeMs,
      ioWriteBytes: childWriteBytes,
    }),
  ];
  return {
    version: 3,
    type: "snapshot",
    sequence,
    sampledAtUnixMs,
    collectionDurationMicros: 100,
    scannedProcessCount: processes.length,
    retainedProcessCount: processes.length,
    inaccessibleProcessCount: 0,
    processes,
  };
}

const health: ResourceTelemetryHealth = {
  native: {
    status: "healthy",
    lastSampleAt: Option.none(),
    lastError: Option.none(),
  },
  desktop: {
    status: "healthy",
    lastSampleAt: Option.none(),
    lastError: Option.none(),
  },
  sidecarVersion: Option.some("0.1.0"),
  sidecarPid: Option.some(400),
  restartCount: 0,
  collectionDurationMicros: 100,
  scannedProcessCount: 3,
  retainedProcessCount: 3,
  inaccessibleProcessCount: 0,
};

function desktopSnapshot(): DesktopHostTelemetrySnapshot {
  const sampledAt = DateTime.makeUnsafe(STARTED_AT_MS + 1_000);
  return {
    version: 1,
    type: "desktopTelemetry",
    sequence: 1,
    sampledAtUnixMs: STARTED_AT_MS + 1_000,
    electronPid: ELECTRON_PID,
    power: {
      source: "electron-main",
      idle: "false",
      idleSeconds: 0,
      locked: "false",
      suspended: false,
      onBattery: "false",
      lowPowerMode: "unknown",
      thermalState: "nominal",
      stale: false,
      updatedAt: sampledAt,
    },
    speedLimitPercent: Option.none(),
    electronProcesses: [
      {
        pid: ELECTRON_PID,
        creationTimeMs: 20,
        type: "Browser",
        cpuPercent: 999,
        idleWakeupsPerSecond: 999,
        workingSetBytes: 999_999,
        peakWorkingSetBytes: 999_999,
      },
    ],
  };
}

describe("buildResourceTelemetryHistory", () => {
  it("normalizes query bounds before requesting native history", () => {
    expect(normalizeResourceTelemetryHistoryInput({ windowMs: 0, bucketMs: 0 })).toEqual({
      windowMs: 1_000,
      bucketMs: 1_000,
    });
  });

  it("replays native snapshots on demand without applying current Electron metrics", () => {
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(STARTED_AT_MS + 2_000),
      windowMs: 10_000,
      bucketMs: 10_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.some(400),
      desktopSnapshot: Option.some(desktopSnapshot()),
      snapshots: [
        snapshot(1, STARTED_AT_MS, 100, 1_000),
        snapshot(2, STARTED_AT_MS + 1_000, 350, 5_000),
      ],
      health,
    });

    const child = history.topProcesses.find((process) => process.identity.pid === CHILD_PID);
    const electron = history.topProcesses.find((process) => process.identity.pid === ELECTRON_PID);
    expect(child?.sampleCount).toBe(2);
    expect(child?.cpuTimeMs).toBe(250);
    expect(child?.ioWriteBytes).toBe(4_000);
    expect(electron?.category).toBe("electron-main");
    expect(electron?.currentRssBytes).toBe(1_024);
    expect(history.buckets.reduce((total, bucket) => total + bucket.ioWriteBytes, 0)).toBe(4_000);
  });

  it("uses observed RSS for the history-window peak instead of the lifetime process peak", () => {
    const first = snapshot(1, STARTED_AT_MS, 100, 1_000);
    const second = snapshot(2, STARTED_AT_MS + 1_000, 200, 2_000);
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(STARTED_AT_MS + 2_000),
      windowMs: 10_000,
      bucketMs: 10_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.none(),
      snapshots: [
        {
          ...first,
          processes: first.processes.map((process) =>
            process.pid === CHILD_PID
              ? { ...process, residentBytes: 2_000, peakResidentBytes: 50_000 }
              : process,
          ),
        },
        {
          ...second,
          processes: second.processes.map((process) =>
            process.pid === CHILD_PID
              ? { ...process, residentBytes: 3_000, peakResidentBytes: 60_000 }
              : process,
          ),
        },
      ],
      health,
    });

    expect(
      history.topProcesses.find((process) => process.identity.pid === CHILD_PID)?.peakRssBytes,
    ).toBe(3_000);
  });

  it("retains cumulative baselines while a process is absent from an intermediate sample", () => {
    const first = snapshot(1, STARTED_AT_MS, 100, 1_000);
    const absent = snapshot(2, STARTED_AT_MS + 1_000, 0, 0);
    const returned = snapshot(3, STARTED_AT_MS + 2_000, 350, 5_000);
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(STARTED_AT_MS + 3_000),
      windowMs: 10_000,
      bucketMs: 10_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.none(),
      snapshots: [
        first,
        {
          ...absent,
          processes: absent.processes.filter((process) => process.pid !== CHILD_PID),
        },
        returned,
      ],
      health,
    });

    const child = history.topProcesses.find((process) => process.identity.pid === CHILD_PID);
    expect(child?.cpuTimeMs).toBe(250);
    expect(child?.ioWriteBytes).toBe(4_000);
  });

  it("uses an exact current Electron identity for slightly older native samples", () => {
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(STARTED_AT_MS + 2_000),
      windowMs: 10_000,
      bucketMs: 10_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.some(desktopSnapshot()),
      snapshots: [snapshot(1, STARTED_AT_MS, 100, 1_000)],
      health,
    });

    expect(
      history.topProcesses.find((process) => process.identity.pid === ELECTRON_PID)?.category,
    ).toBe("electron-main");
  });

  it("uses the preceding sample as a baseline without attributing pre-window deltas", () => {
    const readAtMs = STARTED_AT_MS + 10_000;
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(readAtMs),
      windowMs: 5_000,
      bucketMs: 5_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.none(),
      snapshots: [
        snapshot(1, STARTED_AT_MS, 100, 1_000),
        snapshot(2, STARTED_AT_MS + 5_000, 600, 6_000),
        snapshot(3, readAtMs + 1_000, 10_000, 20_000),
      ],
      health,
    });

    const child = history.topProcesses.find((process) => process.identity.pid === CHILD_PID);
    expect(child?.sampleCount).toBe(1);
    expect(child?.cpuTimeMs).toBe(0);
    expect(child?.ioWriteBytes).toBe(0);
    expect(history.buckets.reduce((total, bucket) => total + bucket.ioWriteBytes, 0)).toBe(0);
    expect(
      history.buckets.every((bucket) => DateTime.toEpochMillis(bucket.startedAt) <= readAtMs),
    ).toBe(true);
  });

  it("prorates a cumulative delta that crosses the history window boundary", () => {
    const readAtMs = STARTED_AT_MS + 10_000;
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(readAtMs),
      windowMs: 5_000,
      bucketMs: 5_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.none(),
      snapshots: [
        snapshot(1, STARTED_AT_MS, 100, 1_000),
        snapshot(2, STARTED_AT_MS + 7_500, 850, 8_500),
      ],
      health,
    });

    const child = history.topProcesses.find((process) => process.identity.pid === CHILD_PID);
    expect(child?.cpuTimeMs).toBe(250);
    expect(child?.ioWriteBytes).toBe(2_500);
    expect(history.buckets.reduce((total, bucket) => total + bucket.ioWriteBytes, 0)).toBe(2_500);
  });

  it("replays the Electron root identity recorded with each native sample", () => {
    const oldElectron = snapshot(1, STARTED_AT_MS, 100, 1_000);
    const restartedElectron = snapshot(2, STARTED_AT_MS + 1_000, 200, 2_000);
    const history = buildResourceTelemetryHistory({
      readAt: DateTime.makeUnsafe(STARTED_AT_MS + 2_000),
      windowMs: 10_000,
      bucketMs: 10_000,
      sampleIntervalMs: 1_000,
      serverPid: SERVER_PID,
      sidecarPid: Option.none(),
      desktopSnapshot: Option.none(),
      snapshots: [
        {
          ...oldElectron,
          externalProcesses: [{ pid: ELECTRON_PID, startTimeMs: 20 }],
        },
        {
          ...restartedElectron,
          externalProcesses: [{ pid: 201, startTimeMs: 40 }],
          processes: [
            ...restartedElectron.processes.filter((process) => process.pid !== ELECTRON_PID),
            processSample({
              pid: ELECTRON_PID,
              ppid: SERVER_PID,
              startTimeMs: 999,
              name: "reused",
              command: "unrelated process",
            }),
            processSample({
              pid: 201,
              ppid: 1,
              startTimeMs: 40,
              name: "electron",
              command: "electron",
            }),
          ],
        },
      ],
      health,
    });

    expect(
      history.topProcesses.find(
        (process) => process.identity.pid === ELECTRON_PID && process.identity.startTimeMs === 20,
      )?.category,
    ).toBe("electron-main");
    expect(
      history.topProcesses.find(
        (process) => process.identity.pid === ELECTRON_PID && process.identity.startTimeMs === 999,
      )?.category,
    ).toBe("server-child");
    expect(history.topProcesses.find((process) => process.identity.pid === 201)?.category).toBe(
      "electron-main",
    );
  });
});