import { join } from "node:path";
import {
  HttpApi,
  HttpApiEndpoint,
  HttpApiGroup,
  HttpApiSchema,
  HttpApiBuilder,
  HttpApiClient,
  FileSystem,
} from "@effect/platform";
import {
  NodeFileSystem,
  NodeHttpServer,
} from "@effect/platform-node";
import {
  describe,
  expect,
  it,
} from "@effect/vitest";
import * as Either from "effect/Either";
import {
  assertInclude,
} from "@effect/vitest/utils";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import {
  makeOpenApiTestServer,
} from "@executor/effect-test-utils";

import {
  createExecutorBackend,
} from "./index";
import {
  createExecutorEffect,
  type ExecutorEffect as Executor,
} from "./effect";
import {
  type LocalInstallation,
  ScopeIdSchema,
} from "./schema";
import {
  createLocalExecutorRepositoriesEffect,
} from "../../sdk-file/src/effect";
import {
  createExecutorApiLayer,
} from "../../api/src/http";
import {
  ExecutorApi,
} from "../../api/src/index";

type LocalExecutorServices = Effect.Effect.Success<
  ReturnType<typeof createLocalExecutorRepositoriesEffect>
>;

const createClientLayer = (executor: Executor) =>
  HttpApiBuilder.serve().pipe(
    Layer.provide(createExecutorApiLayer(executor)),
    Layer.provideMerge(NodeHttpServer.layerTest),
  );

const createExecutorApiClient = () =>
  HttpApiClient.make(ExecutorApi, {
  });

type ExecutorApiClient = Effect.Effect.Success<
  ReturnType<typeof createExecutorApiClient>
>;

const withExecutorApiClient = <A, E>(
  executor: Executor,
  f: (client: ExecutorApiClient) => Effect.Effect<A, E, never>,
): Effect.Effect<A, E, never> =>
  Effect.gen(function* () {
    const client = yield* createExecutorApiClient();
    return yield* f(client);
  }).pipe(Effect.provide(createClientLayer(executor).pipe(Layer.orDie)));

const expectLeft = <A, E>(effect: Effect.Effect<A, E, never>) =>
  Effect.either(effect).pipe(
    Effect.flatMap((result) =>
      Either.isLeft(result)
        ? Effect.succeed(result.left)
        : Effect.die("Expected effect to fail"),
    ),
  );

type OpenApiSpecServer = {
  baseUrl: string;
  specUrl: string;
  close: () => Promise<void>;
};

const ownerParam = HttpApiSchema.param("owner", Schema.String);
const repoParam = HttpApiSchema.param("repo", Schema.String);
const issueIdParam = HttpApiSchema.param("issueId", Schema.String);

class WorkspaceSourceReposApi extends HttpApiGroup.make("repos")
  .add(
    HttpApiEndpoint.get("getRepo")`/repos/${ownerParam}/${repoParam}`
      .addSuccess(Schema.Unknown),
  )
{}

class WorkspaceSourceIssuesApi extends HttpApiGroup.make("issues")
  .add(
    HttpApiEndpoint.get("getIssue")`/issues/${issueIdParam}`
      .addSuccess(Schema.Unknown),
  )
  .add(
    HttpApiEndpoint.get("listIssues")`/issues`
      .addSuccess(Schema.Unknown),
  )
{}

class WorkspaceSourceReposRootApi extends HttpApi.make("workspaceSourceRepos")
  .add(WorkspaceSourceReposApi)
{}

class WorkspaceSourceIssuesRootApi extends HttpApi.make("workspaceSourceIssues")
  .add(WorkspaceSourceIssuesApi)
{}

const workspaceSourceReposLive = HttpApiBuilder.group(
  WorkspaceSourceReposRootApi,
  "repos",
  (handlers) =>
    handlers.handle("getRepo", ({ path }) =>
      Effect.succeed({
        full_name: `${path.owner}/${path.repo}`,
        private: false,
      }),
    ),
);

const workspaceSourceIssuesLive = HttpApiBuilder.group(
  WorkspaceSourceIssuesRootApi,
  "issues",
  (handlers) =>
    handlers
      .handle("getIssue", ({ path }) =>
        Effect.succeed({
          id: path.issueId,
          title: `Issue ${path.issueId}`,
        }),
      )
      .handle("listIssues", () =>
        Effect.succeed([
          {
            id: "1",
            title: "Issue 1",
          },
        ]),
      ),
);

const workspaceSourceReposApiLayer = HttpApiBuilder.api(
  WorkspaceSourceReposRootApi,
).pipe(Layer.provide(workspaceSourceReposLive));

const workspaceSourceIssuesApiLayer = HttpApiBuilder.api(
  WorkspaceSourceIssuesRootApi,
).pipe(Layer.provide(workspaceSourceIssuesLive));

const createScopedExecutor = (input: {
  services: LocalExecutorServices;
  installation: LocalInstallation;
}) =>
  createExecutorEffect({
    backend: createExecutorBackend({
      loadRepositories: () =>
        Effect.succeed({
          ...input.services,
          scope: {
            ...input.services.scope,
            actorScopeId: input.installation.actorScopeId,
            resolutionScopeIds: input.installation.resolutionScopeIds,
          },
          installation: {
            load: () => Effect.succeed(input.installation),
            getOrProvision: () => Effect.succeed(input.installation),
          },
        }),
    }),
    getLocalServerBaseUrl: () => "http://127.0.0.1",
  });

const makeSharedScopeExecutors = Effect.acquireRelease(
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const sharedScopeId = ScopeIdSchema.make("org_shared_sdk_pair_test");

    const workspaceRootA = yield* fs.makeTempDirectoryScoped({
      prefix: "executor-sdk-scope-a-",
    });
    const workspaceRootB = yield* fs.makeTempDirectoryScoped({
      prefix: "executor-sdk-scope-b-",
    });

    const servicesA = yield* createLocalExecutorRepositoriesEffect({
      workspaceRoot: workspaceRootA,
      homeConfigPath: join(workspaceRootA, ".executor-home.jsonc"),
      homeStateDirectory: join(workspaceRootA, ".executor-home-state"),
    });
    const servicesB = yield* createLocalExecutorRepositoriesEffect({
      workspaceRoot: workspaceRootB,
      homeConfigPath: join(workspaceRootB, ".executor-home.jsonc"),
      homeStateDirectory: join(workspaceRootB, ".executor-home-state"),
    });

    const baseInstallationA =
      yield* servicesA.installation.getOrProvision();
    const baseInstallationB =
      yield* servicesB.installation.getOrProvision();

    const sharedStorageClose = (() => {
      let closed = false;
      return async () => {
        if (closed) {
          return;
        }
        closed = true;
        await servicesA.close?.();
        await servicesB.close?.();
      };
    })();

    const sharedStorage = {
      close: sharedStorageClose,
    };

    const installationA: LocalInstallation = {
      ...baseInstallationA,
      actorScopeId: ScopeIdSchema.make("acc_sdk_executor_a"),
      resolutionScopeIds: [
        baseInstallationA.scopeId,
        sharedScopeId,
        ScopeIdSchema.make("acc_sdk_executor_a"),
      ],
    };
    const installationB: LocalInstallation = {
      ...baseInstallationB,
      actorScopeId: ScopeIdSchema.make("acc_sdk_executor_b"),
      resolutionScopeIds: [
        baseInstallationB.scopeId,
        sharedScopeId,
        ScopeIdSchema.make("acc_sdk_executor_b"),
      ],
    };

    const executorA = yield* createScopedExecutor({
      services: {
        ...servicesA,
        ...sharedStorage,
      },
      installation: installationA,
    });
    const executorB = yield* createScopedExecutor({
      services: {
        ...servicesB,
        ...sharedStorage,
      },
      installation: installationB,
    });

    return {
      executorA,
      executorB,
      sharedScopeId,
    };
  }).pipe(Effect.provide(NodeFileSystem.layer)),
  ({ executorA, executorB }) =>
    Effect.promise(async () => {
      await executorA.close();
      await executorB.close();
    }).pipe(Effect.orDie),
);

describe("executor", () => {
  it.scoped(
    "keeps workspace sources isolated across executors that share an ancestor scope",
    () =>
      Effect.gen(function* () {
        const { executorA, executorB, sharedScopeId } =
          yield* makeSharedScopeExecutors;
        const openApiServer: OpenApiSpecServer = yield* makeOpenApiTestServer({
          apiLayer: workspaceSourceReposApiLayer,
        });

        expect(executorA.resolutionScopeIds).toContain(sharedScopeId);
        expect(executorB.resolutionScopeIds).toContain(sharedScopeId);

        const sourceA = yield* withExecutorApiClient(executorA, (client) =>
          client.sources.create({
            path: {
              workspaceId: executorA.scopeId,
            },
            payload: {
              name: "Workspace A Source",
              kind: "openapi",
              endpoint: openApiServer.baseUrl,
              namespace: "workspace.a",
              binding: {
                specUrl: openApiServer.specUrl,
                defaultHeaders: null,
              },
              auth: { kind: "none" },
            },
          }),
        );
        const sourceB = yield* withExecutorApiClient(executorB, (client) =>
          client.sources.create({
            path: {
              workspaceId: executorB.scopeId,
            },
            payload: {
              name: "Workspace B Source",
              kind: "openapi",
              endpoint: openApiServer.baseUrl,
              namespace: "workspace.b",
              binding: {
                specUrl: openApiServer.specUrl,
                defaultHeaders: null,
              },
              auth: { kind: "none" },
            },
          }),
        );

        const listedA = yield* withExecutorApiClient(executorA, (client) =>
          client.sources.list({
            path: {
              workspaceId: executorA.scopeId,
            },
          }),
        );
        const listedB = yield* withExecutorApiClient(executorB, (client) =>
          client.sources.list({
            path: {
              workspaceId: executorB.scopeId,
            },
          }),
        );

        expect(listedA.map((source) => source.id)).toEqual([sourceA.id]);
        expect(listedB.map((source) => source.id)).toEqual([sourceB.id]);

        const lookupFromSibling = yield* expectLeft(
          withExecutorApiClient(executorB, (client) =>
            client.sources.get({
              path: {
                workspaceId: executorB.scopeId,
                sourceId: sourceA.id,
              },
            }),
          ),
        );
        assertInclude(String(lookupFromSibling), "Source not found");
      }),
  );

  it.scoped(
    "keeps each executor's tool surface tied to its own workspace sources",
    () =>
      Effect.gen(function* () {
        const { executorA, executorB } =
          yield* makeSharedScopeExecutors;
        const openApiServerA: OpenApiSpecServer = yield* makeOpenApiTestServer({
          apiLayer: workspaceSourceReposApiLayer,
        });
        const openApiServerB: OpenApiSpecServer = yield* makeOpenApiTestServer({
          apiLayer: workspaceSourceIssuesApiLayer,
        });

        const sourceA = yield* withExecutorApiClient(executorA, (client) =>
          client.sources.create({
            path: {
              workspaceId: executorA.scopeId,
            },
            payload: {
              name: "Workspace A Tools",
              kind: "openapi",
              endpoint: openApiServerA.baseUrl,
              namespace: "workspace.a",
              binding: {
                specUrl: openApiServerA.specUrl,
                defaultHeaders: null,
              },
              auth: { kind: "none" },
            },
          }),
        );
        const sourceB = yield* withExecutorApiClient(executorB, (client) =>
          client.sources.create({
            path: {
              workspaceId: executorB.scopeId,
            },
            payload: {
              name: "Workspace B Tools",
              kind: "openapi",
              endpoint: openApiServerB.baseUrl,
              namespace: "workspace.b",
              binding: {
                specUrl: openApiServerB.specUrl,
                defaultHeaders: null,
              },
              auth: { kind: "none" },
            },
          }),
        );

        const inspectionA = yield* withExecutorApiClient(executorA, (client) =>
          client.sources.inspection({
            path: {
              workspaceId: executorA.scopeId,
              sourceId: sourceA.id,
            },
          }),
        );
        const inspectionB = yield* withExecutorApiClient(executorB, (client) =>
          client.sources.inspection({
            path: {
              workspaceId: executorB.scopeId,
              sourceId: sourceB.id,
            },
          }),
        );

        expect(inspectionA.toolCount).toBe(1);
        expect(inspectionB.toolCount).toBe(2);

        const siblingInspection = yield* expectLeft(
          withExecutorApiClient(executorA, (client) =>
            client.sources.inspection({
              path: {
                workspaceId: executorA.scopeId,
                sourceId: sourceB.id,
              },
            }),
          ),
        );
        assertInclude(String(siblingInspection), "Source not found");
      }),
    60_000,
  );
});