// controllerInputDispatch.ts — shared, SELF-CONTAINED controller-input dispatch logic for the
// `type:'input'` sideband of the ShortPlay bridge protocol (card
// design-phone-controller-pairing-ui-device-agnostic; card
// bug-paired-device-taps-never-reach-the-game).
//
// "Self-contained" here is a HARD REQUIREMENT, not a style preference: this module is consumed
// TWO ways —
//   (1) imported normally by the child SDK (games-sdk/shortplay-sdk.ts), bundled as ordinary TS;
//   (2) `.toString()`'d into a literal inline <script> by the games-worker serve-time INPUT SHIM
//       (games-worker/src/inputShim.ts) and run VERBATIM inside an arbitrary uploaded game's raw
//       HTML document, with NO surrounding module scope.
//
// Path (2) means `isGameInputMessage` and `dispatchControllerInput` below must resolve using ONLY
// their own parameters, their own local declarations, and JS/DOM builtins — NEVER a module-level
// `const`/`import`/helper from this file or any other. A closure-captured free variable renders as
// a `ReferenceError` the moment the embedded function source runs standalone with no surrounding
// scope (proved by actually EXECUTING the extracted shim source in the "INPUT SHIM" describe
// block of games-worker/test/worker.test.ts, not merely asserting its shape). `KeyboardEvent` /
// `PointerEvent` are read as GLOBALS on purpose inside `dispatchControllerInput` — both the real
// browser SDK context and the injected shim's game-document context provide them; a test
// environment without a DOM (games-worker's Node-env vitest) must stub them globally, same as it
// already stubs `HTMLRewriter`.
//
// Wire format mirrors app/src/runtime/protocol.ts's GameInputMessage (parent → game controller
// input, additive `type:'input'` sibling to `type:'lifecycle'`) — kept byte-compatible on purpose;
// see that file's header for the full evolution rationale (why postMessage is the only channel
// that can reach a cross-origin sandboxed iframe at all).

export const SP_PROTOCOL_VERSION = 1 as const;

export type ControllerInputToken =
  | 'tap'
  | 'hold'
  | 'drag'
  | 'swipe'
  | 'multitouch'
  | 'keyboard'
  | 'mouse'
  | 'tilt'
  | 'gamepad'
  | 'dpad'
  | 'remote';

export type ControllerInputPhase = 'start' | 'move' | 'end' | 'cancel';

export type ControllerDpadDirection = 'up' | 'down' | 'left' | 'right' | 'select';

export interface GameInputMessage {
  sp: typeof SP_PROTOCOL_VERSION;
  nonce: string;
  type: 'input';
  token: ControllerInputToken;
  phase: ControllerInputPhase;
  /** Normalized 0..1 within the game's current stage box. */
  x?: number;
  y?: number;
  dx?: number;
  dy?: number;
  dpadDirection?: ControllerDpadDirection;
  /** The sender's player seat ('P1'..'P4'), stamped by the relay. Optional + additive: a game that
   *  has not opted in to `managesPlayers` never reads it (the synthetic DOM path stays untagged). */
  slot?: 'P1' | 'P2' | 'P3' | 'P4';
  /** Monotonic ms on the SENDER's own clock (performance.now() on the controller). players() v1. */
  t?: number;
  /** Press duration measured on the device; only on `end`. players() v1. */
  heldMs?: number;
  /** `KeyboardEvent.code`; only on `token:'keyboard'`. players() v1. */
  code?: string;
  /** Mega 2 (additive): the phone layout that produced this event. */
  layout?: 'touch' | 'touch+dpad' | 'retro' | 'twin-stick';
  /** Mega 2 (additive): which control produced a `gamepad` token (retro A/B, a twin-stick zone). */
  control?: 'A' | 'B' | 'Select' | 'Start' | 'stick-left' | 'stick-right';
  /** Mega 2 + Mega 4 (additive): W3C standard-mapping button index 0..16 (A=0 B=1 Select=8 Start=9
   *  d-pad 12-15; see shortplay-players.ts). */
  button?: number;
  /** Mega 2 + Mega 4 (additive): W3C standard axes -1..1, 1..4 entries, [leftX, leftY, rightX, rightY]. */
  axes?: number[];
  /** ADDITIVE (bug-pair-first-press-after-join...): set by the host on every input for a GAMEPAD-MODE
   *  game (manifest `inputs` has `gamepad`, not `managesPlayers`). A seat's d-pad / button press for
   *  such a game belongs to that seat's `Gamepad`; it must never become a synthetic keyboard key, even
   *  when it arrives before the seat table that creates the pad. Absent for every other game. */
  gamepad?: true;
}

/**
 * SELF-CONTAINED predicate — validates a `type:'input'` message. See module header: references
 * ONLY its own parameter and locally-declared literals, nothing from outer scope.
 */
export function isGameInputMessage(x: unknown): x is GameInputMessage {
  if (typeof x !== 'object' || x === null) return false;
  const rec = x as Record<string, unknown>;
  if (rec.sp !== 1) return false;
  if (typeof rec.nonce !== 'string' || rec.nonce.length === 0 || rec.nonce.length > 128) return false;
  if (rec.type !== 'input') return false;
  const tokens = [
    'tap', 'hold', 'drag', 'swipe', 'multitouch', 'keyboard', 'mouse', 'tilt', 'gamepad', 'dpad', 'remote',
  ];
  if (typeof rec.token !== 'string' || tokens.indexOf(rec.token) === -1) return false;
  const phases = ['start', 'move', 'end', 'cancel'];
  if (typeof rec.phase !== 'string' || phases.indexOf(rec.phase) === -1) return false;
  if (rec.dpadDirection !== undefined) {
    const dirs = ['up', 'down', 'left', 'right', 'select'];
    if (typeof rec.dpadDirection !== 'string' || dirs.indexOf(rec.dpadDirection) === -1) return false;
  }
  if (rec.slot !== undefined) {
    const slots = ['P1', 'P2', 'P3', 'P4'];
    if (typeof rec.slot !== 'string' || slots.indexOf(rec.slot) === -1) return false;
  }
  if (rec.layout !== undefined) {
    const layouts = ['touch', 'touch+dpad', 'retro', 'twin-stick'];
    if (typeof rec.layout !== 'string' || layouts.indexOf(rec.layout) === -1) return false;
  }
  if (rec.control !== undefined) {
    const controls = ['A', 'B', 'Select', 'Start', 'stick-left', 'stick-right'];
    if (typeof rec.control !== 'string' || controls.indexOf(rec.control) === -1) return false;
  }
  const numFields = ['x', 'y', 'dx', 'dy', 't'] as const;
  for (const f of numFields) {
    const v = rec[f];
    if (v !== undefined && (typeof v !== 'number' || !isFinite(v as number))) return false;
  }
  if (rec.heldMs !== undefined && (typeof rec.heldMs !== 'number' || !isFinite(rec.heldMs) || rec.heldMs < 0)) {
    return false;
  }
  if (rec.code !== undefined && (typeof rec.code !== 'string' || rec.code.length === 0 || rec.code.length > 32)) {
    return false;
  }
  if (rec.button !== undefined) {
    // 16 === GAMEPAD_BUTTON_MAX (inlined: this function must stay self-contained, see module header).
    if (typeof rec.button !== 'number' || !isFinite(rec.button) || rec.button < 0 || rec.button > 16) return false;
    if (Math.floor(rec.button) !== rec.button) return false;
  }
  if (rec.axes !== undefined) {
    // 4 === GAMEPAD_AXES_MAX. Integration (Megas 2+4): ONE button/axes validator — the W3C standard
    // bounds the shim reads (Mega 4), and an EMPTY axes array is refused (Mega 2).
    if (!Array.isArray(rec.axes) || rec.axes.length === 0 || rec.axes.length > 4) return false;
    for (const a of rec.axes) {
      if (typeof a !== 'number' || !isFinite(a) || a < -1 || a > 1) return false;
    }
  }
  if (rec.gamepad !== undefined && rec.gamepad !== true) return false;
  return true;
}

/**
 * SELF-CONTAINED dispatcher — delivers one relayed controller input event as a REAL synthetic DOM
 * event inside `win`'s document, standards-first, so an unmodified game's own listeners (attached
 * to a specific canvas, `document`, or `window`) fire identically to a local event.
 *
 * Pointer-shaped tokens (tap/hold/drag/swipe/multitouch/mouse) are dispatched at whichever element
 * sits at the normalized (x, y) position (`elementFromPoint`) — a real pointer event always
 * targets a SPECIFIC element and bubbles from there, not from `window` down. dpad/remote/keyboard
 * tokens have no position, so they dispatch a `keydown`/`keyup` on `win` (where keyboard listeners
 * conventionally attach). See module header: references ONLY its parameters, local declarations,
 * and DOM/JS builtins.
 */
export function dispatchControllerInput(win: Window, root: HTMLElement, msg: GameInputMessage): void {
  // GAMEPAD MODE (bug-pair-first-press-after-join...): the host flags every input for a Gamepad-API
  // game. A seat's key-shaped press (d-pad, remote, keyboard, retro button) for such a game is that
  // seat's pad button and nothing else. A caller reaches this line only when no gamepad shim took the
  // event (it does not exist yet, or does not know the seat), and then the right answer is to drop
  // it, never to press a keyboard key the game would also read. Pointer tokens are unaffected.
  if (
    msg.gamepad === true &&
    msg.slot !== undefined &&
    (msg.token === 'gamepad' || msg.token === 'dpad' || msg.token === 'remote' || msg.token === 'keyboard')
  ) {
    return;
  }
  // Mega 2: a `gamepad` token (retro A/B) has no pointer position — the untagged synthetic path maps
  // the two face buttons to the keys a keyboard game already listens for (A = Space, B = X). The
  // twin-stick zones (and a gamepad frame with no button) have no keyboard equivalent: dropped here,
  // read through the slot-tagged `onInput` of a `managesPlayers` game instead.
  if (msg.token === 'gamepad') {
    const faceKeys: Record<string, { key: string; code: string }> = {
      A: { key: ' ', code: 'Space' },
      B: { key: 'x', code: 'KeyX' },
    };
    const face = msg.control ? faceKeys[msg.control] : undefined;
    if (!face) return;
    const type = msg.phase === 'end' || msg.phase === 'cancel' ? 'keyup' : 'keydown';
    win.dispatchEvent(new KeyboardEvent(type, { key: face.key, code: face.code, bubbles: true, cancelable: true }));
    return;
  }
  if (msg.token === 'dpad' || msg.token === 'remote' || msg.token === 'keyboard') {
    const dpadKey: Record<string, string> = {
      up: 'ArrowUp',
      down: 'ArrowDown',
      left: 'ArrowLeft',
      right: 'ArrowRight',
      select: 'Enter',
    };
    const key = msg.dpadDirection ? dpadKey[msg.dpadDirection] : undefined;
    if (!key) return;
    const type = msg.phase === 'end' || msg.phase === 'cancel' ? 'keyup' : 'keydown';
    win.dispatchEvent(new KeyboardEvent(type, { key, code: msg.code, bubbles: true, cancelable: true }));
    return;
  }
  // Normalized 0..1 → client px within the root the game was built into.
  const rect = root.getBoundingClientRect();
  const clientX = rect.left + (msg.x ?? 0.5) * rect.width;
  const clientY = rect.top + (msg.y ?? 0.5) * rect.height;
  const target =
    (win.document.elementFromPoint?.(clientX, clientY) as HTMLElement | null) ?? root;
  const type =
    msg.phase === 'start'
      ? 'pointerdown'
      : msg.phase === 'end'
        ? 'pointerup'
        : msg.phase === 'cancel'
          ? 'pointercancel'
          : 'pointermove';
  // A fresh negative pointerId per event (never collides with a real pointerId, always >= 0);
  // random rather than a persisted counter so this function needs NO module-level mutable state
  // (module state would not survive the `.toString()` embedding — see module header).
  const pointerId = -(1000 + Math.floor(Math.random() * 1_000_000));
  const evt = new PointerEvent(type, {
    bubbles: true,
    cancelable: true,
    clientX,
    clientY,
    pointerId,
    pointerType: 'touch',
    isPrimary: true,
  });
  target.dispatchEvent(evt);
}