import { createServer, type IncomingMessage, type ServerResponse } from "node:http";

import {
  HttpApi,
  HttpApiEndpoint,
  HttpApiGroup,
  HttpApiSchema,
  OpenApi,
} from "@effect/platform";
import { describe, expect, it } from "@effect/vitest";
import { makeSourceManagerService } from "@executor-v2/management-api";
import { type ToolArtifactStore } from "@executor-v2/persistence-ports";
import { type Source, SourceSchema, type ToolArtifact } from "@executor-v2/schema";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";

import { executeJavaScriptWithTools } from "@executor-v2/runtime-local-inproc";
import { makeOpenApiToolProvider, openApiToolDescriptorsFromManifest } from "./openapi-provider";
import { RuntimeAdapterError } from "./runtime-adapters";
import { makeToolProviderRegistry } from "./tool-providers";

const decodeSource = Schema.decodeUnknownSync(SourceSchema);

type TestServer = {
  baseUrl: string;
  requests: Array<{
    path: string;
    accept: string | null;
  }>;
  close: () => Promise<void>;
};

class TestServerReleaseError extends Data.TaggedError("TestServerReleaseError")<{
  message: string;
}> {}

const jsonResponse = (res: ServerResponse, statusCode: number, body: unknown): void => {
  res.statusCode = statusCode;
  res.setHeader("content-type", "application/json");
  res.end(JSON.stringify(body));
};

const getHeaderValue = (
  req: IncomingMessage,
  key: string,
): string | null => {
  const value = req.headers[key];
  if (typeof value === "string") {
    return value;
  }

  if (Array.isArray(value)) {
    return value[0] ?? null;
  }

  return null;
};

const githubOwnerParam = HttpApiSchema.param("owner", Schema.String);
const githubRepoParam = HttpApiSchema.param("repo", Schema.String);

class GitHubReposApi extends HttpApiGroup.make("repos").add(
  HttpApiEndpoint.get("getRepo")`/repos/${githubOwnerParam}/${githubRepoParam}`.addSuccess(
    Schema.Unknown,
  ),
) {}

class GitHubApi extends HttpApi.make("github").add(GitHubReposApi) {}

const githubOpenApiSpec = OpenApi.fromApi(GitHubApi);

const quoteJavaScriptString = (value: string): string =>
  `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;

const makeTestServer = Effect.acquireRelease(
  Effect.promise<TestServer>(
    () =>
      new Promise<TestServer>((resolve, reject) => {
        const requests: TestServer["requests"] = [];

        const server = createServer((req, res) => {
          const host = getHeaderValue(req, "host") ?? "127.0.0.1";
          const url = new URL(req.url ?? "/", `http://${host}`);

          if (url.pathname === "/repos/octocat/hello-world" && req.method === "GET") {
            requests.push({
              path: url.pathname,
              accept: getHeaderValue(req, "accept"),
            });

            jsonResponse(res, 200, {
              full_name: "octocat/hello-world",
              stargazers_count: 42,
              private: false,
            });
            return;
          }

          jsonResponse(res, 404, { error: "not found" });
        });

        server.once("error", (error) => {
          reject(error);
        });

        server.listen(0, "127.0.0.1", () => {
          const address = server.address();
          if (!address || typeof address === "string") {
            reject(new Error("failed to resolve test server address"));
            return;
          }

          resolve({
            baseUrl: `http://127.0.0.1:${address.port}`,
            requests,
            close: () =>
              new Promise<void>((closeResolve, closeReject) => {
                server.close((error) => {
                  if (error) {
                    closeReject(error);
                    return;
                  }
                  closeResolve();
                });
              }),
          });
        });
      }),
  ),
  (testServer) =>
    Effect.tryPromise({
      try: () => testServer.close(),
      catch: (cause) =>
        new TestServerReleaseError({
          message: cause instanceof Error ? cause.message : String(cause),
        }),
    }).pipe(Effect.orDie),
);

describe("OpenAPI execution vertical slice", () => {
  it.scoped("loads GitHub OpenAPI tool and executes it in sandbox", () =>
    Effect.gen(function* () {
      const testServer = yield* makeTestServer;

      const source: Source = decodeSource({
        id: "src_openapi",
        workspaceId: "ws_local",
        name: "github",
        kind: "openapi",
        endpoint: testServer.baseUrl,
        status: "connected",
        enabled: true,
        configJson: JSON.stringify({ baseUrl: testServer.baseUrl }),
        sourceHash: null,
        lastError: null,
        createdAt: Date.now(),
        updatedAt: Date.now(),
      });

      const artifactsByKey = new Map<string, ToolArtifact>();
      const artifactStore: ToolArtifactStore = {
        getBySource: (workspaceId: Source["workspaceId"], sourceId: Source["id"]) =>
          Effect.succeed(
            Option.fromNullable(artifactsByKey.get(`${workspaceId}:${sourceId}`)),
          ),
        upsert: (artifact: ToolArtifact) =>
          Effect.sync(() => {
            artifactsByKey.set(`${artifact.workspaceId}:${artifact.sourceId}`, artifact);
          }),
      };

      const sourceManager = makeSourceManagerService(artifactStore);
      const refreshResult = yield* sourceManager.refreshOpenApiArtifact({
        source,
        openApiSpec: githubOpenApiSpec,
      });

      const tools = yield* openApiToolDescriptorsFromManifest(
        source,
        refreshResult.artifact.manifestJson,
      );

      expect(tools).toHaveLength(1);
      const githubTool = tools[0]!;

      const registry = makeToolProviderRegistry([makeOpenApiToolProvider()]);

      const executionResult = yield* executeJavaScriptWithTools({
        runId: "run_openapi_1",
        code: `return await tools[${quoteJavaScriptString(githubTool.toolId)}]({ owner: "octocat", repo: "hello-world" });`,
        toolCallService: {
          callTool: (input) => {
            if (input.toolPath !== githubTool.toolId) {
              return new RuntimeAdapterError({
                operation: "call_tool",
                runtimeKind: "local-inproc",
                message: `Unknown tool path: ${input.toolPath}`,
                details: null,
              });
            }

            return registry
              .invoke({
                source,
                tool: githubTool,
                args: input.input ?? {},
              })
              .pipe(
                Effect.mapError(
                  (error) =>
                    new RuntimeAdapterError({
                      operation: "call_tool",
                      runtimeKind: "local-inproc",
                      message: error.message,
                      details: null,
                    }),
                ),
                Effect.flatMap((result) =>
                  result.isError
                    ? Effect.fail(
                        new RuntimeAdapterError({
                          operation: "call_tool",
                          runtimeKind: "local-inproc",
                          message: `Tool call returned error: ${input.toolPath}`,
                          details: null,
                        }),
                      )
                    : Effect.succeed(result.output),
                ),
              );
          },
        },
      });

      expect(executionResult).toMatchObject({
        status: 200,
        body: {
          full_name: "octocat/hello-world",
          stargazers_count: 42,
          private: false,
        },
      });

      const executionWithNestedPathArgs = yield* executeJavaScriptWithTools({
        runId: "run_openapi_2",
        code: `return await tools[${quoteJavaScriptString(githubTool.toolId)}]({ path: { owner: "octocat", repo: "hello-world" } });`,
        toolCallService: {
          callTool: (input) => {
            if (input.toolPath !== githubTool.toolId) {
              return new RuntimeAdapterError({
                operation: "call_tool",
                runtimeKind: "local-inproc",
                message: `Unknown tool path: ${input.toolPath}`,
                details: null,
              });
            }

            return registry
              .invoke({
                source,
                tool: githubTool,
                args: input.input ?? {},
              })
              .pipe(
                Effect.mapError(
                  (error) =>
                    new RuntimeAdapterError({
                      operation: "call_tool",
                      runtimeKind: "local-inproc",
                      message: error.message,
                      details: null,
                    }),
                ),
                Effect.flatMap((result) =>
                  result.isError
                    ? Effect.fail(
                        new RuntimeAdapterError({
                          operation: "call_tool",
                          runtimeKind: "local-inproc",
                          message: `Tool call returned error: ${input.toolPath}`,
                          details: null,
                        }),
                      )
                    : Effect.succeed(result.output),
                ),
              );
          },
        },
      });

      expect(executionWithNestedPathArgs).toMatchObject({
        status: 200,
        body: {
          full_name: "octocat/hello-world",
          stargazers_count: 42,
          private: false,
        },
      });

      expect(testServer.requests).toHaveLength(2);
      expect(testServer.requests[0]?.path).toBe("/repos/octocat/hello-world");
      expect(testServer.requests[1]?.path).toBe("/repos/octocat/hello-world");
    }),
  );
});