import { Effect, Option, Predicate, Schema } from "effect";

import {
  type PluginStorageEntry,
  type StorageDeps,
  type StorageFailure,
} from "@executor-js/sdk/core";

import { OperationBinding } from "./types";

// ---------------------------------------------------------------------------
// OpenAPI plugin store (v2). The catalog row (integration.config) owns the
// auth templates plus the spec's content hash; the resolved spec text itself
// lives in the plugin blob store under `spec/<hash>` (it's multi-MB and only
// a build input). This store keeps the per-operation invocation bindings
// (method / path / params), keyed by integration slug, so `invokeTool` can map
// a tool name back to its HTTP operation without re-parsing the spec on every
// call. There are NO credential bindings, slots, or StoredSource credential
// config here — those concepts are gone in v2.
//
// Operations are spec-derived (identical for every connection on an
// integration), so they live under the org owner (the integration catalog is
// tenant-level). The plugin storage facade partitions by owner; "org" keeps a
// single shared copy per integration.
// ---------------------------------------------------------------------------

const OPERATION_COLLECTION = "operation";
const STORE_OWNER = "org" as const;
const OPERATION_KEY_VERSION = "op";

const encodeBinding = Schema.encodeSync(OperationBinding);
const decodeBinding = Schema.decodeUnknownSync(OperationBinding);
const decodeBindingJson = Schema.decodeUnknownSync(Schema.fromJsonString(OperationBinding));

const toJsonRecord = (value: unknown): Record<string, unknown> => value as Record<string, unknown>;

const OperationStorage = Schema.Struct({
  integration: Schema.String,
  toolName: Schema.String,
  binding: Schema.Unknown,
});
const decodeOperationStorage = Schema.decodeUnknownOption(OperationStorage);

export interface StoredOperation {
  /** The integration slug this operation belongs to. */
  readonly integration: string;
  /** The tool name (the `<tool>` address segment) this operation backs. */
  readonly toolName: string;
  readonly binding: OperationBinding;
}

const rowToOperation = (row: PluginStorageEntry): StoredOperation | null => {
  const decoded = decodeOperationStorage(row.data);
  if (Option.isNone(decoded)) return null;
  const operation = decoded.value;
  return {
    integration: operation.integration,
    toolName: operation.toolName,
    binding: decodeBinding(
      typeof operation.binding === "string"
        ? decodeBindingJson(operation.binding)
        : operation.binding,
    ),
  };
};

const stableKeyHash = (value: string): string => {
  let hash = 0xcbf29ce484222325n;
  const prime = 0x100000001b3n;
  const mask = 0xffffffffffffffffn;
  for (let index = 0; index < value.length; index += 1) {
    hash ^= BigInt(value.charCodeAt(index));
    hash = (hash * prime) & mask;
  }
  return hash.toString(36).padStart(13, "0");
};

const operationKey = (integration: string, toolName: string): string =>
  `${OPERATION_KEY_VERSION}.${stableKeyHash(integration)}.${stableKeyHash(toolName)}`;

const legacyOperationKey = (integration: string, toolName: string): string =>
  `${integration}.${toolName}`;

/** Blob key for a spec's content hash. Content-addressed so re-puts are
 *  idempotent and identical specs share one blob per partition. */
export const specBlobKey = (specHash: string): string => `spec/${specHash}`;

export interface OpenapiStore {
  /** Replace all stored operations for an integration. */
  readonly putOperations: (
    integration: string,
    operations: readonly StoredOperation[],
  ) => Effect.Effect<void, StorageFailure>;
  /** Look up one operation by integration + tool name. */
  readonly getOperation: (
    integration: string,
    toolName: string,
  ) => Effect.Effect<StoredOperation | null, StorageFailure>;
  /** List every stored operation for an integration. */
  readonly listOperations: (
    integration: string,
  ) => Effect.Effect<readonly StoredOperation[], StorageFailure>;
  /** Drop all stored operations for an integration. */
  readonly removeOperations: (integration: string) => Effect.Effect<void, StorageFailure>;
  /** Persist resolved spec text under its content hash. Org-owned and
   *  content-addressed; never removed on integration removal because another
   *  integration in the tenant may share the hash. */
  readonly putSpec: (specHash: string, specText: string) => Effect.Effect<void, StorageFailure>;
  /** Load spec text by content hash; null when no blob exists. */
  readonly getSpec: (specHash: string) => Effect.Effect<string | null, StorageFailure>;
}

export const makeDefaultOpenapiStore = ({ pluginStorage, blobs }: StorageDeps): OpenapiStore => {
  const operationData = (operation: StoredOperation) => ({
    integration: operation.integration,
    toolName: operation.toolName,
    binding: toJsonRecord(encodeBinding(operation.binding)),
  });

  const listRows = (integration: string) =>
    pluginStorage
      .list({ collection: OPERATION_COLLECTION })
      .pipe(
        Effect.map((rows: readonly PluginStorageEntry[]) =>
          rows.filter((row) => rowToOperation(row)?.integration === integration),
        ),
      );

  const removeOperations = (integration: string) =>
    Effect.gen(function* () {
      const rows = yield* listRows(integration);
      yield* pluginStorage.removeMany({
        owner: STORE_OWNER,
        entries: rows.map((row) => ({ collection: OPERATION_COLLECTION, key: row.key })),
      });
    });

  return {
    putOperations: (integration, operations) =>
      Effect.gen(function* () {
        yield* removeOperations(integration);
        yield* pluginStorage.putMany({
          owner: STORE_OWNER,
          entries: operations.map((operation) => ({
            collection: OPERATION_COLLECTION,
            key: operationKey(integration, operation.toolName),
            data: operationData(operation),
          })),
        });
      }),

    getOperation: (integration, toolName) =>
      Effect.gen(function* () {
        const row = yield* pluginStorage.get({
          collection: OPERATION_COLLECTION,
          key: operationKey(integration, toolName),
        });
        if (row) return rowToOperation(row);
        const legacyKey = legacyOperationKey(integration, toolName);
        if (legacyKey.length > 255) return null;
        const legacyRow = yield* pluginStorage.get({
          collection: OPERATION_COLLECTION,
          key: legacyKey,
        });
        return legacyRow ? rowToOperation(legacyRow) : null;
      }),

    listOperations: (integration) =>
      listRows(integration).pipe(
        Effect.map((rows) => rows.map(rowToOperation).filter(Predicate.isNotNull)),
      ),

    removeOperations,

    putSpec: (specHash, specText) =>
      blobs.put(specBlobKey(specHash), specText, { owner: STORE_OWNER }),

    getSpec: (specHash) => blobs.get(specBlobKey(specHash)),
  };
};