import { content } from "@deadhead/content";
import { describe, expect, it } from "vitest";
import {
  MS_PER_HOUR,
  rollTripEvent,
  routeFacts,
  type Contract,
  type DispatchRecord,
  type EventRollInput,
} from "../src/index";

const T0 = Date.parse("2100-01-01T00:00:00Z");
const { timeCompression } = content.config;

const contract = (over: Partial<Contract> = {}): Contract => ({
  id: "c",
  originId: "earth",
  destinationId: "moon",
  cargoTypeId: "standard",
  goodId: "consumer-goods",
  shipper: "Pacific Orbital Logistics",
  priority: false,
  deliveryWindowGameHours: null,
  tier: 0,
  massTonnes: 10,
  payout: 10_000,
  requiredSkill: null,
  requiredLongHaulLevel: 0,
  offeredAt: T0,
  expiresAt: T0 + 600_000,
  firstContact: false,
  ...over,
});

/** A trip of `hours` game hours from `origin` to `destination`. */
function record(
  seed: number,
  origin: string,
  destination: string,
  hours: number,
  job: Partial<Contract> | null = {},
): DispatchRecord {
  return {
    id: `d${seed}`,
    shipId: "s1",
    pilotId: "p1",
    contract:
      job === null ? null : contract({ originId: origin, destinationId: destination, ...job }),
    originId: origin,
    destinationId: destination,
    tutorial: false,
    departureAt: T0,
    arrivalAt: T0 + Math.round((hours * MS_PER_HOUR) / timeCompression),
    distanceMillionKm: 1,
    fuelBurnedFu: 100,
    fuelCost: 500,
    expectedPayout: 10_000,
    seed,
  };
}

const input = (rec: DispatchRecord, over: Partial<EventRollInput> = {}): EventRollInput => ({
  record: rec,
  ship: {
    hullRating: 1,
    hullConditionPct: 100,
    cargoCapacityTonnes: 100,
    fuelAfterDepartureFu: 500,
    quietTrips: 5,
  },
  pilotSkills: {},
  fleetRadioCalls: [],
  company: { firstEventDone: true, tripsSinceDeal: 10 },
  ...over,
});

/** Rolls `n` trips made by `make(seed)` and returns the events. */
function rolls(n: number, make: (seed: number) => EventRollInput) {
  return Array.from({ length: n }, (_, seed) => rollTripEvent(make(seed + 1), content));
}

describe("rolling a trip's event (Step 26.2, decisions 0.5.143–0.5.145)", () => {
  it("gives the same event, outcomes and all, for the same trip", () => {
    const trip = input(record(42, "earth", "jupiter-cloud-platform", 200));
    expect(rollTripEvent(trip, content)).toEqual(rollTripEvent(trip, content));
    const events = rolls(500, (s) => input(record(s, "earth", "jupiter-cloud-platform", 200)));
    expect(new Set(events.map((e) => e?.eventId ?? "quiet")).size).toBeGreaterThan(3);
  });

  it("has none in the tutorial or on the first 3 trips after the deal", () => {
    const long = (s: number) => record(s, "earth", "jupiter-cloud-platform", 200);
    const tutorial = rolls(500, (s) => input({ ...long(s), tutorial: true }));
    expect(tutorial.every((e) => e === null)).toBe(true);
    for (const tripsSinceDeal of [0, 1, 2]) {
      const early = rolls(500, (s) =>
        input(long(s), { company: { firstEventDone: true, tripsSinceDeal } }),
      );
      expect(
        early.every((e) => e === null),
        `trip ${tripsSinceDeal + 1}`,
      ).toBe(true);
    }
    const after = rolls(500, (s) =>
      input(long(s), { company: { firstEventDone: true, tripsSinceDeal: 3 } }),
    );
    expect(after.some((e) => e !== null)).toBe(true);
  });

  it("makes the first event the derelict pod, on the first contract of 6+ game hours", () => {
    const first = { company: { firstEventDone: false, tripsSinceDeal: 3 } };
    const short = rolls(200, (s) => input(record(s, "earth", "moon", 5), first));
    expect(short.every((e) => e === null)).toBe(true);
    const long = rolls(200, (s) => input(record(s, "earth", "mars", 6), first));
    expect(long.every((e) => e?.eventId === "derelict-pod")).toBe(true);
    const deadhead = rolls(50, (s) => input(record(s, "earth", "mars", 40, null), first));
    expect(deadhead.every((e) => e === null)).toBe(true);
  });

  it("gives a ship none on its next 2 trips after an event", () => {
    const long = (s: number) => record(s, "earth", "jupiter-cloud-platform", 200);
    for (const quietTrips of [0, 1]) {
      const cooling = rolls(500, (s) =>
        input(long(s), { ship: { ...input(long(s)).ship, quietTrips } }),
      );
      expect(cooling.every((e) => e === null)).toBe(true);
    }
    const ready = rolls(500, (s) =>
      input(long(s), { ship: { ...input(long(s)).ship, quietTrips: 2 } }),
    );
    expect(ready.some((e) => e !== null)).toBe(true);
  });

  it("drops a radio call within 45 real minutes of another one in the fleet", () => {
    const long = (s: number) => record(s, "earth", "jupiter-cloud-platform", 200);
    const seed = Array.from({ length: 5_000 }, (_, i) => i + 1).find(
      (s) => rollTripEvent(input(long(s)), content)?.kind === "radio",
    )!;
    const call = rollTripEvent(input(long(seed)), content)!;
    const near = [call.fireAt + 44 * 60_000];
    const far = [call.fireAt - 46 * 60_000];
    expect(rollTripEvent(input(long(seed), { fleetRadioCalls: near }), content)).toBeNull();
    expect(rollTripEvent(input(long(seed), { fleetRadioCalls: far }), content)).toEqual(call);
    // A radio call's window: 30 minutes, or what's left of the trip.
    expect(call.windowEndsAt).toBe(Math.min(call.fireAt + 30 * 60_000, long(seed).arrivalAt));
    const trip = long(seed);
    const span = trip.arrivalAt - trip.departureAt;
    expect(call.fireAt).toBeGreaterThanOrEqual(trip.departureAt + span * 0.2 - 1);
    expect(call.fireAt).toBeLessThanOrEqual(trip.departureAt + span * 0.7 + 1);
  });

  it("over 100,000 trips: Earth↔Moon at 3% or less, long hauls at 35% or less, every event where it may happen", () => {
    const routes: [string, string, number, Partial<Contract>][] = [
      ["earth", "moon", 4, { cargoTypeId: "dangerous", goodId: "helium-3", tier: 1 }],
      ["moon", "earth", 4, { cargoTypeId: "heavy", goodId: "machine-parts", tier: 1 }],
      [
        "earth",
        "mars",
        40,
        { priority: true, goodId: "medical-supplies", deliveryWindowGameHours: 60 },
      ],
      [
        "earth",
        "jupiter-cloud-platform",
        220,
        { cargoTypeId: "dangerous", goodId: "helium-3", tier: 1 },
      ],
      ["ceres-station", "mars", 30, { cargoTypeId: "heavy", goodId: "machine-parts", tier: 1 }],
      ["io-sulfur-works", "europa-ice-station", 8, {}],
      [
        "venus-cloud-city",
        "earth",
        20,
        { priority: true, goodId: "cloud-botanicals", deliveryWindowGameHours: 30 },
      ],
    ];
    const tally = new Map<string, { trips: number; events: number }>();
    for (let s = 1; s <= 100_000; s++) {
      const [origin, destination, hours, job] = routes[s % routes.length]!;
      const trip = record(s, origin, destination, hours, s % 11 === 0 ? null : job);
      const event = rollTripEvent(input(trip), content);
      const key = `${origin}>${destination}`;
      const row = tally.get(key) ?? { trips: 0, events: 0 };
      row.trips++;
      if (event) row.events++;
      tally.set(key, row);
      if (!event) continue;
      const def = content.tripEvent(event.eventId)!;
      const route = routeFacts(content.location(origin)!, content.location(destination)!);
      const c = trip.contract;
      const where = `${event.eventId} on ${key}`;
      if (def.when.minTripGameHours)
        expect(hours, where).toBeGreaterThanOrEqual(def.when.minTripGameHours);
      if (event.eventId === "hazmat-leak") expect(c?.cargoTypeId, where).toBe("dangerous");
      if (event.eventId === "load-shift") expect(c?.cargoTypeId, where).toBe("heavy");
      if (event.eventId === "debris-field") expect(route.crossesBelt, where).toBe(true);
      if (event.eventId === "storm-approach") expect(route.stormArrival, where).toBe(true);
      if (event.eventId === "customs-hold") expect(["earth", "mars"], where).toContain(destination);
      if (event.eventId === "spoilage-risk") expect(c?.priority, where).toBe(true);
      if (event.eventId === "spot-freight") expect(route.innerOrBelt, where).toBe(true);
      if (def.when.contract) expect(c, where).not.toBeNull();
    }
    const rate = (key: string) => tally.get(key)!.events / tally.get(key)!.trips;
    expect(rate("earth>moon")).toBeLessThanOrEqual(0.03);
    expect(rate("moon>earth")).toBeLessThanOrEqual(0.03);
    expect(rate("earth>jupiter-cloud-platform")).toBeLessThanOrEqual(0.35);
    expect(rate("earth>jupiter-cloud-platform")).toBeGreaterThan(0.25);
  });

  it("makes leaks rarer for a pilot whose Dangerous Cargo skill is above the job's tier", () => {
    const share = (level: number) => {
      const events = rolls(30_000, (s) =>
        input(
          record(s, "earth", "jupiter-cloud-platform", 220, {
            cargoTypeId: "dangerous",
            goodId: "helium-3",
            tier: 1,
          }),
          { pilotSkills: { "dangerous-cargo": level } },
        ),
      ).filter((e) => e !== null);
      return events.filter((e) => e!.eventId === "hazmat-leak").length / events.length;
    };
    const atTier = share(1);
    const twoAbove = share(3);
    expect(atTier).toBeGreaterThan(0.03);
    // Two levels above: a quarter of the weight, so far rarer among events.
    expect(twoAbove).toBeLessThan(atTier * 0.4);
  });
});