import type { Page } from '@playwright/test';
import { expect, test } from '@playwright/test';
// v0.39.0 (ISS-069) — maintenance: expectations use the real balance constants.
import { REPAIR_COST } from '../lib/game/catalog';

import { authenticate } from './auth';

// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
test.beforeEach(async ({ page }) => { await authenticate(page); });

// v0.39.0 (ISS-069), reworked in v0.45.0 (ISS-089) — maintenance visible flow against the live
// origin: health is shown per plane in the fleet list; forcing it to 0 via the set-health hook shows
// the "broken" pill and blocks dispatch with a 409 that mutates nothing; clicking Repair deducts
// exactly REPAIR_COST and grounds the plane ("in repair" pill) while its health is still ~0 — the
// engine heals it gradually over the gate, landing on exactly 100 when the (hook-shortened) gate
// passes.

const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
const STARTER = 'plane-starter';

interface PlaneState {
  id: string;
  model: string;
  status: 'available' | 'flying' | 'repairing';
  fuel: number;
  maxFuel: number;
  locationIcao: string;
  destIcao: string | null;
  health: number; // v0.39.0 (ISS-069) — structural health in [0, 100]
  repairUntilSimTime: number | null; // v0.39.0 (ISS-069) — active repair gate
}

interface CatalogEntry {
  model: string;
  burnPerKm: number;
  emptyWeightKg: number;
  maxFuel: number;
}

interface StateBody {
  account: { cash: number };
  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
  planes: PlaneState[];
  catalog: CatalogEntry[];
}

async function getState(page: Page): Promise<StateBody> {
  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
  // instantly fail any expect.poll callback, so retry briefly instead.
  for (let attempt = 1; ; attempt++) {
    const res = await page.request.get('/api/state');
    if (res.status() === 200) return (await res.json()) as StateBody;
    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
    await page.waitForTimeout(500);
  }
}

// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
// a silent reset would otherwise surface as an unexplained wait timeout.
async function setScale(page: Page, scale: number): Promise<void> {
  const res = await page.request.post('/api/test/set-timescale', { data: { timeScale: scale } });
  expect(res.status()).toBe(200);
  const body = (await res.json()) as { timeScale: number };
  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
}

// Test hook (FLIGHT_TEST_HOOKS=1): force a plane's health and/or shorten an active repair gate.
async function setHealth(
  page: Page,
  body: { planeId: string; health?: number; repairUntilMs?: number },
): Promise<StateBody> {
  const res = await page.request.post('/api/test/set-health', { data: body });
  expect(res.status()).toBe(200);
  return (await res.json()) as StateBody;
}

// Mirrors haversineKm in lib/geo.ts (same formula → identical floats).
function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
  const toRad = (d: number) => (d * Math.PI) / 180;
  const dLat = toRad(lat2 - lat1);
  const dLon = toRad(lon2 - lon1);
  const a =
    Math.sin(dLat / 2) ** 2 +
    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
  return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(a)));
}

// Closest airport to EDDF from /api/airports — any known destination for the blocked-dispatch check.
async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lon: number; hubLat: number; hubLon: number }> {
  const fc = (await (await page.request.get('/api/airports')).json()) as {
    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
  };
  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
  let nearest = fc.features.filter((f) => f.properties.icao !== HUB)[0].properties;
  for (const f of fc.features) {
    if (f.properties.icao === HUB) continue;
    if (haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon) < haversineKm(hub.lat, hub.lon, nearest.lat, nearest.lon)) {
      nearest = f.properties;
    }
  }
  return { icao: nearest.icao, lat: nearest.lat, lon: nearest.lon, hubLat: hub.lat, hubLon: hub.lon };
}

// Self-heal: let any in-flight leg finish and reposition plane-starter to the hub (shared DB — an
// interrupted earlier run may have left it elsewhere or airborne). Same pattern as flyHomeViaApi in
// right-pane.spec.ts; cargo cleanup is skipped because this flow asserts cash DELTAS, not absolutes.
async function healStarterHome(page: Page): Promise<void> {
  let s = await getState(page);
  let starter = s.planes.find((p) => p.id === STARTER)!;
  if (starter.status === 'repairing') {
    // An interrupted run may have left it mid-repair — shorten the gate so the next tick flips it back.
    await setHealth(page, { planeId: STARTER, health: 100, repairUntilMs: 0 });
    await expect
      .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.status ?? ''), {
        timeout: 30_000,
        message: 'waiting for the shortened repair gate to flip plane-starter back',
      })
      .toBe('available');
    s = await getState(page);
    starter = s.planes.find((p) => p.id === STARTER)!;
  }
  if (starter.status === 'flying' || starter.locationIcao !== HUB) {
    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
    await setScale(page, SCALE);
  }
  if (starter.status === 'flying') {
    await expect
      .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.status ?? ''), {
        timeout: 240_000,
        message: 'waiting for an in-flight plane-starter to land',
      })
      .toBe('available');
    s = await getState(page);
    starter = s.planes.find((p) => p.id === STARTER)!;
  }
  if (starter.locationIcao !== HUB) {
    // Make sure the world rate is back at SCALE for the return leg.
    await setScale(page, SCALE);
    // ISS-082: dispatch auto-refuels, so a grounded plane can always start any full-tank-flyable
    // leg when cash allows — no top-up retry needed.
    const flyHome = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } });
    expect(flyHome.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
    await expect
      .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.locationIcao ?? ''), {
        timeout: 240_000,
        message: 'waiting for plane-starter to land back at the hub',
      })
      .toBe(HUB);
  }
}

// Leave a clean starter for later spec files (shared DB, workers:1): full health and no active
// repair gate — an interrupted run may have left the plane mid-repair or worn down.
async function restoreStarter(page: Page): Promise<void> {
  const s = await getState(page);
  const starter = s.planes.find((p) => p.id === STARTER)!;
  const body: { planeId: string; health?: number; repairUntilMs?: number } = { planeId: STARTER, health: 100 };
  if (starter.status === 'repairing') body.repairUntilMs = 0; // shorten the active gate → flips on the next tick
  await setHealth(page, body);
}

test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file

// On exit (success or failure): restore the fixed world rate for the other specs (house convention)
// and leave a clean starter — full health, no active repair gate.
test.afterEach(async ({ page }) => {
  await setScale(page, WORLD);
  await restoreStarter(page);
});

test('health shown → broken cannot fly → gradual repair → back to service', async ({ page }) => {
  test.setTimeout(300_000); // self-heal + the shortened repair gate wait (no flight leg since v0.45.0)

  await healStarterHome(page); // deterministic: the starter sits grounded at EDDF

  // (a) Force health to 42 — snapshot AND UI show it.
  let s = await setHealth(page, { planeId: STARTER, health: 42 });
  expect(s.planes.find((p) => p.id === STARTER)!.health).toBe(42);

  await page.goto('/');
  const row = page.getByTestId(`plane-${STARTER}`);
  await expect(row, 'the starter fleet row renders').toBeVisible({ timeout: 15_000 });
  await expect(page.getByTestId(`plane-health-${STARTER}`), 'health readout shows the forced value')
    .toContainText('42%');

  // (b) Force broken — the pill shows, and dispatch is blocked with a 409 that mutates nothing.
  s = await setHealth(page, { planeId: STARTER, health: 0 });
  expect(s.planes.find((p) => p.id === STARTER)!.health).toBe(0);
  await expect(page.getByTestId(`plane-broken-${STARTER}`), 'the broken pill appears')
    .toHaveText('broken', { timeout: 15_000 });

  // The destination is irrelevant — a broken plane must be rejected BEFORE any refuel math (v0.45.0).
  const nearest = await nearestToHub(page);
  const fuelBefore = s.planes.find((p) => p.id === STARTER)!.fuel;
  const flyRes = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: nearest.icao } });
  expect(flyRes.status()).toBe(409); // broken planes cannot take off…
  expect(((await flyRes.json()) as { error: string }).error).toMatch(/broken \(health 0\)/);

  s = await getState(page);
  const starter = s.planes.find((p) => p.id === STARTER)!;
  expect(starter.status).toBe('available'); // still grounded…
  expect(starter.fuel).toBe(fuelBefore); // …and the auto-refuel never ran — tank untouched

  // (c) Repair through the UI: exact cash drop + "in repair" pill, health still ~0 (gradual heal).
  const cashBefore = s.account.cash;
  const repairBtn = page.getByTestId(`repair-${STARTER}`);
  await expect(repairBtn, 'the Repair button shows for a grounded worn plane').toBeVisible({ timeout: 15_000 });
  // The click fires the POST asynchronously — capture the endpoint's OWN response so the cash drop is
  // checked against the exact game clock the server used (a later GET would tick further).
  const [res] = await Promise.all([
    page.waitForResponse((r) => r.url().includes(`/api/planes/${STARTER}/repair`), { timeout: 15_000 }),
    repairBtn.click(),
  ]);
  expect(res.status()).toBe(200);
  const post = (await res.json()) as StateBody; // full post-action snapshot at the action's clock
  expect(post.account.cash).toBeCloseTo(cashBefore - REPAIR_COST, 6); // exactly REPAIR_COST
  const repaired = post.planes.find((p) => p.id === STARTER)!;
  expect(repaired.status).toBe('repairing');
  expect(repaired.health).toBeLessThan(5); // still ~0 — the engine heals it gradually over the gate (v0.45.0)…
  expect(repaired.repairUntilSimTime).not.toBeNull(); // …with the gate set (3 sim days out)

  await expect(page.getByTestId(`plane-repairing-${STARTER}`), 'the "in repair" pill appears')
    .toHaveText('in repair', { timeout: 15_000 });

  // (d) Shorten the gate via the hook — the plane comes back to service on the next tick.
  await setHealth(page, { planeId: STARTER, repairUntilMs: 10_000 });
  await setScale(page, SCALE); // fast-forward the shortened gate (each tick advances up to 2 s × scale)
  await expect
    .poll(async () => {
      const p = (await getState(page)).planes.find((x) => x.id === STARTER)!;
      return p.status === 'available' && p.health === 100 ? true : false;
    }, { timeout: 60_000, message: 'waiting for the shortened repair gate to flip the plane back' })
    .toBe(true);
});