import { randomUUID } from 'node:crypto';
import { and, eq, inArray } from 'drizzle-orm';
import * as schema from '@/lib/db/schema';
import { persist, type GameDb } from '@/lib/db/client';
import { loadAirportsGeoJson } from '@/lib/airports';
import { haversineKm } from '@/lib/geo';
import { requiredFuelFor } from '@/lib/sim/movement';
import { runAction } from '@/lib/sim/engine';
import { getStateSnapshot, parseIcaoQueue } from './state';
import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from './catalog';
import { abandonPenalty } from './penalty';
import { HUB_ICAO } from './seed';

// Player actions (v0.8.0, package model v0.12.0) — the core loop, server-side:
// load a package onto a grounded plane at its origin, fly to any airport, deliver
// on arrival, abandon for a penalty while grounded; plus buy/sell planes and
// refuel. Each function validates and mutates ONE throwaway-safe GameDb instance
// (persisted at the end); routes wrap them in engine.runAction() so tick +
// validate + mutate are atomic under the sim lock. Validation failures throw
// GameActionError carrying the HTTP status:
//   404 — unknown entity id
//   409 — valid ids but the current state forbids the action (wrong package/plane
//         status, plane not at origin, no payload room, insufficient fuel/funds, last plane)
//   400 — bad input that isn't an existence problem (unknown airport/model)

export class GameActionError extends Error {
  constructor(
    public readonly status: number,
    message: string,
  ) {
    super(message);
    this.name = 'GameActionError';
  }
}

async function airportByIcao(icao: string): Promise<{ icao: string; lat: number; lon: number }> {
  const fc = await loadAirportsGeoJson();
  const f = fc.features.find((x) => x.properties.icao === icao);
  if (!f) throw new Error(`airport ${icao} missing from dataset`); // → 500, cannot happen for seeded data
  return { icao: f.properties.icao, lat: f.properties.lat, lon: f.properties.lon };
}

// --- Load (POST /api/packages/:id/load {planeId}) ---

// open → loaded, bound to the plane. The plane must be GROUNDED at the package's
// origin with enough payload room (v0.27.0: used kg = sum of weightKg over packages
// 'loaded' or 'expired' on it — expired cargo keeps occupying its space until
// delivered/abandoned).
export async function loadPackage(inst: GameDb, packageId: string, planeId: string): Promise<void> {
  const [pkgRows, planeRows] = await Promise.all([
    inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId)),
    inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId)),
  ]);
  const pkg = pkgRows[0];
  if (!pkg) throw new GameActionError(404, `package ${packageId} not found`);
  if (pkg.status !== 'open') {
    throw new GameActionError(409, `package is ${pkg.status}, only open packages can be loaded`);
  }
  const plane = planeRows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
  if (plane.status !== 'available') {
    throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can load cargo`);
  }
  if (plane.locationIcao !== pkg.originIcao) {
    throw new GameActionError(
      409,
      `plane is at ${plane.locationIcao} but the package originates at ${pkg.originIcao}`,
    );
  }

  const type = PLANE_TYPES[plane.model];
  if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
  const occupied = await inst.db.select({ weightKg: schema.packages.weightKg }).from(schema.packages).where(
    and(inArray(schema.packages.status, ['loaded', 'expired']), eq(schema.packages.planeId, plane.id)),
  );
  const usedKg = occupied.reduce((sum, r) => sum + (r.weightKg ?? 0), 0);
  if (usedKg + pkg.weightKg > type.maxPayloadKg) {
    throw new GameActionError(409, `no payload room: the ${type.name} carries ${Math.round(usedKg)}/${type.maxPayloadKg} kg`);
  }

  await inst.db.update(schema.packages)
    .set({ status: 'loaded', planeId })
    .where(eq(schema.packages.id, packageId));
  await persist(inst);
}

// --- Fly (POST /api/planes/:id/fly {destIcao}) ---

// Manual flight (v0.12.0): a grounded plane can fly to ANY known airport — its
// loaded packages' destinations or pure repositioning. On arrival the engine
// delivers whatever is bound for that airport. Validation: plane 'available',
// destination in the airport dataset, enough fuel for the leg.
export async function flyPlane(inst: GameDb, planeId: string, destIcao: string): Promise<void> {
  const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = planeRows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
  if (plane.status !== 'available') {
    throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can fly`);
  }

  const fc = await loadAirportsGeoJson();
  const destFeature = fc.features.find((f) => f.properties.icao === destIcao);
  if (!destFeature) throw new GameActionError(400, `unknown airport ${destIcao}`);
  const origin = await airportByIcao(plane.locationIcao);

  const type = PLANE_TYPES[plane.model];
  if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
  const distanceKm = haversineKm(origin.lat, origin.lon, destFeature.properties.lat, destFeature.properties.lon);
  // Weighted burn model (v0.16.0): the leg needs enough fuel to cover it arriving empty.
  const requiredL = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm);
  if (requiredL > plane.fuel) {
    throw new GameActionError(409, `insufficient fuel: the leg needs ${Math.round(requiredL)} L but the plane has ${Math.round(plane.fuel)} L`);
  }

  // runAction() ticked first, so this is current game time.
  const sim = (await inst.db.select().from(schema.simState))[0];
  if (!sim) throw new Error('sim_state row missing');

  await inst.db.update(schema.planes)
    .set({
      status: 'flying',
      destIcao,
      departureSimTime: sim.clockMs,
      lat: origin.lat,
      lon: origin.lon,
    })
    .where(eq(schema.planes.id, planeId));
  // ISS-057: dispatch still resumes a MANUALLY paused sim (pause is manual-only now — landings
  // slow to 1× instead of pausing), and restores the last manually selected speed when this
  // dispatch took the LAST grounded plane airborne. Runs inside runAction(), so tick + controls
  // + dispatch are atomic under the sim lock.
  const sets: Partial<Pick<schema.SimStateRow, 'paused' | 'timeScale'>> = { paused: false };
  const remaining = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'available'));
  if (remaining.length === 0) sets.timeScale = sim.lastSelectedTimeScale;
  await inst.db.update(schema.simState).set(sets);
  await persist(inst);
}

// --- Queue (POST /api/planes/:id/queue {destIcao}) — ISS-043 part 1 ---

// Append a NOT-yet-started leg to the plane's queue. Works whether the plane is
// grounded or flying (you can pre-build a route); nothing auto-starts here — the
// active leg still starts via flyPlane, and queued legs chain on landing when fuel
// covers them (lib/sim/engine.ts deliverPackages). Validation: known plane, ICAO
// in the airport dataset.
export async function queueLeg(inst: GameDb, planeId: string, destIcao: string): Promise<void> {
  const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = planeRows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);

  const fc = await loadAirportsGeoJson();
  if (!fc.features.some((f) => f.properties.icao === destIcao)) {
    throw new GameActionError(400, `unknown airport ${destIcao}`);
  }

  // ISS-065: the same route can't be queued twice — re-queuing the active leg's destination or a
  // leg already in the queue would only produce pointless repeated hops on landing.
  if (plane.status === 'flying' && plane.destIcao === destIcao) {
    throw new GameActionError(409, `already flying to ${destIcao}`);
  }

  const queue = parseIcaoQueue(plane.queue);
  if (queue.includes(destIcao)) {
    throw new GameActionError(409, `${destIcao} is already in the flight queue`);
  }
  queue.push(destIcao);
  await inst.db.update(schema.planes).set({ queue: JSON.stringify(queue) }).where(eq(schema.planes.id, planeId));
  await persist(inst);
}

// --- Queue cancel (POST /api/planes/:id/queue/cancel {index}) — ISS-043 part 1 ---

// Remove a NOT-yet-started leg from the queue by index. Only queued legs are
// cancellable — the active in-flight leg (destIcao) is never affected. Validation:
// known plane, integer index within [0, queue.length).
export async function cancelQueuedLeg(inst: GameDb, planeId: string, index: number): Promise<void> {
  const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = planeRows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);

  const queue = parseIcaoQueue(plane.queue);
  if (index < 0 || index >= queue.length) {
    throw new GameActionError(400, `queue index ${index} out of range — the queue holds ${queue.length} legs`);
  }
  queue.splice(index, 1);
  await inst.db.update(schema.planes).set({ queue: JSON.stringify(queue) }).where(eq(schema.planes.id, planeId));
  await persist(inst);
}

// --- Abandon (POST /api/packages/:id/abandon) ---

// Drop a package that is on a GROUNDED plane. Penalty = fraction of the payout
// scaling with time pressure (15% at creation → 60% at the deadline, see
// lib/game/penalty.ts); an already-expired package abandons for free. Cash never
// goes below €0. The slot is freed immediately.
export async function abandonPackage(inst: GameDb, packageId: string): Promise<{ penalty: number }> {
  const pkgRows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId));
  const pkg = pkgRows[0];
  if (!pkg) throw new GameActionError(404, `package ${packageId} not found`);
  if (pkg.status !== 'loaded' && pkg.status !== 'expired') {
    throw new GameActionError(409, `package is ${pkg.status}, only loaded or expired packages can be abandoned`);
  }

  const plane = pkg.planeId
    ? (await inst.db.select().from(schema.planes).where(eq(schema.planes.id, pkg.planeId)))[0]
    : undefined;
  if (!plane) throw new GameActionError(409, `package ${packageId} is not bound to a plane`);
  if (plane.status !== 'available') {
    throw new GameActionError(409, `the plane is in flight — packages can only be abandoned while it is grounded`);
  }

  const sim = (await inst.db.select().from(schema.simState))[0];
  if (!sim) throw new Error('sim_state row missing');
  const penalty = abandonPenalty(pkg, sim.clockMs);

  const account = (await inst.db.select().from(schema.account))[0];
  if (!account) throw new Error('account row missing');
  await inst.db.update(schema.account).set({ cash: Math.max(0, Math.round((account.cash - penalty) * 100) / 100) });
  await inst.db.update(schema.packages).set({ status: 'abandoned', planeId: null }).where(eq(schema.packages.id, packageId));
  await persist(inst);
  return { penalty };
}

// --- Ignore (POST /api/packages/:id/ignore) — ISS-047 part B ---

// Dismiss an OPEN job so it leaves the market permanently; no penalty, nothing else
// changes. The top-up logic (spawnOpenPackages counts 'open') refills the market with
// a new random package on the next tick. 404 unknown id; 409 unless open.
export async function ignorePackage(inst: GameDb, packageId: string): Promise<void> {
  const pkgRows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId));
  const pkg = pkgRows[0];
  if (!pkg) throw new GameActionError(404, `package ${packageId} not found`);
  if (pkg.status !== 'open') {
    throw new GameActionError(409, `package is ${pkg.status}, only open packages can be ignored`);
  }

  await inst.db.update(schema.packages).set({ status: 'ignored' }).where(eq(schema.packages.id, packageId));
  await persist(inst);
}

// --- Market (POST /api/market/buy-plane {model}) ---

// Buy a catalog model at full price; it arrives 'available' with a full tank at
// the home base (EDDF).
export async function buyPlane(inst: GameDb, model: string): Promise<{ planeId: string }> {
  const type = PLANE_TYPES[model];
  if (!type) throw new GameActionError(400, `unknown plane model "${model}"`);

  const account = (await inst.db.select().from(schema.account))[0];
  if (!account) throw new Error('account row missing');
  if (account.cash < type.price) {
    throw new GameActionError(409, `insufficient funds: a ${type.name} costs ${type.price}, you have ${Math.round(account.cash)}`);
  }

  const fc = await loadAirportsGeoJson();
  // Same hub fallback as the seed (HUB_ICAO, else first airport).
  const home = fc.features.find((f) => f.properties.icao === HUB_ICAO)?.properties ?? fc.features[0].properties;

  const planeId = randomUUID();
  await inst.db.insert(schema.planes).values({
    id: planeId,
    model,
    status: 'available',
    fuel: type.maxFuel, // full tank on delivery
    maxFuel: type.maxFuel,
    locationIcao: home.icao,
    destIcao: null,
    lat: home.lat,
    lon: home.lon,
    departureSimTime: null,
  });
  await inst.db.update(schema.account).set({ cash: account.cash - type.price });
  await persist(inst);
  return { planeId };
}

// --- Market (POST /api/market/sell-plane {planeId}) ---

// Sell a grounded plane for SELL_FRACTION of its catalog price. The last
// remaining plane can never be sold — the company needs at least one aircraft.
export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout: number }> {
  const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = rows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
  if (plane.status !== 'available') {
    throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can be sold`);
  }

  // v0.28.0: selling a plane that still carries cargo would orphan it — the packages stay
  // 'loaded'/'expired' with a dangling planeId and could never deliver (same query pattern as loadPackage).
  const carrying = await inst.db.select({ id: schema.packages.id }).from(schema.packages).where(
    and(inArray(schema.packages.status, ['loaded', 'expired']), eq(schema.packages.planeId, plane.id)),
  );
  if (carrying.length > 0) {
    throw new GameActionError(409, `cannot sell a plane carrying cargo`);
  }

  const all = await inst.db.select().from(schema.planes);
  if (all.length <= 1) throw new GameActionError(409, 'cannot sell the last remaining plane');

  const type = PLANE_TYPES[plane.model];
  if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
  const payout = Math.round(type.price * SELL_FRACTION * 100) / 100;

  await inst.db.delete(schema.planes).where(eq(schema.planes.id, planeId));
  const account = (await inst.db.select().from(schema.account))[0];
  if (!account) throw new Error('account row missing');
  await inst.db.update(schema.account).set({ cash: Math.round((account.cash + payout) * 100) / 100 });
  await persist(inst);
  return { payout };
}

// --- Refuel (POST /api/planes/:planeId/refuel) ---

// Refuel modes (v0.16.0): 'full' fills the tank to maxFuel; 'forFlight' adds just
// enough fuel for one loaded package's destination leg — required liters per the
// weighted burn model, independent of how much is already in the tank.
export interface RefuelOptions {
  mode?: 'full' | 'forFlight';
  packageId?: string;
}

// Fill a grounded plane to maxFuel at FUEL_PRICE_PER_L per missing liter — or, with
// {mode:'forFlight', packageId}, top it up just enough to fly the loaded package's
// destination leg (409 if the package isn't loaded on this plane, is expired, or the
// leg doesn't fit a full tank).
export async function refuelPlane(inst: GameDb, planeId: string, opts: RefuelOptions = {}): Promise<{ cost: number }> {
  const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = rows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
  if (plane.status !== 'available') {
    throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can be refueled`);
  }

  const mode = opts.mode ?? 'full';
  let targetFuel: number; // tank level after the refuel
  if (mode === 'forFlight') {
    if (!opts.packageId) throw new GameActionError(400, 'packageId is required when mode is "forFlight"');

    const pkgRows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, opts.packageId));
    const pkg = pkgRows[0];
    if (!pkg) throw new GameActionError(404, `package ${opts.packageId} not found`);
    if (pkg.status !== 'loaded' || pkg.planeId !== plane.id) {
      const where = pkg.planeId === plane.id ? '' : ', and it is bound to another plane';
      throw new GameActionError(409, `only a package loaded on this plane can be refueled for (it is ${pkg.status}${where})`);
    }

    const type = PLANE_TYPES[plane.model];
    if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
    const origin = await airportByIcao(plane.locationIcao);
    const dest = await airportByIcao(pkg.destIcao);
    const distanceKm = haversineKm(origin.lat, origin.lon, dest.lat, dest.lon);
    const requiredL = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm);
    if (requiredL > plane.maxFuel) {
      throw new GameActionError(409, `the leg to ${pkg.destIcao} needs ${Math.round(requiredL)} L even starting empty — it does not fit a full ${plane.maxFuel} L tank`);
    }
    // Land EXACTLY on the leg requirement when topping up: flyPlane re-computes this same value and
    // compares with strict `>`, so fuel := requiredL guarantees the leg is feasible. The alternative
    // (fuel + liters) can round a hair BELOW R in IEEE754 — f + fl(R − f) is not guaranteed ≥ R — and
    // would 409 on an otherwise-feasible leg. Already enough → free no-op, tank untouched.
    targetFuel = Math.max(plane.fuel, requiredL);
  } else {
    // Exactly maxFuel (as before v0.16.0) — clients/tests compare against it with strict equality.
    targetFuel = plane.maxFuel;
  }

  const liters = Math.max(0, targetFuel - plane.fuel);
  const cost = Math.round(liters * FUEL_PRICE_PER_L * 100) / 100;
  const account = (await inst.db.select().from(schema.account))[0];
  if (!account) throw new Error('account row missing');
  if (cost > 0 && account.cash < cost) {
    throw new GameActionError(409, `insufficient funds: refueling costs ${cost}, you have ${Math.round(account.cash)}`);
  }

  await inst.db.update(schema.planes).set({ fuel: targetFuel }).where(eq(schema.planes.id, planeId));
  if (cost > 0) {
    await inst.db.update(schema.account).set({ cash: Math.round((account.cash - cost) * 100) / 100 });
  }
  await persist(inst);
  return { cost };
}

// --- Route helper (response convention, v0.8.0) ---

// Run an action under the sim lock — tick FIRST so validation/mutation see current
// game time — then respond with the FULL current state snapshot (same shape as
// GET /api/state), so clients never need a follow-up poll. GameActionError maps to
// its own status + {error}; anything unexpected is a 500.
export async function performAction(fn: (inst: GameDb) => Promise<unknown>): Promise<Response> {
  try {
    await runAction(fn);
    return Response.json(await getStateSnapshot());
  } catch (err) {
    if (err instanceof GameActionError) {
      return Response.json({ error: err.message }, { status: err.status });
    }
    console.error('action failed', err);
    return Response.json({ error: 'action failed' }, { status: 500 });
  }
}