/**
 * Entity interpolation: a pure function of two samples and a time.
 *
 * What is checked here is what a browser cannot be asked about — that the
 * body walks between the pair at the server's own speed, that a missed
 * snapshot is carried exactly one interval and no further, that the turn is
 * taken the short way round, and that a time between the pair never draws
 * the body anywhere but between them.
 */

import { expect, test } from "bun:test";
import { arrive, bodyAt, delay, feed, GONE, LAG, LAG_MAX, LAG_MIN, makeTimeline, sample } from "../static/interp.js";

type Mark = { t: number; x: number; y: number; angle: number };
const pair = (a: Mark, b: Mark) => [a, b];

const walk = pair({ t: 10, x: 100, y: 200, angle: 0 }, { t: 10.1, x: 120, y: 200, angle: 1 });

test("between the pair it walks at the speed the server moved it", () => {
  expect(sample(walk, 10)).toMatchObject({ x: 100, y: 200 });
  expect(sample(walk, 10.05).x).toBeCloseTo(110, 6);
  expect(sample(walk, 10.1)).toMatchObject({ x: 120, y: 200 });
  // Constant speed: equal steps of time are equal steps of distance, which
  // is the whole difference from an exponential chase that never arrives.
  const a = sample(walk, 10.02).x;
  const b = sample(walk, 10.04).x;
  const c = sample(walk, 10.06).x;
  expect(b - a).toBeCloseTo(c - b, 6);
});

test("a time inside the pair is never a position outside it", () => {
  const diagonal = pair({ t: 1, x: -30, y: 80, angle: 2 }, { t: 1.07, x: 45, y: -10, angle: -2 });
  for (let when = 1; when <= 1.07; when += 0.002) {
    const at = sample(diagonal, when);
    expect(at.x).toBeGreaterThanOrEqual(-30);
    expect(at.x).toBeLessThanOrEqual(45);
    expect(at.y).toBeGreaterThanOrEqual(-10);
    expect(at.y).toBeLessThanOrEqual(80);
  }
});

test("before the older sample it holds rather than running backwards", () => {
  expect(sample(walk, 9.5)).toMatchObject({ x: 100, y: 200 });
  expect(sample(walk, 0)).toMatchObject({ x: 100, y: 200 });
});

test("a missed snapshot is carried one interval and then held", () => {
  // Half an interval late: half an interval of the pair's own velocity.
  expect(sample(walk, 10.15).x).toBeCloseTo(130, 6);
  // A whole one: exactly one more interval of it.
  expect(sample(walk, 10.2).x).toBeCloseTo(140, 6);
  // And never a step further, however long the silence lasts.
  expect(sample(walk, 10.3).x).toBeCloseTo(140, 6);
  expect(sample(walk, 30).x).toBeCloseTo(140, 6);
  expect(sample(walk, 30).angle).toBeCloseTo(2, 6);
});

test("two samples at one instant are one sample", () => {
  const still = pair({ t: 5, x: 7, y: 8, angle: 0.5 }, { t: 5, x: 7, y: 8, angle: 0.5 });
  expect(sample(still, 9)).toMatchObject({ x: 7, y: 8, angle: 0.5 });
});

test("the turn is taken the short way round", () => {
  const spin = pair({ t: 0, x: 0, y: 0, angle: 3.0 }, { t: 0.1, x: 0, y: 0, angle: -3.0 });
  // Not back through zero: onward past π, by a sixth of a radian or so.
  expect(sample(spin, 0.05).angle).toBeCloseTo(3.0 + 0.2831853 / 2, 6);
  const back = pair({ t: 0, x: 0, y: 0, angle: -3.0 }, { t: 0.1, x: 0, y: 0, angle: 3.0 });
  expect(sample(back, 0.05).angle).toBeCloseTo(-3.0 - 0.2831853 / 2, 6);
});

// ------------------------------------------------------------- the timeline

const body = (id: string, x: number, y = 0, angle = 0) => ({ id, x, y, angle });

test("a body is drawn where the server says until there are two of it", () => {
  const timeline = makeTimeline();
  const first = body("a", 50);
  expect(bodyAt(timeline, first, 10)).toBe(first);
  feed(timeline, "a", first, 10);
  expect(bodyAt(timeline, first, 10.2)).toMatchObject({ x: 50, y: 0 });
  feed(timeline, "a", body("a", 60), 10.1);
  expect(bodyAt(timeline, body("a", 60), 10.05).x).toBeCloseTo(55, 6);
});

test("each body keeps its own answer: one can be held while another is asked", () => {
  const timeline = makeTimeline();
  feed(timeline, "a", body("a", 0), 1);
  feed(timeline, "a", body("a", 10), 1.1);
  feed(timeline, "b", body("b", 100), 1);
  feed(timeline, "b", body("b", 110), 1.1);
  const a = bodyAt(timeline, body("a", 10), 1.05);
  const b = bodyAt(timeline, body("b", 110), 1.05);
  expect(a.x).toBeCloseTo(5, 6);
  expect(b.x).toBeCloseTo(105, 6);
});

test("a body that was out of sight starts again rather than sliding back", () => {
  const timeline = makeTimeline();
  feed(timeline, "a", body("a", 0), 1);
  feed(timeline, "a", body("a", 10), 1.1);
  feed(timeline, "a", body("a", 900), 1.1 + GONE + 0.1);
  expect(bodyAt(timeline, body("a", 900), 1.1 + GONE + 0.15).x).toBeCloseTo(900, 6);
});

test("a jump no one could have run is a respawn, not a walk", () => {
  const timeline = makeTimeline();
  feed(timeline, "a", body("a", 0), 1);
  feed(timeline, "a", body("a", 10), 1.1);
  // A third of a second's running is 80-odd units; 600 is a teleport.
  feed(timeline, "a", body("a", 610), 1.2);
  expect(bodyAt(timeline, body("a", 610), 1.25).x).toBeCloseTo(610, 6);
});

test("a sample that arrives out of order is dropped", () => {
  const timeline = makeTimeline();
  feed(timeline, "a", body("a", 0), 1);
  feed(timeline, "a", body("a", 10), 1.1);
  feed(timeline, "a", body("a", 999), 1.05);
  expect(bodyAt(timeline, body("a", 10), 1.1).x).toBeCloseTo(10, 6);
});

test("the delay follows the rate the snapshots actually arrive at", () => {
  const slow = makeTimeline();
  for (let i = 0; i < 60; i++) arrive(slow, 10 + i / 15);
  const fast = makeTimeline();
  for (let i = 0; i < 60; i++) arrive(fast, 10 + i / 30);
  expect(delay(slow)).toBeGreaterThan(delay(fast));
  expect(delay(slow)).toBeCloseTo((1 / 15) * LAG, 3);
  // Thirty a second wants less of a delay, and both stay inside the bounds.
  for (const d of [delay(slow), delay(fast)]) {
    expect(d).toBeGreaterThanOrEqual(LAG_MIN);
    expect(d).toBeLessThanOrEqual(LAG_MAX);
  }
  // A pause — a backgrounded tab, a reconnect — says nothing about the rate.
  arrive(fast, 40);
  expect(delay(fast)).toBeCloseTo(LAG_MIN, 3);
});

test("the moment being drawn is always bracketed by samples on hand", () => {
  // Thirty snapshots a second, a frame every 16ms: the moment being drawn
  // always falls between the two samples on hand, never before them.
  const timeline = makeTimeline();
  let x = 0;
  let last = { t: 0, x: 0 };
  for (let i = 0; i < 40; i++) {
    const at = 10 + i / 30;
    arrive(timeline, at);
    x += 8;
    feed(timeline, "a", body("a", x), at);
    last = { t: at, x };
    if (i < 3) continue;
    for (let f = 0; f < 2; f++) {
      const now = at + f * 0.016;
      const marks = timeline.bodies.get("a")!.marks as Mark[];
      const when = now - delay(timeline);
      expect(when).toBeGreaterThanOrEqual(marks[0]!.t - 1e-9);
      expect(when).toBeLessThanOrEqual(marks[marks.length - 1]!.t + 1e-9);
    }
  }
  // And late is what late means: behind the newest word by the delay, which
  // at eight units an interval is between one and two of them.
  const drawn = bodyAt(timeline, body("a", last.x), last.t - delay(timeline));
  expect(last.x - drawn.x).toBeGreaterThan(0);
  expect(last.x - drawn.x).toBeLessThan(20);
});