import { Effect } from "effect";

import {
  definePluginStorageCollection,
  type PluginStorageFacade,
  type StorageFailure,
} from "@executor-js/sdk";

import type { AppDescriptor } from "../pipeline/descriptor";

// ---------------------------------------------------------------------------
// AppsStore — descriptor + snapshot pointer persistence for the apps plugin,
// over the host-owned `pluginStorage` (collections) + `blobs` (content-addressed
// bundles / skill bodies). Executor plugins do not contribute DB tables, so the
// versioned descriptor is a JSON document in a plugin-storage collection keyed
// by scope, and the compiled bundles + skill bodies are blobs.
//
// One published descriptor per scope (the current published pointer). History
// is the ArtifactStore's git log; the runtime only runs the published snapshot.
// ---------------------------------------------------------------------------

/** The published descriptor document, keyed by scope. */
export const descriptorCollection = definePluginStorageCollection("published_descriptor", {
  Type: {} as {
    readonly scope: string;
    readonly snapshotId: string;
    readonly descriptor: AppDescriptor;
    readonly publishedAt: number;
  },
});

/** The explicit connection-name -> scope mapping (Fix 9), keyed by the
 *  (normalized) connection name. */
export const scopeConnectionCollection = definePluginStorageCollection("apps_scope_connection", {
  Type: {} as {
    readonly connectionName: string;
    readonly scope: string;
  },
});

export interface AppsStore {
  /** Persist the published descriptor for a scope (the published pointer). */
  readonly putDescriptor: (
    owner: "org" | "user",
    descriptor: AppDescriptor,
  ) => Effect.Effect<void, StorageFailure>;
  /** Read the current published descriptor for a scope, or null. */
  readonly getDescriptor: (scope: string) => Effect.Effect<AppDescriptor | null, StorageFailure>;
  /** Store a compiled bundle / skill body blob (content-addressed). */
  readonly putBlob: (key: string, value: string) => Effect.Effect<void, StorageFailure>;
  /** Read a blob by key. */
  readonly getBlob: (key: string) => Effect.Effect<string | null, StorageFailure>;
  /**
   * Record the explicit connection-name -> scope mapping (Fix 9). The executor
   * normalizes connection names to identifiers, so distinct scopes ("my-scope"
   * vs "my_scope") can normalize to the SAME name if we tried to parse the scope
   * back out. Storing the mapping at connect time makes the lookup exact and
   * collision-free; `resolveTools`/`invokeTool` consult it instead of reversing
   * the name. Idempotent (upsert).
   */
  readonly putScopeForConnection: (
    connectionName: string,
    scope: string,
  ) => Effect.Effect<void, StorageFailure>;
  /** The scope a connection name maps to, or null if none was recorded. */
  readonly getScopeForConnection: (
    connectionName: string,
  ) => Effect.Effect<string | null, StorageFailure>;
}

export interface AppsStoreDeps {
  readonly pluginStorage: PluginStorageFacade;
  readonly blobs: {
    readonly get: (key: string) => Effect.Effect<string | null, StorageFailure>;
    readonly put: (
      key: string,
      value: string,
      options: { readonly owner: "org" | "user" },
    ) => Effect.Effect<void, StorageFailure>;
  };
}

export const makeAppsStore = (deps: AppsStoreDeps): AppsStore => {
  const descriptors = deps.pluginStorage.collection(descriptorCollection);
  const scopeConnections = deps.pluginStorage.collection(scopeConnectionCollection);
  return {
    putScopeForConnection: (connectionName, scope) =>
      scopeConnections
        .put({ owner: "org", key: connectionName, data: { connectionName, scope } })
        .pipe(Effect.asVoid),
    getScopeForConnection: (connectionName) =>
      scopeConnections
        .get({ key: connectionName })
        .pipe(Effect.map((entry) => entry?.data.scope ?? null)),
    putDescriptor: (owner, descriptor) =>
      descriptors
        .put({
          owner,
          key: descriptor.scope,
          data: {
            scope: descriptor.scope,
            snapshotId: descriptor.snapshotId,
            descriptor,
            publishedAt: Date.now(),
          },
        })
        .pipe(Effect.asVoid),
    getDescriptor: (scope) =>
      descriptors.get({ key: scope }).pipe(Effect.map((entry) => entry?.data.descriptor ?? null)),
    putBlob: (key, value) => deps.blobs.put(key, value, { owner: "org" }),
    getBlob: (key) => deps.blobs.get(key),
  };
};