import { Line } from "@react-three/drei";
import { useFrame } from "@react-three/fiber";
import { useMemo, useRef } from "react";
import { useShellStore } from "../app/shellStore";
import { saveDungeonSimulationReplay } from "../app/dungeonSimulationClient";
import { useCombatStore } from "../game/combatStore";
import { combatSpatialActor } from "../game/combatSpatial";
import { activeDungeonCompletedObjectiveIds } from "../game/dungeonEncounterRuntime";
import { getMobPosition, updateMobRuntimePosition } from "../game/mobRuntimeRegistry";
import { getPartyRuntimePosition, updatePartyRuntimePosition } from "../game/partyRuntimeRegistry";
import { usePartyStore, type PartyMemberStatus } from "../game/partyStore";
import { dungeonRouteDefinition, positionAlongRouteCorridor, routePointDistanceSquared } from "../game/dungeonRoutes";
import {
  DUNGEON_REPLAY_KEYFRAME_MS,
  DUNGEON_REPLAY_SAMPLE_MS,
  DUNGEON_SIMULATION_MAX_DURATION_MS,
  useDungeonSimulationStore,
} from "../game/dungeonSimulationStore";
import type {
  DungeonReplayFrame,
  DungeonSimulationResult,
  DungeonRouteLeg,
  DungeonSimulationActorSnapshot,
} from "../game/dungeonSimulationTypes";
import type { Vector3Tuple } from "../game/dungeonTypes";

let savingRunKey: string | null = null;

function simulationRoster() {
  return usePartyStore.getState().members.map((member) => ({
    id: member.id,
    name: member.name,
    role: member.role,
    classId: member.classId,
  }));
}

export async function finalizeDungeonSimulation(result: DungeonSimulationResult): Promise<void> {
  const simulation = useDungeonSimulationStore.getState();
  if (simulation.sessionMode !== "spectate-live" || simulation.runState === "finished") return;
  const replay = simulation.finish(result, simulationRoster());
  if (!replay) return;
  const key = `${replay.dungeonId}:${replay.routeHash}:${replay.startedAt}`;
  if (savingRunKey === key) return;
  savingRunKey = key;
  try {
    await saveDungeonSimulationReplay(useShellStore.getState().session, replay);
  } catch (error) {
    console.error("Unable to upload dungeon simulation replay", error);
  }
}

function actorSnapshots(): readonly DungeonSimulationActorSnapshot[] {
  const party = usePartyStore.getState();
  const companions = party.members.map((member) => ({
    id: member.id,
    position: getPartyRuntimePosition(member.id) ?? [0, 0, 0],
    yaw: combatSpatialActor(member.id)?.yaw ?? 0,
    health: member.health,
    maxHealth: member.maxHealth,
    targetId: party.memberTargetIds[member.id] ?? party.activeMobId,
    status: member.status,
  }));
  const mobs = Object.values(useCombatStore.getState().mobs).map((mob) => ({
    id: mob.id,
    position: getMobPosition(mob.id) ?? [0, 0, 0] as Vector3Tuple,
    yaw: combatSpatialActor(mob.id)?.yaw ?? 0,
    health: mob.health,
    maxHealth: mob.maxHealth,
    targetId: mob.targetActorId,
    status: mob.dead ? "dead" : mob.engaged ? "engaged" : "idle",
  }));
  return [...companions, ...mobs];
}

function routeProgress(position: Vector3Tuple, leg: DungeonRouteLeg): number {
  let cumulative = 0;
  let bestDistance = Number.POSITIVE_INFINITY;
  let bestProgress = 0;
  for (let index = 1; index < leg.checkpoints.length; index += 1) {
    const start = leg.checkpoints[index - 1];
    const end = leg.checkpoints[index];
    const segmentLength = Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
    const projection = routePointDistanceSquared(position, start, end);
    const score = projection.planarSquared + projection.vertical ** 2;
    if (score < bestDistance) {
      bestDistance = score;
      bestProgress = cumulative + segmentLength * projection.progress;
    }
    cumulative += segmentLength;
  }
  return bestProgress;
}

interface DiagnosticCursor {
  runKey: string;
  nextSampleAt: number;
  lastLeaderPosition: Vector3Tuple | null;
  lastProgressAt: number;
  offCorridorAt: number | null;
  routeBlockedAt: number | null;
  splitAt: Map<string, number>;
  observedPulls: Set<string>;
  objectiveId: string | null;
  objectiveDistance: number;
  maximumRouteProgress: number;
  finalCheckpointAt: number | null;
  replayFrameAt: number;
}

function newCursor(runKey: string): DiagnosticCursor {
  return {
    runKey,
    nextSampleAt: 0,
    lastLeaderPosition: null,
    lastProgressAt: 0,
    offCorridorAt: null,
    routeBlockedAt: null,
    splitAt: new Map(),
    observedPulls: new Set(),
    objectiveId: null,
    objectiveDistance: 0,
    maximumRouteProgress: 0,
    finalCheckpointAt: null,
    replayFrameAt: -1,
  };
}

function addFinding(
  id: string,
  severity: "info" | "warning" | "critical",
  code: string,
  message: string,
  position?: Vector3Tuple,
  actorId?: string,
): void {
  const simulation = useDungeonSimulationStore.getState();
  simulation.addFinding({
    id,
    atMs: simulation.elapsedMs,
    severity,
    code,
    message,
    position,
    actorId,
    objectiveId: simulation.objectiveId ?? undefined,
    checkpointIndex: simulation.checkpointIndex,
  });
}

function applyReplayFrame(frame: DungeonReplayFrame): void {
  const party = usePartyStore.getState();
  const combat = useCombatStore.getState();
  const snapshots = new Map(frame.actors.map((actor) => [actor.id, actor] as const));
  const members = party.members.map((member) => {
    const snapshot = snapshots.get(member.id);
    if (!snapshot) return member;
    updatePartyRuntimePosition(member.id, ...snapshot.position);
    return {
      ...member,
      health: snapshot.health,
      maxHealth: snapshot.maxHealth,
      status: snapshot.status as PartyMemberStatus,
    };
  });
  const mobs = { ...combat.mobs };
  for (const snapshot of frame.actors) {
    const mob = mobs[snapshot.id];
    if (!mob) continue;
    updateMobRuntimePosition(snapshot.id, ...snapshot.position, snapshot.yaw);
    mobs[snapshot.id] = {
      ...mob,
      health: snapshot.health,
      maxHealth: snapshot.maxHealth,
      dead: snapshot.status === "dead" || snapshot.health <= 0,
      engaged: snapshot.status === "engaged",
      targetActorId: snapshot.targetId,
    };
  }
  party.commitRuntime({
    members,
    activeMobId: null,
    objectiveBossId: frame.objectiveId,
    memberTargetIds: Object.fromEntries(frame.actors.flatMap((actor) => actor.targetId ? [[actor.id, actor.targetId]] : [])),
  });
  useCombatStore.setState({ mobs });
  combat.commitCompanionActors(members);
  useDungeonSimulationStore.getState().setRouteProgress(frame.objectiveId, frame.checkpointIndex);
}

function recordPulls(cursor: DiagnosticCursor, leaderPosition: Vector3Tuple, leg: DungeonRouteLeg | null): void {
  const simulation = useDungeonSimulationStore.getState();
  const partyPositions = usePartyStore.getState().members
    .map((member) => getPartyRuntimePosition(member.id))
    .filter((position): position is Vector3Tuple => Boolean(position));
  for (const mob of Object.values(useCombatStore.getState().mobs).sort((left, right) => left.id.localeCompare(right.id))) {
    if (mob.dead || mob.despawned || cursor.observedPulls.has(mob.id)) continue;
    const position = getMobPosition(mob.id);
    if (!position) continue;
    const theoretical = simulation.mode === "navigation-only" && partyPositions.some((partyPosition) => (
      Math.hypot(position[0] - partyPosition[0], position[1] - partyPosition[1], position[2] - partyPosition[2])
        <= Math.max(0, mob.aggroRange)
    ));
    if (!mob.engaged && !theoretical) continue;
    cursor.observedPulls.add(mob.id);
    const classification = theoretical
      ? "theoretical" as const
      : leg && positionAlongRouteCorridor(position, leg.checkpoints, leg.corridorPlanarDistance, leg.corridorVerticalDistance)
        ? "expected" as const
        : "off-route" as const;
    simulation.addPull({
      atMs: simulation.elapsedMs,
      mobIds: [mob.id],
      routeLegId: leg?.id ?? null,
      position: [leaderPosition[0], leaderPosition[1], leaderPosition[2]],
      classification,
    });
  }
}

function inspectLiveSimulation(cursor: DiagnosticCursor): void {
  const simulation = useDungeonSimulationStore.getState();
  const party = usePartyStore.getState();
  const leader = party.members.find((member) => member.health > 0);
  const leaderPosition = leader ? getPartyRuntimePosition(leader.id) : null;
  if (!leader || !leaderPosition) return;
  const route = simulation.dungeonId ? dungeonRouteDefinition(simulation.dungeonId, simulation.routeId ?? "primary") : null;
  const leg = route?.legs.find((candidate) => candidate.objectiveId === simulation.objectiveId) ?? null;

  if (cursor.objectiveId !== simulation.objectiveId) {
    if (cursor.objectiveId && route) {
      const previousLeg = route.legs.find((candidate) => candidate.objectiveId === cursor.objectiveId);
      if (previousLeg && cursor.objectiveDistance > previousLeg.expectedDistance * 1.5
        && cursor.objectiveDistance > previousLeg.expectedDistance + 10) {
        addFinding(
          `detour:${cursor.objectiveId}`,
          "warning",
          "excessive-detour",
          `Leg ${previousLeg.id} travelled ${cursor.objectiveDistance.toFixed(1)} m for an expected ${previousLeg.expectedDistance.toFixed(1)} m.`,
          leaderPosition,
          leader.id,
        );
      }
    }
    cursor.objectiveId = simulation.objectiveId;
    cursor.objectiveDistance = 0;
    cursor.maximumRouteProgress = 0;
    cursor.finalCheckpointAt = null;
  }

  if (cursor.lastLeaderPosition) {
    const moved = Math.hypot(
      leaderPosition[0] - cursor.lastLeaderPosition[0],
      leaderPosition[1] - cursor.lastLeaderPosition[1],
      leaderPosition[2] - cursor.lastLeaderPosition[2],
    );
    cursor.objectiveDistance += moved;
    if (moved >= 0.1) cursor.lastProgressAt = simulation.elapsedMs;
  } else cursor.lastProgressAt = simulation.elapsedMs;
  cursor.lastLeaderPosition = [leaderPosition[0], leaderPosition[1], leaderPosition[2]];

  if (party.command === "attack" && simulation.objectiveId && simulation.elapsedMs - cursor.lastProgressAt >= 2_000) {
    addFinding(
      `stall:${simulation.objectiveId}:${simulation.checkpointIndex}`,
      "warning",
      "movement-stall",
      `${leader.name} made no movement progress for at least two seconds.`,
      leaderPosition,
      leader.id,
    );
  }

  if (party.routeBlocked) {
    cursor.routeBlockedAt ??= simulation.elapsedMs;
    if (simulation.elapsedMs - cursor.routeBlockedAt >= 1_000) {
      addFinding(
        `no-path:${simulation.objectiveId}:${simulation.checkpointIndex}`,
        "critical",
        "no-path",
        `No collision-valid path to checkpoint ${simulation.checkpointIndex}.`,
        leaderPosition,
        leader.id,
      );
    }
  } else cursor.routeBlockedAt = null;

  if (leg) {
    const inside = positionAlongRouteCorridor(
      leaderPosition,
      leg.checkpoints,
      leg.corridorPlanarDistance,
      leg.corridorVerticalDistance,
    );
    if (!inside) {
      cursor.offCorridorAt ??= simulation.elapsedMs;
      if (simulation.elapsedMs - cursor.offCorridorAt >= 1_000) {
        addFinding(
          `off-corridor:${leg.id}:${simulation.checkpointIndex}`,
          "warning",
          "off-corridor",
          `${leader.name} remained outside the ${leg.corridorPlanarDistance} m / ${leg.corridorVerticalDistance} m route corridor for one second.`,
          leaderPosition,
          leader.id,
        );
      }
    } else cursor.offCorridorAt = null;

    const progress = routeProgress(leaderPosition, leg);
    cursor.maximumRouteProgress = Math.max(cursor.maximumRouteProgress, progress);
    if (cursor.maximumRouteProgress - progress >= 8) {
      addFinding(
        `backtrack:${leg.id}:${Math.floor(cursor.maximumRouteProgress / 8)}`,
        "warning",
        "backtracking",
        `${leader.name} backtracked at least 8 m on ${leg.id}.`,
        leaderPosition,
        leader.id,
      );
    }

    if (simulation.checkpointIndex >= leg.checkpoints.length - 1) {
      cursor.finalCheckpointAt ??= simulation.elapsedMs;
      if (
        simulation.mode === "navigation-only"
        && simulation.elapsedMs - cursor.finalCheckpointAt >= 5_000
      ) {
        addFinding(
          `scripted-progression:${leg.id}`,
          "critical",
          "failed-scripted-progression",
          `Navigation-only progression did not advance after reaching ${leg.objectiveName}.`,
          leaderPosition,
          leader.id,
        );
      }
    } else cursor.finalCheckpointAt = null;
  }

  for (const follower of party.members.filter((member) => member.health > 0 && member.id !== leader.id)) {
    const position = getPartyRuntimePosition(follower.id);
    if (!position) continue;
    const distance = Math.hypot(
      position[0] - leaderPosition[0],
      position[1] - leaderPosition[1],
      position[2] - leaderPosition[2],
    );
    if (distance > 12) {
      const separatedAt = cursor.splitAt.get(follower.id) ?? simulation.elapsedMs;
      cursor.splitAt.set(follower.id, separatedAt);
      if (simulation.elapsedMs - separatedAt >= 2_000) {
        addFinding(
          `separation:${follower.id}:${simulation.objectiveId}`,
          "warning",
          "party-separation",
          `${follower.name} remained more than 12 m from the leader for two seconds.`,
          position,
          follower.id,
        );
      }
    } else cursor.splitAt.delete(follower.id);
  }

  if (simulation.recoveries >= 2) {
    addFinding(
      `repeated-recovery:${simulation.objectiveId}`,
      "critical",
      "repeated-recovery",
      "The simulator required repeated position recovery teleports.",
      leaderPosition,
      leader.id,
    );
  }
  recordPulls(cursor, leaderPosition, leg);

  while (simulation.elapsedMs >= cursor.nextSampleAt) {
    const atMs = cursor.nextSampleAt;
    simulation.addFrame({
      atMs,
      keyframe: atMs % DUNGEON_REPLAY_KEYFRAME_MS === 0,
      actors: actorSnapshots(),
      objectiveId: simulation.objectiveId,
      checkpointIndex: simulation.checkpointIndex,
    });
    cursor.nextSampleAt += DUNGEON_REPLAY_SAMPLE_MS;
  }

  if (simulation.elapsedMs >= DUNGEON_SIMULATION_MAX_DURATION_MS) {
    void finalizeDungeonSimulation("recording-limit");
  } else if (!party.members.some((member) => member.health > 0)) {
    void finalizeDungeonSimulation("wiped");
  } else if (simulation.mode === "navigation-only" && simulation.objectiveId === null) {
    void finalizeDungeonSimulation("completed");
  } else if (
    simulation.mode === "full-combat"
    && simulation.elapsedMs >= 1_000
    && route
    && route.legs.every((candidate) => activeDungeonCompletedObjectiveIds(route.dungeonId).includes(candidate.objectiveId))
  ) {
    void finalizeDungeonSimulation("completed");
  }
}

export function DungeonSimulationSceneBridge() {
  const sessionMode = useDungeonSimulationStore((state) => state.sessionMode);
  const dungeonId = useDungeonSimulationStore((state) => state.dungeonId);
  const routeId = useDungeonSimulationStore((state) => state.routeId);
  const objectiveId = useDungeonSimulationStore((state) => state.objectiveId);
  const checkpointIndex = useDungeonSimulationStore((state) => state.checkpointIndex);
  const frames = useDungeonSimulationStore((state) => state.frames);
  const cursorRef = useRef<DiagnosticCursor>(newCursor(""));
  const route = useMemo(
    () => dungeonId ? dungeonRouteDefinition(dungeonId, routeId ?? "primary") : null,
    [dungeonId, routeId],
  );
  const leg = route?.legs.find((candidate) => candidate.objectiveId === objectiveId) ?? null;
  const trace = useMemo(() => frames
    .map((frame) => frame.actors[0]?.position)
    .filter((position): position is Vector3Tuple => Boolean(position))
    .slice(-2_000), [frames]);

  useFrame(() => {
    const simulation = useDungeonSimulationStore.getState();
    if (simulation.sessionMode === "play") return;
    const runKey = `${simulation.sessionMode}:${simulation.dungeonId}:${simulation.startedAt}`;
    if (cursorRef.current.runKey !== runKey) cursorRef.current = newCursor(runKey);
    if (simulation.sessionMode === "spectate-replay") {
      const replay = simulation.replay;
      if (!replay?.frames.length) return;
      const frame = [...replay.frames].reverse().find((candidate) => candidate.atMs <= simulation.elapsedMs)
        ?? replay.frames[0];
      if (frame.atMs !== cursorRef.current.replayFrameAt) {
        cursorRef.current.replayFrameAt = frame.atMs;
        applyReplayFrame(frame);
      }
      return;
    }
    if (simulation.runState === "finished") return;
    inspectLiveSimulation(cursorRef.current);
  }, 1);

  if (sessionMode === "play") return null;
  return (
    <group name="dungeon-simulation-route-overlay">
      {leg && leg.checkpoints.length > 1 && (
        <Line points={leg.checkpoints} color="#60d9ff" lineWidth={2} transparent opacity={0.72} />
      )}
      {leg?.checkpoints.map((checkpoint, index) => (
        <mesh key={`${leg.id}:${index}`} position={checkpoint}>
          <sphereGeometry args={[index === checkpointIndex ? 0.28 : 0.14, 8, 8]} />
          <meshBasicMaterial color={index === checkpointIndex ? "#ffe56c" : "#59bde8"} transparent opacity={0.85} />
        </mesh>
      ))}
      {trace.length > 1 && (
        <Line points={trace} color="#ff9f43" lineWidth={1.5} transparent opacity={0.8} />
      )}
    </group>
  );
}