import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { gzipSync } from "node:zlib";
import { NodeFileSystem } from "@effect/platform-node";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";

import {
  SourceIdSchema,
  WorkspaceIdSchema,
  type Source,
} from "#schema";

import {
  buildLocalSourceArtifact,
  readLocalSourceArtifact,
  removeLocalSourceArtifact,
  writeLocalSourceArtifact,
} from "./local-source-artifacts";
import type { ResolvedLocalWorkspaceContext } from "./local-config";
import {
  createCatalogImportMetadata,
  createGraphqlCatalogFragment,
  createOpenApiCatalogFragment,
} from "./source-catalog-snapshot";

const makeContext = (): ResolvedLocalWorkspaceContext => {
  const workspaceRoot = mkdtempSync(join(tmpdir(), "executor-artifacts-"));
  return {
    cwd: workspaceRoot,
    workspaceRoot,
    workspaceName: "executor-artifacts",
    configDirectory: join(workspaceRoot, ".executor"),
    projectConfigPath: join(workspaceRoot, ".executor", "executor.jsonc"),
    homeConfigPath: join(workspaceRoot, ".executor-home.jsonc"),
    homeStateDirectory: join(workspaceRoot, ".executor-home-state"),
    artifactsDirectory: join(workspaceRoot, ".executor", "artifacts"),
    stateDirectory: join(workspaceRoot, ".executor", "state"),
  };
};

const makeSource = (): Source => ({
  id: SourceIdSchema.make("src_test"),
  workspaceId: WorkspaceIdSchema.make("ws_test"),
  name: "Test Source",
  kind: "openapi",
  endpoint: "https://example.com/api",
  status: "connected",
  enabled: true,
  namespace: "test",
  bindingVersion: 1,
  binding: {
    specUrl: "https://example.com/openapi.json",
    defaultHeaders: null,
  },
  importAuthPolicy: "none",
  importAuth: { kind: "none" },
  auth: { kind: "none" },
  sourceHash: "hash_test",
  lastError: null,
  createdAt: 0,
  updatedAt: 0,
});

const makeArtifact = () => {
  const source = makeSource();
  const fragment = createOpenApiCatalogFragment({
    source,
    documents: [{
      documentKind: "openapi",
      documentKey: source.binding.specUrl,
      contentText: '{"openapi":"3.1.0"}',
      fetchedAt: 1,
    }],
    operations: [],
  });

  return buildLocalSourceArtifact({
    source,
    syncResult: {
      fragment,
      importMetadata: createCatalogImportMetadata({
        source,
        adapterKey: "openapi",
      }),
      sourceHash: source.sourceHash,
    },
  });
};

const makeGraphqlArtifact = () => {
  const source: Source = {
    ...makeSource(),
    kind: "graphql",
    endpoint: "https://example.com/graphql",
    binding: {
      defaultHeaders: null,
    },
  };
  const fragment = createGraphqlCatalogFragment({
    source,
    documents: [{
      documentKind: "graphql_introspection",
      documentKey: source.endpoint,
      contentText: '{"__schema":{}}',
      fetchedAt: 1,
    }],
    operations: [{
      toolId: "viewer",
      title: "Viewer",
      description: "Load the current viewer",
      effect: "read",
      inputSchema: { type: "object", properties: {} },
      outputSchema: { type: "object", properties: { login: { type: "string" } } },
      providerData: {
        kind: "graphql",
        toolKind: "field",
        toolId: "viewer",
        rawToolId: "viewer",
        group: "query",
        leaf: "viewer",
        fieldName: "viewer",
        operationType: "query",
        operationName: "ViewerQuery",
        operationDocument: "query ViewerQuery { viewer { login } }",
        queryTypeName: "Query",
        mutationTypeName: null,
        subscriptionTypeName: null,
      },
    }],
  });

  return buildLocalSourceArtifact({
    source,
    syncResult: {
      fragment,
      importMetadata: createCatalogImportMetadata({
        source,
        adapterKey: "graphql",
      }),
      sourceHash: source.sourceHash,
    },
  });
};

describe("local-source-artifacts", () => {
  it.effect("writes canonical uncompressed artifacts and reads them back", () =>
    Effect.gen(function* () {
      const context = makeContext();
      const artifact = makeArtifact();
      const path = join(context.artifactsDirectory, "sources", "src_test.json");
      const legacyPath = join(context.artifactsDirectory, "sources", "src_test.json.gz");
      const rawDocumentPath = join(
        context.artifactsDirectory,
        "sources",
        "src_test",
        "documents",
        `${Object.keys(artifact.snapshot.catalog.documents)[0]}.txt`,
      );

      yield* writeLocalSourceArtifact({
        context,
        sourceId: "src_test",
        artifact,
      });

      expect(existsSync(path)).toBe(true);
      expect(existsSync(legacyPath)).toBe(false);
      expect(readFileSync(path, "utf8").startsWith("{")).toBe(true);
      expect(existsSync(rawDocumentPath)).toBe(true);

      const persistedArtifact = JSON.parse(readFileSync(path, "utf8"));
      const persistedDocument = Object.values(persistedArtifact.snapshot.catalog.documents)[0] as {
        native?: ReadonlyArray<{ kind?: string }>;
        provenance?: unknown;
      };
      const persistedResource = Object.values(persistedArtifact.snapshot.catalog.resources)[0] as {
        provenance?: unknown;
      };
      expect(persistedDocument.native?.some((blob) => blob.kind === "source_document") ?? false).toBe(false);
      expect(persistedDocument.provenance).toBeUndefined();
      expect(persistedResource.provenance).toBeDefined();
      expect(Object.keys(persistedArtifact.snapshot.catalog.diagnostics)).toHaveLength(0);

      const decoded = yield* readLocalSourceArtifact({
        context,
        sourceId: "src_test",
      });

      expect(decoded?.snapshot.import.adapterKey).toBe("openapi");
      expect(decoded?.sourceId).toBe("src_test");
      expect((Object.values(decoded?.snapshot.catalog.documents ?? {})[0] as { native?: Array<{ value?: unknown }> })?.native?.[0]?.value).toBe('{"openapi":"3.1.0"}');
      expect((Object.values(decoded?.snapshot.catalog.documents ?? {})[0] as { provenance?: unknown }).provenance).toBeUndefined();
    }).pipe(Effect.provide(NodeFileSystem.layer)),
  );

  it.effect("preserves GraphQL execution metadata across a write/read round-trip", () =>
    Effect.gen(function* () {
      const context = makeContext();
      const artifact = makeGraphqlArtifact();

      yield* writeLocalSourceArtifact({
        context,
        sourceId: artifact.sourceId,
        artifact,
      });

      const decoded = yield* readLocalSourceArtifact({
        context,
        sourceId: artifact.sourceId,
      });

      const executable = Object.values(decoded?.snapshot.catalog.executables ?? {})[0];
      expect(executable?.protocol).toBe("graphql");
      expect(executable?.protocol === "graphql" ? executable.toolKind : null).toBe("field");
      expect(executable?.protocol === "graphql" ? executable.operationName : null).toBe("ViewerQuery");
      expect(executable?.protocol === "graphql" ? executable.operationDocument : null).toBe(
        "query ViewerQuery { viewer { login } }",
      );
    }).pipe(Effect.provide(NodeFileSystem.layer)),
  );

  it.effect("reads legacy gz artifacts and removes both formats", () =>
    Effect.gen(function* () {
      const context = makeContext();
      const artifact = makeArtifact();
      const directory = join(context.artifactsDirectory, "sources");
      const legacyPath = join(directory, "src_test.json.gz");

      mkdirSync(directory, { recursive: true });
      writeFileSync(legacyPath, gzipSync(JSON.stringify(artifact)));

      const decoded = yield* readLocalSourceArtifact({
        context,
        sourceId: "src_test",
      });
      expect(decoded?.catalogId).toBe(artifact.catalogId);

      yield* removeLocalSourceArtifact({
        context,
        sourceId: "src_test",
      });

      expect(existsSync(join(directory, "src_test.json"))).toBe(false);
      expect(existsSync(legacyPath)).toBe(false);
    }).pipe(Effect.provide(NodeFileSystem.layer)),
  );
});