Under the Hood

// Cross-source search registry. Each searchable surface exports a SearchSource
// from its own slice; the wiring manifest in ./register-all pulls those values
// and registers them here — composition above the slices.
export type SearchResult = {
  kind: string;
  id: string;
  label: string;
  sub?: string;
  href: string;
  iconText?: string;
  iconTone?: string;
  typeId?: number;
  originKind?: string;
  matchIndices?: number[];
  onSelect?: (router: AppRouterInstance) => void;
  disabled?: boolean;
};

export type SearchContext = {
  session: Session | null;
  isAdmin: boolean;
  recents: SearchResult[];
  signal?: AbortSignal;
};

export type SearchSource = {
  name: string;
  search: (query: string, ctx: SearchContext) => Promise<SearchResult[]>;
  limit?: number;
  showOnEmpty?: boolean;
};

export function registerLazySearchSource(meta: LazySearchSource): void {
  let loadPromise: Promise<SearchSource> | null = null;
  registerSearchSource({
    name: meta.name,
    limit: meta.limit,
    showOnEmpty: meta.showOnEmpty,
    async search(query, ctx) {
      if (!loadPromise) {
        loadPromise = meta.load().catch((err) => {
          loadPromise = null;
          throw err;
        });
      }
      const resolved = await loadPromise;
      if (ctx.signal?.aborted) throw new DOMException('Aborted', 'AbortError');
      return resolved.search(query, ctx);
    },
  });
}

export async function searchAll(query: string, ctx: SearchContext): Promise<SearchSection[]> {
  const trimmed = query.trim();
  const isEmpty = trimmed.length === 0;
  const settled = await Promise.allSettled(
    sources.map(async (s) => {
      if (isEmpty && !s.showOnEmpty) return { name: s.name, results: [] };
      const raw = await s.search(trimmed, ctx);
      return { name: s.name, results: raw.slice(0, s.limit ?? 5) };
    }),
  );
  if (ctx.signal?.aborted) throw new DOMException('Aborted', 'AbortError');
  return settled.flatMap((r) => r.status === 'fulfilled' && r.value.results.length ? [r.value] : []);
}

// Search-source wiring manifest. Lives in the unclassified src/search/ layer
// ABOVE the data and feature slices. Registration order = dropdown section order.
import { registerSearchSource, registerLazySearchSource } from '@/search';
import { recentsSearchSource } from '@/features/search-recents/search';
import { sitesSearchSource } from '@/features/wormhole-sites/search';
import { blueprintsSearchSource } from '@/features/industry-planner/search';
import { toolsSearchSource } from '@/data/tools/search';
import { commandsSearchSource } from '@/data/commands/search';

registerSearchSource(recentsSearchSource);
registerSearchSource(sitesSearchSource);
registerLazySearchSource(blueprintsSearchSource);
registerSearchSource(toolsSearchSource);
registerSearchSource(commandsSearchSource);

// Side-effect import: registers every search source on the CLIENT instance
// of the registry. Lives here because Next.js's server + client module graphs
// are separate, and the search dropdown renders client-side.
import '@/search/register-all';

export function AppHeaderShell({ siteIndex, serverStatus }: Props) {
  const [searchActive, setSearchActive] = useState(false);
  return (
    <>
      <GlobalSearch
        active={searchActive}
        onActiveChange={setSearchActive}
        siteIndex={siteIndex}
      />
      {/* other header slots */}
    </>
  );
}

export function GlobalSearch({ active, onActiveChange, siteIndex }: Props) {
  const { session, isAdmin } = useAuth();
  const router = useRouter();
  const [value, setValue] = useState('');
  const [debounced, setDebounced] = useState('');
  const [sections, setSections] = useState<SearchSection[]>([]);
  const [recents, setRecents] = useState<SearchResult[]>([]);

  useEffect(() => setSiteSearchIndex(siteIndex), [siteIndex]);
  useEffect(() => { setRecents(readRecents()); }, []);
  useEffect(() => {
    const id = setTimeout(() => setDebounced(value), DEBOUNCE_MS);
    return () => clearTimeout(id);
  }, [value]);

  useEffect(() => {
    const controller = new AbortController();
    searchAll(debounced, { session, isAdmin, recents, signal: controller.signal })
      .then((next) => {
        if (controller.signal.aborted) return;
        setSections(next);
        setActiveIndex(0);
      })
      .catch((err: unknown) => {
        if (err instanceof DOMException && err.name === 'AbortError') return;
        throw err;
      });
    return () => controller.abort();
  }, [debounced, session, isAdmin, recents]);

  function fireResult(result: SearchResult) {
    if (result.disabled) return;
    pushRecent(result);
    setRecents(readRecents());
    setValue('');
    onActiveChange(false);
    if (result.onSelect) return result.onSelect(router);
    router.push(result.href);
  }

  return sections.map((section) =>
    section.results.map((row) =>
      row.typeId ? <TypeIcon typeId={row.typeId} size={22} /> : <span>{row.iconText}</span>,
    ),
  );
}

// Project-shaped wrapper around fuzzysort. Every search source uses this helper
// for both ranking and per-character match highlighting.
import fuzzysort from 'fuzzysort';

export type FuzzyMatch = {
  score: number;
  matchIndices: number[];
};

export function fuzzyMatch(query: string, target: string): FuzzyMatch | null {
  if (query.length === 0) return { score: 0, matchIndices: [] };
  const result = fuzzysort.single(query, target);
  if (result === null) return null;
  return {
    score: result.score,
    matchIndices: [...result.indexes],
  };
}

// search.ts — cheap descriptor registered by the manifest.
export const blueprintsSearchSource: LazySearchSource = {
  name: 'Blueprints',
  limit: 6,
  load: () => import('./blueprints-source').then((m) => m.blueprintsSource),
};

// blueprints-source.ts — loaded only on the first blueprint keystroke.
let indexPromise: Promise<BlueprintIndexEntry[]> | null = null;

function loadIndex(): Promise<BlueprintIndexEntry[]> {
  if (!indexPromise) {
    indexPromise = apiFetch(blueprintsEndpoint)
      .then((result) => {
        if (!result.ok) throw new Error(`blueprint index ${result.status}`);
        return result.data.blueprints;
      })
      .catch((err) => {
        indexPromise = null;
        throw err;
      });
  }
  return indexPromise;
}

export const blueprintsSource: SearchSource = {
  name: 'Blueprints',
  limit: 6,
  async search(query, ctx) {
    if (query.length === 0) return [];
    const index = await loadIndex();
    if (ctx.signal?.aborted) return [];
    return index.flatMap((entry) => {
      const match = fuzzyMatch(query, entry.name);
      return match ? [{ kind: 'blueprint', id: `blueprint:${entry.blueprintTypeId}`, label: entry.name, href: `/industry/${entry.blueprintTypeId}`, typeId: entry.productTypeId, matchIndices: match.matchIndices }] : [];
    });
  },
};

// Sites search source. Reads from a module-scoped site index that
// AppHeaderShell seeds once at mount via setSiteSearchIndex().
let SITE_INDEX: SiteSearchEntry[] = [];

export function setSiteSearchIndex(entries: SiteSearchEntry[]): void {
  SITE_INDEX = entries;
}

export const sitesSearchSource: SearchSource = {
  name: 'Sites',
  limit: 6,
  async search(query) {
    const matches: { entry: SiteSearchEntry; match: FuzzyMatch }[] = [];
    for (const entry of SITE_INDEX) {
      const match = fuzzyMatch(query, entry.name);
      if (match) matches.push({ entry, match });
    }
    matches.sort((a, b) => b.match.score - a.match.score);
    return matches.map<SearchResult>(({ entry, match }) => ({
      kind: 'site',
      id: `site:${entry.id}`,
      label: entry.name,
      sub: `${SITE_TYPE_LABEL[entry.siteType]} · ${formatIskCompact(primaryIsk(entry))}`,
      href: `/sites/${entry.id}`,
      iconText: entry.wormholeClass ?? '—',
      iconTone: iconTone(entry),
      matchIndices: match.matchIndices,
    }));
  },
};

// Commands search source. Rows with side effects use onSelect(router) instead
// of href-driven navigation.
const COMMANDS: CommandEntry[] = [
  { id: 'cmd:open-changelog', label: 'Open changelog', href: '/changelog', iconText: '→', visible: () => true },
  { id: 'cmd:open-admin', label: 'Open admin', href: '/admin', iconText: '→', visible: (ctx) => ctx.isAdmin },
  {
    id: 'cmd:logout',
    label: 'Log out',
    href: '/',
    iconText: '⏏',
    onSelect: () => {
      void apiFetch(signOutEndpoint, { body: {} }).then((result) => {
        if (result.ok) window.location.href = '/';
      });
    },
    visible: (ctx) => ctx.session !== null,
  },
  {
    id: 'cmd:login',
    label: 'Log in with EVE',
    href: '/',
    iconText: '↪',
    onSelect: () => {
      void apiFetch(signInOauth2Endpoint, { body: { providerId: 'eve', callbackURL: '/' } })
        .then((result) => {
          if (result.ok && result.data.url) window.location.href = result.data.url;
        });
    },
    visible: (ctx) => ctx.session === null,
  },
];

export const commandsSearchSource: SearchSource = {
  name: 'Commands',
  limit: 5,
  async search(query, ctx) {
    return COMMANDS.filter((c) => c.visible(ctx)).flatMap((cmd) => {
      const match = fuzzyMatch(query, cmd.label);
      return match ? [{ kind: 'command', id: cmd.id, label: cmd.label, href: cmd.href, iconText: cmd.iconText, onSelect: cmd.onSelect, matchIndices: match.matchIndices }] : [];
    });
  },
};

// Recent search source. The ONLY source that opts into showOnEmpty: true.
export const recentsSearchSource: SearchSource = {
  name: 'Recent',
  limit: 5,
  showOnEmpty: true,
  async search(query, ctx) {
    if (query.length === 0) {
      return ctx.recents.map<SearchResult>((r) => ({ ...r, matchIndices: [] }));
    }
    const matched = ctx.recents
      .map((r) => ({ row: r, match: fuzzyMatch(query, r.label) }))
      .filter((entry): entry is { row: SearchResult; match: NonNullable<typeof entry.match> } => entry.match !== null);
    matched.sort((a, b) => b.match.score - a.match.score);
    return matched.map<SearchResult>(({ row, match }) => ({ ...row, matchIndices: match.matchIndices }));
  },
};

// What gets persisted is a thin subset of SearchResult. typeId is kept so a
// recent row that maps to an EVE type still renders its icon.
type StoredRecent = Pick<
  SearchResult,
  'kind' | 'id' | 'label' | 'sub' | 'href' | 'iconText' | 'iconTone' | 'typeId'
>;

const storedRecentSchema = z.object({
  kind: z.string(),
  id: z.string(),
  label: z.string(),
  sub: z.string().optional(),
  href: z.string(),
  iconText: z.string().optional(),
  iconTone: z.string().optional(),
  typeId: z.number().optional(),
});

const ITEM_KINDS = new Set(['blueprint']);
function rendersIcon(r: StoredRecent): boolean {
  return !ITEM_KINDS.has(r.kind) || r.typeId != null;
}

export function pushRecent(result: SearchResult): void {
  if (result.kind === 'recent') return;
  if (result.disabled) return;
  const current = readStored();
  const without = current.filter((r) => r.id !== result.id);
  const next: StoredRecent[] = [{ kind: result.kind, id: result.id, label: result.label, href: result.href, typeId: result.typeId }, ...without].slice(0, MAX_RECENTS);
  store.setItem(STORAGE_KEY, JSON.stringify(next));
}

function readStored(): StoredRecent[] {
  const parsed = JSON.parse(raw);
  if (!Array.isArray(parsed)) return [];
  return parsed.filter(isStoredRecent).filter(rendersIcon);
}

function isStoredRecent(value: unknown): value is StoredRecent {
  return storedRecentSchema.safeParse(value).success;
}