import { SparseResidualModel, planarSpeeds, unpackState } from './model.js';
import { REST_SPEED, RULE_DESCRIPTIONS, Scoreboard, evaluateRules } from './battery.js';
import { OBJECT_RADIUS, PUSHER_RADIUS, PlanarPushEnv, changedMask } from './planar.js';

const WORLD_BOUND = 0.28;
const BASE_STEP_MS = 60;
const MOTION_THRESHOLD = 0.02;
const HF_BASE = 'https://huggingface.co/datasets/ParamThakkar123/sparse_world_models/resolve/main';

const TASKS = {
  sandbox: {
    title: 'Sandbox: you drive, the model predicts',
    copy: 'Live planar physics, running in this tab. Each frame the model outputs a gate '
        + 'per object and a delta; the dashed outline is where it thinks each object will be. '
        + 'Switch to mouse or keys and push objects yourself. The ground truth is created by you, '
        + 'so nothing here is a recording.',
    hint: 'Mouse: pusher follows cursor. Keys: arrows or WASD. Auto: scripted push to goal.',
  },
  replay: {
    title: 'Four engines: MuJoCo, Box2D, Chipmunk2D, ours',
    copy: 'MuJoCo, Box2D and Chipmunk cannot run in a browser, so these are recorded episodes '
        + 'from the paper datasets, but the model is predicting on each frame live, and the '
        + 'labels are the real ones. The shortcut existence condition holds on all four '
        + 'engines: P(change | already moving) exceeds P(change | at rest) by 36 to 84x.',
    hint: 'Watch already_moving climb on billiards, where objects roll for a long time after contact.',
  },
  transfer: {
    title: 'Count transfer: one checkpoint, any number of objects',
    copy: 'The same weights, trained on three object scenes, driving scenes with up to twelve. '
        + 'The contact featurisation is fixed width, so nothing has to be retrained. Watch the '
        + 'objects the gate leaves off: they are copied forward exactly, which is the one '
        + 'architectural claim that survived proper baselines.',
    hint: 'Turn the count up. The trivial rules degrade too, but they degrade more slowly.',
  },
  planning: {
    title: 'Planning: the model as a forward simulator',
    copy: 'Sampling based MPC (CEM), replanning every step, using the model to imagine each '
        + 'candidate action sequence. The planner is sound: with the true simulator in place of '
        + 'the model it succeeds every time. Anything it fails to do here is model quality.',
    hint: 'In the paper this reaches 0.25 success against a dense monolith at 0.00, and a '
        + 'published probabilistic ensemble (PETS) beats it at 0.35.',
  },
};

const state = {
  models: null,
  model: null,
  modelName: null,
  episodes: null,
  task: 'sandbox',
  running: true,
  drive: 'auto',
  radius: 0.07,
  numObjects: 3,
  env: null,
  replayName: null,
  replayIndex: 0,
  scoreboard: new Scoreboard(),
  frames: 0,
  pointer: null,
  lastPrediction: null,
  lastTruth: null,
  seenFrames: 0,
  planSuccess: 0,
  planAttempts: 0,
  speed: 1,
  showTrails: false,
  showProbs: true,
  showGrid: true,
  showVel: false,
  sortBy: 'f1',
  trails: [],
  keys: {},
  inspector: null,
};

const canvas = document.getElementById('scene');
const context = canvas.getContext('2d');
const statusEl = document.getElementById('status');
const scoresBody = document.querySelector('#scores tbody');
const framesEl = document.getElementById('frames');
const taskCopy = document.getElementById('task-copy');
const hintEl = document.getElementById('hint');

function toCanvas(x, y) {
  const scale = canvas.width / (2 * WORLD_BOUND);
  return [(x + WORLD_BOUND) * scale, (WORLD_BOUND - y) * scale];
}
function styleValue(name) {
  return getComputedStyle(document.body).getPropertyValue(name).trim();
}
function worldFromPointer(event) {
  const rect = canvas.getBoundingClientRect();
  const x = ((event.clientX - rect.left) / rect.width) * 2 * WORLD_BOUND - WORLD_BOUND;
  const y = WORLD_BOUND - ((event.clientY - rect.top) / rect.height) * 2 * WORLD_BOUND;
  return [x, y];
}
function drawGrid(scale) {
  if (!state.showGrid) return;
  context.strokeStyle = 'color-mix(in srgb, var(--line) 55%, transparent)';
  context.lineWidth = 1;
  context.setLineDash([2, 6]);
  for (let g = -0.2; g <= 0.2; g += 0.1) {
    const [x0, y0] = toCanvas(g, -0.26);
    const [x1, y1] = toCanvas(g, 0.26);
    context.beginPath(); context.moveTo(x0, y0); context.lineTo(x1, y1); context.stroke();
    const [hx0, hy0] = toCanvas(-0.26, g);
    const [hx1, hy1] = toCanvas(0.26, g);
    context.beginPath(); context.moveTo(hx0, hy0); context.lineTo(hx1, hy1); context.stroke();
  }
  context.setLineDash([]);
}
function drawScene({ poses, pusher, goal, gates, probs, predicted, truth, velocities }) {
  const scale = canvas.width / (2 * WORLD_BOUND);
  const dpr = window.devicePixelRatio || 1;
  context.setTransform(dpr, 0, 0, dpr, 0, 0);
  context.clearRect(0, 0, canvas.width / dpr, canvas.height / dpr);
  const [tableX, tableY] = toCanvas(-0.26, 0.26);
  context.fillStyle = styleValue('--bg');
  context.fillRect(0, 0, canvas.width, canvas.height);
  drawGrid(scale);
  context.strokeStyle = styleValue('--line');
  context.lineWidth = 2;
  context.strokeRect(tableX / dpr, tableY / dpr, 0.52 * scale / dpr, 0.52 * scale / dpr);
  if (goal) {
    const [gx, gy] = toCanvas(goal[0], goal[1]);
    context.beginPath();
    context.arc(gx / dpr, gy / dpr, 0.03 * scale / dpr, 0, Math.PI * 2);
    context.strokeStyle = styleValue('--goal');
    context.setLineDash([4, 4]);
    context.lineWidth = 2;
    context.stroke();
    context.setLineDash([]);
  }
  if (state.showTrails && state.trails.length) {
    state.trails.forEach((trail, idx) => {
      if (trail.length < 2) return;
      context.strokeStyle = styleValue('--ghost');
      context.lineWidth = 1.5;
      context.globalAlpha = 0.35;
      context.beginPath();
      trail.forEach((p, i) => {
        const [cx, cy] = toCanvas(p[0], p[1]);
        if (i === 0) context.moveTo(cx / dpr, cy / dpr);
        else context.lineTo(cx / dpr, cy / dpr);
      });
      context.stroke();
      context.globalAlpha = 1;
    });
  }
  if (predicted) {
    context.strokeStyle = styleValue('--ghost');
    context.setLineDash([5, 4]);
    context.lineWidth = 2;
    predicted.forEach((pose) => drawBox(pose, scale, null, dpr));
    context.setLineDash([]);
  }
  poses.forEach((pose, index) => {
    const gateOn = gates && gates[index];
    const changed = truth && truth[index];
    context.lineWidth = 3;
    context.fillStyle = gateOn
      ? `color-mix(in srgb, ${styleValue('--gate')} 55%, transparent)`
      : styleValue('--surface');
    context.strokeStyle = changed ? styleValue('--truth') : styleValue('--line');
    drawBox(pose, scale, true, dpr);
    if (state.showProbs && probs) {
      const [px, py] = toCanvas(pose[0], pose[1]);
      context.fillStyle = styleValue('--ink-soft');
      context.font = '11px ui-monospace, monospace';
      context.textAlign = 'center';
      context.fillText(probs[index].toFixed(2), px / dpr, py / dpr - 0.035 * scale / dpr);
    }
    if (state.showVel && velocities) {
      const v = velocities[index];
      if (v) {
        const [px, py] = toCanvas(pose[0], pose[1]);
        const vx = v[3] || 0;
        const vy = v[4] || 0;
        const mag = Math.hypot(vx, vy);
        if (mag > 1e-4) {
          context.strokeStyle = styleValue('--gate');
          context.lineWidth = 1.5;
          context.beginPath();
          context.moveTo(px / dpr, py / dpr);
          context.lineTo((px + vx * 2 * scale) / dpr, (py - vy * 2 * scale) / dpr);
          context.stroke();
        }
      }
    }
    if (state.inspector && state.inspector.index === index) {
      const [px, py] = toCanvas(pose[0], pose[1]);
      context.strokeStyle = styleValue('--accent');
      context.lineWidth = 2;
      context.setLineDash([3, 3]);
      context.beginPath();
      context.arc(px / dpr, py / dpr, OBJECT_RADIUS * scale / dpr + 4, 0, Math.PI * 2);
      context.stroke();
      context.setLineDash([]);
    }
  });
  const [px, py] = toCanvas(pusher[0], pusher[1]);
  context.beginPath();
  context.arc(px / dpr, py / dpr, PUSHER_RADIUS * scale / dpr, 0, Math.PI * 2);
  context.fillStyle = styleValue('--ink');
  context.fill();
  if (state.drive === 'keys') {
    context.fillStyle = styleValue('--accent');
    context.font = '10px ui-sans-serif, sans-serif';
    context.textAlign = 'center';
    context.fillText('KEYS', px / dpr, py / dpr - 18);
  }
}
function drawBox(pose, scale, filled, dpr) {
  const [x, y] = toCanvas(pose[0], pose[1]);
  const half = OBJECT_RADIUS * scale / dpr;
  context.save();
  context.translate(x / dpr, y / dpr);
  context.rotate(-pose[2]);
  context.beginPath();
  context.rect(-half, -half, 2 * half, 2 * half);
  if (filled) context.fill();
  context.stroke();
  context.restore();
}
function passesMotionFilter(before, after) {
  return before.some((pose, i) => Math.hypot(after[i][0] - pose[0], after[i][1] - pose[1]) > MOTION_THRESHOLD);
}
function scoreFrame(stateVector, action, numObjects, truthMask) {
  const speeds = planarSpeeds(stateVector, numObjects);
  const atRest = speeds.map((speed) => speed <= REST_SPEED);
  const { rules } = evaluateRules(stateVector, action, numObjects, state.radius, state.model.constants);
  for (const [name, prediction] of Object.entries(rules)) {
    state.scoreboard.update(name, prediction, truthMask, atRest);
  }
  const { gates } = state.lastPrediction;
  state.scoreboard.update('model', gates, truthMask, atRest);
  state.frames += 1;
}
function renderScores() {
  let rows = state.scoreboard.rows();
  if (state.sortBy === 'onset') rows = [...rows].sort((a, b) => b.onsetF1 - a.onsetF1 || b.f1 - a.f1);
  scoresBody.innerHTML = '';
  for (const row of rows) {
    const tr = document.createElement('tr');
    if (row.isModel) tr.className = 'model';
    else if (row.parameters === 0) tr.className = 'zero-param';
    const label = row.isModel ? 'the trained model' : row.name;
    tr.innerHTML =
      `<td><span class="rule-name">${label}</span></td>` +
      `<td>${row.isModel ? state.model.weights.num_parameters.toLocaleString() : row.parameters}</td>` +
      `<td>${row.f1.toFixed(3)}</td>` +
      `<td>${row.support ? row.onsetF1.toFixed(3) : '-'}</td>`;
    if (!row.isModel && RULE_DESCRIPTIONS[row.name]) tr.title = RULE_DESCRIPTIONS[row.name];
    scoresBody.appendChild(tr);
  }
  framesEl.textContent = state.seenFrames ? `${state.frames} scored / ${state.seenFrames} seen` : '0 frames';
}
function autoAction(env) {
  const target = env.objectXY[env.config.targetObject];
  const goal = env.config.goalXY;
  const toGoal = [goal[0] - target[0], goal[1] - target[1]];
  const norm = Math.hypot(toGoal[0], toGoal[1]) || 1;
  const behind = [target[0] - (toGoal[0] / norm) * 0.06, target[1] - (toGoal[1] / norm) * 0.06];
  const distanceToBehind = Math.hypot(behind[0] - env.pusher[0], behind[1] - env.pusher[1]);
  const aim = distanceToBehind > 0.02 ? behind : target;
  const dx = aim[0] - env.pusher[0];
  const dy = aim[1] - env.pusher[1];
  const magnitude = Math.hypot(dx, dy) || 1;
  return [dx / magnitude, dy / magnitude];
}
function mouseAction(env) {
  if (!state.pointer) return [0, 0];
  const dx = state.pointer[0] - env.pusher[0];
  const dy = state.pointer[1] - env.pusher[1];
  const magnitude = Math.hypot(dx, dy);
  if (magnitude < 0.004) return [0, 0];
  return [dx / magnitude, dy / magnitude];
}
function keysAction() {
  let dx = 0, dy = 0;
  if (state.keys['ArrowUp'] || state.keys['w'] || state.keys['W']) dy += 1;
  if (state.keys['ArrowDown'] || state.keys['s'] || state.keys['S']) dy -= 1;
  if (state.keys['ArrowLeft'] || state.keys['a'] || state.keys['A']) dx -= 1;
  if (state.keys['ArrowRight'] || state.keys['d'] || state.keys['D']) dx += 1;
  const mag = Math.hypot(dx, dy);
  if (!mag) return [0, 0];
  const scale = state.keys['Shift'] ? 0.5 : 1;
  return [(dx / mag) * scale, (dy / mag) * scale];
}
function planAction(env, horizon = 8, samples = 48, iterations = 2, elite = 0.15) {
  const numObjects = env.config.numObjects;
  const goal = env.config.goalXY;
  const target = env.config.targetObject;
  let mean = Array.from({ length: horizon }, () => [0, 0]);
  let std = Array.from({ length: horizon }, () => [0.6, 0.6]);
  for (let iteration = 0; iteration < iterations; iteration += 1) {
    const scored = [];
    for (let sample = 0; sample < samples; sample += 1) {
      const sequence = mean.map(([mx, my], t) => [
        Math.max(-1, Math.min(1, mx + gaussian() * std[t][0])),
        Math.max(-1, Math.min(1, my + gaussian() * std[t][1])),
      ]);
      scored.push([rollout(env, sequence, numObjects, goal, target), sequence]);
    }
    scored.sort((a, b) => a[0] - b[0]);
    const keep = scored.slice(0, Math.max(2, Math.round(samples * elite))).map(([, s]) => s);
    mean = mean.map((_, t) => [
      keep.reduce((sum, s) => sum + s[t][0], 0) / keep.length,
      keep.reduce((sum, s) => sum + s[t][1], 0) / keep.length,
    ]);
    std = mean.map((_, t) => [
      Math.max(0.05, standardDeviation(keep.map((s) => s[t][0]))),
      Math.max(0.05, standardDeviation(keep.map((s) => s[t][1]))),
    ]);
  }
  return mean[0];
}
function rollout(env, sequence, numObjects, goal, target) {
  let vector = env.state().slice();
  let cost = 0;
  const constants = state.model.constants;
  for (let t = 0; t < sequence.length; t += 1) {
    const { poses } = state.model.step(vector, sequence[t], numObjects);
    const unpacked = unpackState(vector, numObjects);
    const pusher = [
      Math.max(-constants.pusher_bound, Math.min(constants.pusher_bound, unpacked.pusher[0] + Math.max(-1, Math.min(1, sequence[t][0])) * constants.pusher_action_scale)),
      Math.max(-constants.pusher_bound, Math.min(constants.pusher_bound, unpacked.pusher[1] + Math.max(-1, Math.min(1, sequence[t][1])) * constants.pusher_action_scale)),
    ];
    vector = rebuildState(pusher, poses, unpacked.velocities, unpacked.goal);
    const distance = Math.hypot(poses[target][0] - goal[0], poses[target][1] - goal[1]);
    const proximity = Math.hypot(pusher[0] - poses[target][0], pusher[1] - poses[target][1]);
    cost += distance + 0.3 * proximity;
  }
  const finalPoses = unpackState(vector, numObjects).poses;
  cost += 3.0 * Math.hypot(finalPoses[target][0] - goal[0], finalPoses[target][1] - goal[1]);
  return cost;
}
function rebuildState(pusher, poses, velocities, goal) {
  const flat = [...pusher];
  poses.forEach((pose) => flat.push(pose[0], pose[1], pose[2]));
  velocities.forEach((v) => flat.push(...v));
  flat.push(goal[0], goal[1]);
  return flat;
}
let spare = null;
function gaussian() {
  if (spare !== null) { const value = spare; spare = null; return value; }
  let u = 0; let v = 0; let s = 0;
  do { u = Math.random() * 2 - 1; v = Math.random() * 2 - 1; s = u * u + v * v; } while (s >= 1 || s === 0);
  const factor = Math.sqrt((-2 * Math.log(s)) / s);
  spare = v * factor; return u * factor;
}
function standardDeviation(values) {
  const mean = values.reduce((a, b) => a + b, 0) / values.length;
  return Math.sqrt(values.reduce((sum, x) => sum + (x - mean) ** 2, 0) / values.length);
}
function pushTrails(poses) {
  if (!state.showTrails) return;
  if (!state.trails.length || state.trails[0].length === 0 || state.trails.length !== poses.length) {
    state.trails = poses.map((p) => [[p[0], p[1]]]);
    return;
  }
  poses.forEach((p, i) => {
    state.trails[i].push([p[0], p[1]]);
    if (state.trails[i].length > 24) state.trails[i].shift();
  });
}
function stepLive() {
  const env = state.env;
  const numObjects = env.config.numObjects;
  const before = env.observation().poses.map((pose) => [...pose]);
  const vector = env.state();
  let action;
  if (state.task === 'planning') action = planAction(env);
  else if (state.drive === 'mouse') action = mouseAction(env);
  else if (state.drive === 'keys') action = keysAction(env);
  else action = autoAction(env);
  state.lastPrediction = state.model.step(vector, action, numObjects);
  env.step(action);
  const after = env.observation().poses;
  const truth = changedMask(before, after);
  state.lastTruth = truth;
  state.seenFrames += 1;
  if (passesMotionFilter(before, after)) scoreFrame(vector, action, numObjects, truth);
  pushTrails(after);
  if (state.task === 'planning') {
    const target = env.config.targetObject;
    const distance = Math.hypot(after[target][0] - env.config.goalXY[0], after[target][1] - env.config.goalXY[1]);
    if (distance < 0.05) { state.planSuccess += 1; state.planAttempts += 1; newScene(); return; }
    if (env.stepCount >= 60) { state.planAttempts += 1; newScene(); return; }
  }
  const unpacked = unpackState(env.state(), numObjects);
  drawScene({ poses: after, pusher: env.pusher, goal: env.config.goalXY, gates: state.lastPrediction.gates, probs: state.lastPrediction.probs, predicted: state.lastPrediction.poses, truth, velocities: [unpacked.velocities] && unpacked.velocities ? unpacked.velocities : null });
}
function stepReplay() {
  const episode = state.episodes[state.replayName];
  const numObjects = episode.num_objects;
  if (state.replayIndex >= episode.state.length) state.replayIndex = 0;
  const vector = episode.state[state.replayIndex];
  const action = episode.action[state.replayIndex];
  const truth = episode.target_mask[state.replayIndex];
  state.lastPrediction = state.model.step(vector, action, numObjects);
  const { poses, pusher, goal, velocities } = unpackState(vector, numObjects);
  state.seenFrames += 1;
  const next = episode.state[state.replayIndex + 1];
  if (next === undefined || passesMotionFilter(poses, unpackState(next, numObjects).poses)) {
    scoreFrame(vector, action, numObjects, truth);
  }
  pushTrails(poses);
  drawScene({ poses, pusher, goal, gates: state.lastPrediction.gates, probs: state.lastPrediction.probs, predicted: state.lastPrediction.poses, truth, velocities });
  state.replayIndex += 1;
}
let lastStep = 0;
let fpsLast = performance.now();
let fpsCount = 0;
function frame(timestamp) {
  fpsCount += 1;
  if (timestamp - fpsLast > 500) {
    const fps = Math.round((fpsCount * 1000) / (timestamp - fpsLast));
    const el = document.getElementById('fps');
    if (el) el.textContent = `${fps} fps`;
    fpsLast = timestamp; fpsCount = 0;
  }
  const stepMs = BASE_STEP_MS / state.speed;
  if (state.running && timestamp - lastStep > stepMs) {
    lastStep = timestamp;
    try {
      if (state.task === 'replay') stepReplay();
      else stepLive();
      renderScores();
      updateStatus();
      updateInspector();
    } catch (error) {
      statusEl.textContent = `Stopped: ${error.message}`;
      state.running = false;
      syncPlayButton();
    }
  }
  requestAnimationFrame(frame);
}
function updateStatus() {
  if (state.task === 'planning' && state.planAttempts > 0) {
    const rate = (state.planSuccess / state.planAttempts).toFixed(2);
    statusEl.textContent = `Planning through the model: ${state.planSuccess}/${state.planAttempts} episodes solved (success ${rate}). The paper reports 0.25 at 20 episodes; a handful of browser episodes is not a measurement.`;
    return;
  }
  const rows = state.scoreboard.rows();
  const best = rows.find((row) => !row.isModel);
  const model = rows.find((row) => row.isModel);
  if (!best || !model || state.frames < 15) { statusEl.textContent = 'Collecting frames…'; return; }
  const margin = model.f1 - best.f1;
  statusEl.textContent = margin <= 0
    ? `Best trivial rule: ${best.name} (${best.parameters} params) at F1 ${best.f1.toFixed(3)}, beating the trained model by ${(-margin).toFixed(3)}.`
    : `The model leads ${best.name} by ${margin.toFixed(3)} F1 on this scene.`;
}
function updateInspector() {
  const el = document.getElementById('inspector');
  if (!el || !state.lastPrediction || !state.env) { if (el) el.hidden = true; return; }
  if (!state.inspector) { el.hidden = true; return; }
  const idx = state.inspector.index;
  const prob = state.lastPrediction.probs[idx];
  const gate = state.lastPrediction.gates[idx];
  const truth = state.lastTruth ? state.lastTruth[idx] : null;
  const dist = state.inspector.distance.toFixed(3);
  const speed = state.inspector.speed.toFixed(4);
  el.innerHTML = `obj ${idx}<br>dist to pusher ${dist} m<br>speed ${speed} m/s<br>gate ${gate} prob ${prob.toFixed(2)}<br>changed ${truth === 1 ? 'yes' : 'no'}`;
  el.hidden = false;
}
function syncPlayButton() {
  const play = document.getElementById('play');
  const overlay = document.getElementById('paused-overlay');
  if (play) play.textContent = state.running ? 'Pause' : 'Play';
  if (overlay) overlay.hidden = state.running;
}
function newScene() {
  state.trails = [];
  if (state.task === 'replay') { state.replayIndex = 0; }
  else {
    state.env = new PlanarPushEnv({ numObjects: state.numObjects, seed: Math.floor(Math.random() * 1e6), minObjectSeparation: state.task === 'planning' ? 0.12 : 0.09 });
  }
  pushUrlState();
}
function resetScores() { state.scoreboard.reset(); state.frames = 0; state.seenFrames = 0; state.trails = []; renderScores(); }
function selectModel(name) {
  state.modelName = state.models.has(name) ? name : state.modelDefault;
  state.model = state.models.get(state.modelName);
  const label = document.getElementById('model-label');
  if (label) label.textContent = `${state.model.weights.source_checkpoint} · ${state.model.weights.num_parameters.toLocaleString()} parameters`;
  renderDomainNotice();
}
function renderDomainNotice() {
  const notice = document.getElementById('domain-notice');
  if (!notice) return;
  const engine = state.task === 'replay' ? state.replayName : 'planar';
  const matched = (state.task === 'replay' && engine === 'tabletop' && state.modelName === 'tabletop') || (state.task !== 'replay' && state.modelName === 'planar');
  notice.hidden = matched;
  if (!matched) notice.textContent = `Out of domain: no checkpoint in this project was trained on ${engine}, so the ${state.modelName} gate is running on a distribution it has not seen. Its score here is a domain shift result, not the paper in distribution comparison. Read the tabletop episode for that.`;
}
function selectTask(task) {
  state.task = task;
  document.querySelectorAll('.tasks button').forEach((button) => { button.classList.toggle('active', button.dataset.task === task); });
  const info = TASKS[task];
  taskCopy.innerHTML = `<h2>${info.title}</h2><p>${info.copy}</p>`;
  hintEl.textContent = info.hint;
  document.getElementById('count-row').hidden = task !== 'transfer';
  document.getElementById('episode-row').hidden = task !== 'replay';
  document.getElementById('drive-row').hidden = task === 'replay' || task === 'planning';
  document.getElementById('keys-hint').hidden = state.drive !== 'keys';
  state.planSuccess = 0; state.planAttempts = 0;
  selectModel(task === 'replay' ? 'tabletop' : 'planar');
  newScene(); resetScores(); pushUrlState();
}
function pushUrlState() {
  const url = new URL(window.location);
  url.searchParams.set('task', state.task);
  url.searchParams.set('count', String(state.numObjects));
  url.searchParams.set('radius', String(state.radius));
  url.searchParams.set('speed', String(state.speed));
  url.searchParams.set('drive', state.drive);
  history.replaceState(null, '', url);
}
function applyUrlState() {
  const p = new URLSearchParams(window.location.search);
  if (p.get('task') && TASKS[p.get('task')]) state.task = p.get('task');
  if (p.get('count')) state.numObjects = Math.max(2, Math.min(12, Number(p.get('count')) || 3));
  if (p.get('radius')) state.radius = Math.max(0.02, Math.min(0.22, Number(p.get('radius')) || 0.07));
  if (p.get('speed')) state.speed = Math.max(0.25, Math.min(3, Number(p.get('speed')) || 1));
  if (p.get('drive') && ['auto', 'mouse', 'keys'].includes(p.get('drive'))) state.drive = p.get('drive');
}
async function fetchWithProgress(url, label) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`${label} not found at ${url}`);
  return res.json();
}
async function loadBundleWithFallback() {
  const params = new URLSearchParams(window.location.search);
  const override = params.get('modelUrl');
  const candidates = [];
  if (override) candidates.push(override);
  candidates.push('assets/model.json');
  candidates.push(`${HF_BASE}/docs/assets/model.json`);
  let lastError = null;
  for (const url of candidates) {
    try {
      const bundle = await SparseResidualModel.loadBundle(url);
      return bundle;
    } catch (e) { lastError = e; }
  }
  throw lastError || new Error('could not load model bundle');
}
function resizeCanvas() {
  const dpr = window.devicePixelRatio || 1;
  const rect = canvas.getBoundingClientRect();
  const size = Math.round(rect.width * dpr);
  if (canvas.width !== size) { canvas.width = size; canvas.height = size; }
}
async function main() {
  resizeCanvas();
  window.addEventListener('resize', resizeCanvas);
  applyUrlState();
  const progress = document.getElementById('progress');
  const progressBar = document.getElementById('progress-bar');
  if (progress) progress.hidden = false;
  if (progressBar) progressBar.style.width = '30%';
  try {
    const bundle = await loadBundleWithFallback();
    state.models = bundle.models; state.modelDefault = bundle.default;
    if (progressBar) progressBar.style.width = '60%';
    let episodes = null;
    try { episodes = await fetchWithProgress('assets/episodes.json', 'episodes'); }
    catch { episodes = await fetchWithProgress(`${HF_BASE}/docs/assets/episodes.json`, 'episodes'); }
    state.episodes = episodes;
    if (progressBar) progressBar.style.width = '100%';
    setTimeout(() => { if (progress) progress.hidden = true; }, 400);
  } catch (error) {
    statusEl.textContent = 'Could not load the model. This page uses ES modules and fetch, so it needs to be served over http. Open it from GitHub Pages, or run `python -m http.server` in docs/.';
    if (progress) progress.hidden = true;
    return;
  }
  selectModel('planar');
  const saved = JSON.parse(localStorage.getItem('demoPrefs') || '{}');
  if (saved.showTrails) state.showTrails = saved.showTrails;
  if (saved.showGrid === false) state.showGrid = false;
  if (saved.showVel) state.showVel = saved.showVel;
  if (saved.showProbs === false) state.showProbs = false;
  document.getElementById('param-count').textContent = state.model.weights.num_parameters.toLocaleString();
  const episodeSelect = document.getElementById('episode');
  for (const [name, episode] of Object.entries(state.episodes)) {
    const option = document.createElement('option');
    option.value = name; option.textContent = `${name}: ${episode.engine} (${episode.num_objects} objects)`;
    episodeSelect.appendChild(option);
  }
  state.replayName = Object.keys(state.episodes)[0];
  episodeSelect.value = state.replayName;
  episodeSelect.addEventListener('change', () => {
    state.replayName = episodeSelect.value; state.replayIndex = 0;
    selectModel('tabletop'); renderDomainNotice(); resetScores();
  });
  document.querySelectorAll('.tasks button').forEach((button) => {
    button.addEventListener('click', () => selectTask(button.dataset.task));
  });
  const play = document.getElementById('play');
  play.addEventListener('click', () => { state.running = !state.running; syncPlayButton(); });
  document.getElementById('reset').addEventListener('click', () => { newScene(); resetScores(); });
  const doStep = () => {
    const was = state.running; state.running = true;
    if (state.task === 'replay') stepReplay(); else stepLive();
    renderScores(); updateStatus(); updateInspector();
    state.running = was; syncPlayButton();
  };
  document.getElementById('step').addEventListener('click', doStep);
  document.getElementById('btn-step').addEventListener('click', doStep);
  document.getElementById('share').addEventListener('click', async () => {
    pushUrlState();
    const url = window.location.href;
    try { await navigator.clipboard.writeText(url); statusEl.textContent = 'Link copied to clipboard.'; setTimeout(updateStatus, 1500); } catch { statusEl.textContent = url; }
  });
  const radius = document.getElementById('radius');
  const radiusOut = document.getElementById('radius-out');
  radius.value = state.radius; radiusOut.textContent = `${state.radius.toFixed(3)} m`;
  radius.addEventListener('input', () => { state.radius = Number(radius.value); radiusOut.textContent = `${state.radius.toFixed(3)} m`; resetScores(); pushUrlState(); });
  const count = document.getElementById('count');
  const countOut = document.getElementById('count-out');
  count.value = state.numObjects; countOut.textContent = count.value;
  count.addEventListener('input', () => { state.numObjects = Number(count.value); countOut.textContent = count.value; newScene(); resetScores(); });
  const speed = document.getElementById('speed');
  const speedOut = document.getElementById('speed-out');
  speed.value = state.speed; speedOut.textContent = `${state.speed}x`;
  speed.addEventListener('input', () => { state.speed = Number(speed.value); speedOut.textContent = `${state.speed}x`; pushUrlState(); });
  const checkTrails = document.getElementById('check-trails');
  const btnTrails = document.getElementById('btn-trails');
  checkTrails.checked = state.showTrails; if (btnTrails) btnTrails.setAttribute('aria-pressed', String(state.showTrails));
  const toggleTrails = () => { state.showTrails = !state.showTrails; checkTrails.checked = state.showTrails; if (btnTrails) btnTrails.setAttribute('aria-pressed', String(state.showTrails)); if (!state.showTrails) state.trails = []; persistPrefs(); };
  checkTrails.addEventListener('change', toggleTrails); if (btnTrails) btnTrails.addEventListener('click', toggleTrails);
  const checkVel = document.getElementById('check-vel');
  checkVel.checked = state.showVel; checkVel.addEventListener('change', () => { state.showVel = checkVel.checked; persistPrefs(); });
  const checkGrid = document.getElementById('check-grid');
  checkGrid.checked = state.showGrid; checkGrid.addEventListener('change', () => { state.showGrid = checkGrid.checked; persistPrefs(); });
  const btnProbs = document.getElementById('btn-probs');
  const syncProbs = () => { if (btnProbs) btnProbs.setAttribute('aria-pressed', String(state.showProbs)); };
  syncProbs();
  if (btnProbs) btnProbs.addEventListener('click', () => { state.showProbs = !state.showProbs; syncProbs(); persistPrefs(); });
  document.getElementById('btn-screenshot').addEventListener('click', () => {
    const a = document.createElement('a'); a.download = `demo-${state.task}-${Date.now()}.png`; a.href = canvas.toDataURL('image/png'); a.click();
  });
  document.getElementById('sort-f1').addEventListener('click', () => { state.sortBy = 'f1'; renderScores(); });
  document.getElementById('sort-onset').addEventListener('click', () => { state.sortBy = 'onset'; renderScores(); });
  document.getElementById('copy-scores').addEventListener('click', async () => {
    const rows = state.scoreboard.rows(); const csv = ['rule,params,f1,onsetF1'].concat(rows.map(r => `${r.name},${r.isModel ? state.model.weights.num_parameters : r.parameters},${r.f1.toFixed(3)},${r.support ? r.onsetF1.toFixed(3) : ''}`)).join('\n');
    try { await navigator.clipboard.writeText(csv); statusEl.textContent = 'Scores copied as CSV.'; setTimeout(updateStatus, 1500); } catch { statusEl.textContent = csv.slice(0, 80); }
  });
  document.querySelectorAll('input[name="drive"]').forEach((input) => {
    if (input.value === state.drive) input.checked = true;
    input.addEventListener('change', () => { state.drive = input.value; document.getElementById('keys-hint').hidden = state.drive !== 'keys'; pushUrlState(); });
  });
  document.getElementById('keys-hint').hidden = state.drive !== 'keys';
  function persistPrefs() { localStorage.setItem('demoPrefs', JSON.stringify({ showTrails: state.showTrails, showVel: state.showVel, showGrid: state.showGrid, showProbs: state.showProbs })); }
  canvas.addEventListener('pointermove', (event) => {
    state.pointer = worldFromPointer(event);
    const env = state.env;
    const poses = env ? env.observation().poses : (state.episodes && state.episodes[state.replayName] ? unpackState(state.episodes[state.replayName].state[state.replayIndex] || state.episodes[state.replayName].state[0], state.episodes[state.replayName].num_objects).poses : null);
    const pusher = env ? env.pusher : (state.episodes && state.episodes[state.replayName] ? unpackState(state.episodes[state.replayName].state[state.replayIndex] || state.episodes[state.replayName].state[0], state.episodes[state.replayName].num_objects).pusher : null);
    if (!poses || !pusher) return;
    let best = null; let bestDist = Infinity;
    poses.forEach((pose, i) => {
      const d = Math.hypot(state.pointer[0] - pose[0], state.pointer[1] - pose[1]);
      if (d < bestDist && d < 0.06) { bestDist = d; best = i; }
    });
    if (best !== null) {
      const speedVal = state.env ? Math.hypot(state.env.objectVel[best][0], state.env.objectVel[best][1]) : 0;
      const distToPusher = Math.hypot(poses[best][0] - pusher[0], poses[best][1] - pusher[1]);
      state.inspector = { index: best, distance: distToPusher, speed: speedVal };
    } else state.inspector = null;
  });
  canvas.addEventListener('pointerleave', () => { state.pointer = null; state.inspector = null; const el = document.getElementById('inspector'); if (el) el.hidden = true; });
  canvas.addEventListener('pointerdown', (e) => { if (state.drive === 'mouse') state.pointer = worldFromPointer(e); });
  window.addEventListener('keydown', (e) => {
    state.keys[e.key] = true;
    if (e.code === 'Space') { e.preventDefault(); state.running = !state.running; syncPlayButton(); }
    else if (e.key.toLowerCase() === 'r') { newScene(); resetScores(); }
    else if (e.key === '.') { const was = state.running; state.running = true; if (state.task === 'replay') stepReplay(); else stepLive(); renderScores(); updateStatus(); state.running = was; syncPlayButton(); }
    else if (e.key.toLowerCase() === 't') { state.showTrails = !state.showTrails; document.getElementById('check-trails').checked = state.showTrails; const b = document.getElementById('btn-trails'); if (b) b.setAttribute('aria-pressed', String(state.showTrails)); if (!state.showTrails) state.trails = []; }
    else if (e.key.toLowerCase() === 'p') { state.showProbs = !state.showProbs; const b = document.getElementById('btn-probs'); if (b) b.setAttribute('aria-pressed', String(state.showProbs)); }
    else if (e.key.toLowerCase() === 'g') { state.showGrid = !state.showGrid; document.getElementById('check-grid').checked = state.showGrid; }
    else if (['1','2','3','4'].includes(e.key)) { const tasks = ['sandbox','replay','transfer','planning']; selectTask(tasks[Number(e.key)-1]); }
  });
  window.addEventListener('keyup', (e) => { state.keys[e.key] = false; });
  document.getElementById('theme-toggle').addEventListener('click', () => {
    const cur = document.documentElement.getAttribute('data-theme');
    const next = cur === 'light' ? 'dark' : cur === 'dark' ? 'light' : (matchMedia('(prefers-color-scheme: dark)').matches ? 'light' : 'dark');
    if (next === 'light') document.documentElement.setAttribute('data-theme', 'light');
    else if (next === 'dark') document.documentElement.setAttribute('data-theme', 'dark');
    else document.documentElement.removeAttribute('data-theme');
  });
  selectTask(state.task);
  syncPlayButton();
  requestAnimationFrame(frame);
}
main();