// scenes.jsx — Foundry NX logo dissipating into AI agents (v2 — Stark flow)

const TL = {
  total: 13,
  introEnd: 2.0,
  quantizeStart: 2.0,
  quantizeEnd: 3.6,
  scatterStart: 3.4,
  scatterEnd: 7.2,
  floodStart: 5.0,
  floodEnd: 9.2,
  resolveStart: 8.6,
  resolveEnd: 11.0,
  holdStart: 11.0,
  holdEnd: 13.0,
};

const ORANGE = '#F5A537';
const ORANGE_DIM = '#A06D1E';
const ORANGE_SOFT = '#F9B961';
const ORANGE_HOT = '#FFD089';
const BLACK = '#000000';
const WHITE = '#FFFFFF';
const INK_400 = '#5A5A5A';
const INK_300 = '#8A8A8A';

const W = 1920;
const H = 1080;

function makeRng(seed) {
  let s = seed >>> 0;
  return () => {
    s = (s * 1664525 + 1013904223) >>> 0;
    return s / 0xffffffff;
  };
}

const MARK_SIZE = 260;
const MARK_CX = W / 2;
const MARK_CY = H / 2;

const WORDMARK_FONT = `800 200px "Space Grotesk", "Helvetica Neue", Arial, sans-serif`;

const CORNER_MARK_SIZE = 56;
const CORNER_MARK_X = 64;
const CORNER_MARK_Y = 64;

const MARK_CELL = 7;
const WORDMARK_CELL = 10;

function getMarkPixels() {
  return PixelSampler.sample('mark', MARK_SIZE, MARK_SIZE, MARK_CELL, (ctx, w, h) => {
    PixelSampler.drawMark(ctx, w, h);
  });
}

function getWordmarkPixels() {
  const w = 1400, h = 220;
  return PixelSampler.sample('foundryNX', w, h, WORDMARK_CELL, (ctx, W, H) => {
    PixelSampler.drawText(ctx, W, H, 'Foundry NX', WORDMARK_FONT);
  });
}

function buildAgents() {
  const markPts = getMarkPixels();
  const wordPts = getWordmarkPixels();
  const rng = makeRng(1337);

  const markOffsetX = MARK_CX - MARK_SIZE / 2;
  const markOffsetY = MARK_CY - MARK_SIZE / 2;

  // More dramatic scatter — a radial burst, not a wander.
  const markAgents = markPts.map((p, i) => {
    const cx = markOffsetX + p.x + MARK_CELL / 2;
    const cy = markOffsetY + p.y + MARK_CELL / 2;
    // Angle points roughly AWAY from the mark's center — radial burst.
    const dx = cx - MARK_CX;
    const dy = cy - (MARK_CY + 20);
    const radial = Math.atan2(dy, dx);
    const jitter = (rng() - 0.5) * 0.6;
    return {
      id: `m${i}`,
      origin: 'mark',
      x0: markOffsetX + p.x,
      y0: markOffsetY + p.y,
      size: MARK_CELL,
      seed: rng(),
      scatterAngle: radial + jitter,
      scatterDist: 500 + rng() * 700,
      swirl: (rng() - 0.5) * 0.6,
      staggerDelay: rng() * 0.5,  // per-agent launch stagger
    };
  });

  const wmOffsetX = W / 2 - 1400 / 2;
  const wmOffsetY = H / 2 - 220 / 2;
  const wordTargets = wordPts.map(p => ({
    tx: wmOffsetX + p.x + WORDMARK_CELL / 2,
    ty: wmOffsetY + p.y + WORDMARK_CELL / 2,
  }));

  const shuffled = [...wordTargets].sort(() => rng() - 0.5);

  markAgents.forEach((a, i) => {
    const t = shuffled[i % shuffled.length];
    a.tx = t.tx;
    a.ty = t.ty;
    a.tJitterX = (rng() - 0.5) * 1.5;
    a.tJitterY = (rng() - 0.5) * 1.5;
  });

  const remainingTargets = shuffled.slice(markAgents.length);
  const floodAgents = remainingTargets.map((t, i) => {
    const side = Math.floor(rng() * 4);
    let sx, sy;
    if (side === 0) { sx = rng() * W; sy = -40; }
    else if (side === 1) { sx = W + 40; sy = rng() * H; }
    else if (side === 2) { sx = rng() * W; sy = H + 40; }
    else { sx = -40; sy = rng() * H; }
    return {
      id: `f${i}`,
      origin: 'flood',
      x0: sx, y0: sy,
      tx: t.tx, ty: t.ty,
      size: WORDMARK_CELL - 2,
      seed: rng(),
      spawnOffset: rng() * (TL.floodEnd - TL.floodStart) * 0.75,
      tJitterX: (rng() - 0.5) * 1.5,
      tJitterY: (rng() - 0.5) * 1.5,
      wanderAngle: rng() * Math.PI * 2,
      wanderAmp: 30 + rng() * 100,
    };
  });

  return { markAgents, floodAgents, wordTargets };
}

function useAgents() {
  return React.useMemo(buildAgents, []);
}

// ─── Static lockup (SVG) — REMOVED. Video now opens on the HUD + swarm build. ──
function StaticLockup() {
  return null;
}

// ─── Corner lockup for the final hold — REMOVED. ───────────────────────────
function CornerLockup() {
  return null;
}

Object.assign(window, {
  TL, ORANGE, ORANGE_DIM, ORANGE_SOFT, ORANGE_HOT, BLACK, WHITE, INK_400, INK_300,
  W, H, MARK_SIZE, MARK_CX, MARK_CY, MARK_CELL, WORDMARK_CELL,
  makeRng, buildAgents, useAgents,
  StaticLockup, CornerLockup,
});