frontend/services/comparisonService.ts

import type { Dataset, DataItem, FullComparisonResult, Modality, SingleComparisonResult } from '../types';

/**
 * NOTE: The logic for live backend queries is in `apiService.ts`.
 * This file's functions are for interacting with pre-computed data stored on the client.
 */

// This helper creates a map of all items for efficient lookups by name.
const createItemsMap = (dataset: Dataset): Map<string, { item: DataItem, modality: Modality }> => {
  const map = new Map<string, { item: DataItem, modality: Modality }>();
  (Object.keys(dataset.data) as (keyof Dataset['data'])[]).forEach(pluralKey => {
    const modality: Modality = pluralKey === 'meshes' ? 'mesh' : pluralKey.slice(0, -1) as Modality;
    dataset.data[pluralKey].forEach(item => {
      map.set(item.name, { item, modality });
    });
  });
  return map;
};

/**
 * Retrieves pre-computed matches for a source item from the dataset's full comparison results.
 */
export const findTopMatchesFromLocal = (
  sourceItem: DataItem,
  sourceModality: Modality,
  dataset: Dataset
): SingleComparisonResult => {
  const results: SingleComparisonResult['results'] = { images: [], texts: [], meshes: [] };

  if (!dataset.fullComparison) {
    console.error("Full comparison data is missing from the dataset.");
    return { sourceItem, sourceModality, results };
  }
  
  const itemsMap = createItemsMap(dataset);
  const pluralKey = sourceModality === 'mesh' ? 'meshes' : `${sourceModality}s`;
  const sourceEntry = dataset.fullComparison[pluralKey as keyof FullComparisonResult].find(
      e => e.source === sourceItem.name
  );

  if (sourceEntry) {
      for (const key in sourceEntry.matches) {
          const modality = key as Modality;
          const resultPluralKey = modality === 'mesh' ? 'meshes' : `${modality}s`;
          if (sourceEntry.matches[modality]) {
              results[resultPluralKey as keyof typeof results] = sourceEntry.matches[modality]!.map(match => {
                  const found = itemsMap.get(match.item);
                  return {
                      item: found ? found.item : { id: `missing_${match.item}`, name: match.item, content: '' },
                      confidence: match.confidence,
                  };
              }).sort((a, b) => b.confidence - a.confidence);
          }
      }
  }

  return { sourceItem, sourceModality, results };
};