import { test, expect } from "vitest";
import { spawn as nodeSpawn } from "node:child_process";
import path from "node:path";
import os from "node:os";
import { chmodSync, unlinkSync, writeFileSync } from "node:fs";
import { buildApp } from "../src/app.js";
import { loadConfig } from "../src/config.js";

const FAKE = path.resolve("../harness/tests/fake_pi/fake_pi_rpc.mjs");
const SCRIPT = path.resolve("../harness/tests/fake_pi/scripts/f1_disambiguation.json");

function mutApp(thtRunner: any) {
  return buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: { ollamaEnsure: async () => ({ ok: true }), ...thtRunner },
    getSettings: () => ({ workspace: "w" }) as any,
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
}

test("POST /sessions usa i settings (workspace/provider/model/thinking) e crea+avvia", async () => {
  const modelKey = path.join(os.tmpdir(), `thoth-model-key-${process.pid}`);
  writeFileSync(modelKey, "test-model-key", { mode: 0o600 });
  chmodSync(modelKey, 0o600);
  let sessionNewArg: any;
  let spawnArg: any;
  const app = buildApp(loadConfig({
    THT_HARNESS_DIR: "../harness", THT_MODEL_API_KEY_FILE: modelKey,
  }), {
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      searchPack: async () => {},
      sessionNew: async (o: any) => { sessionNewArg = o; return { id: "s1" }; },
      sessionList: async () => [{ id: "s1" }],
    } as any,
    getSettings: () => ({ workspace: "w", provider: "zai", model: "glm-5.2", thinking: "high" }),
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  const created = await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  expect(created.json()).toEqual({ id: "s1" });
  expect(sessionNewArg.workspace).toBe("w");
  expect(sessionNewArg.provider).toBe("zai");
  expect(sessionNewArg.model).toBe("glm-5.2");
  expect(sessionNewArg.thinking).toBe("high");
  expect(sessionNewArg.question).toBe("q");
  const list = await app.inject({ method: "GET", url: "/sessions" });
  expect(list.json()).toEqual([{ id: "s1" }]);
  unlinkSync(modelKey);
});

test("POST /sessions configura Pi con il thinking globale selezionato", async () => {
  let configured: any;
  const bridge = { onClientEvent: () => {}, emitClientEvent: () => {} };
  const runtime = { bridge } as any;
  const mgr = {
    createFor: () => runtime,
    configure: async (_rt: any, options: any) => { configured = options; },
    start: () => {},
    teardown: () => {},
  } as any;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    mgr,
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      searchPack: async () => {},
      sessionNew: async () => ({ id: "s-thinking" }),
    } as any,
    getSettings: () => ({ workspace: "psd", provider: "zai", model: "glm-5.2", thinking: "high" }) as any,
  });

  await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  await new Promise((resolve) => setImmediate(resolve));

  expect(configured.thinking).toBe("high");
});

test("POST /sessions/:id/resume configura Pi con il thinking persistito", async () => {
  let configured: any;
  const bridge = { onClientEvent: () => {}, emitClientEvent: () => {} };
  const runtime = { bridge } as any;
  const mgr = {
    get: () => undefined,
    createFor: () => runtime,
    configure: async (_rt: any, options: any) => { configured = options; },
    start: () => {},
    teardown: () => {},
  } as any;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    mgr,
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      sessionShow: async () => ({
        status: "open",
        archived: false,
        provider: "zai",
        model: "glm-5.2",
        thinking: "medium",
      }),
      reopenSession: async () => {},
    } as any,
    getSettings: () => ({ workspace: "psd", thinking: "low" }) as any,
  });

  await app.inject({ method: "POST", url: "/sessions/s-thinking/resume" });
  await new Promise((resolve) => setImmediate(resolve));

  expect(configured.thinking).toBe("medium");
});

test("POST /sessions/:id/resume usa il thinking globale se manca nel manifest", async () => {
  let configured: any;
  const bridge = { onClientEvent: () => {}, emitClientEvent: () => {} };
  const runtime = { bridge } as any;
  const mgr = {
    get: () => undefined,
    createFor: () => runtime,
    configure: async (_rt: any, options: any) => { configured = options; },
    start: () => {},
    teardown: () => {},
  } as any;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    mgr,
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      sessionShow: async () => ({ status: "open", archived: false }),
      reopenSession: async () => {},
    } as any,
    getSettings: () => ({ workspace: "psd", thinking: "low" }) as any,
  });

  await app.inject({ method: "POST", url: "/sessions/s-thinking/resume" });
  await new Promise((resolve) => setImmediate(resolve));

  expect(configured.thinking).toBe("low");
});

test("POST /sessions/:id/response inoltra al bridge (no error)", async () => {
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      searchPack: async () => {},
      sessionNew: async () => ({ id: "s1" }),
      sessionList: async () => [],
    } as any,
    getSettings: () => ({ workspace: "w" }),
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/response",
    payload: { ui_response: { id: "u1", choices: ["a"] } } });
  expect(res.statusCode).toBe(204);
});

test("POST /sessions/:id/rename calls setName", async () => {
  let arg: any;
  const app = mutApp({ setName: async (id: string, name: string) => { arg = { id, name }; } });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/rename", payload: { name: "N" } });
  expect(res.statusCode).toBe(204);
  expect(arg).toEqual({ id: "s1", name: "N" });
});

test("POST /sessions/:id/group calls setGroup", async () => {
  let arg: any;
  const app = mutApp({ setGroup: async (id: string, group: string) => { arg = { id, group }; } });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/group", payload: { group: "G" } });
  expect(res.statusCode).toBe(204);
  expect(arg).toEqual({ id: "s1", group: "G" });
});

test("POST archive / unarchive call the runner", async () => {
  const seen: string[] = [];
  const app = mutApp({
    archive: async (id: string) => { seen.push(`a:${id}`); },
    unarchive: async (id: string) => { seen.push(`u:${id}`); },
  });
  expect((await app.inject({ method: "POST", url: "/sessions/s1/archive" })).statusCode).toBe(204);
  expect((await app.inject({ method: "POST", url: "/sessions/s1/unarchive" })).statusCode).toBe(204);
  expect(seen).toEqual(["a:s1", "u:s1"]);
});

test("DELETE /sessions/:id calls deleteSession", async () => {
  let deleted: string | null = null;
  const app = mutApp({ deleteSession: async (id: string) => { deleted = id; } });
  const res = await app.inject({ method: "DELETE", url: "/sessions/s1" });
  expect(res.statusCode).toBe(204);
  expect(deleted).toBe("s1");
});

test("DELETE /sessions/:id tears down the runtime before deleting on disk", async () => {
  const order: string[] = [];
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: { deleteSession: async (id: string) => { order.push(`del:${id}`); } } as any,
    mgr: { teardown: (id: string) => { order.push(`teardown:${id}`); } } as any,
    getSettings: () => ({ workspace: "w" }) as any,
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  const res = await app.inject({ method: "DELETE", url: "/sessions/s1" });
  expect(res.statusCode).toBe(204);
  expect(order).toEqual(["teardown:s1", "del:s1"]);
});

test("GET /sessions/:id/documents returns the runner output", async () => {
  const app = mutApp({ documents: async () => [{ phase: "—", key: "question", title: "t", format: "text", content: "q" }] });
  const res = await app.inject({ method: "GET", url: "/sessions/s1/documents" });
  expect(res.statusCode).toBe(200);
  expect(res.json()[0].key).toBe("question");
});

test("POST resume on a finalized session is refused with 409", async () => {
  const app = mutApp({ sessionShow: async () => ({ status: "finalized", archived: false }) });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/resume" });
  expect(res.statusCode).toBe(409);
});

test("POST resume on an archived session is refused with 409", async () => {
  const app = mutApp({ sessionShow: async () => ({ status: "open", archived: true }) });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/resume" });
  expect(res.statusCode).toBe(409);
});

test("POST /sessions refuses with 503 when ollamaEnsure fails (no session created)", async () => {
  let createdCalled = false;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: {
      ollamaEnsure: async () => ({ ok: false, stage: "model", error: "modello non installato" }),
      searchPack: async () => {},
      sessionNew: async () => { createdCalled = true; return { id: "s1" }; },
    } as any,
    getSettings: () => ({ workspace: "psd" }) as any,
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  const res = await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  expect(res.statusCode).toBe(503);
  expect(res.json().error).toContain("non installato");
  expect(createdCalled).toBe(false);
});

test("POST /sessions proceeds when ollamaEnsure succeeds", async () => {
  let ensureWs: string | undefined;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: {
      ollamaEnsure: async (ws: string) => { ensureWs = ws; return { ok: true }; },
      searchPack: async () => {},
      sessionNew: async () => ({ id: "s1" }),
    } as any,
    getSettings: () => ({ workspace: "psd" }) as any,
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  const res = await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  expect(res.json()).toEqual({ id: "s1" });
  expect(ensureWs).toBe("psd");
});

test("POST /sessions/:id/resume returns 409 for a read-only session without calling ollamaEnsure", async () => {
  let ensureCalled = false;
  const app = mutApp({
    sessionShow: async () => ({ status: "finalized", archived: false }),
    ollamaEnsure: async () => { ensureCalled = true; return { ok: false, error: "down" }; },
  });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/resume" });
  expect(res.statusCode).toBe(409);
  expect(ensureCalled).toBe(false);
});

test("POST /sessions/:id/resume refuses with 503 when ollamaEnsure fails", async () => {
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: {
      ollamaEnsure: async () => ({ ok: false, error: "Ollama down" }),
      sessionShow: async () => ({ status: "open", archived: false }),
    } as any,
    getSettings: () => ({ workspace: "psd" }) as any,
    spawnFn: () => nodeSpawn("node", [FAKE, SCRIPT]) as any,
  });
  const res = await app.inject({ method: "POST", url: "/sessions/s1/resume" });
  expect(res.statusCode).toBe(503);
});

test("POST /runtime/prewarm returns 202 without awaiting readiness", async () => {
  let workspace: string | undefined;
  let finish!: (value: any) => void;
  const pending = new Promise((resolve) => { finish = resolve; });
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    thtRunner: {} as any,
    readiness: {
      ensure: (ws: string) => { workspace = ws; return pending; },
    } as any,
    getSettings: () => ({ workspace: "psd" }) as any,
  });
  const res = await app.inject({ method: "POST", url: "/runtime/prewarm" });
  expect(res.statusCode).toBe(202);
  expect(res.json()).toEqual({ status: "warming" });
  expect(workspace).toBe("psd");
  finish({ ok: true });
});

test("POST /sessions returns after bridge attachment but starts only after retrieval", async () => {
  let finishPack!: () => void;
  const pack = new Promise<void>((resolve) => { finishPack = resolve; });
  let bridgeAttached = false;
  let started = false;
  const bridge = {
    onClientEvent: () => { bridgeAttached = true; },
    emitClientEvent: () => {},
  };
  const runtime = { bridge } as any;
  const mgr = {
    createFor: () => runtime,
    configure: async () => {},
    start: () => {
      expect(bridgeAttached).toBe(true);
      started = true;
    },
    teardown: () => {},
  } as any;
  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "../harness" }), {
    mgr,
    thtRunner: {
      ollamaEnsure: async () => ({ ok: true }),
      sessionNew: async () => ({ id: "s-early" }),
      searchPack: async () => pack,
    } as any,
    getSettings: () => ({ workspace: "psd" }) as any,
  });

  const res = await app.inject({ method: "POST", url: "/sessions", payload: { question: "q" } });
  expect(res.json()).toEqual({ id: "s-early" });
  expect(bridgeAttached).toBe(true);
  expect(started).toBe(false);
  finishPack();
  await new Promise((resolve) => setImmediate(resolve));
  expect(started).toBe(true);
});