// Pre-load QuickJS WASM for compiled binaries — must run before server imports
import { dirname, join } from "node:path";
const wasmOnDisk = join(dirname(process.execPath), "emscripten-module.wasm");
if (typeof Bun !== "undefined" && await Bun.file(wasmOnDisk).exists()) {
  const { setQuickJSModule } = await import("@executor/runtime-quickjs");
  const { newQuickJSWASMModule } = await import("quickjs-emscripten");
  const wasmBinary = await Bun.file(wasmOnDisk).arrayBuffer();
  const variant = {
    type: "sync" as const,
    importFFI: () => import("@jitl/quickjs-wasmfile-release-sync/ffi").then((m: any) => m.QuickJSFFI),
    importModuleLoader: () =>
      import("@jitl/quickjs-wasmfile-release-sync/emscripten-module").then((m: any) => {
        const original = m.default;
        return (moduleArg: any = {}) => original({ ...moduleArg, wasmBinary });
      }),
  };
  const mod = await newQuickJSWASMModule(variant as any);
  setQuickJSModule(mod);
}

import { spawn } from "node:child_process";
import { resolve } from "node:path";
import { Command, Options, Args } from "@effect/cli";
import { BunRuntime } from "@effect/platform-bun";
import { FetchHttpClient, HttpApiClient } from "@effect/platform";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Cause from "effect/Cause";

import { ExecutorApi } from "@executor/api";
import { createServerHandlers, runMcpStdioServer, getExecutor } from "@executor/server";

// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------

const CLI_NAME = "executor";
const { version: CLI_VERSION } = await import("../package.json");
const DEFAULT_PORT = 4788;
const DEFAULT_BASE_URL = `http://localhost:${DEFAULT_PORT}`;

// Embedded web UI — baked into compiled binaries via `with { type: "file" }`
import embeddedWebUI from "./embedded-web-ui.gen";

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

const waitForShutdownSignal = () =>
  Effect.async<void, never>((resume) => {
    const shutdown = () => resume(Effect.void);
    process.once("SIGINT", shutdown);
    process.once("SIGTERM", shutdown);
    return Effect.sync(() => {
      process.off("SIGINT", shutdown);
      process.off("SIGTERM", shutdown);
    });
  });

const appendUrlPath = (baseUrl: string, pathname: string): string =>
  new URL(pathname, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();

const renderSessionSummary = (kind: "web" | "mcp", baseUrl: string): string => {
  const displayKind = kind === "mcp" ? "MCP" : "web";
  const primaryLabel = kind === "web" ? "Web" : "MCP";
  const primaryUrl = kind === "web" ? baseUrl : appendUrlPath(baseUrl, "mcp");
  const secondaryLabel = kind === "web" ? "MCP" : "Web";
  const secondaryUrl = kind === "web" ? appendUrlPath(baseUrl, "mcp") : baseUrl;
  const guidance =
    kind === "web"
      ? "Keep this process running while you use the browser session."
      : "Use this MCP URL in your client and keep this process running.";

  return [
    `Executor ${displayKind} session is ready.`,
    `${primaryLabel}: ${primaryUrl}`,
    `${secondaryLabel}: ${secondaryUrl}`,
    `OpenAPI: ${appendUrlPath(baseUrl, "docs")}`,
    "",
    guidance,
    "Press Ctrl+C to stop.",
  ].join("\n");
};

// ---------------------------------------------------------------------------
// Background server management
// ---------------------------------------------------------------------------

const isServerReachable = async (baseUrl: string): Promise<boolean> => {
  try {
    const res = await fetch(`${baseUrl}/docs`, { signal: AbortSignal.timeout(2000) });
    return res.ok;
  } catch {
    return false;
  }
};

const script = process.argv[1];
const isDevMode = script?.endsWith(".ts") || script?.endsWith(".js");
const cliPrefix = isDevMode ? `bun run ${script}` : "executor";

const startBackgroundServer = (port: number): void => {
  const args = isDevMode
    ? ["run", script, "web", "--port", String(port)]
    : ["web", "--port", String(port)];
  const child = spawn(process.execPath, args, {
    detached: true,
    stdio: "ignore",
  });
  child.unref();
};

const ensureServer = (baseUrl: string) =>
  Effect.gen(function* () {
    if (yield* Effect.promise(() => isServerReachable(baseUrl))) return;

    const url = new URL(baseUrl);
    const port = Number(url.port) || DEFAULT_PORT;
    console.error(`Starting background server on port ${port}...`);
    startBackgroundServer(port);

    const deadline = Date.now() + 30_000;
    while (Date.now() < deadline) {
      yield* Effect.promise(() => new Promise((r) => setTimeout(r, 200)));
      if (yield* Effect.promise(() => isServerReachable(baseUrl))) return;
    }

    return yield* Effect.fail(new Error(`Server failed to start within 30s at ${baseUrl}`));
  });

// ---------------------------------------------------------------------------
// Typed API client
// ---------------------------------------------------------------------------

const makeApiClient = (baseUrl: string) =>
  HttpApiClient.make(ExecutorApi, { baseUrl }).pipe(
    Effect.provide(FetchHttpClient.layer),
  );

// ---------------------------------------------------------------------------
// Static file serving from embedded web UI
// ---------------------------------------------------------------------------

const WEB_DIST_DIR = resolve(import.meta.dirname, "../../web/dist");

const serveStatic = async (pathname: string): Promise<Response | null> => {
  const key = pathname.replace(/^\//, "");

  // Compiled binary: serve from embedded bunfs
  if (embeddedWebUI) {
    const match = embeddedWebUI[key] ?? embeddedWebUI["index.html"] ?? null;
    if (!match) return null;
    const file = Bun.file(match);
    return new Response(file, {
      headers: { "content-type": file.type || "application/octet-stream" },
    });
  }

  // Dev mode: serve from apps/web/dist on disk
  const filePath = resolve(WEB_DIST_DIR, key);
  if (!filePath.startsWith(WEB_DIST_DIR)) return null;

  const file = Bun.file(filePath);
  if (await file.exists()) {
    return new Response(file, {
      headers: { "content-type": file.type || "application/octet-stream" },
    });
  }

  // SPA fallback
  const index = Bun.file(resolve(WEB_DIST_DIR, "index.html"));
  if (await index.exists()) {
    return new Response(index, { headers: { "content-type": "text/html" } });
  }

  return null;
};

// ---------------------------------------------------------------------------
// Host-header allowlist — blocks DNS rebinding attacks
// ---------------------------------------------------------------------------

const ALLOWED_HOSTS = new Set([
  "localhost",
  "127.0.0.1",
  "[::1]",
  "::1",
]);

const isAllowedHost = (request: Request): boolean => {
  const host = request.headers.get("host");
  if (!host) return true; // no host header (e.g. HTTP/1.0) — allow
  // Strip port ("localhost:4788" → "localhost")
  const hostname = host.replace(/:\d+$/, "");
  return ALLOWED_HOSTS.has(hostname);
};

// ---------------------------------------------------------------------------
// Foreground session — API + MCP + Web UI on one Bun.serve()
// ---------------------------------------------------------------------------

const runForegroundSession = (input: { kind: "web" | "mcp"; port: number }) =>
  Effect.gen(function* () {
    const handlers = yield* Effect.promise(() => createServerHandlers());

    // Bind to loopback only — one server per address family so both
    // "localhost" (which may resolve to ::1 on Windows) and 127.0.0.1 work,
    // without exposing the server on the LAN.
    const fetch = async (request: Request): Promise<Response> => {
      if (!isAllowedHost(request)) {
        return new Response("Forbidden", { status: 403 });
      }

      const url = new URL(request.url);

      if (url.pathname.startsWith("/mcp")) {
        return handlers.mcp.handleRequest(request);
      }

      if (
        url.pathname.startsWith("/v1/") ||
        url.pathname.startsWith("/docs") ||
        url.pathname === "/openapi.json"
      ) {
        return handlers.api.handler(request);
      }

      const staticResponse = await serveStatic(url.pathname);
      if (staticResponse) return staticResponse;

      return new Response("Not Found", { status: 404 });
    };

    const serverV4 = Bun.serve({ port: input.port, hostname: "127.0.0.1", fetch });

    // IPv6 loopback — may fail on systems without IPv6; that's fine.
    let serverV6: ReturnType<typeof Bun.serve> | null = null;
    try {
      serverV6 = Bun.serve({ port: input.port, hostname: "::1", fetch });
    } catch {
      // IPv6 not available — continue with IPv4 only
    }

    const server = serverV4;

    const baseUrl = `http://localhost:${server.port}`;
    console.log(renderSessionSummary(input.kind, baseUrl));

    yield* waitForShutdownSignal();

    serverV4.stop(true);
    serverV6?.stop(true);
    yield* Effect.promise(() => handlers.mcp.close());
    yield* Effect.promise(() => handlers.api.dispose());
  });

// ---------------------------------------------------------------------------
// Stdio MCP session
// ---------------------------------------------------------------------------

const runStdioMcpSession = () =>
  Effect.gen(function* () {
    const executor = yield* Effect.promise(() => getExecutor());
    yield* Effect.promise(() => runMcpStdioServer({ executor }));
  });

// ---------------------------------------------------------------------------
// Code resolution — positional arg > --file > stdin
// ---------------------------------------------------------------------------

const readCode = (input: {
  code: Option.Option<string>;
  file: Option.Option<string>;
  stdin: boolean;
}): Effect.Effect<string, Error> =>
  Effect.gen(function* () {
    const code = Option.getOrUndefined(input.code);
    if (code && code.trim().length > 0) return code;

    const file = Option.getOrUndefined(input.file);
    if (file && file.trim().length > 0) {
      const contents = yield* Effect.tryPromise({
        try: () => Bun.file(file).text(),
        catch: (e) => new Error(`Failed to read file: ${e}`),
      });
      if (contents.trim().length > 0) return contents;
    }

    if (input.stdin || !process.stdin.isTTY) {
      const chunks: string[] = [];
      process.stdin.setEncoding("utf8");
      const contents = yield* Effect.tryPromise({
        try: async () => {
          for await (const chunk of process.stdin) chunks.push(chunk as string);
          return chunks.join("");
        },
        catch: (e) => new Error(`Failed to read stdin: ${e}`),
      });
      if (contents.trim().length > 0) return contents;
    }

    return yield* Effect.fail(
      new Error("No code provided. Pass code as an argument, --file, or pipe to stdin."),
    );
  });

// ---------------------------------------------------------------------------
// Commands
// ---------------------------------------------------------------------------

const callCommand = Command.make(
  "call",
  {
    code: Args.text({ name: "code" }).pipe(Args.optional),
    file: Options.text("file").pipe(Options.optional),
    stdin: Options.boolean("stdin").pipe(Options.withDefault(false)),
    baseUrl: Options.text("base-url").pipe(Options.withDefault(DEFAULT_BASE_URL)),
  },
  ({ code, file, stdin, baseUrl }) =>
    Effect.gen(function* () {
      const resolvedCode = yield* readCode({ code, file, stdin });
      yield* ensureServer(baseUrl);

      const client = yield* makeApiClient(baseUrl);
      const result = yield* client.executions.execute({ payload: { code: resolvedCode } });

      if (result.status === "completed") {
        if (result.isError) {
          console.error(result.text);
          process.exitCode = 1;
        } else {
          console.log(result.text);
        }
      } else {
        console.log(result.text);
        const executionId = (result.structured as any)?.executionId;
        if (executionId) {
          console.log(
            `\nTo resume:\n  ${cliPrefix} resume --execution-id ${executionId} --action accept`,
          );
        }
      }
    }),
).pipe(Command.withDescription("Execute code against the local executor"));

const resumeCommand = Command.make(
  "resume",
  {
    executionId: Options.text("execution-id"),
    action: Options.text("action").pipe(Options.withDefault("accept")),
    content: Options.text("content").pipe(Options.optional),
    baseUrl: Options.text("base-url").pipe(Options.withDefault(DEFAULT_BASE_URL)),
  },
  ({ executionId, action, content, baseUrl }) =>
    Effect.gen(function* () {
      yield* ensureServer(baseUrl);

      const parsedContent = Option.getOrUndefined(content);
      const contentObj = parsedContent ? JSON.parse(parsedContent) : undefined;

      const client = yield* makeApiClient(baseUrl);
      const result = yield* client.executions.resume({
        path: { executionId },
        payload: { action: action as "accept" | "decline" | "cancel", content: contentObj },
      });

      if (result.isError) {
        console.error(result.text);
        process.exitCode = 1;
      } else {
        console.log(result.text);
      }
    }),
).pipe(Command.withDescription("Resume a paused execution"));

const webCommand = Command.make(
  "web",
  {
    port: Options.integer("port").pipe(Options.withDefault(DEFAULT_PORT)),
  },
  ({ port }) => runForegroundSession({ kind: "web", port }),
).pipe(Command.withDescription("Start a foreground web session"));

const mcpCommand = Command.make(
  "mcp",
  {},
  () => runStdioMcpSession(),
).pipe(Command.withDescription("Start an MCP server over stdio"));

// ---------------------------------------------------------------------------
// Root command
// ---------------------------------------------------------------------------

const root = Command.make("executor").pipe(
  Command.withSubcommands([callCommand, resumeCommand, webCommand, mcpCommand] as const),
  Command.withDescription("Executor local CLI"),
);

// ---------------------------------------------------------------------------
// Run
// ---------------------------------------------------------------------------

const runCli = Command.run(root, {
  name: CLI_NAME,
  version: CLI_VERSION,
  executable: CLI_NAME,
});

const program = runCli(process.argv).pipe(
  Effect.catchAllCause((cause) =>
    Effect.sync(() => {
      console.error(Cause.pretty(cause));
      process.exitCode = 1;
    }),
  ),
);

BunRuntime.runMain(program as Effect.Effect<void, never, never>);