import { UI_THEME as T } from "../../shared/ui-theme.mjs";
import { facingViewer } from "../../shared/cast-layout.mjs";
import * as THREE from "three";
import { actorMotionId, createPerformance, parseDirectorCommand } from "../../shared/actors.mjs";
import { actorMotionPresets, nextActorMotionPreset, STYLE_LABELS, changeCastStyle } from "../../shared/actor-presets.mjs";
import { createActorLayer } from "./actor-view.mjs";
import { CAST_SIZE as MAX_ACTORS, nextCastSlot } from "../../shared/actor-slots.mjs";
function createDirector({ authoring = false, world, assets, getState, getPhase, spatialKey, viewPosition, pickGround, occlusionDistance = () => Infinity, api, acceptState, notify, canEdit, canPlay = () => true, deferNewMotion = () => false, onSelect = () => {
}, recordEvent = () => {
}, mapFrames = (f) => f, pathCompleted = () => null }) {
  const performance = createPerformance(), layer = createActorLayer(world, assets);
  const cursor = new THREE.Mesh(new THREE.RingGeometry(0.18, 0.25, 32), new THREE.MeshBasicMaterial({ toneMapped: false, color: T.accent, side: THREE.DoubleSide, depthTest: false }));
  cursor.rotation.x = -Math.PI / 2;
  cursor.visible = false;
  cursor.renderOrder = 15;
  world.add(cursor);
  const facingArrow = new THREE.ArrowHelper(new THREE.Vector3(0, 0, 1), new THREE.Vector3(), 0.65, T.accent, 0.18, 0.12);
  facingArrow.line.material.toneMapped = facingArrow.cone.material.toneMapped = false;
  facingArrow.visible = false;
  facingArrow.line.material.depthTest = facingArrow.cone.material.depthTest = false;
  world.add(facingArrow);
  let lockedTarget = null;
  let selected = null, placing = false, placementDelay = 0, target = null, pending = false, frames = [], message = "Enter the room, then point at the floor to place an actor.";
  const emit = (text, status = true) => {
    message = text;
    notify(text, { status });
  };
  const selectedActor = () => getState()?.scene.actors?.find((a) => a.id === selected);
  function requireEdit() {
    if (getPhase() !== "explore") throw new Error("Enter the room first");
    if (pending || !canEdit()) throw new Error("Finish the current request or preview first");
  }
  function requirePlacement() {
    requireEdit();
    if ((getState().scene.actors || []).length >= MAX_ACTORS) throw new Error(`${MAX_ACTORS} actors already placed. Remove one before adding another.`);
  }
  function validTarget(anchor) {
    if (!anchor || anchor.spatialKey !== spatialKey()) throw new Error("Point at the floor. Select a new location after alignment changes.");
    return anchor;
  }
  async function persist(command2) {
    requireEdit();
    pending = true;
    try {
      const next = await api("/api/actors", { revision: getState().revision, command: command2 });
      acceptState(next);
      recordEvent("actor-edit", { command: command2, revision: next.revision });
      return next;
    } finally {
      pending = false;
    }
  }
  async function create(anchor, delay = 0) {
    requirePlacement();
    const point = validTarget(anchor), actors = getState().scene.actors || [], preset = nextActorMotionPreset(actors, assets, getState().scene.actorStyle || "zombie"), asset = authoring && [...assets.values()].find((a) => a.defaultActor) || preset || [...assets.values()].find((a) => a.preferred) || assets.values().next().value;
    if (!asset) throw new Error("The default character asset has not loaded yet");
    const delta = new THREE.Vector3().fromArray(point.viewer).sub(new THREE.Vector3().fromArray(point.position));
    const actor = { id: "actor-" + crypto.randomUUID(), castSlot: nextCastSlot(actors), assetId: asset.id, motionId: deferNewMotion() || asset.bodyOnly ? null : preset?.id || null, name: `Actor ${nextCastSlot(actors)}`, position: [...point.position], yaw: Math.atan2(delta.x, delta.z), color: "#e7e9e5", trigger: "start", delay };
    await persist({ type: "create", actor });
    selected = actor.id;
    onSelect(selected);
    placing = false;
    cursor.visible = facingArrow.visible = false;
    emit(authoring ? "Mannequin placed. Select it and describe a basic motion; no motion import is needed." : actor.motionId ? `T-Pose actor placed · ${preset.name} assigned. Use the left grip to play or select another motion.` : "Mannequin placed. Select it to request a generated motion.");
    return message;
  }
  function select(id) {
    selected = id;
    onSelect(id);
    const actor = selectedActor();
    if (actor) emit(authoring ? `${actor.name} selected. Describe a basic motion to the Agent, or draw a curve to guide this actor.` : `${actor.name} selected: ${assets.get(actorMotionId(actor))?.name || "No motion assigned"}. Choose a motion, move the actor, ask it to face you, or adjust its entrance delay. A style request changes the whole cast.`);
  }
  function updateRay(raycaster) {
    const point = pickGround(raycaster);
    target = lockedTarget ? structuredClone(lockedTarget) : point ? { position: point.toArray(), viewer: viewPosition().toArray(), spatialKey: spatialKey() } : null;
    cursor.visible = !!target && (authoring ? placing : placing || !!lockedTarget || deferNewMotion() && !getState().scene.actors?.length && canEdit());
    facingArrow.visible = cursor.visible;
    if (target) {
      cursor.position.fromArray(target.position).add(new THREE.Vector3(0, 0.015, 0));
      try {
        const yaw = facingViewer(target.position, target.viewer);
        facingArrow.position.copy(cursor.position);
        facingArrow.setDirection(new THREE.Vector3(Math.sin(yaw), 0, Math.cos(yaw)));
      } catch {
        cursor.visible = facingArrow.visible = false;
      }
    }
  }
  function beginPlacement(delay = 0) {
    requirePlacement();
    placing = true;
    placementDelay = delay;
    target = null;
    cursor.visible = facingArrow.visible = false;
    emit(authoring ? "Point at the ground to place the actor · A Create · B Cancel" : "Point at the floor and press the right trigger to place an actor.");
    return message;
  }
  async function confirmPlacement(raycaster) {
    if (!placing) return false;
    updateRay(raycaster);
    if (!target) throw Error("Point at visible ground before confirming placement");
    return create(structuredClone(target), placementDelay);
  }
  function interceptRay(raycaster) {
    if (getPhase() !== "explore") return false;
    if (placing) {
      if (authoring) {
        updateRay(raycaster);
        emit("A Create actor · B Cancel", false);
      } else confirmPlacement(raycaster).catch((e) => emit(e.message, false));
      return true;
    }
    const hit = layer.pick(raycaster);
    if (hit && hit.distance <= occlusionDistance(raycaster)) {
      select(hit.id);
      return true;
    }
    return false;
  }
  function playable(actorIds) {
    requireEdit();
    if (!canPlay()) throw new Error("Wait until ready, then say Preview or select the Preview button.");
    const all = getState().scene.actors || [], actors = actorIds ? all.filter((a) => actorIds.includes(a.id)) : all;
    if (actorIds && actors.length !== new Set(actorIds).size) throw new Error("The door-triggered cast has changed");
    if (!actors.length) throw new Error("Place actors first");
    if (!actors.some((a) => a.motionPlan || actorMotionId(a))) throw new Error("Select an actor and assign a motion first");
    if (actors.some((a) => !assets.has(a.assetId) || actorMotionId(a) && !assets.has(actorMotionId(a)))) throw new Error("Actor motions are not loaded. Playback is unavailable.");
    return actors;
  }
  function start({ actorIds } = {}) {
    playable(actorIds);
    placing = false;
    cursor.visible = false;
    performance.start(actorIds);
    recordEvent("performance-start", { ...performance.snapshot(), ...actorIds ? { actorIds: [...actorIds] } : {} });
    emit("Playing · Left grip or Stop to pause · Unassigned actors remain in T-Pose");
  }
  function arm(actorIds, { cue = "door" } = {}) {
    playable(actorIds);
    placing = false;
    cursor.visible = false;
    performance.arm(actorIds);
    recordEvent("performance-armed", { ...performance.snapshot(), actorIds: [...actorIds] });
    emit(cue === "preview" ? "Actors are ready at the first frame. Press the left grip to preview." : "Actors are ready at the first frame. Open the door to start them together.");
  }
  function stop() {
    performance.stop();
    recordEvent("performance-stop", performance.snapshot());
    emit("Motion stopped. You can still move, speak, and edit.");
  }
  function resume() {
    requireEdit();
    if (!canPlay()) throw new Error("Confirm Preview first.");
    performance.resume();
    recordEvent("performance-resume", performance.snapshot());
    emit("Playing · Left grip to pause");
  }
  function toggleTransport() {
    const s = performance.snapshot(), done = pathCompleted(s) ?? performance.completed(assets);
    if (s.mode === "running" && !done) {
      stop();
      return;
    }
    if (placing) throw new Error(authoring ? "Press A to place the actor or B to cancel placement" : "Place with the right trigger, or press A to cancel");
    if (s.mode === "paused" && !done) resume();
    else start();
  }
  function edit() {
    performance.edit();
    recordEvent("performance-edit", performance.snapshot());
    emit("Back to T-Pose layout. Assigned motions are kept and restart on the next playback.");
  }
  async function change(changes, id = selected) {
    const actor = getState().scene.actors?.find((a) => a.id === id);
    if (!actor) throw new Error("Select an actor first");
    await persist({ type: "update", id: actor.id, changes });
  }
  async function assignMotion(motionId, id = selected) {
    const actor = getState().scene.actors?.find((a) => a.id === id);
    if (!actor) throw new Error("Select an actor first");
    const asset = motionId && assets.get(motionId);
    if (motionId && !asset) throw new Error("This motion has not been imported");
    if (asset?.bodyOnly) throw new Error("This is the default character asset. Describe a basic motion to the Agent.");
    await change({ motionId }, id);
    const nextRun = performance.snapshot().mode !== "editing";
    emit((asset ? `Assigned “${asset.name}” to ${actor.name}.` : `Cleared the motion for ${actor.name}.`) + (nextRun ? "Takes effect on the next playback. Current timing is unchanged." : asset ? "Holding T-Pose. Use the left grip to play." : "Holding T-Pose."));
    return message;
  }
  function assignPreferredMotion(id = selected) {
    const motions = [...assets.values()].filter((a) => !a.bodyOnly), preferred = motions.find((a) => a.preferred) || motions[0];
    if (!preferred) throw new Error("No motion assets imported");
    return assignMotion(preferred.id, id);
  }
  function nextMotion(id = selected) {
    const actor = getState().scene.actors?.find((a) => a.id === id);
    if (!actor) throw new Error("Select an actor first");
    const style = actorMotionPresets(assets).find((p) => p.id === actorMotionId(actor))?.style || getState().scene.actorStyle || "zombie", presets = actorMotionPresets(assets, style);
    if (!presets.length) return assignPreferredMotion(id);
    const index = presets.findIndex((p) => p.id === actorMotionId(actor));
    return assignMotion(presets[(index + 1) % presets.length].id, id);
  }
  async function setStyle(style, { playback = "play", context = {} } = {}) {
    requireEdit();
    if (playback === "play" && !canPlay()) throw new Error("Confirm Preview or prepare the motions again.");
    const initial = getState(), space = spatialKey();
    if (context.revision !== void 0 && context.revision !== initial.revision || context.spatialContext?.spatialKey && context.spatialContext.spatialKey !== space) throw new Error("Scene or alignment changed since you spoke. Submit the style request again.");
    changeCastStyle(initial.scene, style, [...assets.keys()]);
    const previous = performance.snapshot(), offsets = {};
    for (const actor of initial.scene.actors) {
      const view = layer.views.get(actor.id);
      if (view?.visible && previous.mode !== "editing") {
        const root = view.worldToLocal(view.bones[0].getWorldPosition(new THREE.Vector3()));
        offsets[actor.id] = [root.x, 0, root.z];
      }
    }
    performance.stop();
    pending = true;
    try {
      const next = await api("/api/actor-style", { revision: initial.revision, style });
      acceptState(next);
      performance.sync(next.scene.actors);
      placing = false;
      cursor.visible = false;
      if (spatialKey() !== space || getPhase() !== "explore") {
        performance.edit();
        emit("Motion style saved. Alignment changed; return to creating before playing.");
        return message;
      }
      if (previous.mode === "running") performance.resume();
      performance.switchMotions(offsets, playback);
      recordEvent("actor-style-switch", { style, playback, offsets, ...performance.snapshot(), actors: next.scene.actors.map((a) => ({ id: a.id, slot: a.castSlot, motionId: actorMotionId(a) })) });
      emit(`Changed ${next.scene.actors.length} actors to ${STYLE_LABELS[style]} motions. ${playback === "assign" ? "Takes effect on the next playback." : playback === "preserve" && previous.mode !== "running" ? "Paused / layout state retained. Left grip to play." : "Playing from the start. Left grip to pause."}`);
      return message;
    } catch (error) {
      if (previous.mode === "running" && getPhase() === "explore" && spatialKey() === space) performance.resume();
      throw error;
    } finally {
      pending = false;
    }
  }
  async function command(text, context = {}) {
    const intent = parseDirectorCommand(text);
    if (!intent) return null;
    if (intent.type === "style") return setStyle(intent.style, { context });
    if (intent.type === "create") return authoring ? beginPlacement(intent.delay) : create(context.actorTarget, intent.delay);
    if (intent.type === "start") {
      start();
      return message;
    }
    if (intent.type === "stop") {
      stop();
      return message;
    }
    if (intent.type === "resume") {
      resume();
      return message;
    }
    if (intent.type === "edit") {
      edit();
      return message;
    }
    if (intent.type === "unavailable") return "Choose an available motion from the asset list. Additional imported motions are required for unsupported actions.";
    if (intent.type === "motion") {
      if (!context.actorId) throw new Error("Select an actor first");
      if (intent.number) {
        const preset = actorMotionPresets(assets, getState().scene.actorStyle || "zombie").find((p) => p.number === intent.number);
        if (!preset) throw new Error(`Motion ${intent.number} has not loaded`);
        return assignMotion(preset.id, context.actorId);
      }
      return assignPreferredMotion(context.actorId);
    }
    if (intent.type === "clearMotion") return assignMotion(null, context.actorId);
    if (intent.type === "save") {
      await api("/api/save-scene", { revision: getState().revision }).then(acceptState);
      emit("Scene, actor positions, and entry timing saved.");
      return message;
    }
    if (intent.type === "delay") {
      await change({ delay: intent.delay }, context.actorId);
      emit(`Will appear ${intent.delay} seconds after the next playback starts.`);
      return message;
    }
    if (intent.type === "move") {
      await change({ position: [...validTarget(context.actorTarget).position] }, context.actorId);
      emit("Actor moved to the selected point. Motion timing is unchanged.");
      return message;
    }
    if (intent.type === "face") {
      const actor = getState().scene.actors?.find((a) => a.id === context.actorId);
      if (!actor) throw new Error("Select an actor first");
      const p = context.actorViewer || viewPosition().toArray();
      await change({ yaw: Math.atan2(p[0] - actor.position[0], p[2] - actor.position[2]) }, actor.id);
      emit("Actor now faces your current position.");
      return message;
    }
    if (intent.type === "remove") {
      if (!context.actorId) throw new Error("Select an actor first");
      const name = getState().scene.actors?.find((a) => a.id === context.actorId)?.name || "Actor";
      await persist({ type: "remove", id: context.actorId });
      selected = null;
      emit(`${name} removed and saved · Left stick click to undo`);
      return message;
    }
    return null;
  }
  return {
    lockPlacement(anchor) {
      validTarget(anchor);
      lockedTarget = structuredClone(anchor);
    },
    unlockPlacement() {
      lockedTarget = null;
      cursor.visible = facingArrow.visible = false;
    },
    command,
    setStyle,
    start,
    arm,
    stop,
    resume,
    toggleTransport,
    edit,
    select,
    change,
    assignMotion,
    assignPreferredMotion,
    nextMotion,
    updateRay,
    interceptRay,
    beginPlacement,
    confirmPlacement,
    cancelPlacement() {
      placing = false;
      target = null;
      cursor.visible = facingArrow.visible = false;
    },
    togglePlacement() {
      if (placing) {
        placing = false;
        target = null;
        cursor.visible = facingArrow.visible = false;
        emit("Placement closed. Click the right stick to toggle editing.");
      } else beginPlacement();
    },
    clearTarget() {
      target = null;
      cursor.visible = facingArrow.visible = false;
    },
    captureContext() {
      return { actorTarget: target ? structuredClone(target) : null, actorViewer: viewPosition().toArray(), actorId: selected };
    },
    previewGenerated(id) {
      performance.start([id]);
    },
    freeze(ids) {
      performance.arm(ids);
    },
    sync(scene) {
      performance.sync(scene.actors || []);
      if (selected && !scene.actors?.some((a) => a.id === selected)) selected = null;
    },
    frame(dt, opacity, { showSelection = true, selectedIds = null, overrides = [] } = {}) {
      performance.advance(dt);
      const changes = new Map(overrides.map((o) => [o.id, o]));
      frames = mapFrames(performance.frames(assets), performance.snapshot()).map((f) => changes.has(f.id) ? { ...f, ...changes.get(f.id) } : f);
      layer.apply(frames, { opacity, selected: showSelection ? selectedIds || selected : null });
      return frames;
    },
    snapshot() {
      return { placementPreview: { visible: cursor.visible, arrowVisible: facingArrow.visible, locked: !!lockedTarget, target: target ? structuredClone(target) : null }, style: getState()?.scene.actorStyle || "zombie", ...performance.snapshot(), completed: pathCompleted(performance.snapshot()) ?? performance.completed(assets), selected, placing, pending, message, actors: frames.map((f) => ({ id: f.id, assetId: f.assetId, motionId: f.motionId, pose: f.pose, castSlot: f.castSlot, motionOffset: f.motionOffset, position: f.position, yaw: f.yaw, delay: f.delay, clipTime: f.clipTime, visible: f.visible, preview: f.preview })), assetCount: assets.size };
    },
    frames: () => frames,
    layer
  };
}
export {
  createDirector
};