import { Data, Effect } from "effect";
import {
  definePluginStorageCollection,
  sha256Hex,
  type Owner,
  type PluginBlobStore,
  type PluginStorageFacade,
  type StorageFailure,
} from "@executor-js/sdk";

import type { AppDescriptor } from "../pipeline/descriptor";
import type { SyncDiagnostic } from "../source/app-source";

export class AppPublishConflictError extends Data.TaggedError("AppPublishConflictError")<{
  readonly app: string;
  readonly expectedSourceRef: string | null;
  readonly actualSourceRef: string | null;
}> {}

export const descriptorCollection = definePluginStorageCollection("apps_descriptors", {
  Type: {} as {
    readonly app: string;
    readonly sourceRef: string;
    readonly descriptorKey: string;
    readonly publishedAt: number;
    readonly toolchain: AppDescriptor["toolchain"];
  },
});

export const toolCollection = definePluginStorageCollection(
  "apps_tools",
  {
    Type: {} as {
      readonly app: string;
      readonly name: string;
      readonly sourceRef: string;
      readonly descriptorKey: string;
      readonly bundleKey: string;
      readonly description: string;
      readonly inputSchema?: unknown;
      readonly outputSchema?: unknown;
      readonly integrations: AppDescriptor["tools"][number]["integrations"];
      readonly annotations?: AppDescriptor["tools"][number]["annotations"];
      readonly tombstoned: boolean;
      readonly updatedAt: number;
    },
  },
  { indexes: ["app", "name", "tombstoned"] },
);

export const sourceCollection = definePluginStorageCollection(
  "apps_sources",
  {
    Type: {} as AppSourceRecord,
  },
  { indexes: ["kind", "app"] },
);

export type AppSourceKind = "git" | "local-directory";

export type AppSourceConfig =
  | {
      readonly kind: "git";
      readonly url: string;
      readonly ref?: string;
      readonly tokenProvider?: string;
      readonly tokenItemId?: string;
    }
  | {
      readonly kind: "local-directory";
      readonly path: string;
    };

export interface AppSourceRecord {
  readonly slug: string;
  readonly app: string;
  readonly kind: AppSourceKind;
  readonly config: AppSourceConfig;
  readonly sourceRef?: string;
  readonly description?: string;
  readonly status:
    | { readonly type: "pending" }
    | { readonly type: "published"; readonly at: number; readonly tools: readonly string[] }
    | { readonly type: "up-to-date"; readonly at: number; readonly tools: readonly string[] }
    | { readonly type: "failed"; readonly at: number; readonly errors: readonly SyncDiagnostic[] };
  readonly updatedAt: number;
}

export interface AppsStore {
  readonly putBlob: (body: string, owner: Owner) => Effect.Effect<string, StorageFailure>;
  readonly getBlob: (key: string) => Effect.Effect<string | null, StorageFailure>;
  readonly getDescriptorRecord: (app: string) => Effect.Effect<
    {
      readonly sourceRef: string;
      readonly descriptorKey: string;
    } | null,
    StorageFailure
  >;
  readonly putPublished: (
    descriptor: AppDescriptor,
    descriptorKey: string,
    owner: Owner,
    expectedSourceRef: string | null,
  ) => Effect.Effect<void, StorageFailure | AppPublishConflictError>;
  readonly listActiveTools: () => Effect.Effect<
    readonly AppDescriptor["tools"][number][],
    StorageFailure
  >;
  readonly getTool: (name: string) => Effect.Effect<
    {
      readonly app: string;
      readonly name: string;
      readonly bundleKey: string;
      readonly description: string;
      readonly inputSchema?: unknown;
      readonly outputSchema?: unknown;
      readonly integrations: AppDescriptor["tools"][number]["integrations"];
      readonly annotations?: AppDescriptor["tools"][number]["annotations"];
    } | null,
    StorageFailure
  >;
  readonly putSource: (
    record: AppSourceRecord,
    owner: Owner,
  ) => Effect.Effect<void, StorageFailure>;
  readonly listSources: () => Effect.Effect<readonly AppSourceRecord[], StorageFailure>;
  readonly getSource: (slug: string) => Effect.Effect<AppSourceRecord | null, StorageFailure>;
  readonly removeSource: (slug: string, owner: Owner) => Effect.Effect<void, StorageFailure>;
}

interface PutManyEntry {
  readonly collection: string;
  readonly key: string;
  readonly data: unknown;
}

export const makeAppsStore = (input: {
  readonly blobs: PluginBlobStore;
  readonly pluginStorage: PluginStorageFacade;
}): AppsStore => {
  const descriptors = input.pluginStorage.collection(descriptorCollection);
  const tools = input.pluginStorage.collection(toolCollection);
  const sources = input.pluginStorage.collection(sourceCollection);
  const keyForTool = (app: string, name: string) => `${app}:${name}`;
  return {
    putBlob: (body, owner) =>
      sha256Hex(body).pipe(
        Effect.flatMap((hash) =>
          input.blobs.put(`apps/${hash}`, body, { owner }).pipe(Effect.as(`apps/${hash}`)),
        ),
      ),
    getBlob: (key) => input.blobs.get(key),
    getDescriptorRecord: (app) =>
      descriptors.get({ key: app }).pipe(
        Effect.map((entry) =>
          entry
            ? {
                sourceRef: entry.data.sourceRef,
                descriptorKey: entry.data.descriptorKey,
              }
            : null,
        ),
      ),
    putPublished: (descriptor, descriptorKey, owner, expectedSourceRef) =>
      Effect.gen(function* () {
        const current = yield* descriptors.get({ key: descriptor.app });
        const actualSourceRef = current?.data.sourceRef ?? null;
        if (actualSourceRef !== expectedSourceRef) {
          return yield* new AppPublishConflictError({
            app: descriptor.app,
            expectedSourceRef,
            actualSourceRef,
          });
        }
        const now = descriptor.publishedAt;
        const existing = yield* tools.query({ where: { app: descriptor.app } });
        const activeNames = new Set(descriptor.tools.map((tool) => tool.name));
        const entries: PutManyEntry[] = descriptor.tools.map((tool) => ({
          collection: toolCollection.name,
          key: keyForTool(descriptor.app, tool.name),
          data: {
            app: descriptor.app,
            name: tool.name,
            sourceRef: descriptor.sourceRef,
            descriptorKey,
            bundleKey: tool.bundleKey,
            description: tool.description,
            inputSchema: tool.inputSchema,
            outputSchema: tool.outputSchema,
            integrations: tool.integrations,
            annotations: tool.annotations,
            tombstoned: false,
            updatedAt: now,
          },
        }));
        for (const entry of existing) {
          if (!activeNames.has(entry.data.name) && !entry.data.tombstoned) {
            entries.push({
              collection: toolCollection.name,
              key: entry.key,
              data: { ...entry.data, tombstoned: true, updatedAt: now },
            });
          }
        }
        yield* input.pluginStorage.putMany({ owner, entries });
        yield* descriptors.put({
          owner,
          key: descriptor.app,
          data: {
            app: descriptor.app,
            sourceRef: descriptor.sourceRef,
            descriptorKey,
            publishedAt: descriptor.publishedAt,
            toolchain: descriptor.toolchain,
          },
        });
      }),
    listActiveTools: () =>
      tools.query({ where: { tombstoned: false } }).pipe(
        Effect.map((entries) =>
          entries.map((entry) => ({
            name: entry.data.name,
            sourcePath: "",
            source: { path: "", sourceHash: "" },
            bundleKey: entry.data.bundleKey,
            description: entry.data.description,
            integrations: entry.data.integrations,
            inputSchema: entry.data.inputSchema,
            outputSchema: entry.data.outputSchema,
            annotations: entry.data.annotations,
          })),
        ),
      ),
    getTool: (name) =>
      tools.query({ where: { name, tombstoned: false }, limit: 1 }).pipe(
        Effect.map((entries) => {
          const entry = entries[0];
          return entry
            ? {
                app: entry.data.app,
                name: entry.data.name,
                bundleKey: entry.data.bundleKey,
                description: entry.data.description,
                inputSchema: entry.data.inputSchema,
                outputSchema: entry.data.outputSchema,
                integrations: entry.data.integrations,
                annotations: entry.data.annotations,
              }
            : null;
        }),
      ),
    putSource: (record, owner) =>
      sources.put({ owner, key: record.slug, data: record }).pipe(Effect.asVoid),
    listSources: () =>
      sources.list().pipe(Effect.map((entries) => entries.map((entry) => entry.data))),
    getSource: (slug) =>
      sources.get({ key: slug }).pipe(Effect.map((entry) => entry?.data ?? null)),
    removeSource: (slug, owner) => sources.remove({ owner, key: slug }),
  };
};