Blame for engine.py

"""
Palate / TasteOS Universal Intelligence Engine
100% ARCHITECTURAL PURITY. Zero regex brand name cheating. Zero paid Google APIs.
1. Universal Craft Lexicon: Evaluates genuine culinary techniques only.
2. Relational Accreditations: Joins third-party critic awards (Michelin, 50 Top Pizza, Eater).
"""

import json
import math
import os
import re
import sys
import pickle
from collections import Counter
import numpy as np

# Ensure UTF-8 output on Windows consoles
if sys.platform == "win32" and hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

DATA_DIR = os.path.join(os.path.dirname(__file__), "data")
DATA_FILE = os.path.join(DATA_DIR, "amsterdam_places.json")
ACCREDITATIONS_FILE = os.path.join(DATA_DIR, "amsterdam_accreditations.json")
VECTORS_FILE = os.path.join(DATA_DIR, "amsterdam_vectors.npy")
MODEL_FILE = os.path.join(DATA_DIR, "semantic_model.pkl")

# Generic OSM administrative wrapper tags that do NOT dilute culinary purity
GENERIC_WRAPPER_TAGS = {
    "restaurant", "fast_food", "cafe", "bar", "pub", "sandwich", 
    "diner", "food", "takeaway", "delivery", "food_court"
}

GENERIC_WRAPPER_RE = re.compile(
    r'\b(restaurant|restaurants|studio|bistro|bistrot|cafe|caffe|coffee|kitchen|bar|grill|dubai|uae|amsterdam|'
    r'bakery|bakkerij|pizzeria|pizza|gelato|gelateria|roasters|roastery|ramen|pasta|trattoria|osteria|'
    r'brasserie|taverna|pub|lounge|house|shop|store|the|de|het|den|der|la|le|les|il|lo|el|al|da|di)\b',
    re.IGNORECASE
)

# Generic query intent filler nouns (these indicate grammatical intent, not specific cuisine)
QUERY_INTENT_STOPWORDS = {
    "restaurant", "restaurants", "resturant", "resturants",
    "food", "foods", "place", "places", "spot", "spots", 
    "joint", "joints", "eatery", "eateries", "kitchen", "kitchens",
    "eat", "eating", "dinner", "lunch", "breakfast",
    "best", "good", "great", "top", "famous", "local", "authentic"
}

# Bidirectional mapping between country names and cuisine adjectives
CUISINE_NATIONALITY_EXPANSIONS = {
    "syria": ["syria", "syrian"],
    "syrian": ["syria", "syrian"],
    "italy": ["italy", "italian"],
    "italian": ["italy", "italian"],
    "mexico": ["mexico", "mexican"],
    "mexican": ["mexico", "mexican"],
    "turkey": ["turkey", "turkish"],
    "turkish": ["turkey", "turkish"],
    "japan": ["japan", "japanese"],
    "japanese": ["japan", "japanese"],
    "korea": ["korea", "korean"],
    "korean": ["korea", "korean"],
    "china": ["china", "chinese"],
    "chinese": ["china", "chinese"],
    "vietnam": ["vietnam", "vietnamese"],
    "vietnamese": ["vietnam", "vietnamese"],
    "thailand": ["thailand", "thai"],
    "thai": ["thailand", "thai"],
    "greece": ["greece", "greek"],
    "greek": ["greece", "greek"],
    "spain": ["spain", "spanish"],
    "spanish": ["spain", "spanish"],
    "lebanon": ["lebanon", "lebanese"],
    "lebanese": ["lebanon", "lebanese"],
    "morocco": ["morocco", "moroccan"],
    "moroccan": ["morocco", "moroccan"],
    "ethiopia": ["ethiopia", "ethiopian"],
    "ethiopian": ["ethiopia", "ethiopian"],
    "india": ["india", "indian"],
    "indian": ["india", "indian"],
    "indonesia": ["indonesia", "indonesian"],
    "indonesian": ["indonesia", "indonesian"],
    "suriname": ["suriname", "surinamese"],
    "surinamese": ["suriname", "surinamese"],
    "historic": ["historic", "monument", "rijksmonument", "heritage", "monumenten", "century", "monumental"],
    "monument": ["monument", "rijksmonument", "historic", "heritage", "monumenten", "monumental"],
    "monuments": ["monument", "rijksmonument", "historic", "heritage", "monumenten", "monumental"],
    "rijksmonument": ["rijksmonument", "monument", "historic", "heritage"],
    "heritage": ["heritage", "historic", "monument", "rijksmonument"]
}

# Multi-City Neighborhood & Sub-District Spatial Lexicon
NEIGHBORHOOD_ALIASES_BY_CITY = {
    "dubai": {
        "jlt": ["jlt", "jumeirah lakes towers", "lake view"],
        "jumeirah lakes towers": ["jlt", "jumeirah lakes towers"],
        "marina": ["marina", "dubai marina"],
        "dubai marina": ["marina", "dubai marina"],
        "jbr": ["jbr", "jumeirah beach residence", "the beach"],
        "jumeirah beach residence": ["jbr", "jumeirah beach residence"],
        "satwa": ["satwa", "al dhiyafah", "2nd december"],
        "al satwa": ["satwa", "al dhiyafah", "2nd december"],
        "deira": ["deira", "al rigga", "naif", "al muraqqabat", "al sabkha"],
        "bur dubai": ["bur dubai", "al fahidi", "meena bazaar", "al bastakiya", "al souq"],
        "al fahidi": ["al fahidi", "bur dubai", "al bastakiya"],
        "karama": ["karama", "al karama"],
        "al karama": ["karama", "al karama"],
        "downtown": ["downtown", "downtown dubai", "sheikh mohammed bin rashid"],
        "downtown dubai": ["downtown", "downtown dubai"],
        "difc": ["difc", "gate village", "gate avenue", "financial centre"],
        "business bay": ["business bay"],
        "al barsha": ["al barsha", "barsha"],
        "barsha": ["al barsha", "barsha"],
        "al quoz": ["al quoz", "alserkal", "alserkal avenue", "quoz"],
        "jumeirah": ["jumeirah", "jumeirah 1", "jumeirah 2", "jumeirah 3"],
        "umm suqeim": ["umm suqeim", "fishing harbour"],
        "palm": ["palm", "palm jumeirah"],
        "palm jumeirah": ["palm", "palm jumeirah"],
        "bluewaters": ["bluewaters", "bluewaters island"],
        "motor city": ["motor city"],
        "mirdif": ["mirdif"],
        "al safa": ["al safa", "wasl", "dar wasl"],
        "wasl": ["wasl 51", "dar wasl", "al wasl"]
    },
    "amsterdam": {
        "jordaan": ["jordaan"],
        "pijp": ["de pijp", "pijp"],
        "de pijp": ["de pijp", "pijp"],
        "oud west": ["oud-west", "oud west", "de baarsjes"],
        "de baarsjes": ["de baarsjes", "oud-west"],
        "centrum": ["centrum", "amsterdam-centrum", "grachtengordel"],
        "oost": ["oost", "amsterdam-oost", "indische buurt"],
        "noord": ["noord", "amsterdam-noord", "ndsm"],
        "zuid": ["zuid", "amsterdam-zuid", "oud-zuid"],
        "westerpark": ["westerpark"],
        "nieuw west": ["nieuw-west", "nieuw west"]
    },
    "istanbul": {
        "kadikoy": ["kadıköy", "kadikoy", "moda", "caferağa"],
        "kadıköy": ["kadıköy", "kadikoy", "moda", "caferağa"],
        "moda": ["moda", "kadıköy", "kadikoy"],
        "beyoglu": ["beyoğlu", "beyoglu", "taksim", "cihangir", "istiklal"],
        "beyoğlu": ["beyoğlu", "beyoglu", "taksim", "cihangir", "istiklal"],
        "karakoy": ["karaköy", "karakoy", "galata"],
        "karaköy": ["karaköy", "karakoy", "galata"],
        "besiktas": ["beşiktaş", "besiktas", "ortaköy", "akaretler"],
        "beşiktaş": ["beşiktaş", "besiktas", "ortaköy", "akaretler"],
        "fatih": ["fatih", "sultanahmet", "eminönü", "balat"],
        "sultanahmet": ["sultanahmet", "fatih"],
        "nisantasi": ["nişantaşı", "nisantasi", "teşvikiye"],
        "nişantaşı": ["nişantaşı", "nisantasi", "teşvikiye"],
        "sisli": ["şişli", "sisli", "mecidiyeköy"],
        "şişli": ["şişli", "sisli", "mecidiyeköy"],
        "uskudar": ["üsküdar", "uskudar"],
        "üsküdar": ["üsküdar", "uskudar"],
        "bebek": ["bebek", "arnavutköy"]
    },
    "london": {
        "soho": ["soho"],
        "shoreditch": ["shoreditch", "hackney"],
        "covent garden": ["covent garden"],
        "mayfair": ["mayfair"],
        "camden": ["camden", "camden town"],
        "brixton": ["brixton"],
        "borough": ["borough", "london bridge"],
        "kensington": ["kensington", "south kensington"],
        "chelsea": ["chelsea"],
        "notting hill": ["notting hill"],
        "islington": ["islington", "angel"],
        "fitzrovia": ["fitzrovia"],
        "marylebone": ["marylebone"]
    },
    "paris": {
        "marais": ["le marais", "marais"],
        "le marais": ["le marais", "marais"],
        "montmartre": ["montmartre"],
        "saint germain": ["saint-germain", "saint germain"],
        "bastille": ["bastille"],
        "belleville": ["belleville"],
        "canal saint martin": ["canal saint-martin", "canal saint martin"],
        "latin quarter": ["quartier latin", "latin quarter"],
        "pigalle": ["pigalle", "so-pi"],
        "opera": ["opéra", "opera"]
    },
    "tokyo": {
        "shinjuku": ["shinjuku", "新宿"],
        "shibuya": ["shibuya", "渋谷"],
        "ginza": ["ginza", "銀座"],
        "roppongi": ["roppongi", "六本木"],
        "asakusa": ["asakusa", "浅草"],
        "akihabara": ["akihabara", "秋葉原"],
        "tsukiji": ["tsukiji", "築地"],
        "shimokitazawa": ["shimokitazawa", "下北沢"],
        "ebisu": ["ebisu", "恵比寿"],
        "ueno": ["ueno", "上野"],
        "ikebukuro": ["ikebukuro", "池袋"]
    },
    "new york": {
        "soho": ["soho"],
        "williamsburg": ["williamsburg"],
        "east village": ["east village"],
        "west village": ["west village", "greenwich village"],
        "greenwich village": ["greenwich village", "west village"],
        "lower east side": ["lower east side", "les"],
        "chelsea": ["chelsea"],
        "chinatown": ["chinatown"],
        "harlem": ["harlem"],
        "astoria": ["astoria"],
        "bushwick": ["bushwick"],
        "dumbo": ["dumbo"],
        "tribeca": ["tribeca"]
    },
    "rome": {
        "trastevere": ["trastevere"],
        "testaccio": ["testaccio"],
        "monti": ["monti", "rione monti"],
        "prati": ["prati"],
        "centro storico": ["centro storico", "pantheon", "navona"],
        "san lorenzo": ["san lorenzo"],
        "pigneto": ["pigneto"],
        "campo de fiori": ["campo de' fiori", "campo de fiori"]
    }
}

# Global Industrial Fast Food Franchises (Actual commercial megachains to penalize)
GLOBAL_INDUSTRIAL_CHAINS = {
    "mcdonald's", "mcdonalds", "burger king", "kfc", "subway", 
    "domino's", "dominos", "domino's pizza", "new york pizza", 
    "pizza hut", "starbucks", "dunkin'", "dunkin", "dunkin' donuts",
    "five guys", "taco bell", "vapiano", "wagamama", "febò", "febo",
    "dam express franchising", "nightlife food group", "tours & waffles holding bv"
}

# Amsterdam Tourist Trap Epicenters (Dense tourist pedestrian corridors)
TOURIST_EPICENTERS = [
    {"name": "Dam Square", "lat": 52.3731, "lon": 4.8932},
    {"name": "Damrak / Centraal Corridor", "lat": 52.3775, "lon": 4.8990},
    {"name": "Red Light District (De Wallen)", "lat": 52.3725, "lon": 4.8970},
    {"name": "Leidseplein Tourist Ring", "lat": 52.3639, "lon": 4.8829},
    {"name": "Rembrandtplein Tourist Ring", "lat": 52.3660, "lon": 4.8967}
]

# Universal All-Dish Craft Lexicon
# STRICT RULE: Contains ONLY universal cooking techniques and culinary terminology.
# ZERO individual restaurant brand names permitted here!
CRAFT_PATTERNS = [
    # 1. 🍕 Pizza & Italian Artisanal Craft
    {
        "regex": r"\b(forno a legna|wood[\s-]fired|houtoven|houtgestookt)\b",
        "badge": "🔥 Wood-Fired Stone Oven",
        "detail": "Bakes inside a high-temperature wood fire stone oven at 450°C",
        "points": 35
    },
    {
        "regex": r"\b(napoletana|neapolitan|verace|san marzano|impasto)\b",
        "badge": "🍕 Authentic Neapolitan Pizza Craft",
        "detail": "High-hydration long-fermented dough, San Marzano tomatoes, and blistered cornicione",
        "points": 35
    },
    {
        "regex": r"\b(pizzeria|pizzabakker|pizzabakkers|italian_pizza)\b",
        "badge": "🍕 Dedicated Pizzeria Kitchen",
        "detail": "Specialized pizza kitchen focusing on scratch-made dough and classic fermentation",
        "points": 25
    },
    {
        "regex": r"\b(fatta in casa|pasta fresca|casereccia|homemade pasta)\b",
        "badge": "🍝 Fresh In-House Pasta",
        "detail": "Noodles and pasta hand-rolled from scratch daily using semola and egg",
        "points": 35
    },
    {
        "regex": r"\b(trattoria|osteria|ristorante tradizionale)\b",
        "badge": "🇮🇹 Traditional Italian Kitchen",
        "detail": "Classic regional Italian tavern cooking",
        "points": 20
    },

    # 2. 🍔 Burgers, Barbecue & Prime Meat Craft
    {
        "regex": r"\b(smash|smashburger|smashed)\b",
        "badge": "🍔 Crispy-Edge Smash Patty",
        "detail": "High-heat griddled smash patty with deep Maillard caramelization",
        "points": 35
    },
    {
        "regex": r"\b(butcher|slager|butchery|dry[\s-]aged|wagyu|angus|black angus|weidevlees|biologisch rundvlees)\b",
        "badge": "🥩 Butcher Blend & Prime Meat",
        "detail": "Coarse-ground prime beef blend (Angus/Wagyu/Dry-Aged) from dedicated butchery",
        "points": 35
    },
    {
        "regex": r"\b(brioche|potato bun|artisanaal broodje)\b",
        "badge": "🍞 Artisanal Burger Bun",
        "detail": "Freshly baked golden brioche or soft potato bun",
        "points": 25
    },
    {
        "regex": r"\b(smokehouse|barbecue|bbq|low[\s-]and[\s-]slow|pulled pork|smoked brisket)\b",
        "badge": "🪵 Low & Slow Wood Smokehouse",
        "detail": "Authentic wood-smoked barbecue slow-cooked over hardwood for 10+ hours",
        "points": 35
    },
    {
        "regex": r"\b(rotisserie|spit[\s-]roast)\b",
        "badge": "🍗 Flame Rotisserie",
        "detail": "Slow-turned spit-roasted poultry and meats over open flame",
        "points": 25
    },

    # 3. 🍞 Sourdough, Bread & Viennoiserie Craft
    {
        "regex": r"\b(ambachtelijk|ambachtelijke|ambacht|artisan|artisanal)\b",
        "badge": "🍞 Certified Scratch Artisan",
        "detail": "Traditional scratch production without premade commercial mixes",
        "points": 30
    },
    {
        "regex": r"\b(desem|zuurdesem|sourdough|levain)\b",
        "badge": "🌾 Wild Ferment Sourdough",
        "detail": "Naturally fermented wild starter slow dough, zero commercial additives",
        "points": 35
    },
    {
        "regex": r"\b(croissant|pain au chocolat|viennoiserie|patisserie|kouign[\s-]amann)\b",
        "badge": "🥐 French Viennoiserie",
        "detail": "Laminated real butter pastry dough folded in-house",
        "points": 30
    },
    {
        "regex": r"\b(appeltaart|dutch apple pie|verse stroopwafel)\b",
        "badge": "🥧 Traditional Dutch Baking",
        "detail": "Heirloom Dutch bakery craft, warm cinnamon spice and fresh pressed dough",
        "points": 25
    },

    # 4. 🍜 Japanese & East Asian Noodle/Grill Craft
    {
        "regex": r"\b(ramen|自家製麺|jikaseimen|tonkotsu|paitan|shoyu ramen)\b",
        "badge": "🍜 Authentic Slow-Broth Ramen",
        "detail": "12-hour simmered bone broth with crafted alkaline noodles",
        "points": 35
    },
    {
        "regex": r"\b(udon|soba|teuchi|hand[\s-]pulled|handmade noodles)\b",
        "badge": "🥢 Hand-Pulled Artisan Noodles",
        "detail": "Fresh hand-kneaded noodles cut or pulled to order",
        "points": 35
    },
    {
        "regex": r"\b(yakitori|sumibiyaki|binchotan|charcoal skewer)\b",
        "badge": "🍢 Binchotan Charcoal Grill",
        "detail": "Skewered meats grilled over smokeless Japanese white oak charcoal",
        "points": 35
    },
    {
        "regex": r"\b(omakase|edomae|sushi master)\b",
        "badge": "🍣 Traditional Edomae Sushi",
        "detail": "Hand-pressed nigiri with seasoned shari rice and cured wild fish",
        "points": 35
    },
    {
        "regex": r"\b(dim sum|dumpling|dumplings|gyoza|bao)\b",
        "badge": "🥟 Fresh Hand-Pleated Dim Sum",
        "detail": "Hand-folded dumplings and buns steamed fresh in bamboo baskets",
        "points": 25
    },

    # 5. 🔥 Middle Eastern, Turkish & Levant Charcoal Craft
    {
        "regex": r"\b(közde|odun ateşi|mangal|charcoal|wood charcoal|cağ)\b",
        "badge": "🔥 Oak Charcoal Embers",
        "detail": "Cooks over natural hardwood charcoal embers, not gas or electric elements",
        "points": 35
    },
    {
        "regex": r"\b(yaprak döner|fillet|marinated lamb)\b",
        "badge": "🥩 100% Whole Layered Meat",
        "detail": "Hand-stacked whole meat fillets, never frozen industrial minced paste",
        "points": 35
    },
    {
        "regex": r"\b(tandır|tandoor|clay oven)\b",
        "badge": "🔥 High-Heat Clay Tandoor",
        "detail": "Bakes skewers and flatbreads inside an open-flame clay tandoor",
        "points": 30
    },
    {
        "regex": r"\b(falafel|hummus|mezze|sabich|lavaş|saj)\b",
        "badge": "🧆 Traditional Levant Street Craft",
        "detail": "House-ground fresh herbs, soaked chickpeas, and hot stone flatbreads",
        "points": 25
    },

    # 6. 🐟 Dutch Seafood & Fishmonger Heritage
    {
        "regex": r"\b(haringhandel|vishandel|visspecialist|nieuwe haring|kibbeling|volendammer|paling)\b",
        "badge": "🐟 Dedicated Fishmonger & Haring Master",
        "detail": "Specialized fishmonger cleaning fresh Dutch raw herring daily",
        "points": 35
    },

    # 7. 🍛 Surinamese & Indonesian Colonial Diaspora Craft
    {
        "regex": r"\b(surinaams|warung|spang|makandra|roti|doksa|bara|saoto|pom)\b",
        "badge": "🍛 Authentic Surinamese Craft",
        "detail": "Heirloom slow-cooked curries, Madame Jeanette sambal, and handmade roti",
        "points": 30
    },
    {
        "regex": r"\b(rijsttafel|indonesisch|rendang|sat[eé]|gado[\s-]gado)\b",
        "badge": "🍚 Traditional Indonesian Rijsttafel",
        "detail": "Authentic multi-dish Dutch-Indonesian heritage feast",
        "points": 30
    },

    # 8. 🌮 Mexican, Taco & Latin Craft
    {
        "regex": r"\b(al carbón|hechas a mano|tortillería|birria|carnitas|suadero|taquería|trompo)\b",
        "badge": "🌮 Authentic Mexican Street Craft",
        "detail": "Fresh comal-pressed corn tortillas, slow-braised meats, and fire-roasted salsas",
        "points": 35
    },

    # 9. 🍲 Southeast Asian Craft (Thai, Vietnamese)
    {
        "regex": r"\b(pho|phở|bánh mì|banh mi|pad thai|som tum|tom yum)\b",
        "badge": "🍲 Authentic Southeast Asian Street Craft",
        "detail": "Fresh herbs, 10-hour spiced bone broth, and crispy French-Vietnamese baguettes",
        "points": 30
    },

    # 10. ☕ Specialty Coffee & Micro-Roasters
    {
        "regex": r"\b(specialty coffee|micro[\s-]roastery|koffiebranderij|single origin|filter coffee|v60|cold brew)\b",
        "badge": "☕ Third-Wave Specialty Coffee",
        "detail": "Direct-trade single origin beans roasted in-house and extracted to precision",
        "points": 30
    },

    # 11. 🍦 Artisanal Gelato & Ice Cream
    {
        "regex": r"\b(gelato|gelateria|gelataio|cremeria|pozzetti|ambachtelijk ijs|ijssalon|vers gedraaid|sorbetto|granita)\b",
        "badge": "🍦 Artisanal Scratch Gelato",
        "detail": "Slow-churned whole milk and fresh seasonal fruit with zero industrial pastes",
        "points": 30
    },

    # 12. 🍺 Historic Tasting Rooms, Brown Cafés & Craft Breweries
    {
        "regex": r"\b(jenever|proeflokaal|bruin caf[eé]|oude jenever|brouwerij|craft beer|microbrewery)\b",
        "badge": "🍺 Historic Tasting Room & Craft Brewery",
        "detail": "Traditional Dutch tavern culture with heritage genever and local small-batch beer",
        "points": 30
    }
]

# Tourist Trap & Commercial Warning Markers
TOURIST_TRAP_PATTERNS = [
    {
        "regex": r"\b(nutella)\b",
        "penalty": -35,
        "flag": "⚠️ Mass-Market Commercial Spread",
        "reason": "Uses industrial palm-oil spread instead of artisanal chocolate/pastry"
    },
    {
        "regex": r"\b(waffle|waffles)\b.*(steak|pizza|kebab|burger)",
        "penalty": -40,
        "flag": "⚠️ Multi-Concept Tourist Mill",
        "reason": "Combines frozen waffles, steaks, and pizza under one tourist-focused roof"
    },
    {
        "regex": r"\b(argentinian grill|argentinian steakhouse)\b",
        "penalty": -35,
        "flag": "⚠️ Damrak Tourist Steakhouse Archetype",
        "reason": "Famous Amsterdam tourist corridor trap with inflated pricing and generic frozen beef"
    },
    {
        "regex": r"\b(tours & tickets|nightlife food group|american bakery|ice bakery)\b",
        "penalty": -30,
        "flag": "⚠️ Commercial Holding Franchise",
        "reason": "Owned by a nightlife or ticket-broker corporate holding company"
    },
    {
        "regex": r"\b(express|corner)\b",
        "penalty": -15,
        "flag": "⚠️ High-Turnover Fast Casual",
        "reason": "Optimized for speed rather than slow culinary craft"
    }
]

def haversine_distance_m(lat1, lon1, lat2, lon2):
    R = 6371000.0
    phi1 = math.radians(lat1)
    phi2 = math.radians(lat2)
    delta_phi = math.radians(lat2 - lat1)
    delta_lambda = math.radians(lon2 - lon1)
    a = math.sin(delta_phi / 2.0) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(delta_lambda / 2.0) ** 2
    c = 2.0 * math.atan2(math.sqrt(a), math.sqrt(1.0 - a))
    return R * c

MASTER_CRAFT_ARCHETYPES = [
    # Italian & Mediterranean
    {'id': 'pizza', 'label': 'Neapolitan Pizza', 'icon': '🍕', 'query': 'pizza', 'regex': r'\b(pizza|pizzeria|napoletana)\b'},
    {'id': 'italian', 'label': 'Pasta & Italian Trattorias', 'icon': '🍝', 'query': 'italian', 'regex': r'\b(italian|pasta|trattoria|osteria|spaghetti)\b'},
    {'id': 'tapas', 'label': 'Spanish Tapas & Jamón', 'icon': '🇪🇸', 'query': 'tapas', 'regex': r'\b(tapas|spanish|spaans|paella|jamon|jamón)\b'},
    {'id': 'greek', 'label': 'Greek & Mediterranean', 'icon': '🇬🇷', 'query': 'greek', 'regex': r'\b(greek|grieks|souvlaki|gyros|taverna)\b'},

    # Bread, Baking & Sweet Craft
    {'id': 'bakery', 'label': 'Wild Sourdough & Bakeries', 'icon': '🍞', 'query': 'sourdough', 'regex': r'\b(bakery|bakkerij|sourdough|zuurdesem|croissant|artisan bread)\b'},
    {'id': 'deli', 'label': 'Artisanal Broodjes & Delis', 'icon': '🥪', 'query': 'broodje', 'regex': r'\b(sandwich|broodje|deli|delicatessen|pastrami|bagel|belegd)\b'},
    {'id': 'patisserie', 'label': 'Pâtisserie & Chocolaterie', 'icon': '🍫', 'query': 'patisserie', 'regex': r'\b(pastry|confectionery|chocolate|chocolatier|patisserie|stroopwafel|bonbon)\b'},
    {'id': 'gelato', 'label': 'Artisanal Scratch Gelato', 'icon': '🍦', 'query': 'gelato', 'regex': r'\b(gelato|gelateria|ijssalon|ice_cream|sorbetto)\b'},
    {'id': 'pancakes', 'label': 'Dutch Pannenkoeken & Crêpes', 'icon': '🥞', 'query': 'pancake', 'regex': r'\b(pancake|pannenkoek|poffertjes|crepe|cr[eê]pe)\b'},

    # Low Countries & Local Heritage
    {'id': 'seafood', 'label': 'Haring & North Sea Seafood', 'icon': '🐟', 'query': 'haring', 'regex': r'\b(haring|seafood|fish|vishandel|kibbeling|vis|oyster|mosselen)\b'},
    {'id': 'frites', 'label': 'Artisanal Flemish Frites', 'icon': '🍟', 'query': 'friture', 'regex': r'\b(frit|friture|frites|patat|vlaams|friet)\b'},
    {'id': 'tavern', 'label': 'Historic Bruin Cafés & Jenever', 'icon': '🏛️', 'query': 'jenever', 'regex': r'\b(jenever|bruin caf[eé]|brown caf[eé]|proeflokaal|historic tavern|eetcaf[eé])\b'},
    {'id': 'craft_beer', 'label': 'Craft Breweries & Taprooms', 'icon': '🍺', 'query': 'craft beer', 'regex': r'\b(brewery|brouwerij|craft beer|taproom|microbrewery|draught)\b'},

    # Diaspora & Heritage Kitchens
    {'id': 'indonesian', 'label': 'Indonesian Rijsttafel', 'icon': '🍚', 'query': 'indonesian', 'regex': r'\b(indonesisch|indonesian|rijsttafel|rendang|warung|satay|sate)\b'},
    {'id': 'surinamese', 'label': 'Surinamese Roti & Warung', 'icon': '🍛', 'query': 'surinaams', 'regex': r'\b(surinaams|surinamese|roti|saoto|bara|pom|bakkeljauw)\b'},
    {'id': 'moroccan', 'label': 'Moroccan Tagine & Couscous', 'icon': '🫕', 'query': 'moroccan', 'regex': r'\b(moroccan|marokkaans|tagine|tajine|couscous|pastilla)\b'},
    {'id': 'ethiopian', 'label': 'Ethiopian & Eritrean Injera', 'icon': '🫓', 'query': 'ethiopian', 'regex': r'\b(ethiopian|eritrean|injera|tibs|wat|habesha)\b'},

    # Middle East, Levant, Anatolia & Gulf
    {'id': 'esnaf', 'label': 'Historic Esnaf Lokantaları', 'icon': '🥘', 'query': 'esnaf', 'regex': r'\b(esnaf|lokanta|sulu yemek|guvec|güveç|kuru fasulye)\b'},
    {'id': 'doner', 'label': 'Wood-Fired Yaprak Döner', 'icon': '🥙', 'query': 'doner', 'regex': r'\b(doner|döner|yaprak|donerci|dönerci)\b'},
    {'id': 'ocakbasi', 'label': 'Ocakbaşı Charcoal Mangal', 'icon': '🔥', 'query': 'ocakbasi', 'regex': r'\b(ocakbasi|ocakbaşı|mangal|adana|urfa|cop sis|çöp şiş)\b'},
    {'id': 'pide', 'label': 'Stone Oven Pide & Lahmacun', 'icon': '🥖', 'query': 'pide', 'regex': r'\b(pide|lahmacun|karadeniz|tas firin|taş fırın)\b'},
    {'id': 'mandi', 'label': 'Yemeni Mandi & Khaleeji', 'icon': '🍗', 'query': 'mandi', 'regex': r'\b(mandi|kabsa|machboos|khaleeji)\b'},
    {'id': 'persian', 'label': 'Persian Charcoal Grills', 'icon': '🍢', 'query': 'persian', 'regex': r'\b(persian|iranian|koobideh|sangak)\b'},
    {'id': 'kofte', 'label': 'Kasap Köfte & Piyaz', 'icon': '🥩', 'query': 'kofte', 'regex': r'\b(kofte|köfte|köfteci|kofteci|piyaz)\b'},
    {'id': 'baklava', 'label': 'Artisanal Antep Baklava', 'icon': '🍯', 'query': 'baklava', 'regex': r'\b(baklava|baklavacı|gulluoglu|fistikli|fıstıklı)\b'},
    {'id': 'bosphorus_seafood', 'label': 'Coastal & Bosphorus Seafood', 'icon': '🐟', 'query': 'seafood', 'regex': r'\b(balik|balık|balikci|balıkçı|balik ekmek|hamour|fish fry)\b'},
    {'id': 'breakfast', 'label': 'Village Breakfast & Kaymak', 'icon': '🍳', 'query': 'breakfast', 'regex': r'\b(kahvalti|kahvaltı|kaymak|menemen)\b'},
    {'id': 'shawarma', 'label': 'Charcoal Kebab & Shawarma', 'icon': '🥙', 'query': 'shawarma', 'regex': r'\b(shawarma|shoarma|d[oö]ner|kebab|durum|d[uü]r[uü]m|mangal|tandur)\b'},
    {'id': 'falafel', 'label': 'Levant Hummus & Falafel', 'icon': '🧆', 'query': 'falafel', 'regex': r'\b(falafel|hummus|mezze|meze|sabich|lebanese|libanees|manaeesh)\b'},

    # Asian Craft
    {'id': 'ramen', 'label': 'Slow-Broth Ramen & Noodles', 'icon': '🍜', 'query': 'ramen', 'regex': r'\b(ramen|noodles|udon|soba)\b'},
    {'id': 'sushi', 'label': 'Edomae Sushi & Izakaya', 'icon': '🍣', 'query': 'sushi', 'regex': r'\b(sushi|japanese|izakaya|yakitori|omakase)\b'},
    {'id': 'chinese', 'label': 'Dim Sum & Cantonese', 'icon': '🥟', 'query': 'chinese', 'regex': r'\b(chinese|chinees|dim sum|cantonese|sichuan|dumpling)\b'},
    {'id': 'thai', 'label': 'Thai Street Kitchen', 'icon': '🍲', 'query': 'thai', 'regex': r'\b(thai|pad thai|curry|tom yum)\b'},
    {'id': 'vietnamese', 'label': 'Vietnamese & Pho', 'icon': '🥢', 'query': 'vietnamese', 'regex': r'\b(vietnamese|vietnamees|pho|phở|b[aá]nh m[iì])\b'},
    {'id': 'korean', 'label': 'Korean & Fried Chicken', 'icon': '🍗', 'query': 'korean', 'regex': r'\b(korean|koreaans|kimchi|bibimbap|chimaek)\b'},
    {'id': 'indian', 'label': 'Indian & Curry Houses', 'icon': '🥘', 'query': 'indian', 'regex': r'\b(indian|indiase|curry|tandoori|masala|biryani|dosa|thali)\b'},

    # The Americas & Bistro
    {'id': 'burger', 'label': 'Craft & Smash Burgers', 'icon': '🍔', 'query': 'burger', 'regex': r'\b(burger|burgers|smash)\b'},
    {'id': 'steak', 'label': 'Steak & Prime Grill', 'icon': '🥩', 'query': 'steak', 'regex': r'\b(steak|steakhouse|grill|ribeye|churrasco|asado)\b'},
    {'id': 'bbq', 'label': 'Smokehouse BBQ & Ribs', 'icon': '🍖', 'query': 'bbq', 'regex': r'\b(barbecue|bbq|smokehouse|brisket|pulled pork|spareribs)\b'},
    {'id': 'mexican', 'label': 'Mexican & Taquerías', 'icon': '🌮', 'query': 'mexican', 'regex': r'\b(mexican|mexicaans|taco|taqueria|birria|burrito)\b'},
    {'id': 'french', 'label': 'French Bistro & Brasserie', 'icon': '🍷', 'query': 'french', 'regex': r'\b(french|frans|bistro|brasserie|charcuterie)\b'},

    # Roast & Sips
    {'id': 'coffee', 'label': 'Specialty Coffee Micro-Roasters', 'icon': '☕', 'query': 'coffee', 'regex': r'\b(coffee|koffie|espresso|roastery|filter coffee|pourover)\b'},
    {'id': 'bubble_tea', 'label': 'Taiwanese Bubble Tea & Boba', 'icon': '🧋', 'query': 'bubble tea', 'regex': r'\b(bubble tea|boba|tapioca)\b'},

    # Broad Regional, Heritage & Evening Dining (Collectively Exhaustive MECE Buckets)
    {'id': 'dutch', 'label': 'Dutch Heritage & Eetcafés', 'icon': '🇳🇱', 'query': 'dutch', 'regex': r'\b(dutch|nederlands|stamppot|snert|bitterballen|poffertjes|hollands|eetcaf[eé])\b'},
    {'id': 'bistro', 'label': 'Modern European & Chef Bistros', 'icon': '🍽️', 'query': 'bistro', 'regex': r'\b(bistro|european|contemporary|gastronomy|fine dining|seasonal|farm[\s-]to[\s-]table|international)\b'},
    {'id': 'gastropub', 'label': 'British & Irish Gastropubs', 'icon': '🍺', 'query': 'pub', 'regex': r'\b(british|irish|cask_ale|sunday_roast|gastropub|pub)\b'},
    {'id': 'wine_bar', 'label': 'Natural Wine Bars & Cellars', 'icon': '🍷', 'query': 'wine bar', 'regex': r'\b(wine_bar|wine bar|vinotheque|natural wine|wijnbar|cocktails|drinks)\b'},
    {'id': 'latin', 'label': 'Latin American & Caribbean', 'icon': '🌮', 'query': 'latin', 'regex': r'\b(argentinian|caribbean|peruvian|colombian|empanada|arepa|ceviche|latin)\b'}
]

ARCHETYPE_BY_ID = {a['id']: a for a in MASTER_CRAFT_ARCHETYPES}
for _a in MASTER_CRAFT_ARCHETYPES:
    _a['_re'] = re.compile(_a['regex'], re.IGNORECASE)

# MECE Mutually Exclusive Priority Order (Specific Craft Specialist > Broad Regional Dining)
SPECIFICITY_PRIORITY = [
    # Level 1: Dedicated sweet & beverage specialists
    'gelato', 'pancakes', 'patisserie', 'bubble_tea', 'coffee',
    # Level 2: Dedicated craft mono-specialists
    'pizza', 'ramen', 'sushi', 'doner', 'ocakbasi', 'pide', 'kofte', 'baklava',
    'shawarma', 'falafel', 'mandi', 'persian', 'esnaf', 'frites', 'bbq', 'burger', 'steak',
    # Level 3: Distinct national heritage kitchens
    'surinamese', 'indonesian', 'ethiopian', 'moroccan', 'thai', 'vietnamese',
    'korean', 'indian', 'chinese', 'mexican', 'tapas', 'greek',
    # Level 4: Core traditional culinary categories
    'seafood', 'deli', 'bakery', 'italian', 'french', 'craft_beer', 'tavern',
    # Level 5: Broad European & Regional heritage
    'latin', 'gastropub', 'wine_bar', 'bistro', 'dutch'
]

class PalateEngine:
    def __init__(self, city_id="amsterdam", data_path=None, accreditations_path=None, vectors_path=None, model_path=None):
        self.city_id = (city_id or "amsterdam").lower().strip()
        self.city_config = self.load_city_config()
        
        city_dir = os.path.join(DATA_DIR, self.city_id)
        self.data_path = data_path or (os.path.join(city_dir, "places.json") if os.path.exists(os.path.join(city_dir, "places.json")) else DATA_FILE)
        self.accreditations_path = accreditations_path or (os.path.join(city_dir, "accreditations.json") if os.path.exists(os.path.join(city_dir, "accreditations.json")) else ACCREDITATIONS_FILE)
        self.vectors_path = vectors_path or (os.path.join(city_dir, "vectors.npy") if os.path.exists(os.path.join(city_dir, "vectors.npy")) else VECTORS_FILE)
        self.model_path = model_path or (os.path.join(city_dir, "semantic_model.pkl") if os.path.exists(os.path.join(city_dir, "semantic_model.pkl")) else MODEL_FILE)
        
        self.epicenters = self.city_config.get("epicenters", TOURIST_EPICENTERS)
        self.places = []
        self.accreditations = []
        self.vectors = None
        self.vectorizer = None
        self.svd = None
        self.load_accreditations()
        self.load_data()
        self.load_semantic_model()
        self.neighborhood_map = NEIGHBORHOOD_ALIASES_BY_CITY.get(self.city_id, {})

    def load_city_config(self):
        cities_file = os.path.join(DATA_DIR, "cities.json")
        if os.path.exists(cities_file):
            try:
                with open(cities_file, "r", encoding="utf-8") as f:
                    cities = json.load(f)
                    for c in cities:
                        if c.get("id") == self.city_id:
                            return c
            except Exception as e:
                print(f"Error loading cities.json: {e}")
        return {
            "id": self.city_id,
            "name": self.city_id.capitalize(),
            "epicenters": TOURIST_EPICENTERS,
            "waterfront_label": "⛵ Canal Terrace",
            "heritage_badge_label": "🏛️ Historic Monuments"
        }

    def load_semantic_model(self):
        """Load the precomputed 128-dim dense semantic vector matrix and SVD pipeline."""
        if os.path.exists(self.vectors_path) and os.path.exists(self.model_path):
            try:
                self.vectors = np.load(self.vectors_path)
                with open(self.model_path, "rb") as f:
                    model = pickle.load(f)
                self.vectorizer = model.get("vectorizer")
                self.svd = model.get("svd")
                if self.vectorizer is not None and self.svd is not None and len(self.places) > len(self.vectors):
                    extra_places = self.places[len(self.vectors):]
                    extra_texts = [f"{p.get('name', '')} {p.get('primary_category', '')} {p.get('cuisine', '')} {' '.join(p.get('craft_badges', []))}" for p in extra_places]
                    extra_tfidf = self.vectorizer.transform(extra_texts)
                    extra_dense = self.svd.transform(extra_tfidf)
                    norms = np.linalg.norm(extra_dense, axis=1, keepdims=True)
                    norms[norms == 0] = 1.0
                    extra_dense = extra_dense / norms
                    self.vectors = np.vstack([self.vectors, extra_dense])
                print(f"Loaded {self.vectors.shape[0]} dense semantic vectors (128-dim) for TasteOS semantic search.")
            except Exception as e:
                print(f"Warning: Failed to load semantic model: {e}")
                self.vectors = None
                self.vectorizer = None
                self.svd = None

    def load_accreditations(self):
        """Load the structured Guide of Guides awards table (place_accreditations)."""
        if os.path.exists(self.accreditations_path):
            with open(self.accreditations_path, "r", encoding="utf-8") as f:
                raw_accs = json.load(f)
            self.accreditations = []
            for acc in raw_accs:
                item = dict(acc)
                item["_m_name"] = acc.get("match_name", "").lower().strip()
                item["_m_norm"] = self._normalize_name(item["_m_name"])
                m_core = GENERIC_WRAPPER_RE.sub(' ', item["_m_norm"])
                item["_m_core"] = re.sub(r'\s+', ' ', m_core).strip()
                item["_re_norm"] = re.compile(r'\b' + re.escape(item["_m_norm"]) + r'\b') if len(item["_m_norm"]) >= 6 else None
                item["_re_core"] = re.compile(r'\b' + re.escape(item["_m_core"]) + r'\b') if len(item["_m_core"]) >= 6 else None
                item["_ex_patterns"] = []
                if acc.get("exclude_match"):
                    raw_ex = acc["exclude_match"]
                    patterns = raw_ex if isinstance(raw_ex, list) else [p.strip() for p in str(raw_ex).split("|") if p.strip()]
                    for p in patterns:
                        item["_ex_patterns"].append((p.lower(), self._normalize_name(p)))
                self.accreditations.append(item)
            print(f"Loaded {len(self.accreditations)} official third-party accreditations.")

    def _normalize_name(self, text):
        s = text.lower().strip()
        replacements = {
            'ö': 'o', 'ç': 'c', 'ş': 's', 'ı': 'i', 'ğ': 'g', 'ü': 'u',
            'é': 'e', 'è': 'e', 'ê': 'e', 'ë': 'e',
            'à': 'a', 'á': 'a', 'â': 'a', 'ä': 'a',
            'î': 'i', 'ï': 'i', 'ô': 'o', 'ó': 'o',
            'û': 'u', 'ú': 'u', 'ñ': 'n',
            'ō': 'o', 'ū': 'u', 'ī': 'i', 'ā': 'a', 'ē': 'e'
        }
        for k, v in replacements.items():
            s = s.replace(k, v)
        s = s.replace('\ufffd', 'e')
        # Strip apostrophes and punctuation for fuzzy token joining
        s = re.sub(r"['’`\.\-]", "", s)
        s = re.sub(r"\s+", " ", s)
        return s.strip()

    def match_all_accreditations(self, place_name):
        """Find ALL matching third-party accreditations for a place (e.g. Michelin + Lekker 500)."""
        p_name = place_name.lower().strip()
        p_norm = self._normalize_name(place_name)
        matches = []
        source_priority = {
            "michelin": 10,
            "michelin_bib": 9,
            "worlds_50_best": 10,
            "50_top_pizza": 9,
            "avpn_napoli": 9,
            "gault_millau": 9,
            "vedat_milor": 9,
            "incili_gastronomi": 8,
            "oad": 8,
            "la_liste": 8,
            "grandes_tables": 8,
            "relais_chateaux": 8,
            "50_best_discovery": 9,
            "gouden_pollepel": 8,
            "entree_awards": 7,
            "lekker_500": 8,
            "european_coffee_trip": 8,
            "world_barista_championship": 8,
            "specialty_coffee_association": 8,
            "fact_awards": 7,
            "timeout_awards": 7,
            "whats_on": 7,
            "eater_38": 7,
            "worlds_101_best_steak": 9,
            "burgerdudes_worlds_best_burgers": 8,
            "gelato_festival_world_masters": 8,
            "tokyo_ramen_of_the_year": 9,
            "coupe_du_monde_boulangerie": 9,
            "texas_monthly_bbq": 9,
            "concurso_paella_valenciana": 8,
            "tabelog": 9,
            "gambero_rosso": 9,
            "slow_food": 8,
            "guia_repsol": 8,
            "le_fooding": 8,
            "good_food_guide": 8,
            "james_beard": 9,
            "het_parool": 6,
            "amsterdam_heritage": 5
        }
        p_core = GENERIC_WRAPPER_RE.sub(' ', p_norm)
        p_core = re.sub(r'\s+', ' ', p_core).strip()

        for acc in self.accreditations:
            if acc.get("_ex_patterns"):
                if any(ex_norm in p_norm or ex_raw in p_name for ex_raw, ex_norm in acc["_ex_patterns"]):
                    continue
            m_raw = acc["_m_name"]
            m_norm = acc["_m_norm"]
            
            # 1. Exact match on raw name or normalized form
            if m_raw == p_name or m_norm == p_norm:
                matches.append(acc)
                continue
                
            # 2. Distinctive core equality (e.g. "bocca" == "bocca", "massimo" == "massimo")
            m_core = acc["_m_core"]

            if len(m_core) >= 4 and len(p_core) >= 4 and m_core == p_core:
                matches.append(acc)
            # 3. Whole-phrase word-bounded match (e.g. "\bfort negen\b" in "fort negen bakery")
            elif acc["_re_norm"] and acc["_re_norm"].search(p_norm):
                matches.append(acc)
            # 4. Multi-word or long distinctive core inclusion (>= 6 chars)
            elif acc["_re_core"] and len(p_core) >= 6 and acc["_re_core"].search(p_core):
                matches.append(acc)
        # Sort so highest prestige comes first
        matches.sort(key=lambda x: source_priority.get(x.get("source", ""), 1), reverse=True)
        return [{k: v for k, v in x.items() if not k.startswith("_")} for x in matches]

    def match_accreditation(self, place_name):
        """Simulate SQL JOIN place_accreditations ON place_id / name."""
        matches = self.match_all_accreditations(place_name)
        return matches[0] if matches else None

    def get_place_archetypes(self, p):
        badges = " ".join(p.get("craft_badges") or []).lower()
        name = (p.get("name") or "").lower()
        cat = (p.get("primary_category") or "").lower()
        cuisine = (p.get("cuisine") or "").lower()
        must_try = (p.get("must_try") or "").lower()
        
        # Generic OSM tag sanitize: cafes, bars, and bistros frequently have "coffee;tea;pastry;espresso"
        sanitized_cuisine = cuisine
        if cat in ("cafe", "bar", "pub", "restaurant") or "coffee" in cuisine:
            sanitized_cuisine = re.sub(r'\bpastry\b', '', sanitized_cuisine)
        
        text = f"{name} {cat} {sanitized_cuisine} {badges} {must_try}".lower()
        
        matched_candidates = set()
        for a in MASTER_CRAFT_ARCHETYPES:
            aid = a["id"]
            if aid == "patisserie":
                if re.search(r'\b(p[aâ]tisserie|chocolatier|chocolade|chocolate|bonbon|stroopwafel|banketbakkerij|confectionery|macaron|viennoiserie|eclair|éclair|croissant)\b', f"{name} {badges} {must_try}"):
                    matched_candidates.add("patisserie")
                elif cat in ["bakery", "pastry", "chocolatier", "confectionery"]:
                    if re.search(r'\b(pastry|cake|taart|baking|sweet|viennoiserie|patisserie|chocolate|bonbon|stroopwafel|croissant)\b', f"{name} {cuisine} {must_try} {badges}") or cat in ["pastry", "chocolatier", "confectionery"]:
                        matched_candidates.add("patisserie")
                elif re.search(r'\b(p[aâ]tisserie|chocolatier|bonbon|stroopwafel)\b', sanitized_cuisine):
                    matched_candidates.add("patisserie")
            elif aid == "pizza":
                if re.search(r'\b(pizza|pizzeria|napoletana)\b', f"{name} {cat} {cuisine}"):
                    matched_candidates.add("pizza")
            elif aid == "dutch":
                if self.city_id == "amsterdam" and a["_re"].search(text):
                    matched_candidates.add("dutch")
            else:
                if a["_re"].search(text):
                    matched_candidates.add(aid)
                    
        # MECE Selection: Mutually exclusive priority assignment (most specific craft wins)
        for prio_id in SPECIFICITY_PRIORITY:
            if prio_id in matched_candidates:
                return [prio_id]
                
        # MECE Fallback: 100% Collective Exhaustiveness (every authentic venue has a home)
        if cat in ("cafe", "coffee_shop"):
            return ["coffee"]
        if cat in ("bakery", "pastry"):
            return ["bakery"]
        if cat == "pub" or "pub" in cuisine or "cask_ale" in cuisine:
            return ["gastropub"]
        if cat == "bar" or "wine" in cuisine or "cocktails" in cuisine:
            return ["wine_bar"]
        if cat == "pizza":
            return ["pizza"]
        if "argentinian" in cuisine or "latin" in cuisine:
            return ["latin"]
        if self.city_id == "amsterdam":
            return ["dutch"]
        return ["bistro"]

    def load_data(self):
        if not os.path.exists(self.data_path):
            print(f"Data file not found: {self.data_path}")
            return
        with open(self.data_path, "r", encoding="utf-8") as f:
            raw_places = json.load(f)
        
        # Deduplication safeguard: eliminate duplicate venue records with same normalized (name, address)
        seen_keys = set()
        deduped = []
        for p in raw_places:
            addr = (p.get("address") or "").lower().strip()
            name = (p.get("name") or "").lower().strip()
            key = (name, addr)
            if addr and addr not in ["amsterdam, netherlands", "dubai, united arab emirates", "istanbul, turkey"] and key in seen_keys:
                continue
            if addr and addr not in ["amsterdam, netherlands", "dubai, united arab emirates", "istanbul, turkey"]:
                seen_keys.add(key)
            deduped.append(p)

        self.places = [self.evaluate_place(p) for p in deduped]
        for p in self.places:
            mece_clusters = self.get_place_archetypes(p)
            p["_cluster_ids"] = mece_clusters
            primary_id = mece_clusters[0] if mece_clusters else "bistro"
            p["primary_cluster_id"] = primary_id
            arch_meta = ARCHETYPE_BY_ID.get(primary_id, {})
            p["primary_cluster_label"] = arch_meta.get("label", primary_id.capitalize())
            p["primary_cluster_icon"] = arch_meta.get("icon", "✨")
        print(f"PalateEngine [{self.city_id}] initialized with {len(self.places)} analyzed venues (100% MECE architecture).")

    def evaluate_place(self, p):
        name = p.get("name", "")
        cats = p.get("alternate_categories", [])
        combined_text = f"{name} {p.get('primary_category', '')} {' '.join(cats)} {p.get('cuisine', '')} {p.get('must_try', '')}".lower()
        
        # 1. Smarter Category Purity
        # Filters out generic administrative tags that do NOT dilute culinary craft
        specialized_alts = [
            c for c in cats 
            if c.lower() not in GENERIC_WRAPPER_TAGS 
            and c.lower() != p.get("primary_category", "").lower()
        ]
        
        total_relevant_categories = 1 + len(specialized_alts)
        category_purity = 1.0 / total_relevant_categories
        purity_score = round(category_purity * 25.0, 1)

        # 2. Universal Craft Lexicon Matching
        craft_score = 0
        craft_badges = []
        craft_details = []
        
        for rule in CRAFT_PATTERNS:
            if re.search(rule["regex"], combined_text, re.IGNORECASE):
                craft_badges.append(rule["badge"])
                craft_details.append(rule["detail"])
                craft_score += rule["points"]

        craft_score = min(craft_score, 35)

        # 3. Relational Critic Accreditations (The 'Guide of Guides' Join)
        accreditations = self.match_all_accreditations(name)
        primary_accreditation = accreditations[0] if accreditations else p.get("accreditation")
        accreditation = primary_accreditation

        critic_score = 0
        if accreditations:
            # 35 base for primary guide + 5 consensus bonus for each additional authority (max 45)
            critic_score = min(45, 35 + (len(accreditations) - 1) * 5)
            for acc in reversed(accreditations):
                tier_name = acc.get("award_tier") or acc.get("award") or "Culinary Distinction"
                award_badge = tier_name if any(tier_name.startswith(sym) for sym in ["🏅", "⭐", "🍴", "🏆", "🟢", "🍕", "☕", "🇳🇱", "🎖️", "💎"]) else f"🏅 {tier_name}"
                if award_badge not in craft_badges:
                    craft_badges.insert(0, award_badge)
            if len(accreditations) >= 2:
                consensus_badge = f"🏆 Critical Consensus ({len(accreditations)} Independent Guides)"
                if consensus_badge not in craft_badges:
                    craft_badges.insert(0, consensus_badge)
        elif p.get("accreditation"):
            critic_score = 35
            tier_name = p["accreditation"].get("award_tier") or p["accreditation"].get("award") or "Culinary Distinction"
            award_badge = tier_name if any(tier_name.startswith(sym) for sym in ["🏅", "⭐", "🍴", "🏆", "🟢", "🍕", "☕", "🇳🇱", "🎖️", "💎"]) else f"🏅 {tier_name}"
            if award_badge not in craft_badges:
                craft_badges.insert(0, award_badge)

        # 4. Tourist Trap Negative Patterns
        trap_flags = []
        trap_penalty = 0
        for pat in TOURIST_TRAP_PATTERNS:
            if re.search(pat["regex"], combined_text, re.IGNORECASE):
                trap_flags.append(pat["flag"])
                trap_penalty += pat["penalty"]

        # 5. Tourist Zone Spatial Penalty
        lat = p.get("latitude")
        lon = p.get("longitude")
        min_epicenter_dist = 999999.0
        nearest_epicenter = ""
        if lat and lon:
            for epic in self.epicenters:
                d = haversine_distance_m(lat, lon, epic["lat"], epic["lon"])
                if d < min_epicenter_dist:
                    min_epicenter_dist = d
                    nearest_epicenter = epic["name"]

        spatial_score = 0
        is_tourist_trap = False
        if min_epicenter_dist < 85:
            if craft_score < 20 and not accreditation:
                spatial_score = -30
                trap_flags.append(f"⚠️ Epicenter Alert: Located within {int(min_epicenter_dist)}m of {nearest_epicenter}")
                is_tourist_trap = True
        elif min_epicenter_dist < 180:
            if craft_score < 15 and not accreditation:
                spatial_score = -15
        elif min_epicenter_dist > 350:
            spatial_score = 10

        # 6. Independence vs. Global Industrial Chains
        ownership = p.get("ownership", {})
        brand = p.get("brand")
        brand_clean = (brand or "").strip().lower()
        is_industrial_chain = brand_clean in GLOBAL_INDUSTRIAL_CHAINS or (not ownership.get("is_independent", True) if ownership else False)
        
        if ownership.get("type") == "independent":
            independence_score = 25
        elif ownership.get("type") == "mini_group":
            independence_score = 15
        elif is_industrial_chain:
            independence_score = 0
            chain_label = ownership.get("badge") or f"Owned by '{brand}'"
            trap_flags.append(f"🏢 Multi-Unit Chain: {chain_label}")
        else:
            independence_score = 15

        # 7. Lindy Longevity Score
        start_year = p.get("start_year")
        longevity_score = 0
        longevity_badge = None
        if start_year:
            age = 2026 - start_year
            if age >= 100:
                longevity_score = 30
                longevity_badge = f"🏛️ Century-Old Institution ({age} yrs, est. {start_year})"
            elif age >= 25:
                longevity_score = 20
                longevity_badge = f"⏳ Lindy Survivor ({age} yrs, est. {start_year})"
            elif age >= 10:
                longevity_score = 10
                longevity_badge = f"Established Local Favorite (est. {start_year})"

        # 8. Operational Rhythm & In-House Production Signal
        rhythm_score = 0
        schedule_rhythm = p.get("schedule_rhythm", "standard")
        if schedule_rhythm == "artisan_rhythm":
            rhythm_score = 10
        elif schedule_rhythm == "tourist_continuous":
            rhythm_score = -15
            trap_flags.append("⚠️ Factory Schedule: Continuous 7-day all-hours commercial mass production")

        amenities = p.get("amenities", {})
        in_house_score = 0
        if amenities.get("microbrewery"):
            in_house_score += 15
            craft_badges.append("🍺 In-House Craft Microbrewery")
        if amenities.get("in_house_roastery"):
            in_house_score += 15
            craft_badges.append("☕ In-House Specialty Coffee Roastery")

        # 10. Classic Cash-Only Lindy Marker
        cash_score = 5 if p.get("cash_only") else 0
        if p.get("cash_only") and "💶 Old-School Cash Only" not in craft_badges:
            craft_badges.append("💶 Old-School Cash Only")

        # 11. Architectural Monument & Heritage Signal (Gemeente Amsterdam / BAG)
        heritage = p.get("heritage", {})
        heritage_score = 0
        if heritage.get("is_monument"):
            if heritage.get("badge") and heritage["badge"] not in craft_badges:
                craft_badges.append(heritage["badge"])
            if heritage.get("authenticity_boost"):
                # Meaningful quality boost for authentic operators in protected monuments
                heritage_score = 15 if heritage.get("status") == "Rijksmonument" else 10

        # Dietary Badges
        dietary = p.get("dietary", {})
        dietary_badges = []
        if dietary.get("halal"):
            dietary_badges.append("🥩 Halal Friendly")
        if dietary.get("vegan"):
            dietary_badges.append("🌿 100% Vegan Friendly")
        elif dietary.get("vegetarian"):
            dietary_badges.append("🌱 Vegetarian Friendly")
        if dietary.get("gluten_free"):
            dietary_badges.append("🌾 Gluten-Free Options")
        if dietary.get("kosher"):
            dietary_badges.append("✡️ Kosher")

        # Amenity Badges
        amenity_badges = []
        if amenities.get("canal_terrace"):
            waterfront_badge = "⛵ Canal Terrace" if self.city_id == "amsterdam" else ("🌊 Bosphorus Terrace" if self.city_id == "istanbul" else "🌊 Waterfront Terrace")
            amenity_badges.append(waterfront_badge)
        elif amenities.get("outdoor_seating"):
            amenity_badges.append("☀️ Outdoor Seating")
        if amenities.get("wheelchair_accessible"):
            amenity_badges.append("♿ Wheelchair Accessible")

        # Celiac & Medical Kitchen Safety
        celiac_safety = p.get("celiac_safety", {})
        celiac_score = 0
        if celiac_safety.get("is_safe"):
            celiac_score = 15 if celiac_safety.get("certified_by") == "NCV Horeca Alliantie" else 10
            if celiac_safety.get("badge") and celiac_safety["badge"] not in dietary_badges:
                dietary_badges.insert(0, celiac_safety["badge"])

        # Scratch Kitchen Craft
        scratch = p.get("scratch_kitchen", {})
        scratch_score = 0
        if scratch.get("is_scratch"):
            scratch_score = 10
            if scratch.get("badge") and scratch["badge"] not in craft_badges:
                craft_badges.append(scratch["badge"])

        # Honest Hospitality / Tap Water
        hospitality = p.get("hospitality", {})
        hospitality_score = 0
        if hospitality.get("free_tap_water"):
            hospitality_score = 5
            if hospitality.get("badge") and hospitality["badge"] not in amenity_badges:
                amenity_badges.append(hospitality["badge"])

        # 12. Urban Food Habitat Matrix (Local Resident Enclave vs Tourist Corridor)
        habitat = p.get("habitat", {})
        habitat_score = 0
        resident_density = habitat.get("resident_food_density", 0)
        tourist_kiosks = habitat.get("tourist_kiosk_density", 0)
        if resident_density >= 2:
            habitat_score = 10
            if "🏘️ Resident Food Habitat" not in craft_badges:
                craft_badges.append("🏘️ Resident Food Habitat")
        elif tourist_kiosks >= 3 and not accreditation:
            spatial_score -= 15
            trap_flags.append("⚠️ Tourist Funnel Corridor: Surrounded by souvenir & exchange kiosks")

        # 13. Multilingual Over-Translation Distortion Index
        translations_count = p.get("translations_count", len(p.get("name_translations", [])))
        if translations_count >= 5 and not accreditation and not p.get("is_luxury_hotel"):
            trap_penalty -= 15
            trap_flags.append("🚩 Multilingual Tourist Lure: 5+ languages printed to capture tourist foot-traffic")

        # 14. Dedicated Experiential Dining vs Ghost / Virtual Dark Kitchen
        is_ghost = p.get("is_ghost_kitchen") or (
            amenities.get("indoor_seating") is False and (amenities.get("takeaway_only") or amenities.get("delivery_only"))
        )
        if is_ghost:
            p["is_ghost_kitchen"] = True
            trap_flags.append("📦 Dark / Ghost Kitchen: Virtual delivery brand without experiential dining room")

        # 15. Direct Digital Independence (Custom Domain vs Aggregator)
        website = p.get("website", "")
        digital_score = 0
        if website:
            domain = website.lower()
            if not any(agg in domain for agg in ["deliveroo", "talabat", "ubereats", "yemeksepeti", "thuisbezorgd", "linktr.ee", "facebook.com", "instagram.com"]):
                digital_score = 5

        # 16. Government Food Safety & Clean Kitchen Inspection
        food_safety = p.get("food_safety") or {}
        fs_grade = food_safety.get("inspection_grade", "")
        food_safety_score = 0
        if fs_grade in ["Grade A", "5/5", "Très satisfaisant", "Elite Smiley"]:
            food_safety_score = 15
            fs_badge = food_safety.get("badge") or "🏆 Grade A Clean Kitchen"
            if fs_badge not in amenity_badges:
                amenity_badges.append(fs_badge)
        elif fs_grade in ["Grade B", "4/5", "Satisfaisant"]:
            food_safety_score = 5
            fs_badge = food_safety.get("badge") or "🥈 Grade B Clean Kitchen"
            if fs_badge not in amenity_badges:
                amenity_badges.append(fs_badge)
        elif fs_grade in ["Grade D", "Grade E", "0/5", "1/5", "Violation"]:
            trap_penalty -= 50
            trap_flags.append(f"⚠️ Municipal Hygiene Warning: Critical sanitation failure ({fs_grade})")

        # Confidence Factor
        conf = p.get("confidence", 0.85)
        conf_multiplier = min(1.0, 0.85 + (conf * 0.15))

        # Final Composite Quality Score
        positive_components = (
            purity_score +
            craft_score +
            independence_score +
            longevity_score +
            critic_score +
            rhythm_score +
            in_house_score +
            cash_score +
            heritage_score +
            celiac_score +
            scratch_score +
            hospitality_score +
            habitat_score +
            digital_score +
            food_safety_score
        )
        adjusted_positive = positive_components * conf_multiplier
        raw_score = adjusted_positive + spatial_score + trap_penalty
        final_score = max(5, min(99, int(raw_score)))

        if trap_penalty <= -30 or (min_epicenter_dist < 85 and craft_score < 15 and not accreditation) or is_industrial_chain:
            is_tourist_trap = True

        if final_score >= 80:
            tier_label = "🏆 Artisanal Culinary Master"
        elif final_score >= 60:
            tier_label = "⭐ Authentic Local Favorite"
        elif final_score >= 40:
            tier_label = "☕ Decent Neighborhood Spot"
        else:
            tier_label = "☕ Neighborhood Spot"

        # 17. Rule-Based Culinary Price Tiering (Option B)
        # Tier 4: Fine Dining / Michelin Stars / World's 50 Best / Luxury Omakase
        # Tier 3: Upscale Dining / Bib Gourmand / Premium Steakhouses & Bistros
        # Tier 2: Casual Sit-down / Neighborhood Favorites / Ramen / Trattorias / Burgers
        # Tier 1: Street Food / Budget / Döner / Bakeries / Falafel / Fast Casual
        award_sources = [a.get("source", "").lower() for a in accreditations]
        award_tiers = [a.get("award_tier", "").lower() for a in accreditations]
        primary_cat = p.get("primary_category", "").lower()
        amenity_type = p.get("amenity", "").lower()

        # Explicit budget / street food signals
        has_budget_or_street_signal = (
            any(k in t for t in award_tiers for k in ["budget", "street food", "fish fry", "cheap", "shack", "karahi", "kebab master"]) or
            primary_cat in ["haringhandel", "doner", "shawarma", "falafel", "bakery", "tea", "ice_cream", "gelato", "fast_food", "soup", "deli", "sandwich", "mandi"] or
            amenity_type in ["fast_food"] or
            p.get("is_ghost_kitchen")
        )

        is_tier_4 = (
            not has_budget_or_street_signal and (
                any("star" in t and "green star" not in t.lower() for t in award_tiers) or
                any(s in ["worlds_50_best", "oad", "grandes_tables"] for s in award_sources if not any("discovery" in t for t in award_tiers)) or
                primary_cat in ["omakase", "fine_dining"] or
                any("michelin 3 star" in b.lower() or "michelin 2 star" in b.lower() or "michelin 1 star" in b.lower() for b in craft_badges)
            )
        )
        is_tier_3 = (
            not has_budget_or_street_signal and not is_tier_4 and (
                any("bib" in t for t in award_tiers) or
                any(s in ["gault_millau", "50_top_pizza", "lekker_500", "vedat_milor"] for s in award_sources) or
                primary_cat in ["steak", "french", "contemporary", "bistro", "seafood", "bosphorus_seafood", "spanish", "tapas"] or
                (primary_cat == "italian" and "pizza" not in p.get("cuisine", ""))
            )
        )
        is_tier_1 = (
            has_budget_or_street_signal or
            any("budget" in t or "street food" in t for t in award_tiers)
        )

        if is_tier_4:
            price_tier = 4
        elif is_tier_3:
            price_tier = 3
        elif is_tier_1:
            price_tier = 1
        else:
            price_tier = 2

        currency_sym = self.city_config.get("currency_symbol", "€")
        tier_names = {
            1: "Budget / Street Food",
            2: "Casual Dining",
            3: "Upscale Dining",
            4: "Fine Dining / Tasting"
        }
        price_label = currency_sym * price_tier if currency_sym != "AED" else ("AED" if price_tier == 1 else f"AED {price_tier}")

        return {
            **p,
            "quality_score": final_score,
            "category_purity": round(category_purity, 2),
            "purity_score": purity_score,
            "craft_badges": craft_badges,
            "craft_details": craft_details,
            "dietary_badges": dietary_badges,
            "amenity_badges": amenity_badges,
            "trap_flags": trap_flags,
            "is_tourist_trap": is_tourist_trap,
            "longevity_badge": longevity_badge,
            "is_chain": is_industrial_chain,
            "tier_label": tier_label,
            "accreditation": accreditation,
            "all_accreditations": accreditations,
            "confidence": conf,
            "dist_to_tourist_hub_m": int(min_epicenter_dist) if min_epicenter_dist < 999999 else None,
            "nearest_tourist_hub": nearest_epicenter,
            "food_safety": food_safety,
            "price_tier": price_tier,
            "price_label": price_label,
            "price_tier_name": tier_names[price_tier]
        }

    def parse_geo_intent(self, query):
        """Extract neighborhood entity and decouple location terms from food query."""
        q_clean = (query or "").strip()
        q_lower = q_clean.lower()
        if not q_lower:
            return query, None, []

        sorted_keys = sorted(self.neighborhood_map.keys(), key=lambda k: len(k), reverse=True)
        for key in sorted_keys:
            aliases = self.neighborhood_map[key]
            for alias in aliases:
                # 1. Prepositional phrases: e.g. "in marina", "near jlt", "around satwa", "bij de pijp"
                prep_pattern = rf'\b(in|at|near|around|by|bij)\s+{re.escape(alias)}\b'
                prep_match = re.search(prep_pattern, q_lower)
                if prep_match:
                    food_q = re.sub(prep_pattern, '', q_clean, flags=re.IGNORECASE).strip()
                    food_q = re.sub(r'\s+', ' ', food_q)
                    return food_q, key, aliases

                # 2. Standalone neighborhood token: e.g. "shawarma satwa" or "satwa"
                token_pattern = rf'\b{re.escape(alias)}\b'
                if re.search(token_pattern, q_lower):
                    food_q = re.sub(token_pattern, '', q_clean, flags=re.IGNORECASE).strip()
                    food_q = re.sub(r'\b(in|at|near|around|by|bij)\b', '', food_q, flags=re.IGNORECASE).strip()
                    food_q = re.sub(r'\s+', ' ', food_q)
                    return food_q, key, aliases

        return query, None, []

    def search(
        self, 
        query="", 
        user_lat=52.3680, 
        user_lon=4.8900, 
        offset=0,
        max_results=40,
        cuisine=None,
        diet=None,
        outdoor=False,
        canal=False,
        wheelchair=False,
        accredited_only=False,
        monuments_only=False,
        independent_only=False,
        celiac_safe_only=False,
        scratch_only=False,
        tap_water_only=False,
        clean_only=False,
        late_night_only=False,
        roastery_only=False,
        historic_only=False,
        price_tiers=None,
        min_score=0,
        sort_by="quality",
        has_user_coords=False,
        return_total=False,
        bbox=None,
        max_dist_m=None
    ):
        # Geographic Entity Decoupling
        food_query, geo_target, geo_aliases = self.parse_geo_intent(query)
        effective_query = food_query if geo_target else query
        q_clean = effective_query.strip()
        q_lower = q_clean.lower()
        results = []

        arch = ARCHETYPE_BY_ID.get(cuisine) if cuisine else None
        arch_regex = re.compile(arch["regex"], re.IGNORECASE) if arch else None

        # Vector semantic inference
        sims = None
        if q_lower and self.vectorizer is not None and self.svd is not None and self.vectors is not None:
            try:
                q_tfidf = self.vectorizer.transform([q_clean])
                q_dense = self.svd.transform(q_tfidf)
                q_norm = np.linalg.norm(q_dense)
                if q_norm > 0:
                    q_dense = q_dense / q_norm
                sims = np.dot(self.vectors, q_dense.T).flatten()
            except Exception as e:
                print(f"Semantic inference error: {e}")
                sims = None

        tokens = q_lower.split() if q_lower else []
        intent_tokens = [t for t in tokens if t not in QUERY_INTENT_STOPWORDS]
        if not intent_tokens:
            intent_tokens = tokens  # fallback if query was purely generic (e.g., "restaurants")

        # Expand nationality / cuisine stems (e.g., syria <-> syrian, italy <-> italian)
        expanded_intent = set(intent_tokens)
        for t in intent_tokens:
            if t in CUISINE_NATIONALITY_EXPANSIONS:
                for exp in CUISINE_NATIONALITY_EXPANSIONS[t]:
                    expanded_intent.add(exp)

        for i, p in enumerate(self.places):
            # Exclude low-quality tourist traps completely
            if p.get("is_tourist_trap"):
                continue

            # Exclude delivery-only dark / ghost kitchens from experiential dining discovery
            if p.get("is_ghost_kitchen"):
                continue

            # Viewport Bounding Box Filter (min_lat, min_lon, max_lat, max_lon)
            if bbox and len(bbox) == 4:
                min_lat, min_lon, max_lat, max_lon = bbox
                plat = p.get("latitude")
                plon = p.get("longitude")
                if plat is None or plon is None or not (min_lat <= plat <= max_lat and min_lon <= plon <= max_lon):
                    continue

            # Calculate Distance
            dist_m = 0
            if p.get("latitude") and p.get("longitude"):
                dist_m = int(haversine_distance_m(user_lat, user_lon, p["latitude"], p["longitude"]))

            # Walking / Transit Radius Filter
            if max_dist_m is not None and dist_m > max_dist_m:
                continue

            # Geographic Neighborhood Intent Filtering
            venue_in_geo = False
            if geo_target and geo_aliases:
                venue_geo_text = f"{p.get('neighborhood') or ''} {p.get('address') or ''} {p.get('name') or ''}".lower()
                venue_in_geo = any(a in venue_geo_text for a in geo_aliases)
                # If query was solely a neighborhood (e.g. 'satwa', 'jordaan') without a food term, exclude other districts
                if not q_lower and not venue_in_geo:
                    continue

            # Dedicated craft archetype / cuisine cluster filter
            if arch:
                if arch["id"] not in p.get("_cluster_ids", []):
                    continue
            elif arch_regex:
                badges = " ".join(p.get("craft_badges") or [])
                text = f"{p['name']} {p.get('primary_category', '')} {p.get('cuisine', '')} {badges}".lower()
                if not arch_regex.search(text):
                    continue

            # 1. Dietary filter
            if diet:
                diet_key = diet.lower().strip()
                if diet_key in ("celiac", "celiac_safe"):
                    if not p.get("celiac_safety", {}).get("is_safe"):
                        continue
                elif diet_key in ("gluten_free", "glutenfree", "gf"):
                    if not (p.get("dietary", {}).get("gluten_free") or p.get("celiac_safety", {}).get("is_safe")):
                        continue
                elif not p.get("dietary", {}).get(diet_key):
                    continue

            # 2. Amenity, Heritage & Transparency filters
            if outdoor and not p.get("amenities", {}).get("outdoor_seating"):
                continue
            if canal and not p.get("amenities", {}).get("canal_terrace"):
                continue
            if wheelchair and not p.get("amenities", {}).get("wheelchair_accessible"):
                continue
            if accredited_only and not p.get("accreditation"):
                continue
            if monuments_only and not p.get("heritage", {}).get("is_monument"):
                continue
            if independent_only and not p.get("ownership", {}).get("is_independent"):
                continue
            if celiac_safe_only and not p.get("celiac_safety", {}).get("is_safe"):
                continue
            if scratch_only and not p.get("scratch_kitchen", {}).get("is_scratch"):
                continue
            if tap_water_only and not p.get("hospitality", {}).get("free_tap_water"):
                continue
            if clean_only:
                fs = p.get("food_safety") or {}
                if fs.get("inspection_grade") not in ["Grade A", "5/5", "Très satisfaisant", "Elite Smiley"]:
                    continue
            if late_night_only and not p.get("amenities", {}).get("late_night"):
                continue
            if roastery_only and not p.get("amenities", {}).get("in_house_roastery"):
                continue
            if historic_only and not ((p.get("heritage") or {}).get("is_historic") or (p.get("start_year") and p["start_year"] <= 2010)):
                continue
            if price_tiers:
                tiers_set = {price_tiers} if isinstance(price_tiers, int) else set(price_tiers)
                if p.get("price_tier") not in tiers_set:
                    continue
            if min_score and p["quality_score"] < min_score:
                continue

            sim = float(sims[i]) if (sims is not None and i < len(sims)) else 0.0
            exact_bonus = 0.0
            intent_matched = False

            if not q_lower:
                match_weight = 1.0
            else:
                p_name = p["name"].lower()
                p_norm = self._normalize_name(p["name"])
                q_norm = self._normalize_name(q_lower)
                p_cat = p.get("primary_category", "").lower()
                p_cuisine = (p.get("cuisine") or "").lower()
                p_alts = [c.lower() for c in p.get("alternate_categories", [])]
                p_badges = [b.lower() for b in p.get("craft_badges", [])]

                # 1. Exact entity matches on place name (with unicode diacritic tolerance)
                if q_lower == p_name or q_norm == p_norm:
                    exact_bonus += 50.0
                    intent_matched = True
                elif q_lower in p_name or q_norm in p_norm:
                    exact_bonus += 35.0
                    intent_matched = True
                elif any(t in p_name or self._normalize_name(t) in p_norm for t in intent_tokens if len(t) > 2):
                    exact_bonus += 20.0
                    intent_matched = True

                # 2. Specific Category / Cuisine / Craft match (NEVER match generic stops like 'restaurant')
                for t in expanded_intent:
                    if t == p_cat or (len(t) >= 4 and t in p_cat and p_cat not in QUERY_INTENT_STOPWORDS):
                        exact_bonus += 25.0
                        intent_matched = True
                    if t in p_cuisine:
                        exact_bonus += 20.0
                        intent_matched = True
                    if any(t in c for c in p_alts if c not in QUERY_INTENT_STOPWORDS):
                        exact_bonus += 15.0
                        intent_matched = True
                    if any(t in b for b in p_badges):
                        exact_bonus += 15.0
                        intent_matched = True
                    dossier = p.get("dossier")
                    if dossier:
                        sig_lower = dossier.get("signature_dishes", "").lower()
                        if len(t) >= 4 and t in sig_lower:
                            exact_bonus += 25.0
                            intent_matched = True

                # 2b. Monument / Heritage queries boost authentic monuments
                if any(h in expanded_intent for h in ["historic", "monument", "rijksmonument", "heritage", "century", "oldest", "brown"]):
                    if p.get("heritage", {}).get("is_monument") and p.get("heritage", {}).get("authenticity_boost"):
                        exact_bonus += 35.0
                        intent_matched = True

                # 2c. Geographic Neighborhood Intent Match / Mismatch Penalty
                if geo_target:
                    if venue_in_geo:
                        exact_bonus += 250.0
                        intent_matched = True
                    else:
                        exact_bonus -= 100.0

                # 3. If user specified a clear intent (e.g. "syrian") and venue does NOT match it:
                # require strong semantic similarity (>= 0.65) to even be considered.
                has_clear_intent = len(intent_tokens) > 0 and len(intent_tokens) < len(tokens)
                if has_clear_intent and not intent_matched and sim < 0.65:
                    continue

                # Standard semantic cutoff
                if not intent_matched and sim < 0.20:
                    continue

            dist_penalty = min(15, (dist_m / 450.0))

            if not q_lower:
                if sort_by == "distance":
                    effective_rank = 10000 - dist_m + (p["quality_score"] * 0.5)
                elif sort_by == "endorsed":
                    effective_rank = (p.get("endorsement_count", 0) * 15.0) + p["quality_score"]
                elif sort_by == "heritage":
                    is_monument = 1 if p.get("heritage", {}).get("is_monument") else 0
                    dist_bias = dist_penalty if has_user_coords else 0
                    effective_rank = (is_monument * 500.0) + (p["quality_score"] * 0.85) - dist_bias
                else: # quality (default)
                    # When sorting by Culinary Quality across a city, quality score is king.
                    # Endorsement count is a subtle tie-breaker; distance is only a gentle tie-breaker if user gave real GPS.
                    tie_breaker = (p.get("endorsement_count", 0) * 0.05)
                    if has_user_coords:
                        tie_breaker -= min(1.0, dist_m / 10000.0)
                    effective_rank = (p["quality_score"] * 10.0) + tie_breaker
            else:
                # Active Search Query: Hybrid Vector Cosine Similarity (75x) + Palate Quality (0.40x) + Intent Exact Bonuses
                if sort_by == "distance":
                    effective_rank = 10000 - dist_m + (p["quality_score"] * 0.4) + (sim * 50.0) + exact_bonus
                elif sort_by == "endorsed":
                    effective_rank = (p.get("endorsement_count", 0) * 15.0) + (p["quality_score"] * 0.7) + (sim * 50.0) + exact_bonus
                elif sort_by == "heritage":
                    is_monument = 1 if p.get("heritage", {}).get("is_monument") else 0
                    dist_bias = dist_penalty if has_user_coords else 0
                    effective_rank = (is_monument * 500.0) + (sim * 75.0) + (p["quality_score"] * 0.40) + exact_bonus - dist_bias
                else: # quality (default)
                    dist_bias = min(2.0, dist_penalty) if has_user_coords else 0
                    effective_rank = (sim * 75.0) + (p["quality_score"] * 0.40) + exact_bonus - dist_bias

            results.append({
                **p,
                "distance_m": dist_m,
                "similarity_score": round(sim, 3) if q_lower else None,
                "effective_rank": round(effective_rank, 1),
                "matched_neighborhood": geo_target if venue_in_geo else None
            })

        results.sort(key=lambda x: x["effective_rank"], reverse=True)
        total_count = len(results)
        paginated = results[offset:offset + max_results]
        if return_total:
            return paginated, total_count
        return paginated

    def get_facets(self, authentic_only=False):
        """Return aggregations for UI filter buttons and system stats."""
        pool = [p for p in self.places if not p.get('is_tourist_trap') and not p.get('is_ghost_kitchen')] if authentic_only else self.places
        total = len(pool)
        return {
            "total_eateries": total,
            "halal_count": sum(1 for p in pool if p.get("dietary", {}).get("halal")),
            "vegan_count": sum(1 for p in pool if p.get("dietary", {}).get("vegan")),
            "vegetarian_count": sum(1 for p in pool if p.get("dietary", {}).get("vegetarian")),
            "gluten_free_count": sum(1 for p in pool if p.get("dietary", {}).get("gluten_free")),
            "canal_terrace_count": sum(1 for p in pool if p.get("amenities", {}).get("canal_terrace")),
            "outdoor_count": sum(1 for p in pool if p.get("amenities", {}).get("outdoor_seating")),
            "wheelchair_count": sum(1 for p in pool if p.get("amenities", {}).get("wheelchair_accessible")),
            "accredited_count": sum(1 for p in pool if p.get("accreditation")),
            "craft_artisans_detected": sum(1 for p in pool if p.get("craft_badges")),
            "tourist_traps_flagged": sum(1 for p in self.places if p.get("is_tourist_trap")),
            "mono_specialists": sum(1 for p in pool if p.get("category_purity", 0) == 1.0),
            "high_confidence_count": sum(1 for p in pool if p.get("confidence", 0) >= 0.85),
            "monuments_count": sum(1 for p in pool if p.get("heritage", {}).get("is_monument")),
            "rijksmonumenten_count": sum(1 for p in pool if p.get("heritage", {}).get("status") == "Rijksmonument"),
            "independent_count": sum(1 for p in pool if p.get("ownership", {}).get("is_independent")),
            "corporate_chain_count": sum(1 for p in pool if not p.get("ownership", {}).get("is_independent")),
            "celiac_safe_count": sum(1 for p in pool if p.get("celiac_safety", {}).get("is_safe")),
            "scratch_count": sum(1 for p in pool if p.get("scratch_kitchen", {}).get("is_scratch")),
            "tap_water_count": sum(1 for p in pool if p.get("hospitality", {}).get("free_tap_water")),
            "clean_kitchen_count": sum(1 for p in pool if (p.get("food_safety") or {}).get("inspection_grade") in ["Grade A", "5/5", "Très satisfaisant", "Elite Smiley"]),
            "late_night_count": sum(1 for p in pool if p.get("amenities", {}).get("late_night")),
            "roastery_count": sum(1 for p in pool if p.get("amenities", {}).get("in_house_roastery")),
            "historic_count": sum(1 for p in pool if (p.get("heritage") or {}).get("is_historic") or (p.get("start_year") and p["start_year"] <= 2010)),
            "price_1_count": sum(1 for p in pool if p.get("price_tier") == 1),
            "price_2_count": sum(1 for p in pool if p.get("price_tier") == 2),
            "price_3_count": sum(1 for p in pool if p.get("price_tier") == 3),
            "price_4_count": sum(1 for p in pool if p.get("price_tier") == 4)
        }

    def place_matches_filters(self, p, filters, exclude_keys=None):
        if not filters:
            return True
        if exclude_keys is None:
            exclude_keys = set()
            
        # 0. Exclude low-quality tourist traps and ghost kitchens
        if p.get("is_tourist_trap") or p.get("is_ghost_kitchen"):
            return False

        # 1. Price tier
        if "price" not in exclude_keys and filters.get("price") is not None:
            pt = filters["price"]
            tiers = {pt} if isinstance(pt, int) else set(pt)
            if p.get("price_tier") not in tiers:
                return False

        # 2. Cuisine cluster
        if "cuisine" not in exclude_keys and filters.get("cuisine"):
            target_c = filters["cuisine"]
            if target_c not in p.get("_cluster_ids", []):
                return False

        # 3. Diet
        if "diet" not in exclude_keys and filters.get("diet"):
            d = str(filters["diet"]).lower().strip()
            if d in ("celiac", "celiac_safe"):
                if not p.get("celiac_safety", {}).get("is_safe"):
                    return False
            elif d in ("gluten_free", "glutenfree", "gf"):
                if not (p.get("dietary", {}).get("gluten_free") or p.get("celiac_safety", {}).get("is_safe")):
                    return False
            elif not p.get("dietary", {}).get(d):
                return False

        # 4. Amenities / Flags
        amenities_map = {
            "outdoor": ("amenities", "outdoor_seating"),
            "canal": ("amenities", "canal_terrace"),
            "wheelchair": ("amenities", "wheelchair_accessible"),
            "late_night": ("amenities", "late_night"),
            "roastery": ("amenities", "in_house_roastery"),
            "scratch": ("scratch_kitchen", "is_scratch"),
            "water": ("hospitality", "free_tap_water"),
            "celiac": ("celiac_safety", "is_safe"),
            "monument": ("heritage", "is_monument"),
            "independent": ("ownership", "is_independent"),
        }
        for key, (sec, prop) in amenities_map.items():
            if key not in exclude_keys and filters.get(key):
                if not p.get(sec, {}).get(prop):
                    return False

        if "accredited" not in exclude_keys and filters.get("accredited"):
            if not p.get("accreditation"):
                return False

        if "clean" not in exclude_keys and filters.get("clean"):
            fs = p.get("food_safety") or {}
            if fs.get("inspection_grade") not in ["Grade A", "5/5", "Très satisfaisant", "Elite Smiley"]:
                return False

        if "historic" not in exclude_keys and filters.get("historic"):
            if not ((p.get("heritage") or {}).get("is_historic") or (p.get("start_year") and p["start_year"] <= 2010)):
                return False

        # 5. Spatial bounding box
        if "bbox" not in exclude_keys and filters.get("bbox"):
            bbox = filters["bbox"]
            if len(bbox) == 4:
                min_lat, min_lon, max_lat, max_lon = bbox
                plat, plon = p.get("latitude"), p.get("longitude")
                if plat is None or plon is None or not (min_lat <= plat <= max_lat and min_lon <= plon <= max_lon):
                    return False

        # 6. Max distance
        if "max_dist" not in exclude_keys and filters.get("max_dist") is not None and filters.get("user_lat") and filters.get("user_lon"):
            plat, plon = p.get("latitude"), p.get("longitude")
            if plat and plon:
                dist = haversine_distance_m(filters["user_lat"], filters["user_lon"], plat, plon)
                if dist > filters["max_dist"]:
                    return False

        return True

    def get_city_taxonomy(self, city_name=None, active_filters=None):
        """
        Dynamic City Taxonomy Engine with Cascading Facets:
        Computes top craft clusters, price tiers, and environmental facets for any city based on ground-truth data.
        When active_filters is provided, dynamically calculates cross-facet and disjunctive counts.
        """
        if not city_name:
            city_name = self.city_config.get("name", self.city_id.capitalize())

        authentic_places = [p for p in self.places if not p.get('is_tourist_trap') and not p.get('is_ghost_kitchen')]

        has_active_filters = False
        if active_filters:
            for k, v in active_filters.items():
                if v:
                    has_active_filters = True
                    break

        if not has_active_filters:
            base_pool = authentic_places
            cuisine_pool = authentic_places
            price_pool = authentic_places
        else:
            base_pool = [p for p in self.places if self.place_matches_filters(p, active_filters)]
            cuisine_pool = [p for p in self.places if self.place_matches_filters(p, active_filters, exclude_keys={"cuisine"})]
            price_pool = [p for p in self.places if self.place_matches_filters(p, active_filters, exclude_keys={"price"})]

        currency_sym = self.city_config.get("currency_symbol", "€")
        price_labels = {
            1: currency_sym if currency_sym != "AED" else "AED",
            2: currency_sym * 2 if currency_sym != "AED" else "AED 2",
            3: currency_sym * 3 if currency_sym != "AED" else "AED 3",
            4: currency_sym * 4 if currency_sym != "AED" else "AED 4"
        }
        price_tiers_data = [
            {
                "tier": 1,
                "symbol": price_labels[1],
                "label": "Budget / Street Food",
                "count": sum(1 for p in price_pool if p.get("price_tier") == 1)
            },
            {
                "tier": 2,
                "symbol": price_labels[2],
                "label": "Casual Dining",
                "count": sum(1 for p in price_pool if p.get("price_tier") == 2)
            },
            {
                "tier": 3,
                "symbol": price_labels[3],
                "label": "Upscale Dining",
                "count": sum(1 for p in price_pool if p.get("price_tier") == 3)
            },
            {
                "tier": 4,
                "symbol": price_labels[4],
                "label": "Fine Dining / Stars",
                "count": sum(1 for p in price_pool if p.get("price_tier") == 4)
            }
        ]

        # Calculate cluster counts from cuisine_pool (Disjunctive faceting)
        cluster_counts = Counter()
        for p in cuisine_pool:
            for cid in p.get("_cluster_ids", []):
                cluster_counts[cid] += 1

        all_clusters = []
        for arch in MASTER_CRAFT_ARCHETYPES:
            aid = arch["id"]
            cnt = cluster_counts[aid]
            label = arch["label"]
            if aid == "seafood":
                if self.city_id == "dubai":
                    label = "Coastal & Fresh Seafood"
                elif self.city_id == "istanbul":
                    label = "Bosphorus & Coastal Seafood"
            elif aid == "deli" and self.city_id != "amsterdam":
                label = "Artisanal Delis & Sandwiches"

            # Check if this cluster exists in this city at all
            city_has_cluster = any(aid in p.get("_cluster_ids", []) for p in authentic_places)
            if city_has_cluster:
                all_clusters.append({
                    "id": aid,
                    "label": label,
                    "icon": arch["icon"],
                    "query": arch["query"],
                    "count": cnt,
                    "avg_score": 85.0
                })

        # Rank clusters by count descending
        all_clusters.sort(key=lambda x: x["count"], reverse=True)
        row1_clusters = all_clusters[:10]

        waterfront_label = self.city_config.get("waterfront_label") or ("Canal Terrace" if self.city_id == "amsterdam" else "Waterfront Terrace")
        heritage_label = self.city_config.get("heritage_badge_label") or "Historic Monuments"

        amenity_counts = {
            "independent": sum(1 for p in base_pool if p.get("ownership", {}).get("is_independent")),
            "clean": sum(1 for p in base_pool if (p.get("food_safety") or {}).get("inspection_grade") in ["Grade A", "5/5", "Très satisfaisant", "Elite Smiley"]),
            "accredited": sum(1 for p in base_pool if p.get("accreditation")),
            "late_night": sum(1 for p in base_pool if p.get("amenities", {}).get("late_night")),
            "roastery": sum(1 for p in base_pool if p.get("amenities", {}).get("in_house_roastery")),
            "historic": sum(1 for p in base_pool if ((p.get("heritage") or {}).get("is_historic") or (p.get("start_year") and p["start_year"] <= 2010))),
            "wheelchair": sum(1 for p in base_pool if p.get("amenities", {}).get("wheelchair_accessible")),
            "canal": sum(1 for p in base_pool if p.get("amenities", {}).get("canal_terrace")),
            "outdoor": sum(1 for p in base_pool if p.get("amenities", {}).get("outdoor_seating")),
            "scratch": sum(1 for p in base_pool if p.get("scratch_kitchen", {}).get("is_scratch")),
            "halal": sum(1 for p in base_pool if p.get("dietary", {}).get("halal")),
            "vegan": sum(1 for p in base_pool if p.get("dietary", {}).get("vegan")),
            "vegetarian": sum(1 for p in base_pool if p.get("dietary", {}).get("vegetarian")),
            "celiac": sum(1 for p in base_pool if p.get("celiac_safety", {}).get("is_safe")),
            "water": sum(1 for p in base_pool if p.get("hospitality", {}).get("free_tap_water")),
            "monument": sum(1 for p in base_pool if p.get("heritage", {}).get("is_monument"))
        }

        # Baseline counts over all authentic places in city to know what options exist in the city
        baseline_facets = self.get_facets(authentic_only=True)
        city_supported_keys = {
            "independent": baseline_facets["independent_count"] > 0,
            "clean": baseline_facets.get("clean_kitchen_count", 0) > 0,
            "accredited": baseline_facets["accredited_count"] > 0,
            "late_night": baseline_facets.get("late_night_count", 0) > 0,
            "roastery": baseline_facets.get("roastery_count", 0) > 0,
            "historic": baseline_facets.get("historic_count", 0) > 0,
            "wheelchair": baseline_facets.get("wheelchair_count", 0) > 0,
            "canal": baseline_facets["canal_terrace_count"] > 0,
            "outdoor": baseline_facets["outdoor_count"] > 0,
            "scratch": baseline_facets["scratch_count"] > 0,
            "halal": baseline_facets["halal_count"] > 0,
            "vegan": baseline_facets["vegan_count"] > 0,
            "vegetarian": baseline_facets["vegetarian_count"] > 0,
            "celiac": baseline_facets["celiac_safe_count"] > 0,
            "water": baseline_facets["tap_water_count"] > 0,
            "monument": baseline_facets.get("monuments_count", 0) > 0
        }

        row2_facets = [
            {"id": "independent", "type": "amenity", "label": "100% Independent", "icon": "👨‍🍳", "count": amenity_counts["independent"]},
            {"id": "clean", "type": "amenity", "label": "Grade A Clean Kitchen" if self.city_id == "dubai" else "Gov Hygiene Certified", "icon": "🏆", "count": amenity_counts["clean"]},
            {"id": "accredited", "type": "amenity", "label": "Awarded by Guides", "icon": "🏅", "count": amenity_counts["accredited"]},
            {"id": "late_night", "type": "amenity", "label": "Late-Night Dining (Post-Midnight)", "icon": "🌙", "count": amenity_counts["late_night"]},
            {"id": "roastery", "type": "amenity", "label": "On-Site Micro-Roaster", "icon": "☕", "count": amenity_counts["roastery"]},
            {"id": "historic", "type": "amenity", "label": "Historic Icons (Est. Pre-2010)", "icon": "⏳", "count": amenity_counts["historic"]},
            {"id": "wheelchair", "type": "amenity", "label": "Wheelchair Accessible", "icon": "♿", "count": amenity_counts["wheelchair"]},
            {"id": "canal", "type": "amenity", "label": waterfront_label, "icon": "⛵" if "Canal" in waterfront_label else "🌊", "count": amenity_counts["canal"]},
            {"id": "outdoor", "type": "amenity", "label": "Outdoor Seating", "icon": "☀️", "count": amenity_counts["outdoor"]},
            {"id": "scratch", "type": "amenity", "label": "Scratch Kitchen", "icon": "🌾", "count": amenity_counts["scratch"]},
            {"id": "halal", "type": "diet", "label": "Halal Verified", "icon": "🥩", "count": amenity_counts["halal"]},
            {"id": "vegan", "type": "diet", "label": "100% Vegan", "icon": "🌿", "count": amenity_counts["vegan"]},
            {"id": "vegetarian", "type": "diet", "label": "Vegetarian", "icon": "🌱", "count": amenity_counts["vegetarian"]},
            {"id": "celiac", "type": "amenity", "label": "Celiac Safe Kitchen", "icon": "🩺", "count": amenity_counts["celiac"]},
            {"id": "water", "type": "amenity", "label": "Free Tap Water", "icon": "💧", "count": amenity_counts["water"]},
            {"id": "monument", "type": "amenity", "label": heritage_label, "icon": "🏛️", "count": amenity_counts["monument"]}
        ]

        active_facets = [f for f in row2_facets if city_supported_keys.get(f["id"], False)]

        return {
            "city": city_name,
            "city_id": self.city_id,
            "currency_symbol": currency_sym,
            "price_tiers": price_tiers_data,
            "total_authentic": len(base_pool),
            "row1_clusters": row1_clusters,
            "all_clusters": all_clusters,
            "row2_facets": active_facets,
            "dining_guide": self.city_config.get("dining_guide", {}),
            "is_dynamic": has_active_filters
        }

    def compare_head_to_head(self, id1, id2):
        p1 = next((p for p in self.places if p["id"] == id1), None)
        p2 = next((p for p in self.places if p["id"] == id2), None)
        if not p1 or not p2:
            return None

        winner = p1 if p1["quality_score"] >= p2["quality_score"] else p2
        loser = p2 if winner == p1 else p1

        dist_between_m = int(haversine_distance_m(
            p1["latitude"], p1["longitude"],
            p2["latitude"], p2["longitude"]
        ))

        advantages = []
        if winner.get("ownership", {}).get("is_independent") and not loser.get("ownership", {}).get("is_independent"):
            advantages.append(f"Ownership Advantage: 100% independent artisan shop vs multi-unit commercial chain ({loser.get('ownership', {}).get('badge', 'Chain')}).")
        if winner.get("accreditation") and not loser.get("accreditation"):
            tier = winner['accreditation'].get('award_tier') or winner['accreditation'].get('award')
            advantages.append(f"Holds official culinary accreditation ({tier}).")
        if winner.get("celiac_safety", {}).get("is_safe") and not loser.get("celiac_safety", {}).get("is_safe"):
            advantages.append(f"Medical Safety Advantage: {winner['celiac_safety'].get('badge')} with verified cross-contamination protocols.")
        if winner.get("scratch_kitchen", {}).get("is_scratch") and not loser.get("scratch_kitchen", {}).get("is_scratch"):
            advantages.append("Culinary Craft Advantage: Verified scratch production (scratch dough, in-house butchery, fresh prep).")
        if winner.get("heritage", {}).get("is_monument") and not loser.get("heritage", {}).get("is_monument"):
            badge = winner['heritage'].get('badge') or 'Historic Monument'
            advantages.append(f"Architectural Heritage Advantage: Housed in authentic protected monument ({badge}) vs modern commercial space.")
        if winner.get("hospitality", {}).get("free_tap_water") and not loser.get("hospitality", {}).get("free_tap_water"):
            advantages.append("Honest Hospitality: Pledged complimentary fresh tap water carafes.")
        if winner["craft_badges"] and not loser["craft_badges"]:
            advantages.append(f"Uses verified craft techniques ({', '.join(winner['craft_badges'][:2])}) whereas {loser['name']} has none.")
        if winner.get("amenities", {}).get("canal_terrace") and not loser.get("amenities", {}).get("canal_terrace"):
            advantages.append("Offers scenic outdoor canal terrace seating along historic waterways.")
        if winner.get("schedule_rhythm") == "artisan_rhythm" and loser.get("schedule_rhythm") == "tourist_continuous":
            advantages.append("Follows traditional artisan kitchen rhythms with fresh prep and rest days instead of continuous factory heating.")
        if winner["category_purity"] > loser["category_purity"]:
            advantages.append(f"100% focused on its core specialty ({winner['primary_category']}) instead of a diluted multi-menu.")
        if not winner["is_chain"] and loser["is_chain"]:
            advantages.append(f"Independent local artisan shop vs. a multi-unit corporate franchise ({loser['brand']}).")
        if winner.get("start_year") and (not loser.get("start_year") or winner["start_year"] < loser["start_year"]):
            advantages.append(f"Proven Lindy longevity: established in {winner['start_year']}.")
        if loser.get("dist_to_tourist_hub_m") and loser["dist_to_tourist_hub_m"] < 100:
            advantages.append(f"{winner['name']} avoids high-density commercial corridor congestion.")

        if not advantages:
            advantages.append(f"{winner['name']} ranks higher on authentic neighborhood presence and category focus.")

        return {
            "place_a": p1,
            "place_b": p2,
            "winner_id": winner["id"],
            "winner_name": winner["name"],
            "loser_name": loser["name"],
            "distance_between_m": dist_between_m,
            "advantages": advantages,
            "recommendation": f"Walk {dist_between_m}m to {winner['name']} for authentic quality." if dist_between_m > 0 else f"Choose {winner['name']}."
        }

class MultiCityEngineManager:
    def __init__(self):
        self.engines = {}
        self.cities = self.load_cities()
        self._cached_city_list = None

    def load_cities(self):
        cities_file = os.path.join(DATA_DIR, "cities.json")
        if os.path.exists(cities_file):
            try:
                with open(cities_file, "r", encoding="utf-8") as f:
                    return json.load(f)
            except Exception as e:
                print(f"Error loading cities.json: {e}")
        return [{"id": "amsterdam", "name": "Amsterdam", "country": "Netherlands", "flag": "🇳🇱"}]

    def get_engine(self, city_id="amsterdam"):
        cid = (city_id or "amsterdam").lower().strip()
        valid_ids = [c["id"] for c in self.cities]
        if cid not in valid_ids:
            cid = "amsterdam"
        if cid not in self.engines:
            print(f"Initializing PalateEngine for city: {cid}...")
            self.engines[cid] = PalateEngine(city_id=cid)
        return self.engines[cid]

    def list_cities(self):
        result = []
        for c in self.cities:
            cid = c["id"]
            eng = self.engines.get(cid)
            total = len(eng.places) if eng else c.get("total_eateries", 3500)
            authentic = sum(1 for p in eng.places if not p.get("is_tourist_trap")) if eng else total
            craft = sum(1 for p in eng.places if p.get("craft_badges")) if eng else int(total * 0.4)
            independent = sum(1 for p in eng.places if p.get("ownership", {}).get("is_independent")) if eng else int(total * 0.7)
            result.append({
                "id": cid,
                "name": c["name"],
                "country": c["country"],
                "country_code": c.get("country_code", ""),
                "flag": c.get("flag", "🌐"),
                "center": c["center"],
                "default_zoom": c.get("default_zoom", 13),
                "tagline": c.get("tagline", ""),
                "currency": c.get("currency", "EUR"),
                "currency_symbol": c.get("currency_symbol", "€"),
                "total_eateries": total,
                "authentic_eateries": authentic,
                "craft_artisans_detected": craft,
                "independent_count": independent,
                "dining_guide": c.get("dining_guide", {})
            })
        return result

if __name__ == "__main__":
    engine = PalateEngine()
    print("\n--- TEST: 'burger' TOP RESULTS ---")
    for r in engine.search("burger", max_results=5):
        print(f"[{r['quality_score']} pts] {r['name']} ({r['neighborhood']})")
        print(f"   Badges: {r['craft_badges']}")

    print("\n--- TEST: 'pizza' TOP RESULTS ---")
    for r in engine.search("pizza", max_results=6):
        print(f"[{r['quality_score']} pts] {r['name']} ({r['neighborhood']})")
        print(f"   Badges: {r['craft_badges']}")