#!/usr/bin/env node
import { spawn } from "node:child_process";
import fs from "node:fs";
import path from "node:path";
import { Readable, Writable } from "node:stream";
import * as acp from "@agentclientprotocol/sdk";

const PNG_HEADER = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);

const pending = new Map();
const logFile = process.env.FAKE_ACP_LOG;
const log = (entry) => { if (logFile) fs.appendFileSync(logFile, `${JSON.stringify(entry)}\n`); };
const assistantEnvelope = (reply, actions) => `${reply}\n<GORI_ASSISTANT_ACTION_V2>${JSON.stringify({ reply, actions })}</GORI_ASSISTANT_ACTION_V2>`;
const workerEnvelope = (result) => `worker reply\n<GORI_WORKER_RESULT_V2>${JSON.stringify(result)}</GORI_WORKER_RESULT_V2>`;
const workerEnvelopeTruncated = (result) => `worker reply\n<GORI_WORKER_RESULT_V2>${JSON.stringify(result)}`;

const app = acp.agent({ name: "fake-acp-agent" })
  .onRequest(acp.methods.agent.initialize, ({ params }) => {
    log({ method: "initialize" });
    return {
      protocolVersion: params.protocolVersion,
      agentCapabilities: {
        loadSession: true,
        promptCapabilities: { image: process.env.FAKE_ACP_IMAGE_CAP !== "0" },
        sessionCapabilities: { resume: {}, close: {}, list: {} }
      },
      agentInfo: { name: "fake-acp-agent", version: "1" }
    };
  })
  .onRequest(acp.methods.agent.session.new, async ({ params }) => {
    const sessionId = `fake-${Date.now()}-${Math.random().toString(16).slice(2)}`;
    log({ method: "session/new", sessionId, cwd: params.cwd });
    if (process.env.FAKE_ACP_NEW_HANG === "1") await new Promise(() => undefined);
    return { sessionId };
  })
  .onRequest(acp.methods.agent.session.load, ({ params }) => {
    log({ method: "session/load", sessionId: params.sessionId });
    if (process.env.FAKE_ACP_LOAD_FAIL === "1" || (process.env.FAKE_ACP_LOAD_FAIL_FILE && fs.existsSync(process.env.FAKE_ACP_LOAD_FAIL_FILE))) throw new Error("load failed");
    return {};
  })
  .onRequest(acp.methods.agent.session.resume, ({ params }) => {
    log({ method: "session/resume", sessionId: params.sessionId });
    if (process.env.FAKE_ACP_RESUME_FAIL === "1" || (process.env.FAKE_ACP_RESUME_FAIL_FILE && fs.existsSync(process.env.FAKE_ACP_RESUME_FAIL_FILE))) throw new Error("resume failed");
    return {};
  })
  .onRequest(acp.methods.agent.session.close, ({ params }) => { log({ method: "session/close", sessionId: params.sessionId }); return {}; })
  .onRequest(acp.methods.agent.session.list, () => ({ sessions: [] }))
  .onRequest(acp.methods.agent.session.prompt, async ({ params, client, signal }) => {
    const text = params.prompt.filter((item) => item.type === "text").map((item) => item.text).join("");
    const images = params.prompt.filter((item) => item.type === "image").length;
    log({ method: "session/prompt", sessionId: params.sessionId, text, images });
    if (text === "crash" || text.startsWith("crash\n\nWhen this turn")) process.exit(9);
    if (text.includes("Initialize this ACP session")) {
      if (process.env.FAKE_ACP_BOOTSTRAP_DELAY_MS) await new Promise((resolve) => setTimeout(resolve, Number(process.env.FAKE_ACP_BOOTSTRAP_DELAY_MS)));
      await update(client, params.sessionId, "READY");
      return { stopReason: "end_turn" };
    }

    // Assistant protocol
    if (text.startsWith("Your previous response did not end with a valid GORI_ASSISTANT_ACTION_V2")) {
      await update(client, params.sessionId, assistantEnvelope("repaired", []));
      return { stopReason: "end_turn" };
    }
    if (text.startsWith("Your previous response did not end with a valid GORI_WORKER_RESULT_V2")) {
      await update(client, params.sessionId, process.env.FAKE_ACP_INVALID_REPAIR === "1"
        ? "still invalid"
        : workerEnvelope({ status: "PENDING", summary: "repaired" }));
      return { stopReason: "end_turn" };
    }
    if (text.includes("[Internal event")) {
      await update(client, params.sessionId, assistantEnvelope("event received: worker update", []));
      return { stopReason: "end_turn" };
    }
    if (text.includes("[User message]")) {
      const userText = (text.split("[User message]\n")[1] || "").split("\n\n")[0].trim();
      if (userText === "force tool") {
        await client.notify(acp.methods.client.session.update, {
          sessionId: params.sessionId,
          update: { sessionUpdate: "tool_call", toolCallId: "read-1", title: "Read a file", kind: "read", status: "in_progress" }
        });
        return { stopReason: "end_turn" };
      }
      let response;
      if (userText.startsWith("create proposal:")) {
        const goal = userText.slice("create proposal:".length).trim();
        response = assistantEnvelope("proposal drafted", [{ type: "create_proposal", title: "Test proposal", goal, steps: ["step 1"] }]);
      } else if (userText === "confirm") response = assistantEnvelope("confirmed", [{ type: "confirm" }]);
      else if (userText === "confirm and start next") response = assistantEnvelope("confirmed", [{ type: "confirm" }, { type: "start_next" }]);
      else if (userText === "finish") response = assistantEnvelope("finishing", [{ type: "finish" }]);
      else if (userText.startsWith("follow up:")) response = assistantEnvelope("following up", [{ type: "follow_up", instruction: userText.slice("follow up:".length).trim() }]);
      else if (userText.startsWith("adjust proposal:")) response = assistantEnvelope("adjusting", [{ type: "adjust_proposal", title: userText.slice("adjust proposal:".length).trim() }]);
      else if (userText.startsWith("send image:")) response = assistantEnvelope("sending image", [{ type: "send_image", path: userText.slice("send image:".length).trim() }]);
      else if (userText === "start next") response = assistantEnvelope("starting next", [{ type: "start_next" }]);
      else if (userText === "stop") response = assistantEnvelope("stopping", [{ type: "stop" }]);
      else if (userText === "cancel proposal") response = assistantEnvelope("cancelling", [{ type: "cancel" }]);
      else if (userText === "ack pending") response = assistantEnvelope("任务「Test proposal」还在等你确认。", []);
      else if (userText === "truncated assistant") response = `ok\n<GORI_ASSISTANT_ACTION_V2>${JSON.stringify({ reply: "ok", actions: [] })}`;
      else if (userText === "invalid assistant") response = "invalid without envelope";
      else response = assistantEnvelope("ok", []);
      await update(client, params.sessionId, response);
      return { stopReason: "end_turn" };
    }

    // Worker protocol
    if (text.startsWith("The user sent a follow-up instruction")) {
      await update(client, params.sessionId, workerEnvelope({ status: "PENDING", summary: `continued ${params.sessionId}` }));
      return { stopReason: "end_turn" };
    }
    if (text.startsWith("Execute this confirmed proposal")) {
      const goal = ((text.split("Goal: ")[1] || "").split("\n")[0] || "").trim();
      if (goal.includes("toolhang")) {
        await client.notify(acp.methods.client.session.update, {
          sessionId: params.sessionId,
          update: { sessionUpdate: "tool_call", toolCallId: "read-1", title: "Read package.json", kind: "read", status: "in_progress" }
        });
        await client.notify(acp.methods.client.session.update, {
          sessionId: params.sessionId,
          update: { sessionUpdate: "tool_call", toolCallId: "read-2", title: "Read README.md", kind: "read", status: "in_progress" }
        });
        await client.notify(acp.methods.client.session.update, {
          sessionId: params.sessionId,
          update: { sessionUpdate: "tool_call", toolCallId: "exec-1", title: "bash npm test", kind: "execute", status: "in_progress" }
        });
        await new Promise((resolve) => {
          const done = () => resolve(undefined);
          pending.set(params.sessionId, done);
          signal.addEventListener("abort", done, { once: true });
        });
        pending.delete(params.sessionId);
        return { stopReason: "cancelled" };
      }
      if (goal.includes("hang")) {
        await new Promise((resolve) => {
          const done = () => resolve(undefined);
          pending.set(params.sessionId, done);
          signal.addEventListener("abort", done, { once: true });
        });
        pending.delete(params.sessionId);
        return { stopReason: "cancelled" };
      }
      if (goal.includes("invalid")) {
        await update(client, params.sessionId, "invalid without envelope");
        return { stopReason: "end_turn" };
      }
      if (process.env.FAKE_ACP_WORKER_GATE_FILE) {
        while (!fs.existsSync(process.env.FAKE_ACP_WORKER_GATE_FILE)) await new Promise((resolve) => setTimeout(resolve, 5));
      }
      if (goal.includes("truncbad")) {
        await update(client, params.sessionId, `worker reply\n<GORI_WORKER_RESULT_V2>{"status":"PENDING","summary":"cut off mid json"`);
        return { stopReason: "end_turn" };
      }
      if (goal.includes("truncattach")) {
        const outbox = path.join(process.cwd(), ".gori-outbox");
        fs.mkdirSync(outbox, { recursive: true });
        fs.writeFileSync(path.join(outbox, "shot.png"), Buffer.concat([PNG_HEADER, Buffer.from("fake-png-payload-truncated")]));
        await update(client, params.sessionId, workerEnvelopeTruncated({ status: "PENDING", summary: "made a pic", attachments: [{ path: ".gori-outbox/shot.png", mimeType: "image/png" }] }));
        return { stopReason: "end_turn" };
      }
      if (goal.includes("attachbad")) {
        await update(client, params.sessionId, workerEnvelope({ status: "PENDING", summary: "made a pic", attachments: [{ path: "/tmp/evil.png" }, { path: "not-an-image.txt" }] }));
        return { stopReason: "end_turn" };
      }
      if (goal.includes("attach")) {
        const outbox = path.join(process.cwd(), ".gori-outbox");
        fs.mkdirSync(outbox, { recursive: true });
        fs.writeFileSync(path.join(outbox, "shot.png"), Buffer.concat([PNG_HEADER, Buffer.from("fake-png-payload-v1")]));
        fs.writeFileSync(path.join(process.cwd(), "not-an-image.txt"), "plain text");
        await update(client, params.sessionId, workerEnvelope({ status: "PENDING", summary: "made a pic", attachments: [{ path: ".gori-outbox/shot.png", mimeType: "image/png" }] }));
        return { stopReason: "end_turn" };
      }
      const result = goal.includes("ask")
        ? { status: "PENDING", summary: "hit a dirty target", question: "May I overwrite it?", workspaceDirty: true }
        : goal.includes("fail")
          ? { status: "PENDING", summary: "something broke" }
          : { status: "PENDING", summary: "goal done" };
      await update(client, params.sessionId, workerEnvelope(result));
      return { stopReason: "end_turn" };
    }

    // Legacy behaviors used by acp-worker/acp-client tests
    const request = text.split("\n\nWhen this turn is finished")[0];
    if (request === "spawn descendant") {
      const descendant = spawn(process.execPath, ["-e", "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"], { stdio: "ignore" });
      if (process.env.FAKE_ACP_DESCENDANT_PID_FILE) fs.writeFileSync(process.env.FAKE_ACP_DESCENDANT_PID_FILE, `${descendant.pid}\n`);
      await new Promise((resolve) => signal.addEventListener("abort", resolve, { once: true }));
      return { stopReason: "cancelled" };
    }
    if (request === "hang") {
      await new Promise((resolve) => {
        const done = () => resolve(undefined);
        pending.set(params.sessionId, done);
        signal.addEventListener("abort", done, { once: true });
      });
      pending.delete(params.sessionId);
      return { stopReason: "cancelled" };
    }
    if (request === "activity") {
      await update(client, params.sessionId, "first");
      await new Promise((resolve) => setTimeout(resolve, 600));
      await update(client, params.sessionId, "second");
      await new Promise((resolve) => setTimeout(resolve, 700));
      return { stopReason: "end_turn" };
    }
    await update(client, params.sessionId, `reply:${params.sessionId}:${request}`);
    return { stopReason: "end_turn" };
  })
  .onNotification(acp.methods.agent.session.cancel, ({ params }) => {
    log({ method: "session/cancel", sessionId: params.sessionId });
    pending.get(params.sessionId)?.();
  });

function update(client, sessionId, text) {
  return client.notify(acp.methods.client.session.update, {
    sessionId,
    update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } }
  });
}

const stream = acp.ndJsonStream(
  Writable.toWeb(process.stdout),
  Readable.toWeb(process.stdin)
);
const connection = app.connect(stream);
await connection.closed;