import * as THREE from 'three';
import { createPhysicsWorld, initPhysics } from '../src/physics/world.js';
import { createMatch } from '../src/game/match.js';
import { createShootout } from '../src/game/shootout.js';
import { NET, goalLineX, goalieSpot, isGoal } from '../shared/net.js';
import { PUCK } from '../src/physics/puck.js';
import { done, near, ok, section } from './harness.mjs';

/**
 * The shootout: net, goalie, and the loop that turns them into a result.
 *
 * The thing worth testing hard is that it *terminates*. A shootout that can
 * hang — a puck asleep in a corner, a goalie who never lets go of it, an
 * attempt with no way to end — is worse than one that scores wrongly, because
 * nothing tells you it has happened.
 */

const DT = 1 / 60;
await initPhysics();

function arena() {
  const physics = createPhysicsWorld();
  const match = createMatch({ scene: new THREE.Group(), physics, perTeam: 3, teams: 2 });
  const shootout = createShootout({ scene: new THREE.Group(), physics, match });
  match.addSubstepSync((dt) => {
    shootout.goalies[1].syncPhysics(dt);
    shootout.goalies[-1].syncPhysics(dt);
  });
  shootout.reset();
  return { physics, match, shootout };
}

function run(w, seconds) {
  for (let n = 0; n < seconds / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
  }
}

section('goal detection follows the rule');
{
  const end = 1;
  const line = goalLineX(end);
  const r = PUCK.radius;

  ok(!isGoal({ x: line, y: 0.02, z: 0 }, end, r), 'a puck on the line is not a goal');
  ok(!isGoal({ x: line + r * 0.5, y: 0.02, z: 0 }, end, r), 'nor one only half across');
  ok(isGoal({ x: line + r * 2, y: 0.02, z: 0 }, end, r), 'fully across and between the posts is');
  ok(!isGoal({ x: line + r * 2, y: 0.02, z: NET.width }, end, r), 'wide of the post is not');
  ok(!isGoal({ x: line + r * 2, y: NET.height + 0.2, z: 0 }, end, r), 'over the bar is not');
  ok(!isGoal({ x: line + NET.depth + 0.5, y: 0.02, z: 0 }, end, r), 'behind the net is not');
  // And the same at the other end, where every sign flips.
  const l2 = goalLineX(-1);
  ok(isGoal({ x: l2 - r * 2, y: 0.02, z: 0 }, -1, r), 'the far end scores too');
  ok(!isGoal({ x: l2 + r * 2, y: 0.02, z: 0 }, -1, r), 'and not from in front of it');
}

section('the goalie plays the angle');
{
  const end = 1;
  const line = goalLineX(end);
  const spot = { x: 0, z: 0 };

  goalieSpot({ x: 0, z: 0 }, end, 0.6, spot);
  near(spot.z, 0, 1e-9, 'a puck dead centre puts them dead centre');
  ok(spot.x < line && spot.x > line - 1, `and out in front of the line (${spot.x.toFixed(2)})`);

  // Puck to one side: the goalie shifts the same way, but less.
  goalieSpot({ x: line - 8, z: 4 }, end, 0.6, spot);
  ok(spot.z > 0, 'a puck to the left moves them left');
  ok(spot.z < 4, 'but they do not chase it out there');
  ok(Math.abs(spot.z) <= NET.width / 2 + 0.25, `and never past the post (${spot.z.toFixed(2)})`);

  // Extreme angle: still covering the post, never abandoning the net.
  goalieSpot({ x: line, z: 12 }, end, 0.6, spot);
  ok(Math.abs(spot.z) <= NET.width / 2 + 0.25, 'even from the goal line corner');
}

section('a shootout sets itself up');
{
  const w = arena();
  const so = w.shootout.state;
  ok(so.phase === 'ready', 'it starts in the ready phase');
  ok(so.score[0] === 0 && so.score[1] === 0, 'nil-nil');
  ok(w.match.possession.carrier === null, 'nobody starts holding the puck');
  const s = w.match.states[so.shooter];
  const puck = w.match.puck.position();
  near(Math.hypot(puck.x, puck.z), 0, 0.3, 'the puck is on the dot at centre ice');
  ok(Math.hypot(s.x - puck.x, s.z - puck.z) > 3, `and the shooter starts back from it (${Math.hypot(s.x - puck.x, s.z - puck.z).toFixed(1)}m)`);
  w.physics.destroy();
}

section('the shooter skates onto the puck rather than spawning on it');
{
  const w = arena();
  ok(w.match.possession.carrier === null, 'loose at the start');
  // Give them time to get released and reach it.
  let gained = false;
  for (let n = 0; n < 6 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
    if (w.match.possession.carrier === w.shootout.state.shooter) {
      gained = true;
      break;
    }
  }
  ok(gained, 'the shooter picked the puck up on the way through');
  w.physics.destroy();
}

section('losing the handle does not end the attempt');
{
  const w = arena();
  // Run to live, then knock the puck away from whoever has it.
  for (let n = 0; n < 5 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
    if (w.shootout.state.phase === 'live' && w.match.possession.carrier !== null) break;
  }
  ok(w.shootout.state.phase === 'live', 'the attempt is live');
  const before = w.shootout.state.attempts.slice();
  w.match.possession.release('test', 0.2);
  w.match.puck.setVelocity(0, 0, 0);
  // Sit on a dead loose puck for well over the old two-second dead timeout.
  for (let n = 0; n < 3 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
  }
  ok(
    w.shootout.state.attempts[0] === before[0] && w.shootout.state.attempts[1] === before[1],
    'a dead loose puck did not end the attempt',
  );
  w.physics.destroy();
}

section('the AI takes attempts and they all resolve');
{
  const w = arena();
  const results = [];
  let lastRound = null;
  for (let n = 0; n < 120 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
    const last = w.shootout.state.last;
    if (last && last !== lastRound) {
      results.push(last);
      lastRound = last;
    }
  }
  ok(results.length >= 4, `several attempts completed in two minutes (${results.length})`);
  for (const r of results) {
    ok(r.result === 'goal' || r.result === 'save', `every attempt resolved (${r.result} ${r.detail})`);
  }
  const so = w.shootout.state;
  ok(so.attempts[0] > 0 && so.attempts[1] > 0, 'both teams got to shoot');
  ok(Math.abs(so.attempts[0] - so.attempts[1]) <= 1, 'and the sides alternate');
  w.physics.destroy();
}

section('bots actually shoot');
{
  // This is the gap that made the whole shooting layer human-only: a bot with
  // the puck used to carry it forever.
  const w = arena();
  let shots = 0;
  const seen = new Set();
  for (let n = 0; n < 90 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
    for (const p of w.match.recentPlays) {
      const id = `${p.at}|${p.type}|${p.skater}`;
      if (!seen.has(id)) {
        seen.add(id);
        if (p.type === 'shot') shots++;
      }
    }
  }
  ok(shots > 0, `bots put shots on net without a human driving (${shots})`);
  w.physics.destroy();
}

section('the goalie makes saves and the shooter sometimes scores');
{
  // Over enough attempts both outcomes have to be reachable, or the goalie is
  // either a wall or a turnstile and neither is a game.
  const w = arena();
  let goals = 0;
  let saves = 0;
  let lastRound = null;
  for (let n = 0; n < 240 / DT; n++) {
    w.match.update(DT);
    w.shootout.update(DT);
    const last = w.shootout.state.last;
    if (last && last !== lastRound) {
      lastRound = last;
      if (last.result === 'goal') goals++;
      else saves++;
    }
  }
  ok(goals + saves >= 8, `plenty of attempts to judge on (${goals + saves})`);
  ok(saves > 0, `the goalie stops some (${saves} saves)`);
  // Not asserted the other way round: a goalie who is currently unbeatable is
  // a tuning problem, and the number is reported so it can be tuned.
  console.log(`    ${goals} goals / ${saves} saves`);
  w.physics.destroy();
}

section('nothing escapes and nothing hangs');
{
  const w = arena();
  run(w, 120);
  const p = w.match.puck.position();
  ok(Number.isFinite(p.x) && Number.isFinite(p.z), 'the puck is finite');
  ok(Math.abs(p.x) < 40 && Math.abs(p.z) < 20, `and still in the building (${p.x.toFixed(1)}, ${p.z.toFixed(1)})`);
  for (let i = 0; i < w.match.states.length; i++) {
    ok(Number.isFinite(w.match.states[i].x), `skater ${i} is finite`);
  }
  ok(w.shootout.state.round > 1, `rounds advanced (round ${w.shootout.state.round})`);
  w.physics.destroy();
}

section('the goalie is not knocked around by the puck');
{
  const w = arena();
  run(w, 3);
  const g = w.shootout.goalies[1];
  const before = { x: g.pos.x, z: g.pos.z };
  // Fire a puck straight into them at full pace.
  w.match.puck.place(goalLineX(1) - 4, 0.3, 0);
  w.match.puck.setVelocity(45, 0, 0);
  run(w, 0.6);
  // They may have shuffled to track it, but not been shoved into the net.
  ok(Math.abs(g.pos.x - before.x) < 1.2, `the goalie held their ground (${(g.pos.x - before.x).toFixed(2)}m)`);
  w.physics.destroy();
}

done('shootout');