import { useMemo } from 'react';

import { SUBCATEGORY_ORDER, SubcategoryId, ToolCategoryId, ToolRegistryEntry } from '@app/data/toolsTaxonomy';
import { useTranslation } from 'react-i18next';
import { ToolId } from "@app/types/toolId";

type SubcategoryIdMap = {
  [subcategoryId in SubcategoryId]: Array<{ id: ToolId; tool: ToolRegistryEntry }>;
}

type GroupedTools = {
  [categoryId in ToolCategoryId]: SubcategoryIdMap;
};

export interface SubcategoryGroup {
  subcategoryId: SubcategoryId;
  tools: {
    id: ToolId;
    tool: ToolRegistryEntry;
  }[];
};

export type ToolSectionKey = 'quick' | 'all';

export interface ToolSection {
  key: ToolSectionKey;
  title: string;
  subcategories: SubcategoryGroup[];
};

export function useToolSections(
  filteredTools: Array<{ item: [ToolId, ToolRegistryEntry]; matchedText?: string }>,
  searchQuery?: string
) {
  const { t } = useTranslation();

  const groupedTools = useMemo(() => {
    if (!filteredTools || !Array.isArray(filteredTools)) {
      return {} as GroupedTools;
    }

    const grouped = {} as GroupedTools;
    filteredTools.forEach(({ item: [id, tool] }) => {
      const categoryId = tool.categoryId;
      const subcategoryId = tool.subcategoryId;
      if (!grouped[categoryId]) grouped[categoryId] = {} as SubcategoryIdMap;
      if (!grouped[categoryId][subcategoryId]) grouped[categoryId][subcategoryId] = [];
      grouped[categoryId][subcategoryId].push({ id, tool });
    });
    return grouped;
  }, [filteredTools]);

  const sections: ToolSection[] = useMemo(() => {
    const getOrderIndex = (id: SubcategoryId) => {
      const idx = SUBCATEGORY_ORDER.indexOf(id);
      return idx === -1 ? Number.MAX_SAFE_INTEGER : idx;
    };

    const quick = {} as SubcategoryIdMap;
    const all = {} as SubcategoryIdMap;

    Object.entries(groupedTools).forEach(([c, subs]) => {
      const categoryId = c as ToolCategoryId;

      Object.entries(subs).forEach(([s, tools]) => {
        const subcategoryId = s as SubcategoryId;
        // Build the 'all' collection without duplicating recommended tools
        // Recommended tools are shown in the Quick section only
        if (categoryId !== ToolCategoryId.RECOMMENDED_TOOLS) {
          if (!all[subcategoryId]) all[subcategoryId] = [];
          all[subcategoryId].push(...tools);
        }
      });

      if (categoryId === ToolCategoryId.RECOMMENDED_TOOLS) {
        Object.entries(subs).forEach(([s, tools]) => {
          const subcategoryId = s as SubcategoryId;
          if (!quick[subcategoryId]) quick[subcategoryId] = [];
          // Only include ready tools (have a component or external link) in Quick Access
          // Special case: read and multiTool are navigational tools that don't need components
          const readyTools = tools.filter(({ tool, id }) =>
            tool.component !== null || !!tool.link || id === 'read' || id === 'multiTool'
          );
          quick[subcategoryId].push(...readyTools);
        });
      }
    });

    const sortSubs = (obj: SubcategoryIdMap) =>
      Object.entries(obj)
        .sort(([a], [b]) => {
          const aId = a as SubcategoryId;
          const bId = b as SubcategoryId;
          const ai = getOrderIndex(aId);
          const bi = getOrderIndex(bId);
          if (ai !== bi) return ai - bi;
          return aId.localeCompare(bId);
        })
        .map(([subcategoryId, tools]) => ({ subcategoryId, tools } as SubcategoryGroup));

    const built: ToolSection[] = [
      { key: 'quick', title: t('toolPicker.quickAccess', 'QUICK ACCESS'), subcategories: sortSubs(quick) },
      { key: 'all', title: t('toolPicker.allTools', 'ALL TOOLS'), subcategories: sortSubs(all) }
    ];

    return built.filter(section => section.subcategories.some(sc => sc.tools.length > 0));
  }, [groupedTools]);

  const searchGroups: SubcategoryGroup[] = useMemo(() => {
    if (!filteredTools || !Array.isArray(filteredTools)) {
      return [];
    }

    const subMap = {} as SubcategoryIdMap;
    const seen = new Set<ToolId>();
    filteredTools.forEach(({ item: [id, tool] }) => {
      const toolId = id as ToolId;
      if (seen.has(toolId)) return;
      seen.add(toolId);
      const sub = tool.subcategoryId;
      if (!subMap[sub]) subMap[sub] = [];
      subMap[sub].push({ id: toolId as ToolId, tool });
    });
    const entries = Object.entries(subMap);

    // If a search query is present, always order subcategories by first occurrence in
    // the ranked filteredTools list so the top-ranked tools' subcategory appears first.
    if (searchQuery && searchQuery.trim()) {
      const order: SubcategoryId[] = [];
      filteredTools.forEach(({ item: [_, tool] }) => {
        const sc = tool.subcategoryId;
        if (!order.includes(sc)) order.push(sc);
      });
      return entries
        .sort(([a], [b]) => {
          const ai = order.indexOf(a as SubcategoryId);
          const bi = order.indexOf(b as SubcategoryId);
          if (ai !== bi) return ai - bi;
          return (a as SubcategoryId).localeCompare(b as SubcategoryId);
        })
        .map(([subcategoryId, tools]) => ({ subcategoryId, tools } as SubcategoryGroup));
    }

    // No search: alphabetical subcategory ordering
    return entries
      .sort(([a], [b]) => a.localeCompare(b))
      .map(([subcategoryId, tools]) => ({ subcategoryId, tools } as SubcategoryGroup));
  }, [filteredTools, searchQuery]);

  return { sections, searchGroups };
}