import * as fs from "node:fs/promises";
import path from "node:path";
import { execFileSync } from "node:child_process";
import * as NodeWS from "@effect/platform-node/NodeWS";
import {
  ORCHESTRATION_PROTOCOL_VERSION,
  WsRpcGroup,
  ProviderInstanceId,
  ProviderDriverKind,
} from "@t3tools/contracts";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import { RpcClient, RpcSerialization } from "effect/rpc";
import { Socket } from "effect/socket";
import { T3_HOME } from "../e2e.config.ts";
import { makeState, runPromise, test, WEB } from "./t3.ts";

const configure = (
  origin: string,
  environment: Array<{ name: string; value: string; sensitive: boolean }>,
  terminal?: { threadId: string; cwd: string },
) =>
  Effect.gen(function* () {
    const issued = yield* makeState(T3_HOME).cli(["auth", "session", "issue", "--token-only"]);
    const response = yield* Effect.promise(() =>
      fetch(`${origin}/api/auth/websocket-ticket`, {
        method: "POST",
        headers: { Authorization: `Bearer ${issued.stdout.trim()}` },
      }),
    );
    const { ticket } = yield* Effect.promise(() => response.json());
    const protocol = yield* Layer.build(
      RpcClient.layerProtocolSocket().pipe(
        Layer.provide(
          Socket.layerWebSocket(
            `${origin.replace(/^http/, "ws")}/ws?orchestrationProtocol=${ORCHESTRATION_PROTOCOL_VERSION}&wsTicket=${encodeURIComponent(ticket)}`,
          ),
        ),
        Layer.provide(RpcSerialization.layerJson),
        Layer.provide(NodeWS.layerWebSocketConstructor),
      ),
    );
    const client = yield* RpcClient.make(WsRpcGroup).pipe(Effect.provideContext(protocol));
    if (terminal) {
      yield* client["terminal.open"]({
        ...terminal,
        terminalId: "term-1",
        cols: 110,
        rows: 18,
        env: { PS1: "proof> ", PROMPT_COMMAND: "", TERM: "xterm-256color" },
      });
      yield* client["terminal.write"]({
        threadId: terminal.threadId,
        terminalId: "term-1",
        data: "PS1='proof> '; PROMPT_COMMAND=''; clear; node evidence.cjs\r",
      });
      return;
    }
    yield* client["server.updateSettings"]({
      patch: {},
      providerInstanceMutation: {
        operation: "upsert",
        instanceId: ProviderInstanceId.make("npmProof"),
        instance: {
          driver: ProviderDriverKind.make("acpRegistry"),
          displayName: "Managed npm proof",
          enabled: true,
          environment,
          config: {
            source: "registry",
            agentId: "pi-acp",
            distribution: "npx",
            customModels: ["default"],
          },
        },
      },
    });
  }).pipe(Effect.scoped);

test(
  "A missing managed npm executable never launches a same-name PATH command",
  WEB,
  async ({ t3, app, screen, browser }) => {
    const binLinks = process.env.PROOF_BIN_LINKS ?? "false";
    const logStart = (await fs.stat(path.resolve(import.meta.dirname, "../.e2e/app.log"))).size;
    const project = await t3.project("npm-resolution");
    const prefix = path.join(T3_HOME, "tools/pi-acp/0.0.34/npm");
    const registryDir = path.join(T3_HOME, "caches/acp-registry");
    await fs.mkdir(registryDir, { recursive: true });
    const registry = await (
      await fetch("https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json")
    ).json();
    await fs.writeFile(path.join(registryDir, "registry.json"), JSON.stringify(registry));
    execFileSync("npm", ["install", "--global", "--prefix", prefix, "pi-acp@0.0.34"], {
      env: { ...process.env, npm_config_bin_links: "true" },
      stdio: "pipe",
    });
    await fs.unlink(path.join(prefix, "bin/pi-acp"));
    const marker = path.join(T3_HOME, "unrelated-launched");
    const shim = path.join(T3_HOME, "bin/pi-acp");
    await fs.writeFile(
      path.join(T3_HOME, "bin/package.json"),
      JSON.stringify({ type: "commonjs" }),
    );
    await fs.writeFile(
      shim,
      `#!/usr/bin/env node\nrequire('node:fs').appendFileSync(${JSON.stringify(marker)}, 'UNRELATED PATH COMMAND EXECUTED\\n');\nrequire('node:readline').createInterface({input:process.stdin}).on('line', line => {try {const m=JSON.parse(line); if(m.id!==undefined) console.log(JSON.stringify({jsonrpc:'2.0',id:m.id,error:{code:-32603,message:'UNRELATED PATH COMMAND EXECUTED: inherited PATH executable selected instead of managed npm binary'}}));}catch{}});\n`,
      { mode: 0o755 },
    );
    await runPromise(
      configure(app.baseUrl ?? "", [
        { name: "npm_config_bin_links", value: binLinks, sensitive: false },
        {
          name: "PATH",
          value: path.join(T3_HOME, "bin") + ":" + process.env.PATH,
          sensitive: false,
        },
        { name: "PI_ACP_PI_COMMAND", value: "proof-no-model", sensitive: false },
        { name: "PI_CODING_AGENT_DIR", value: path.join(T3_HOME, "pi"), sensitive: false },
      ]),
    );
    const cli = makeState(T3_HOME).cli;
    const result = await runPromise(
      cli([
        "thread",
        "start",
        project,
        "Check managed executable resolution",
        "--title",
        "Missing managed npm link",
        "--provider",
        "npmProof",
        "--model",
        "default",
        "--json",
      ]),
    );
    const thread = JSON.parse(result.stdout);
    await t3.open({ threadId: thread.threadId });
    await screen
      .getByText("Provider session failed to open", { exact: true })
      .waitFor({ timeout: 120000 });
    const report = `const fs = require('node:fs');
const home = ${JSON.stringify(T3_HOME)};
const log = fs.readFileSync(${JSON.stringify(path.resolve(import.meta.dirname, "../.e2e/app.log"))}, 'utf8');
console.log('Linux / real T3 server / pi-acp@0.0.34');
console.log('npm_config_bin_links=${binLinks}; managed bin link removed before launch');
console.log('Installed manifest: ' + JSON.parse(fs.readFileSync(home+'/tools/pi-acp/0.0.34/npm/lib/node_modules/pi-acp/package.json')).version);
console.log('Managed executable exists: ' + fs.existsSync(home+'/tools/pi-acp/0.0.34/npm/bin/pi-acp'));
console.log('Unrelated PATH command launched: ' + fs.existsSync(home+'/unrelated-launched'));
const current = log.slice(${logStart});
const errorLine = current.split(String.fromCharCode(10)).find(l => l.includes('AcpRegistryError:') || l.includes('AcpRequestError:'));
if(errorLine) console.log(errorLine.trim().replace(/^.*?(AcpRegistryError:|AcpRequestError:)/, '$1').split(String.fromCharCode(92)+'n')[0]);
fs.writeFileSync('report-ready', 'done');
`;
    await fs.writeFile(path.join(project, "evidence.cjs"), report);
    await runPromise(configure(app.baseUrl ?? "", [], { threadId: thread.threadId, cwd: project }));
    await expect
      .poll(async () => fs.readFile(path.join(project, "report-ready"), "utf8").catch(() => ""), {
        timeout: 15000,
      })
      .toBe("done");
    await screen.getByRole("button", "Toggle terminal drawer").tap();
    const dismiss = screen.getByRole("button", /^Dismiss Managed npm proof provider/);
    if (await dismiss.count()) await dismiss.tap();
    await browser.mouse.move(100, 700);
    await screen
      .getByText("Managed npm proof provider status", { exact: true })
      .waitFor({ state: "hidden" });
    await app.screenshot(`missing-managed-link-bin-links-${binLinks}`);
    await expect(
      await fs.access(marker).then(
        () => true,
        () => false,
      ),
    ).toBe(false);
    await expect(
      await fs.access(path.join(prefix, "bin/pi-acp")).then(
        () => true,
        () => false,
      ),
    ).toBe(binLinks === "true");
  },
);
