import type { AxisStateView, Capabilities, MessageEnvelope, PanelSnapshotV1, SimSnapshotV1 } from "./protocol";

export type SessionStatus = "disconnected" | "handshaking" | "attaching" | "loading" | "ready" | "running" | "paused" | "recovering" | "blocked" | "error";

export type FrontendState = {
  status: SessionStatus;
  contextId: string;
  sessionId: string;
  tick: number;
  lastSeq: number;
  capabilities: Capabilities | null;
  snapshot: SimSnapshotV1 | null;
  pending: string[];
  error: { code: string; message?: string } | null;
  alarms: Array<Record<string, unknown>>;
  task: Record<string, unknown> | null;
  program: Record<string, unknown> | null;
  devices: Record<string, unknown> | null;
  deviceIo: Record<string, unknown> | null;
  hal: Record<string, unknown> | null;
  plc: Record<string, unknown> | null;
  python: Record<string, unknown> | null;
  ioAck: Record<string, unknown> | null;
  axisState: AxisStateView | null;
  gates: Record<string, { action: string; enabled: boolean; reason: string }>;
  toolpath: Array<{ id: number; source_line?: number | null; start: Record<string, number>; end: Record<string, number>; active?: boolean }>;
  executionTrace: Array<{ line: number; text: string; program_status?: string | null }>;
};

// Keep enough authoritative WASM execution lines for long files while bounding
// browser memory when a session runs continuously.
export const EXECUTION_TRACE_CACHE_LIMIT = 8192;

export const INITIAL_STATE: FrontendState = {
  status: "disconnected",
  contextId: "linuxcnc-2.10.0-pre0-wasm-m1-py-c1",
  sessionId: "",
  tick: 0,
  lastSeq: 0,
  capabilities: null,
  snapshot: null,
  pending: [],
  error: null,
  alarms: [],
  task: null,
  program: null,
  devices: null,
  deviceIo: null,
  hal: null,
  plc: null,
  python: null,
  ioAck: null,
  axisState: null,
  gates: {},
  toolpath: [],
  executionTrace: [],
};

function payload<T>(message: MessageEnvelope): T {
  return message.payload as T;
}

function projection(result: Record<string, unknown>, message: MessageEnvelope, previous: FrontendState) {
  const panel = result.panel_snapshot as PanelSnapshotV1 | undefined;
  const trace = Array.isArray(result.execution_trace)
    ? (result.execution_trace as Array<Record<string, unknown>>)
      .map((entry) => ({ line: Number(entry.line), text: String(entry.text ?? ""), program_status: entry.program_status ? String(entry.program_status) : null }))
      .filter((entry) => Number.isSafeInteger(entry.line) && entry.line > 0)
    : [];
  const resetExecutionTrace = ["PROGRAM_LOAD", "PROGRAM_RESTART"].includes(String(result.command ?? ""));
  const executionTrace = resetExecutionTrace ? trace.slice(-EXECUTION_TRACE_CACHE_LIMIT) : trace.length ? [...previous.executionTrace, ...trace].slice(-EXECUTION_TRACE_CACHE_LIMIT) : previous.executionTrace;
  const delta = result.motion_sample as { tick?: number; pose?: Record<string, number>; joints?: number[]; active_segment_id?: number; active_progress?: number } | undefined;
  if (!panel && delta && previous.snapshot) {
    const pose = delta.pose ?? {};
    const joints = Array.isArray(delta.joints) ? [...delta.joints] : previous.snapshot.motion?.joints ?? [];
    const visual = previous.snapshot.visual ? {
      ...previous.snapshot.visual,
      pose: { ...previous.snapshot.visual.pose, ...pose },
      joints,
      ...(delta.active_segment_id !== undefined ? { active_segment_id: delta.active_segment_id } : {}),
      ...(delta.active_progress !== undefined ? { active_progress: delta.active_progress } : {}),
      ...(Array.isArray(result.motion_trace) ? { motion_trace: result.motion_trace } : {}),
    } : previous.snapshot.visual;
    const nextSnapshot = {
      ...previous.snapshot,
      simulation_tick: message.simulation_tick ?? delta.tick ?? previous.snapshot.simulation_tick,
      state_hash: String(result.state_hash ?? previous.snapshot.state_hash),
      task: (result.task as SimSnapshotV1["task"]) ?? previous.snapshot.task,
      program: (result.program as Record<string, unknown>) ?? previous.snapshot.program,
      overrides: (result.overrides as SimSnapshotV1["overrides"]) ?? previous.snapshot.overrides,
      motion: {
        ...previous.snapshot.motion,
        ...(result.motion as SimSnapshotV1["motion"] | undefined),
        // Keep the XYZAC axis vector intact on every motion delta. Older
        // projection code rebuilt only XYZ, which made A/C disappear from
        // consumers that read the canonical motion array.
        axes: [
          Number(pose.x ?? previous.snapshot.motion?.axes?.[0] ?? 0),
          Number(pose.y ?? previous.snapshot.motion?.axes?.[1] ?? 0),
          Number(pose.z ?? previous.snapshot.motion?.axes?.[2] ?? 0),
          Number(pose.a ?? previous.snapshot.motion?.axes?.[3] ?? 0),
          Number(pose.c ?? previous.snapshot.motion?.axes?.[4] ?? 0),
        ],
        joints,
      },
      wasm_motion: (result.wasm_motion as Record<string, unknown>) ?? previous.snapshot.wasm_motion,
      ...(visual ? { visual } : {}),
    } satisfies SimSnapshotV1;
    return {
      snapshot: nextSnapshot,
      toolpath: previous.toolpath,
      task: (result.task as Record<string, unknown>) ?? previous.task,
      program: (result.program as Record<string, unknown>) ?? previous.program,
      axisState: (result.axis_state as AxisStateView) ?? previous.axisState,
      gates: (result.gates as FrontendState["gates"]) ?? previous.gates,
      executionTrace,
    };
  }
  if (panel?.schema === "axis-panel-snapshot.v1") {
    const visualSegments = (Array.isArray(panel.visual.toolpath) ? panel.visual.toolpath : previous.toolpath)
      .filter((segment) => segment && typeof segment === "object" && Number.isSafeInteger((segment as { id?: unknown }).id ?? 0))
      .map((segment, index) => {
        const value = segment as Record<string, unknown>;
        return {
          id: Number(value.id ?? index + 1),
          source_line: typeof value.source_line === "number" ? value.source_line : null,
          start: value.start as Record<string, number>,
          end: value.end as Record<string, number>,
          ...(value.center ? { center: value.center as Record<string, number> } : {}),
          ...(value.normal ? { normal: value.normal as Record<string, number> } : {}),
          ...(Array.isArray(value.samples) ? { samples: value.samples as Array<Record<string, number>> } : {}),
          ...(typeof value.samples_source === "string" ? { samples_source: value.samples_source } : {}),
          ...(typeof value.kind === "string" ? { kind: value.kind } : {}),
          ...(typeof value.helix === "boolean" ? { helix: value.helix } : {}),
          ...(typeof value.radius === "number" ? { radius: value.radius } : {}),
          ...(typeof value.turns === "number" ? { turns: value.turns } : {}),
          ...(typeof value.axial_delta === "number" ? { axial_delta: value.axial_delta } : {}),
          ...(typeof value.canonical_motion_mode === "number" ? { canonical_motion_mode: value.canonical_motion_mode } : {}),
          ...(typeof value.kinematics_mode === "number" ? { kinematics_mode: value.kinematics_mode } : {}),
          ...(typeof value.motion_type === "number" ? { motion_type: value.motion_type } : {}),
          ...(typeof value.turn === "number" ? { turn: value.turn } : {}),
          active: value.id === panel.visual.active_segment_id,
        };
      });
    const pose = panel.visual.pose;
    const axes = [pose.x, pose.y, pose.z, pose.a, pose.c].map((value) => Number.isFinite(value) ? value : 0);
    const snapshot = {
      schema: panel.schema,
      simulation_tick: panel.simulation_tick,
      state_hash: panel.state_hash,
      task: panel.task as SimSnapshotV1["task"],
      motion: { ...(panel.motion as SimSnapshotV1["motion"]), axes, joints: panel.visual.joints },
      coordinates: panel.coordinates,
      overrides: panel.overrides,
      wasm_motion: panel.wasm_motion,
      authoritative: panel.authoritative as SimSnapshotV1["authoritative"],
      configuration: (panel.configuration ?? previous.snapshot?.configuration ?? null) as SimSnapshotV1["configuration"],
      visual: { ...panel.visual, toolpath: visualSegments },
      kinematics: panel.kinematics,
      xyzac: panel.xyzac,
      gates: panel.gates,
      motion_authority: panel.motion_authority,
      task_authority: panel.task_authority,
    } satisfies SimSnapshotV1;
    return {
      snapshot,
      toolpath: visualSegments,
      task: panel.task,
      program: panel.program,
      devices: panel.devices ?? previous.devices,
      deviceIo: panel.device_io ?? previous.deviceIo,
      hal: panel.hal ?? previous.hal,
      axisState: panel.axis_state,
      gates: { ...panel.gates, jog: panel.gates.jogStart, load: panel.gates.load, run: panel.gates.run, step: panel.gates.step, pause: panel.gates.pause, resume: panel.gates.resume, abort: panel.gates.abort, mdi: panel.gates.mdi, home: panel.gates.home },
      executionTrace,
    };
  }
  const wasmMotion = (result.wasm_motion as { state?: Record<string, unknown> } | undefined)?.state;
  const rawMotion = (wasmMotion ?? result.motion ?? previous.snapshot?.motion ?? {}) as Record<string, unknown>;
  const motionState = (rawMotion.state ?? rawMotion) as Record<string, unknown>;
  const axesObject = (motionState.axes ?? motionState.position) as Record<string, unknown> | undefined;
  const interpreterState = (result.state ?? result.interpreter_state) as Record<string, unknown> | undefined;
  const axes = result.motion !== undefined
    ? Array.isArray(motionState.axes)
      ? motionState.axes as number[]
      : axesObject && [axesObject.x, axesObject.y, axesObject.z].some((value) => typeof value === "number")
        ? [axesObject.x, axesObject.y, axesObject.z].map((value) => typeof value === "number" ? value : 0)
        : [0, 0, 0]
    : interpreterState && [interpreterState.x, interpreterState.y, interpreterState.z].some((value) => typeof value === "number")
      ? [interpreterState.x, interpreterState.y, interpreterState.z].map((value, index) => typeof value === "number" ? value : Number(previous.snapshot?.motion?.axes?.[index] ?? 0))
      : [Number(previous.snapshot?.motion?.axes?.[0] ?? 0), Number(previous.snapshot?.motion?.axes?.[1] ?? 0), Number(previous.snapshot?.motion?.axes?.[2] ?? 0)];
  const joints = Array.isArray(motionState.joints) ? motionState.joints as number[] : [];
  const authoritative = result.authoritative as SimSnapshotV1["authoritative"];
  const programResult = result.program ?? (typeof result.program_status === "string" ? result : previous.program);
  const planner = authoritative?.planner;
  const preview = result.preview as { status?: string; segments?: Array<Record<string, unknown>> } | undefined;
  const previewSegments = preview?.status === "verified" && Array.isArray(preview.segments) ? preview.segments : [];
  const plannerSegments = [
    ...(planner?.queue ?? []),
    ...(planner?.active ? [planner.active] : []),
  ].filter((segment): segment is NonNullable<typeof segment> & { id: number; start: Record<string, number>; end: Record<string, number> } => Number.isSafeInteger(segment.id) && Boolean(segment.start) && Boolean(segment.end));
  const command = String(result.command ?? "");
  const resetPath = command === "PROGRAM_LOAD" || command === "PROGRAM_RESTART";
  const known = resetPath ? new Set<number>() : new Set(previous.toolpath.map((segment) => segment.id));
  const nextToolpath = resetPath
    ? previewSegments.map((segment, index) => ({ ...segment, id: index + 1, source_line: typeof segment.source_line === "number" ? segment.source_line : null, start: segment.start as Record<string, number>, end: segment.end as Record<string, number>, active: false }))
    : previous.toolpath.map((segment) => ({ ...segment, start: { ...segment.start }, end: { ...segment.end } }));
  for (const segment of plannerSegments) {
    if (!known.has(segment.id)) nextToolpath.push({ id: segment.id, source_line: segment.source_line, start: segment.start, end: segment.end, active: segment.id === planner?.active?.id });
  }
  if (planner?.active?.id !== undefined) {
    for (const segment of nextToolpath) segment.active = segment.id === planner.active?.id;
  } else {
    for (const segment of nextToolpath) segment.active = false;
  }
  const visual = resetPath
    ? {
        ...(previous.snapshot?.visual ?? { schema: "axis-visual.v1", pose: {}, joints: [], source: "wasm_canonical_motion" as const }),
        toolpath: nextToolpath,
        active_segment_id: null,
        active_progress: 0,
        motion_trace: [],
      }
    : previous.snapshot?.visual;
  const snapshot = { simulation_tick: message.simulation_tick ?? previous.tick, state_hash: String(result.state_hash ?? previous.snapshot?.state_hash ?? ""), task: result.task as SimSnapshotV1["task"], motion: { axes, joints, velocity: Array.isArray(motionState.velocity) ? motionState.velocity as number[] : [], homed: typeof motionState.homed === "boolean" ? motionState.homed : undefined, homed_axes: Array.isArray(motionState.homed_axes) ? motionState.homed_axes as boolean[] : undefined }, overrides: (result.overrides as SimSnapshotV1["overrides"]) ?? previous.snapshot?.overrides, authoritative, ...(visual ? { visual } : {}) } satisfies SimSnapshotV1;
  return { snapshot, toolpath: nextToolpath, task: (result.task as Record<string, unknown>) ?? previous.task, program: programResult as Record<string, unknown> ?? previous.program, devices: (result.devices as Record<string, unknown>) ?? previous.devices, deviceIo: (result.device_io as Record<string, unknown>) ?? previous.deviceIo, hal: (result.hal_runtime as Record<string, unknown>) ?? previous.hal, plc: (result.plc as Record<string, unknown>) ?? previous.plc, python: (result.python as Record<string, unknown>) ?? previous.python, ioAck: (result.io_ack as Record<string, unknown>) ?? previous.ioAck, axisState: (result.axis_state as AxisStateView) ?? previous.axisState, gates: (result.gates as FrontendState["gates"]) ?? previous.gates, executionTrace };
}

export function reduceFrontendState(state: FrontendState, message: MessageEnvelope): FrontendState {
  const tick = message.simulation_tick ?? state.tick;
  const base = { ...state, contextId: message.context_id, sessionId: message.session_id, lastSeq: Math.max(state.lastSeq, message.seq), tick, error: null };
  switch (message.kind) {
    case "CAPABILITIES": return { ...base, status: "handshaking", capabilities: payload<Capabilities>(message) };
    case "SESSION_READY": { const readyPayload = payload<Record<string, unknown>>(message); return { ...base, status: "ready", task: (readyPayload.task as Record<string, unknown>) ?? state.task, axisState: (readyPayload.axis_state as AxisStateView) ?? state.axisState }; }
    case "RECOVERY_STATUS": return { ...base, status: payload<{ status?: string }>(message).status === "verified" ? "ready" : "recovering" };
    case "STATE_SNAPSHOT": {
      const value = payload<Record<string, unknown>>(message);
      const projected = projection(value, message, state);
      return { ...base, status: "ready", ...projected };
    }
    case "COMMAND_RESULT": {
      const result = payload<Record<string, unknown>>(message);
      const task = result.task as { state?: string } | undefined;
      const status = result.status === "blocked" || ["ESTOP", "FAULT"].includes(String(task?.state)) ? "blocked" : task?.state === "RUNNING" ? "running" : task?.state === "PAUSED" ? "paused" : "ready";
      return { ...base, status, ...projection(result, message, state) };
    }
    case "ALARM": return { ...base, status: "blocked", alarms: [...state.alarms, payload<Record<string, unknown>>(message)] };
    case "ERROR": {
      const value = payload<Record<string, unknown>>(message);
      const projected = projection(value, message, state);
      const taskState = String((value.task as Record<string, unknown> | undefined)?.state ?? "").toUpperCase();
      const status = ["ESTOP", "FAULT"].includes(taskState) ? "blocked" : "error";
      const readable = value.reason ?? value.gate_reason ?? value.message_key ?? value.code ?? "worker_error";
      return { ...base, status, error: { code: String(value.code ?? "worker_error"), message: String(readable) }, ...projected };
    }
    default: return base;
  }
}