import fs from "node:fs/promises";
import path from "node:path";

export type SkynetBifurcationEvent = {
  timestamp: number;
  label: string;
  contextSnapshot: string;
  options: string[];
  selected: string;
  stabilized: boolean;
};

export type SkynetBifurcationState = {
  sessionKey: string;
  updatedAt: number;
  activeBifurcation?: SkynetBifurcationEvent;
  history: SkynetBifurcationEvent[];
};

function sanitizeSessionKey(sessionKey: string): string {
  return (sessionKey.trim() || "main").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 64) || "main";
}

function resolveBifurcationJsonPath(params: { workspaceRoot: string; sessionKey: string }): string {
  return path.join(
    params.workspaceRoot,
    ".openskynet",
    "skynet-bifurcation",
    `${sanitizeSessionKey(params.sessionKey)}.json`,
  );
}

function resolveBifurcationMarkdownPath(workspaceRoot: string): string {
  return path.join(workspaceRoot, "memory", "SKYNET_BIFURCATION.md");
}

export async function loadSkynetBifurcationState(params: {
  workspaceRoot: string;
  sessionKey: string;
}): Promise<SkynetBifurcationState> {
  const jsonPath = resolveBifurcationJsonPath(params);
  try {
    const data = await fs.readFile(jsonPath, "utf-8");
    return JSON.parse(data);
  } catch {
    return {
      sessionKey: params.sessionKey,
      updatedAt: Date.now(),
      history: [],
    };
  }
}

export async function saveSkynetBifurcationState(params: {
  workspaceRoot: string;
  state: SkynetBifurcationState;
}): Promise<void> {
  const jsonPath = resolveBifurcationJsonPath({
    workspaceRoot: params.workspaceRoot,
    sessionKey: params.state.sessionKey,
  });
  const markdownPath = resolveBifurcationMarkdownPath(params.workspaceRoot);
  await fs.mkdir(path.dirname(jsonPath), { recursive: true });
  await fs.writeFile(jsonPath, JSON.stringify(params.state, null, 2) + "\n", "utf-8");
  await fs.writeFile(markdownPath, buildBifurcationMarkdown(params.state), "utf-8");
}

export async function recordSkynetBifurcation(params: {
  workspaceRoot: string;
  sessionKey: string;
  label: string;
  contextSnapshot: string;
  options: string[];
  selected: string;
}): Promise<SkynetBifurcationEvent> {
  const state = await loadSkynetBifurcationState(params);
  const event: SkynetBifurcationEvent = {
    timestamp: Date.now(),
    label: params.label,
    contextSnapshot: params.contextSnapshot,
    options: params.options,
    selected: params.selected,
    stabilized: false,
  };
  state.activeBifurcation = event;
  state.updatedAt = Date.now();
  await saveSkynetBifurcationState({ workspaceRoot: params.workspaceRoot, state });
  return event;
}

export async function stabilizeSkynetBifurcation(params: {
  workspaceRoot: string;
  sessionKey: string;
}): Promise<void> {
  const state = await loadSkynetBifurcationState(params);
  if (state.activeBifurcation) {
    state.activeBifurcation.stabilized = true;
    state.history.push(state.activeBifurcation);
    state.activeBifurcation = undefined;
    state.updatedAt = Date.now();
    await saveSkynetBifurcationState({ workspaceRoot: params.workspaceRoot, state });
  }
}

function buildBifurcationMarkdown(state: SkynetBifurcationState): string {
  const lines = [
    "# SKYNET Bifurcation",
    "",
    `Actualizado: ${new Date(state.updatedAt).toISOString()}`,
    `Sesion: ${state.sessionKey}`,
    "",
  ];

  if (state.activeBifurcation) {
    lines.push("## Bifurcación Activa");
    lines.push("");
    lines.push(`- **Label**: ${state.activeBifurcation.label}`);
    lines.push(`- **Contexto**: ${state.activeBifurcation.contextSnapshot}`);
    lines.push(`- **Opciones**: ${state.activeBifurcation.options.join(" | ")}`);
    lines.push(`- **Seleccionada**: ${state.activeBifurcation.selected}`);
    lines.push("");
  }

  if (state.history.length > 0) {
    lines.push("## Historial");
    lines.push("");
    state.history
      .slice(-10)
      .reverse()
      .forEach((event) => {
        lines.push(`### ${event.label} (${new Date(event.timestamp).toISOString()})`);
        lines.push(`- Contexto: ${event.contextSnapshot}`);
        lines.push(`- Seleccionada: **${event.selected}**`);
        lines.push("");
      });
  }

  return lines.join("\n").trim() + "\n";
}

export function formatSkynetBifurcationBlock(state?: SkynetBifurcationState): string[] {
  if (!state || (!state.activeBifurcation && state.history.length === 0)) {
    return [];
  }
  const lines = ["", "[Skynet Bifurcation]"];
  if (state.activeBifurcation) {
    lines.push(`Active: ${state.activeBifurcation.label} -> ${state.activeBifurcation.selected}`);
  } else if (state.history.length > 0) {
    const last = state.history[state.history.length - 1]!;
    lines.push(`Last stabilized: ${last.label} -> ${last.selected}`);
  }
  return lines;
}