/**
 * Cross-plugin API: globalThis.__prismFacet
 *
 * PrismFacet is the registration mechanism (routers, rules, the
 * before_prompt_build hook that resolves them); other plugins (notably
 * ClawPrompts) supply the actual content by calling into this API at
 * their own register() time.
 *
 * Installation idempotence: safe to call install() multiple times — the
 * function attaches the same set of methods to globalThis.__prismFacet
 * if not already present. Plugin reload doesn't break consumers.
 *
 * If a consumer plugin (ClawPrompts) loads BEFORE PrismFacet, the
 * `globalThis.__prismFacet` slot will be undefined at the consumer's
 * register() time. To make load-order independence work, this module
 * pre-creates the slot at module-import time too — consumers can call
 * .addRouter / .addRule even if PrismFacet's register() hasn't run yet
 * (the registration still lands in the shared maps).
 */
import { addExternalRouter, type RouterContext } from "./router-loader.js";
import { addExternalRule } from "./rule-store.js";

const _G = globalThis as Record<string, unknown>;

export interface PrismFacetCrossPluginApi {
  /**
   * Register a router programmatically.
   * @param name router name (matches the "router:" prefix of rule keys)
   * @param resolve function returning a key string for the given context
   *                (or empty/null to skip this router for this context)
   */
  addRouter(
    name: string,
    resolve: (ctx: RouterContext) => string | Promise<string>,
  ): void;

  /**
   * Register a rule programmatically (in-memory; persistent rules.json
   * entries set by the prompt-rules tool take precedence on conflict).
   * @param routerName router this rule binds to
   * @param key value the router must resolve to for this rule to fire
   * @param prompt either { file: "/abs/path.md" } or { text: "..." }
   */
  addRule(
    routerName: string,
    key: string,
    prompt: { file?: string; text?: string },
  ): void;
}

/** Idempotent install. Called from PrismFacet's register(). Also runs
 * at module-import time below so that consumer plugins loading before
 * PrismFacet still find a usable API. */
export function installCrossPluginApi(): PrismFacetCrossPluginApi {
  const existing = _G["__prismFacet"] as PrismFacetCrossPluginApi | undefined;
  if (existing && typeof existing.addRouter === "function") return existing;

  const api: PrismFacetCrossPluginApi = {
    addRouter(name, resolve) {
      addExternalRouter(name, resolve);
    },
    addRule(routerName, key, prompt) {
      // Phase 1: only file-based prompts are wired through the existing
      // injector. `text` inline prompts will need a tmpfile-or-store
      // backend; surfaced as a TODO so an early caller failing loudly
      // beats silently dropping the prompt.
      if (!prompt.file) {
        throw new Error(
          "__prismFacet.addRule: only { file: '/abs/path.md' } is supported today; " +
          "inline { text } pending injector update",
        );
      }
      addExternalRule(routerName, key, prompt.file);
    },
  };
  _G["__prismFacet"] = api;
  return api;
}

// Eager install on module load so a consumer plugin importing into the
// same gateway process can register even if it runs before PrismFacet's
// register() does.
installCrossPluginApi();