// ---------------------------------------------------------------------------
// integrations.sh catalog client — the connect dialog's long-tail search.
//
// The curated presets stay the featured list; this module reaches the rest of
// the public registry. Search stays server-side (`/api/search`, edge-cached)
// so the client never downloads the full multi-thousand-entry catalog, and the
// per-domain surface document is fetched only when the user picks a result,
// to resolve the URL the add form needs (MCP endpoint, OpenAPI spec URL, or
// GraphQL endpoint).
// ---------------------------------------------------------------------------

import { useEffect, useRef, useState } from "react";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import { getDomain } from "tldts";
import type { IntegrationPlugin } from "@executor-js/sdk/client";

export const INTEGRATIONS_SH_ORIGIN = "https://integrations.sh";

/** Registry kinds executor can connect (the registry also lists CLIs). Kind
 *  strings deliberately match the plugin keys. */
export const CONNECTABLE_KINDS = ["mcp", "openapi", "graphql"] as const;
export type CatalogKind = (typeof CONNECTABLE_KINDS)[number];

const isConnectableKind = (kind: string): kind is CatalogKind =>
  (CONNECTABLE_KINDS as readonly string[]).includes(kind);

export interface CatalogSearchEntry {
  readonly domain: string;
  readonly description: string;
  readonly kinds: readonly CatalogKind[];
}

export const catalogLogoUrl = (domain: string, size: number): string =>
  `${INTEGRATIONS_SH_ORIGIN}/logo/${domain}?sz=${size * 2}`;

class CatalogRequestError extends Data.TaggedError("CatalogRequestError")<{
  readonly message: string;
}> {}

const fetchCatalogJson = (url: URL): Effect.Effect<unknown, CatalogRequestError> =>
  Effect.gen(function* () {
    const response = yield* Effect.tryPromise({
      try: () => fetch(url),
      catch: () => new CatalogRequestError({ message: `Failed to reach ${url.host}.` }),
    });
    if (!response.ok) {
      return yield* new CatalogRequestError({
        message: `Unexpected status ${response.status} from ${url.host}.`,
      });
    }
    return yield* Effect.tryPromise({
      try: () => response.json() as Promise<unknown>,
      catch: () => new CatalogRequestError({ message: "Response was not valid JSON." }),
    });
  });

// ---------------------------------------------------------------------------
// Search
// ---------------------------------------------------------------------------

const SearchResponse = Schema.Struct({
  results: Schema.Array(
    Schema.Struct({
      domain: Schema.String,
      description: Schema.String,
      kinds: Schema.Array(Schema.String),
    }),
  ),
});
const decodeSearchResponse = Schema.decodeUnknownOption(SearchResponse);

export const parseCatalogSearch = (payload: unknown): readonly CatalogSearchEntry[] =>
  Option.match(decodeSearchResponse(payload), {
    onNone: () => [],
    onSome: ({ results }) =>
      results
        .map((entry) => ({
          domain: entry.domain,
          description: entry.description,
          kinds: entry.kinds.filter(isConnectableKind),
        }))
        .filter((entry) => entry.kinds.length > 0),
  });

export const searchCatalog = (
  query: string,
  limit = 10,
): Effect.Effect<readonly CatalogSearchEntry[], CatalogRequestError> => {
  const url = new URL("/api/search", INTEGRATIONS_SH_ORIGIN);
  url.searchParams.set("q", query);
  url.searchParams.set("limit", String(limit));
  return Effect.map(fetchCatalogJson(url), parseCatalogSearch);
};

// ---------------------------------------------------------------------------
// Connect-target resolution (per-domain surface document)
// ---------------------------------------------------------------------------

const SurfaceDocument = Schema.Struct({
  surfaces: Schema.Array(
    Schema.Struct({
      type: Schema.String,
      slug: Schema.optional(Schema.String),
      url: Schema.optional(Schema.String),
      spec: Schema.optional(Schema.String),
    }),
  ),
});
const decodeSurfaceDocument = Schema.decodeUnknownOption(SurfaceDocument);

type SurfaceRecord = (typeof SurfaceDocument.Type)["surfaces"][number];

export interface CatalogConnectTarget {
  readonly kind: CatalogKind;
  /** What the add form's URL field expects: the MCP endpoint, the OpenAPI
   *  spec URL, or the GraphQL endpoint. */
  readonly url: string;
  /** The registry's stable slug for the surface — seeds the namespace field. */
  readonly slug?: string;
}

// The surface document's `type` vocabulary: OpenAPI surfaces are `http` (spec
// present ⇒ machine-readable), and `spec` on a GraphQL surface is an SDL
// pointer or the literal "introspection" — the endpoint is what executor adds.
const connectUrlOf = (surface: SurfaceRecord, kind: CatalogKind): string | undefined =>
  kind === "mcp" && surface.type === "mcp"
    ? surface.url
    : kind === "openapi" && surface.type === "http"
      ? surface.spec
      : kind === "graphql" && surface.type === "graphql"
        ? surface.url
        : undefined;

export const pickConnectTarget = (
  payload: unknown,
  kind: CatalogKind,
): CatalogConnectTarget | undefined =>
  Option.match(decodeSurfaceDocument(payload), {
    onNone: () => undefined,
    onSome: ({ surfaces }) => {
      for (const surface of surfaces) {
        const url = connectUrlOf(surface, kind);
        if (url) return { kind, url, ...(surface.slug ? { slug: surface.slug } : {}) };
      }
      return undefined;
    },
  });

/** The connect target for the first of `kinds` (caller's preference order)
 *  that has a usable locator in the domain's surface document. */
export const resolveConnectTarget = (
  domain: string,
  kinds: readonly CatalogKind[],
): Effect.Effect<CatalogConnectTarget | undefined, CatalogRequestError> => {
  const url = new URL(`/api/${encodeURIComponent(domain)}/surface`, INTEGRATIONS_SH_ORIGIN);
  return Effect.map(fetchCatalogJson(url), (payload) => {
    for (const kind of kinds) {
      const target = pickConnectTarget(payload, kind);
      if (target) return target;
    }
    return undefined;
  });
};

// ---------------------------------------------------------------------------
// Filtering against the curated presets
// ---------------------------------------------------------------------------

/** Domains already represented by a loaded plugin's presets, so the catalog
 *  section doesn't repeat what the preset list above it already shows. */
export const presetDomains = (plugins: readonly IntegrationPlugin[]): ReadonlySet<string> => {
  const domains = new Set<string>();
  for (const plugin of plugins) {
    for (const preset of plugin.presets ?? []) {
      for (const candidate of [preset.icon, preset.url]) {
        if (!candidate) continue;
        const logoMatch = /^https:\/\/integrations\.sh\/logo\/([^/?]+)/.exec(candidate);
        const domain = logoMatch?.[1] ?? getDomain(candidate);
        if (domain) domains.add(domain);
      }
    }
  }
  return domains;
};

/** Kinds this deployment can actually add — the plugin key vocabulary matches
 *  the catalog kind vocabulary. */
export const availableCatalogKinds = (
  plugins: readonly IntegrationPlugin[],
): readonly CatalogKind[] =>
  CONNECTABLE_KINDS.filter((kind) => plugins.some((plugin) => plugin.key === kind));

export const filterCatalogEntries = (
  entries: readonly CatalogSearchEntry[],
  opts: {
    readonly excludeDomains: ReadonlySet<string>;
    readonly availableKinds: readonly CatalogKind[];
  },
): readonly CatalogSearchEntry[] =>
  entries
    .filter((entry) => !opts.excludeDomains.has(entry.domain))
    .map((entry) => ({
      ...entry,
      kinds: entry.kinds.filter((kind) => opts.availableKinds.includes(kind)),
    }))
    .filter((entry) => entry.kinds.length > 0);

// ---------------------------------------------------------------------------
// Hook — debounced search with an in-session response cache
// ---------------------------------------------------------------------------

const SEARCH_DEBOUNCE_MS = 250;
const MIN_QUERY_LENGTH = 2;
const searchCache = new Map<string, readonly CatalogSearchEntry[]>();

export interface CatalogSearchState {
  readonly entries: readonly CatalogSearchEntry[];
  readonly loading: boolean;
}

export function useCatalogSearch(rawQuery: string): CatalogSearchState {
  const query = rawQuery.trim().toLowerCase();
  const [state, setState] = useState<CatalogSearchState>({ entries: [], loading: false });
  const generation = useRef(0);

  useEffect(() => {
    const requestId = ++generation.current;
    if (query.length < MIN_QUERY_LENGTH) {
      setState({ entries: [], loading: false });
      return;
    }
    const cached = searchCache.get(query);
    if (cached) {
      setState({ entries: cached, loading: false });
      return;
    }
    setState((previous) => ({ ...previous, loading: true }));
    const timer = setTimeout(() => {
      void Effect.runPromiseExit(searchCatalog(query)).then((exit) => {
        if (Exit.isSuccess(exit)) searchCache.set(query, exit.value);
        if (generation.current !== requestId) return;
        // Reachability is best-effort — the presets and URL detection above
        // the catalog section keep working without it.
        setState({ entries: Exit.isSuccess(exit) ? exit.value : [], loading: false });
      });
    }, SEARCH_DEBOUNCE_MS);
    return () => clearTimeout(timer);
  }, [query]);

  return state;
}