// Zentrale Kuechen-Chips + OSM-Alias-Map.
// Eine Quelle fuer UI (ToggleChipBar), Estimate, Deck-Filter UND Anzeige-Labels
// auf den Swipe-Karten (kein rohes "bakery"/"german" mehr sichtbar).
//
// i18n-Schritt 5: Diese Datei ist jetzt zweisprachig (de/en). CUISINE_OPTIONS
// bleibt UNVERAENDERT deutsch und als Default-Export bestehen, weil der
// Admin-Bereich (app/admin/dashboard/sponsors/page.tsx) bewusst nicht
// uebersetzt wird (Product-Owner-Entscheidung) und weiterhin darauf
// zugreift. Fuer alle nutzer-sichtbaren, uebersetzten Bereiche (Home-Wizard,
// Swipe-Karten, Session-Info) gibt es die NEUEN Funktionen getCuisineOptions
// (locale) und getCuisineLabel(rawValue, locale) - beide fallen ohne
// Locale-Parameter weiterhin auf Deutsch zurueck, damit bestehende,
// nicht-migrierte Aufrufstellen unveraendert funktionieren.

export type CuisineLocale = 'de' | 'en';

export type CuisineOption = {
  value: string;
  label: string;
};

/** Sichtbare Chips (Multi-Select + Wuerfeln) - DEUTSCH, unveraendert fuer Admin-Bereich. */
export const CUISINE_OPTIONS: CuisineOption[] = [
  { value: 'italian', label: 'Italienisch' },
  { value: 'german', label: 'Deutsch / Regional' },
  { value: 'turkish', label: 'Türkisch' },
  { value: 'greek', label: 'Griechisch' },
  { value: 'asian', label: 'Asiatisch' },
  { value: 'chinese', label: 'Chinesisch' },
  { value: 'japanese', label: 'Japanisch' },
  { value: 'thai', label: 'Thailändisch' },
  { value: 'vietnamese', label: 'Vietnamesisch' },
  { value: 'indian', label: 'Indisch' },
  { value: 'mexican', label: 'Mexikanisch' },
  { value: 'spanish', label: 'Spanisch' },
  { value: 'french', label: 'Französisch' },
  { value: 'american', label: 'Amerikanisch' },
  { value: 'mediterranean', label: 'Mediterran' },
  { value: 'lebanese', label: 'Libanesisch / Orientalisch' },
  { value: 'balkan', label: 'Balkan' },
  { value: 'international', label: 'International' },
  { value: 'pizza', label: 'Pizza' },
  { value: 'burger', label: 'Burger' },
  { value: 'sushi', label: 'Sushi' },
  { value: 'kebab', label: 'Kebab' },
  { value: 'cafe', label: 'Café & Kuchen' },
  { value: 'breakfast', label: 'Frühstück' },
  { value: 'steak_house', label: 'Steak' },
  { value: 'seafood', label: 'Meeresfrüchte' },
  { value: 'ice_cream', label: 'Eis' },
  { value: 'bakery', label: 'Bäckerei' },
];

/** Englische Labels fuer dieselben Chip-values, gleiche Reihenfolge/Keys wie CUISINE_OPTIONS. */
const CUISINE_LABELS_EN: Record<string, string> = {
  italian: 'Italian', german: 'German / Regional', turkish: 'Turkish', greek: 'Greek',
  asian: 'Asian', chinese: 'Chinese', japanese: 'Japanese', thai: 'Thai',
  vietnamese: 'Vietnamese', indian: 'Indian', mexican: 'Mexican', spanish: 'Spanish',
  french: 'French', american: 'American', mediterranean: 'Mediterranean',
  lebanese: 'Lebanese / Middle Eastern', balkan: 'Balkan', international: 'International',
  pizza: 'Pizza', burger: 'Burger', sushi: 'Sushi', kebab: 'Kebab',
  cafe: 'Café & Cake', breakfast: 'Breakfast', steak_house: 'Steak',
  seafood: 'Seafood', ice_cream: 'Ice cream', bakery: 'Bakery',
};

/**
 * Zusaetzliche Labels NUR fuer die Anzeige (keine eigenen Filter-Chips),
 * z.B. rohe OSM-Werte die als derivedCuisine (amenity/shop) durchkommen
 * koennen, aber in CUISINE_OPTIONS keinen eigenen Chip haben. Deutsch,
 * unveraendert (Fallback-Sprache fuer nicht-migrierte Aufrufstellen).
 */
const DISPLAY_ONLY_LABELS: Record<string, string> = {
  restaurant: 'Restaurant',
  fast_food: 'Fast Food',
  bar: 'Bar',
  pub: 'Kneipe',
  biergarten: 'Biergarten',
  food_court: 'Food Court',
  confectionery: 'Konditorei',
  deli: 'Feinkost',
  pastry: 'Patisserie',
  coffee_shop: 'Café',
  cake: 'Kuchen',
  regional: 'Regional',
  bavarian: 'Bayerisch',
  swabian: 'Schwäbisch',
  gyros: 'Gyros',
  doner: 'Döner',
  döner: 'Döner',
  ramen: 'Ramen',
  korean: 'Koreanisch',
  curry: 'Curry',
  tacos: 'Tacos',
  'tex-mex': 'Tex-Mex',
  tapas: 'Tapas',
  bistro: 'Bistro',
  steak: 'Steak',
  fish: 'Fisch',
  fish_and_chips: 'Fish & Chips',
  'fish and chips': 'Fish & Chips',
  oriental: 'Orientalisch',
  middle_eastern: 'Nahöstlich',
  syrian: 'Syrisch',
  arabic: 'Arabisch',
  croatian: 'Kroatisch',
  serbian: 'Serbisch',
  bosnian: 'Bosnisch',
  romanian: 'Rumänisch',
  fusion: 'Fusion',
};

/** Englisches Gegenstueck zu DISPLAY_ONLY_LABELS. */
const DISPLAY_ONLY_LABELS_EN: Record<string, string> = {
  restaurant: 'Restaurant',
  fast_food: 'Fast food',
  bar: 'Bar',
  pub: 'Pub',
  biergarten: 'Beer garden',
  food_court: 'Food court',
  confectionery: 'Confectionery',
  deli: 'Deli',
  pastry: 'Patisserie',
  coffee_shop: 'Café',
  cake: 'Cake',
  regional: 'Regional',
  bavarian: 'Bavarian',
  swabian: 'Swabian',
  gyros: 'Gyros',
  doner: 'Döner kebab',
  döner: 'Döner kebab',
  ramen: 'Ramen',
  korean: 'Korean',
  curry: 'Curry',
  tacos: 'Tacos',
  'tex-mex': 'Tex-Mex',
  tapas: 'Tapas',
  bistro: 'Bistro',
  steak: 'Steak',
  fish: 'Fish',
  fish_and_chips: 'Fish & Chips',
  'fish and chips': 'Fish & Chips',
  oriental: 'Oriental',
  middle_eastern: 'Middle Eastern',
  syrian: 'Syrian',
  arabic: 'Arabic',
  croatian: 'Croatian',
  serbian: 'Serbian',
  bosnian: 'Bosnian',
  romanian: 'Romanian',
  fusion: 'Fusion',
};

/**
 * Chip-value -> OSM-Suchbegriffe (OR).
 * Bewusst breit bei Sammel-Chips (asian), enger bei konkreten Dishes.
 * Pasta u.ae. nur als Alias unter italian — kein eigener Chip.
 */
export const CUISINE_ALIASES: Record<string, string[]> = {
  italian: ['italian', 'pizza', 'pasta'],
  german: ['german', 'regional', 'bavarian', 'swabian'],
  turkish: ['turkish', 'kebab', 'doner', 'döner'],
  greek: ['greek', 'gyros'],
  asian: [
    'asian', 'chinese', 'thai', 'vietnamese', 'japanese', 'korean',
    'sushi', 'ramen', 'indian',
  ],
  chinese: ['chinese', 'asian'],
  japanese: ['japanese', 'sushi', 'ramen', 'asian'],
  thai: ['thai', 'asian'],
  vietnamese: ['vietnamese', 'asian'],
  indian: ['indian', 'asian', 'curry'],
  mexican: ['mexican', 'tex-mex', 'tacos'],
  spanish: ['spanish', 'tapas'],
  french: ['french', 'bistro'],
  american: ['american', 'burger', 'steak'],
  mediterranean: ['mediterranean', 'greek', 'italian', 'spanish', 'turkish'],
  lebanese: ['lebanese', 'oriental', 'middle_eastern', 'syrian', 'arabic'],
  balkan: ['balkan', 'croatian', 'serbian', 'bosnian', 'romanian'],
  international: ['international', 'fusion'],
  pizza: ['pizza', 'italian'],
  burger: ['burger', 'american'],
  sushi: ['sushi', 'japanese'],
  kebab: ['kebab', 'turkish', 'doner', 'döner'],
  cafe: ['cafe', 'coffee_shop', 'cake', 'confectionery', 'bakery'],
  breakfast: ['breakfast', 'brunch', 'cafe'],
  steak_house: ['steak_house', 'steak', 'american'],
  seafood: ['seafood', 'fish', 'fish_and_chips'],
  ice_cream: ['ice_cream'],
  bakery: ['bakery', 'pastry', 'cake'],
};

/** Alle Alias-Strings zu den gewaehlten Chip-values (dedupliziert, lowercased). */
export function expandCuisineTags(tags: string[]): string[] {
  const out = new Set<string>();
  for (const tag of tags) {
    const key = tag.toLowerCase();
    const aliases = CUISINE_ALIASES[key];
    if (aliases) {
      for (const a of aliases) out.add(a.toLowerCase());
    } else {
      out.add(key);
    }
  }
  return [...out];
}

/**
 * Baut den durchsuchbaren Cuisine-String aus OSM-Tags
 * (cuisine bevorzugt, fallback amenity/shop — analog bisheriger Estimate-Logik).
 */
export function derivedCuisineHaystack(tags: {
  cuisine?: string;
  amenity?: string;
  shop?: string;
} | null | undefined): string {
  if (!tags) return '';
  return (tags.cuisine || tags.amenity || tags.shop || '').toLowerCase();
}

/**
 * true, wenn die Location zu mindestens einem gewaehlten Chip passt (OR).
 * Leere Auswahl = kein Cuisine-Filter (alles erlaubt).
 */
export function matchesCuisineTags(
  osmTags: { cuisine?: string; amenity?: string; shop?: string } | null | undefined,
  selectedChips: string[],
): boolean {
  if (!selectedChips.length) return true;
  const haystack = derivedCuisineHaystack(osmTags);
  if (!haystack) return false;
  const aliases = expandCuisineTags(selectedChips);
  return aliases.some((a) => haystack.includes(a));
}

/**
 * NEU (i18n-Schritt 5): liefert CUISINE_OPTIONS mit lokalisierten Labels fuer
 * die gewaehlte Sprache. Wird vom Home-Wizard (Kueche-Auswahl) und ueberall
 * genutzt, wo Nutzer:innen die Chips tatsaechlich sehen. Admin-Bereich nutzt
 * weiterhin direkt CUISINE_OPTIONS (immer Deutsch).
 */
export function getCuisineOptions(locale: CuisineLocale = 'de'): CuisineOption[] {
  if (locale === 'de') return CUISINE_OPTIONS;
  return CUISINE_OPTIONS.map((opt) => ({
    value: opt.value,
    label: CUISINE_LABELS_EN[opt.value] ?? opt.label,
  }));
}

/**
 * Liefert ein lesbares Label fuer einen einzelnen rohen Cuisine-Wert in der
 * gewuenschten Sprache (Default: Deutsch, fuer Ruecken-Kompatibilitaet mit
 * nicht-migrierten Aufrufstellen wie dem Admin-Bereich).
 */
export function getCuisineLabel(rawValue: string, locale: CuisineLocale = 'de'): string {
  const key = rawValue.trim().toLowerCase();
  if (!key) return rawValue;

  if (locale === 'en') {
    const chipEn = CUISINE_LABELS_EN[key];
    if (chipEn) return chipEn;
    const extraEn = DISPLAY_ONLY_LABELS_EN[key];
    if (extraEn) return extraEn;
    const cleanedEn = key.replace(/_/g, ' ');
    return cleanedEn.charAt(0).toUpperCase() + cleanedEn.slice(1);
  }

  const chip = CUISINE_OPTIONS.find((o) => o.value === key);
  if (chip) return chip.label;
  const extra = DISPLAY_ONLY_LABELS[key];
  if (extra) return extra;
  const cleaned = key.replace(/_/g, ' ');
  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
}

/**
 * Wandelt einen rohen, ggf. komma-/semikolon-getrennten cuisine-String
 * (wie er aus restaurants.cuisine kommt) in eine Liste lesbarer Labels fuer
 * die Anzeige auf Karten/Overlays um, in der gewuenschten Sprache.
 * Dedupliziert Labels (z.B. wenn OSM "pizza, pizza" liefert).
 */
export function formatCuisineDisplay(
  cuisineRaw: string | null | undefined,
  locale: CuisineLocale = 'de',
): string[] {
  if (!cuisineRaw) return [];
  const parts = cuisineRaw
    .split(/[,;]/)
    .map((t) => t.trim())
    .filter(Boolean)
    .map((v) => getCuisineLabel(v, locale));
  return [...new Set(parts)];
}

/**
 * Erraet aus einem rohen (ggf. komma-getrennten) OSM-cuisine-String die
 * passenden Chip-values aus CUISINE_OPTIONS, per Reverse-Lookup gegen die
 * bereits bestehende CUISINE_ALIASES-Map (keine Logik-Duplizierung). Wird
 * fuer das Auto-Fill der Kuechen-Pillen beim Verknuepfen eines Sponsors mit
 * einem Suchergebnis genutzt (Admin-Bereich, bleibt sprachunabhaengig da nur
 * values, keine Labels, zurueckgegeben werden).
 */
export function guessCuisineChipsFromRaw(cuisineRaw: string | null | undefined): string[] {
  if (!cuisineRaw) return [];
  const haystack = cuisineRaw.toLowerCase();
  const matched = new Set<string>();
  for (const opt of CUISINE_OPTIONS) {
    const aliases = expandCuisineTags([opt.value]);
    if (aliases.some((a) => haystack.includes(a))) {
      matched.add(opt.value);
    }
  }
  return [...matched];
}