// physics.js — PURE math: only imports dims.js constants, no three.js, no DOM.
// Node-testable. Units: meters + seconds.
// Contact plane z=0, release z=-18.44 (mound, from dims.js). See CONTRACT.md.

import { RELEASE } from './dims.js';

export { RELEASE };
export const PLANE_Z = 0;
export const ZONE = { x0: -0.45, x1: 0.45, y0: 0.45, y1: 1.55 };
export const SWING = { min: 0.02, max: 0.32, ideal: 0.14 }; // seconds before crossing (R16: longer window, later sweet spot)

const TAU = Math.PI * 2;

const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
const lerp = (a, b, s) => a + (b - a) * s;

// ---------------------------------------------------------------------------
// Deterministic RNG shared by game + capture mode.
// ---------------------------------------------------------------------------
export function mulberry32(seed) {
  let a = seed >>> 0;
  return function () {
    a = (a + 0x6D2B79F5) | 0;
    let t = Math.imul(a ^ (a >>> 15), 1 | a);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// ---------------------------------------------------------------------------
// createPitch — draw one pitch from a levelDef + rng.
// levelDef fields used: duration, speedVar, curve:[lo,hi]?, jitter:[lo,hi]?
// Consumes rng in a FIXED order (deterministic for a given seed + levelDef):
//   duration, target.x, target.y, curve?, curveDir, drop, jitter?, jf1, jf2, p1, p2
// ---------------------------------------------------------------------------
export function createPitch(levelDef, rng) {
  // Duration jittered by speedVar (± speedVar * duration).
  const duration = levelDef.duration * (1 + (rng() * 2 - 1) * (levelDef.speedVar ?? 0));
  // Nominal aim point at the contact plane (inside-ish of the strike zone).
  const target = {
    x: -0.32 + rng() * 0.64, // x ∈ [-0.32, 0.32]
    y: 0.75 + rng() * 0.70, //  y ∈ [0.75, 1.45]
  };
  const cr = levelDef.curve; // [lo,hi] or absent
  const curve = cr ? lerp(cr[0], cr[1], rng()) : 0;
  const curveDir = rng() < 0.5 ? -1 : 1;
  const drop = 0.08 + rng() * 0.22; // [0.08, 0.30]
  const jr = levelDef.jitter; // [lo,hi] or absent
  const jitterAmp = jr ? lerp(jr[0], jr[1], rng()) : 0;
  const jf1 = 2 + rng() * 2; // jitter freq 1 ∈ [2,4] Hz (R15: knuckleball wobble, not buzz)
  const jf2 = 2 + rng() * 2; // jitter freq 2 ∈ [2,4] Hz
  const p1 = rng() * TAU; // phases ∈ [0, 2π)
  const p2 = rng() * TAU;
  return {
    duration,
    release: { x: RELEASE.x, y: RELEASE.y, z: RELEASE.z },
    target,
    curve,
    curveDir,
    drop,
    jitterAmp,
    jf1,
    jf2,
    p1,
    p2,
  };
}

// ---------------------------------------------------------------------------
// Internal path evaluation, t clamped into [0, duration] by callers.
//   s = t/duration
//   z = lerp(-18.44 → 0, s)
//   x = lerp(release.x → target.x, s) + curveDir*curve*breakShape(s) + jitterX
//   y = lerp(release.y → target.y, s) - drop·s²                       + jitterY
//   jitterX = jitterAmp·min(1,2s)·sin(2π·jf1·t + p1)  — env 0 at s=0 ⇒ release exact,
//   jitterY = jitterAmp·min(1,2s)·sin(2π·jf2·t + p2)    full-strength from s≥0.5 (R15)
// breakShape(s) = sin(π·s^1.7)·(1−s)/BREAK_PEAK — R6 curve-snap fix.
// The bare sin(π·s^1.7) bump is 0 at s=1 but lands with a nonzero slope
// (≈5.34·curve/duration lateral m/s): the ball visibly zips sideways in
// the last instant and the plane velocity carries that kink. Multiplying
// by (1−s) makes BOTH the value and the derivative vanish at s=1 — the
// break settles before the plate like a real breaking ball, and the
// linear extrapolation past the plane is C1-continuous through it.
// BREAK_PEAK normalizes so `curve` still means "peak lateral break in
// meters" (peak at s≈0.516, vs 0.665 before — the pitch commits to its
// break a touch earlier, then runs true).
// ---------------------------------------------------------------------------
// Numerically measured max of sin(π·s^1.7)·(1−s) on s∈[0,1] (at s≈0.51586).
const BREAK_PEAK = 0.41245259522492866;

function breakShape(s) {
  return (Math.sin(Math.PI * Math.pow(s, 1.7)) * (1 - s)) / BREAK_PEAK;
}

function evalPath(pitch, t) {
  const s = t / pitch.duration;
  const wob = pitch.jitterAmp * Math.min(1, s * 2); // R15: ramp in early, wobble reads mid-flight
  return {
    x:
      lerp(pitch.release.x, pitch.target.x, s) +
      pitch.curveDir * pitch.curve * breakShape(s) +
      wob * Math.sin(TAU * pitch.jf1 * t + pitch.p1),
    y:
      lerp(pitch.release.y, pitch.target.y, s) -
      pitch.drop * s * s +
      wob * Math.sin(TAU * pitch.jf2 * t + pitch.p2),
    z: lerp(pitch.release.z, PLANE_Z, s),
  };
}

// ---------------------------------------------------------------------------
// pitchPosition(pitch, t) → {x,y,z}
// t<0 clamps to the release point; 0..duration follows the path;
// t>duration extrapolates linearly with the plane velocity so a missed
// ball keeps sailing toward the camera.
// ---------------------------------------------------------------------------
export function pitchPosition(pitch, t) {
  if (t <= 0) return evalPath(pitch, 0);
  if (t <= pitch.duration) return evalPath(pitch, t);
  const end = evalPath(pitch, pitch.duration);
  const v = pitchVelocityAtPlane(pitch);
  const dt = t - pitch.duration;
  return { x: end.x + v.x * dt, y: end.y + v.y * dt, z: end.z + v.z * dt };
}

// ---------------------------------------------------------------------------
// pitchVelocityAtPlane — CENTRAL finite difference straddling s=1 (evalPath
// stays valid slightly past the plane). Central ≈ 2nd-order: with
// breakShape'(1)=0 this is exactly the slope a missed ball keeps when the
// game extrapolates it toward the mitt — no kink, no snap.
// ---------------------------------------------------------------------------
export function pitchVelocityAtPlane(pitch) {
  const eps = Math.min(1e-3, pitch.duration * 0.5);
  const a = evalPath(pitch, pitch.duration - eps);
  const b = evalPath(pitch, pitch.duration + eps);
  return {
    x: (b.x - a.x) / (2 * eps),
    y: (b.y - a.y) / (2 * eps),
    z: (b.z - a.z) / (2 * eps),
  };
}

// ---------------------------------------------------------------------------
// inZone — strike-zone test on a plane position {x,y}.
// ---------------------------------------------------------------------------
export function inZone({ x, y }) {
  return x >= ZONE.x0 && x <= ZONE.x1 && y >= ZONE.y0 && y <= ZONE.y1;
}

// ---------------------------------------------------------------------------
// zoneOverlap(pos) — fraction of the ball disc inside the strike zone (R23).
// The ball is sampled as a 16-point ring of radius BALL_ZONE_R around pos
// (deterministic angles i·2π/16); returns (#samples inside ZONE.x/y)/16 ∈[0,1].
// Pure, no rng. Used at the CLICK instant so "how much of the ball was in the
// zone" feeds contact quality.
// ---------------------------------------------------------------------------
export const BALL_ZONE_R = 0.10;
export function zoneOverlap(pos) {
  let inside = 0;
  for (let i = 0; i < 16; i++) {
    const a = (i * TAU) / 16;
    const x = pos.x + BALL_ZONE_R * Math.cos(a);
    const y = pos.y + BALL_ZONE_R * Math.sin(a);
    if (x >= ZONE.x0 && x <= ZONE.x1 && y >= ZONE.y0 && y <= ZONE.y1) inside += 1;
  }
  return inside / 16;
}

// ---------------------------------------------------------------------------
// judgeContact({timingErr, clickOff, zoneFrac}, hrThreshold=0.60)  (R23 v2)
//   timingErr: seconds the swing lands BEFORE crossing (positive = early).
//   clickOff:  reticle-aim distance from the ball's LIVE position at click.
//   zoneFrac:  zoneOverlap(clickPos) — ball-disc fraction inside the zone.
//   tq = clamp(1 - |timingErr-ideal|/ideal, 0, 1)   — swing timing
//   cq = clamp(1 - clickOff/0.5, 0, 1)             — where on the ball (1=dead-on)
//   quality = clamp(0.55*tq + 0.30*cq + 0.15*zoneFrac, 0, 1)
//   contact iff SWING.min<=timingErr<=SWING.max && tq>0.1 && cq>0.15
//   R16: SWING widened to [0.02, 0.32] around ideal 0.14 — effective contact
//        reach extends to ~0.266 s early (tq>0.1 still gates the tail).
//   R17: homerun iff quality >= hrThreshold (level 1 passes 0.50);
//        else 'popup' (weak contact) iff quality < 0.45; else 'inplay'.
// ---------------------------------------------------------------------------
export function judgeContact({ timingErr, clickOff, zoneFrac }, hrThreshold = 0.6) {
  const tq = clamp(1 - Math.abs(timingErr - SWING.ideal) / SWING.ideal, 0, 1);
  const cq = clamp(1 - clickOff / 0.5, 0, 1);
  const quality = clamp(0.55 * tq + 0.3 * cq + 0.15 * zoneFrac, 0, 1);
  const contact =
    timingErr >= SWING.min && timingErr <= SWING.max && tq > 0.1 && cq > 0.15;
  if (!contact) return { kind: 'none', quality };
  if (quality >= hrThreshold) return { kind: 'homerun', quality };
  return { kind: quality < 0.45 ? 'popup' : 'inplay', quality };
}