import fs from "fs";
import path from "path";
import {
  recommendTask,
  buildBridgeDeepLink,
  ingestRagTexts,
  supervisorConfig,
} from "./supervisorAiService";

const MISSIONS_DIR = path.join(process.cwd(), "data", "agent-missions");
const MISSIONS_FILE = path.join(MISSIONS_DIR, "missions.jsonl");

export type MissionStatus = "pending" | "launched" | "completed" | "cancelled";

export interface AgentMission {
  id: string;
  task: string;
  agent: string;
  status: MissionStatus;
  created_at: string;
  launched_at?: string;
  bridge_url?: string;
  recommendation?: Record<string, unknown>;
  note?: string;
}

function ensureDir(): void {
  if (!fs.existsSync(MISSIONS_DIR)) {
    fs.mkdirSync(MISSIONS_DIR, { recursive: true });
  }
}

function readAll(): AgentMission[] {
  ensureDir();
  if (!fs.existsSync(MISSIONS_FILE)) return [];
  const lines = fs.readFileSync(MISSIONS_FILE, "utf8").split("\n").filter(Boolean);
  const out: AgentMission[] = [];
  for (const line of lines) {
    try {
      out.push(JSON.parse(line) as AgentMission);
    } catch {
      /* skip corrupt line */
    }
  }
  return out.reverse();
}

function append(mission: AgentMission): void {
  ensureDir();
  fs.appendFileSync(MISSIONS_FILE, JSON.stringify(mission) + "\n", "utf8");
}

function updateStatus(id: string, patch: Partial<AgentMission>): AgentMission | null {
  const all = readAll().reverse();
  let found: AgentMission | null = null;
  const updated = all.map((m) => {
    if (m.id !== id) return m;
    found = { ...m, ...patch };
    return found;
  });
  fs.writeFileSync(
    MISSIONS_FILE,
    updated.map((m) => JSON.stringify(m)).join("\n") + (updated.length ? "\n" : ""),
    "utf8"
  );
  return found;
}

export function listMissions(limit = 30): AgentMission[] {
  return readAll().slice(0, limit);
}

export async function createAndLaunchMission(
  task: string,
  agent = "code",
  autoBridge = true
): Promise<{ mission: AgentMission; bridgeUrl: string | null }> {
  const id = `mission-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
  const mission: AgentMission = {
    id,
    task,
    agent,
    status: "pending",
    created_at: new Date().toISOString(),
  };

  const rec = await recommendTask(task, agent);
  const data = (rec.data || {}) as Record<string, unknown>;
  const primary = data.primary_match as Record<string, unknown> | undefined;
  const prompt = [
    "MODO REVISIÓN — Captajaus · misión semi-autónoma",
    primary ? `Agente: ${primary.agent} · ${primary.title}` : `Agente: ${agent}`,
    "",
    task,
  ]
    .filter(Boolean)
    .join("\n");

  const bridgeUrl = buildBridgeDeepLink(prompt, autoBridge);
  mission.status = "launched";
  mission.launched_at = new Date().toISOString();
  mission.bridge_url = bridgeUrl;
  mission.recommendation = data;
  append(mission);

  return { mission, bridgeUrl };
}

export function completeMission(id: string, note?: string): AgentMission | null {
  return updateStatus(id, {
    status: "completed",
    note,
  });
}

export function cancelMission(id: string, note?: string): AgentMission | null {
  return updateStatus(id, {
    status: "cancelled",
    note,
  });
}

export async function ingestMissionSummaryToRag(limit = 10): Promise<{ ok: boolean; chars: number }> {
  const missions = listMissions(limit);
  const doc = [
    `# Captajaus agent missions ${new Date().toISOString()}`,
    `Bridge: ${supervisorConfig().bridgeUrl}`,
    "",
    JSON.stringify(missions, null, 2),
  ].join("\n");
  const ing = await ingestRagTexts([{ text: doc, type: "operational_insight", id: `captajaus-missions-${Date.now()}` }]);
  return { ok: ing.ok, chars: doc.length };
}