"use client";

import { useMemo } from "react";
import { mergeCompactCardIdsWithPinnedSelected } from "../../../../lib/create/methodCardDisplayOrder";
import {
  deriveCompactCards,
  rankMethodsByScore,
  useFacetRecommendations,
  type RecommendationSection,
} from "./useFacetRecommendations";

type MethodEntry = { id: string; label: string; supportText: string };

/**
 * Applies score ranking and compact-slot rules. Expanded CardStack order stays
 * the ranked catalog (selected cards keep their place). Compact slots still
 * pin selected ids first so a pick outside the unpinned top-N remains visible
 * when the stack is collapsed.
 */
export function useMethodCardDeckOrdering(
  section: RecommendationSection,
  methods: readonly MethodEntry[],
  selectedIds: readonly string[],
) {
  const { scoresBySlug, hasAnyFacets, isReady } =
    useFacetRecommendations(section);
  const recommendationsReady = !hasAnyFacets || isReady;

  const rankedMethods = useMemo(
    () => rankMethodsByScore(methods, scoresBySlug),
    [methods, scoresBySlug],
  );

  const selectionShowcaseActive = selectedIds.length > 0;
  const displayMethods = rankedMethods;

  const { compactCardIds: baseCompactCardIds, recommendedIds } = useMemo(
    () =>
      deriveCompactCards(
        rankedMethods,
        scoresBySlug,
        hasAnyFacets,
        /* limit */ 5,
      ),
    [rankedMethods, scoresBySlug, hasAnyFacets],
  );

  const compactCardIds = useMemo(
    () =>
      mergeCompactCardIdsWithPinnedSelected(
        rankedMethods.map((m) => m.id),
        baseCompactCardIds,
        selectedIds,
        selectionShowcaseActive,
        5,
      ),
    [rankedMethods, baseCompactCardIds, selectedIds, selectionShowcaseActive],
  );

  const sampleCards = useMemo(
    () =>
      displayMethods.map((entry) => ({
        id: entry.id,
        label: entry.label,
        supportText: entry.supportText,
        recommended: recommendedIds.has(entry.id),
      })),
    [displayMethods, recommendedIds],
  );

  const methodById = useMemo(
    () => new Map(rankedMethods.map((entry) => [entry.id, entry])),
    [rankedMethods],
  );

  return {
    rankedMethods,
    displayMethods,
    compactCardIds,
    recommendedIds,
    sampleCards,
    methodById,
    recommendationsReady,
  };
}