Blame for server.py

"""
Lightweight, Zero-Dependency HTTP API & Static Server for Palate / TasteOS Global Multi-City Engine.
Supports Amsterdam, Dubai, Istanbul with zero paid Google APIs.
Runs on localhost:3050.
"""

import json
import os
import sys
import urllib.parse
from http.server import HTTPServer, SimpleHTTPRequestHandler, ThreadingHTTPServer
from engine import MultiCityEngineManager
from spatial_copilot_service import copilot_service

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

PORT = int(os.environ.get("PORT", 3050))
PUBLIC_DIR = os.path.join(os.path.dirname(__file__), "public")

manager = MultiCityEngineManager()

class PalateRequestHandler(SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=PUBLIC_DIR, **kwargs)

    def do_GET(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path
        query = urllib.parse.parse_qs(parsed.query)

        # 0. API: List Available Global Cities
        if path == "/api/cities":
            cities = manager.list_cities()
            self.send_json(cities)
            return

        # Extract city context (defaults to Amsterdam for backward compatibility)
        city_id = query.get("city", ["amsterdam"])[0].lower().strip()
        engine = manager.get_engine(city_id)
        default_center = engine.city_config.get("center", {"lat": 52.3680, "lon": 4.8900})

        # 1. API: Search with Rich Dietary & Amenity Filters
        if path == "/api/search":
            q = query.get("q", [""])[0]
            has_user_coords = "lat" in query and "lon" in query
            lat = float(query.get("lat", [default_center["lat"]])[0])
            lon = float(query.get("lon", [default_center["lon"]])[0])
            offset = int(query.get("offset", [0])[0])
            limit = int(query.get("limit", [40])[0])
            cuisine = query.get("cuisine", [""])[0]
            diet = query.get("diet", [""])[0]
            outdoor = query.get("outdoor", ["false"])[0].lower() == "true"
            canal = query.get("canal", ["false"])[0].lower() == "true"
            wheelchair = query.get("wheelchair", ["false"])[0].lower() == "true"
            accredited = query.get("accredited", ["false"])[0].lower() == "true"
            monument = query.get("monument", ["false"])[0].lower() == "true"
            independent = query.get("independent", ["false"])[0].lower() == "true"
            celiac = query.get("celiac", ["false"])[0].lower() == "true"
            if diet and diet.lower().strip() in ("celiac", "celiac_safe"):
                celiac = True
                diet = ""
            scratch = query.get("scratch", ["false"])[0].lower() == "true"
            water = query.get("water", ["false"])[0].lower() == "true"
            clean = query.get("clean", ["false"])[0].lower() == "true"
            late_night = query.get("late_night", ["false"])[0].lower() == "true"
            roastery = query.get("roastery", ["false"])[0].lower() == "true"
            historic = query.get("historic", ["false"])[0].lower() == "true"
            price_raw = query.get("price", [""])[0]
            price_tiers = None
            if price_raw:
                try:
                    price_tiers = [int(p.strip()) for p in price_raw.split(",") if p.strip().isdigit()]
                    if not price_tiers:
                        price_tiers = None
                except Exception:
                    price_tiers = None
            min_score = int(query.get("min_score", [0])[0])
            sort_by = query.get("sort", ["quality"])[0]

            # Bounding box filter (min_lat, min_lon, max_lat, max_lon)
            bbox_raw = query.get("bbox", [""])[0]
            bbox = None
            if bbox_raw:
                try:
                    parts = [float(x.strip()) for x in bbox_raw.split(",") if x.strip()]
                    if len(parts) == 4:
                        bbox = parts
                except Exception:
                    bbox = None

            # Walking / Transit distance radius filter in meters
            max_dist_raw = query.get("max_dist", [""])[0]
            max_dist = None
            if max_dist_raw:
                try:
                    max_dist = int(max_dist_raw.strip())
                except Exception:
                    max_dist = None
            
            results, total_count = engine.search(
                query=q, 
                user_lat=lat, 
                user_lon=lon, 
                offset=offset,
                max_results=limit,
                cuisine=cuisine if cuisine else None,
                diet=diet if diet else None,
                outdoor=outdoor,
                canal=canal,
                wheelchair=wheelchair,
                accredited_only=accredited,
                monuments_only=monument,
                independent_only=independent,
                celiac_safe_only=celiac,
                scratch_only=scratch,
                tap_water_only=water,
                clean_only=clean,
                late_night_only=late_night,
                roastery_only=roastery,
                historic_only=historic,
                price_tiers=price_tiers,
                min_score=min_score,
                sort_by=sort_by,
                has_user_coords=has_user_coords,
                return_total=True,
                bbox=bbox,
                max_dist_m=max_dist
            )
            include_facets = query.get("facets", ["false"])[0].lower() in ["true", "1"]
            headers = {
                "X-Total-Count": str(total_count),
                "X-Offset": str(offset),
                "X-Limit": str(limit),
                "Access-Control-Expose-Headers": "X-Total-Count, X-Offset, X-Limit"
            }
            if include_facets:
                active_filters = {
                    "price": price_tiers,
                    "cuisine": cuisine if cuisine else None,
                    "diet": diet if diet else None,
                    "outdoor": outdoor,
                    "canal": canal,
                    "wheelchair": wheelchair,
                    "accredited": accredited,
                    "monument": monument,
                    "independent": independent,
                    "celiac": celiac,
                    "scratch": scratch,
                    "water": water,
                    "clean": clean,
                    "late_night": late_night,
                    "roastery": roastery,
                    "historic": historic,
                    "bbox": bbox,
                    "max_dist": max_dist,
                    "user_lat": lat if has_user_coords else None,
                    "user_lon": lon if has_user_coords else None
                }
                taxonomy = engine.get_city_taxonomy(city_id, active_filters=active_filters)
                self.send_json({
                    "places": results,
                    "total": total_count,
                    "taxonomy": taxonomy
                }, headers=headers)
                return
            else:
                self.send_json(results, headers=headers)
                return

        # 2. API: Head-to-Head Compare
        elif path == "/api/compare":
            id1 = query.get("id1", [""])[0]
            id2 = query.get("id2", [""])[0]
            comparison = engine.compare_head_to_head(id1, id2)
            if comparison:
                self.send_json(comparison)
            else:
                self.send_json({"error": "Places not found for comparison"}, status=404)
            return

        # 3. API: Dynamic City Taxonomy Engine
        elif path == "/api/taxonomy":
            price_raw = query.get("price", [""])[0]
            price_tier = None
            if price_raw and price_raw.strip().isdigit():
                price_tier = int(price_raw.strip())
            cuisine = query.get("cuisine", [""])[0]
            diet = query.get("diet", [""])[0]
            outdoor = query.get("outdoor", ["false"])[0].lower() == "true"
            canal = query.get("canal", ["false"])[0].lower() == "true"
            wheelchair = query.get("wheelchair", ["false"])[0].lower() == "true"
            accredited = query.get("accredited", ["false"])[0].lower() == "true"
            monument = query.get("monument", ["false"])[0].lower() == "true"
            independent = query.get("independent", ["false"])[0].lower() == "true"
            celiac = query.get("celiac", ["false"])[0].lower() == "true"
            if diet and diet.lower().strip() in ("celiac", "celiac_safe"):
                celiac = True
                diet = ""
            scratch = query.get("scratch", ["false"])[0].lower() == "true"
            water = query.get("water", ["false"])[0].lower() == "true"
            clean = query.get("clean", ["false"])[0].lower() == "true"
            late_night = query.get("late_night", ["false"])[0].lower() == "true"
            roastery = query.get("roastery", ["false"])[0].lower() == "true"
            historic = query.get("historic", ["false"])[0].lower() == "true"

            has_filters = any([
                price_tier is not None, cuisine, diet, outdoor, canal, wheelchair,
                accredited, monument, independent, celiac, scratch, water, clean,
                late_night, roastery, historic
            ])
            active_filters = None
            if has_filters:
                active_filters = {
                    "price": price_tier,
                    "cuisine": cuisine if cuisine else None,
                    "diet": diet if diet else None,
                    "outdoor": outdoor,
                    "canal": canal,
                    "wheelchair": wheelchair,
                    "accredited": accredited,
                    "monument": monument,
                    "independent": independent,
                    "celiac": celiac,
                    "scratch": scratch,
                    "water": water,
                    "clean": clean,
                    "late_night": late_night,
                    "roastery": roastery,
                    "historic": historic
                }
            taxonomy = engine.get_city_taxonomy(city_id, active_filters=active_filters)
            self.send_json(taxonomy)
            return

        # 4. API: Facets & Aggregations
        elif path == "/api/facets":
            facets = engine.get_facets(authentic_only=True)
            self.send_json(facets)
            return

        # 5. API: Stats & System Metrics
        elif path == "/api/stats":
            facets = engine.get_facets()
            self.send_json({
                "city": engine.city_config.get("name", city_id.capitalize()),
                "city_id": city_id,
                "country": engine.city_config.get("country", ""),
                "flag": engine.city_config.get("flag", ""),
                "total_eateries_indexed": facets["total_eateries"],
                "craft_artisans_detected": facets["craft_artisans_detected"],
                "tourist_traps_flagged": facets["tourist_traps_flagged"],
                "mono_specialists": facets["mono_specialists"],
                "halal_eateries": facets["halal_count"],
                "vegan_eateries": facets["vegan_count"],
                "canal_terraces": facets["canal_terrace_count"],
                "protected_monuments": facets["monuments_count"],
                "independent_artisans": facets["independent_count"],
                "celiac_safe_kitchens": facets["celiac_safe_count"],
                "scratch_kitchens": facets["scratch_count"],
                "tap_water_welcoming": facets["tap_water_count"],
                "clean_kitchens_verified": facets.get("clean_kitchen_count", 0),
                "data_source": "Overture Maps, OpenStreetMap & Government Registries",
                "google_api_cost": "$0.00"
            })
            return

        # 6. API: Spatial God Mode AI Copilot
        elif path == "/api/copilot/ask":
            q = query.get("q", [""])[0]
            city_id = query.get("city", ["dubai"])[0].lower().strip()
            if not q:
                self.send_json({"error": "Query parameter 'q' is required"}, status=400)
                return
            result = copilot_service.ask(q, city=city_id)
            self.send_json(result)
            return

        # Serve static assets (index.html, etc.)
        return super().do_GET()

    def do_POST(self):
        parsed = urllib.parse.urlparse(self.path)
        if parsed.path == "/api/copilot/ask":
            content_length = int(self.headers.get("Content-Length", 0))
            body = self.rfile.read(content_length).decode("utf-8")
            try:
                data = json.loads(body)
                q = data.get("q", "")
                city_id = data.get("city", "dubai").lower().strip()
                if not q:
                    self.send_json({"error": "Field 'q' is required"}, status=400)
                    return
                result = copilot_service.ask(q, city=city_id)
                self.send_json(result)
            except Exception as e:
                self.send_json({"error": str(e)}, status=400)
            return

        elif parsed.path == "/api/endorse":
            content_length = int(self.headers.get("Content-Length", 0))
            body = self.rfile.read(content_length).decode("utf-8")
            try:
                data = json.loads(body)
                place_id = data.get("place_id")
                positive = data.get("positive", True)
                city_id = data.get("city", "amsterdam").lower().strip()
                engine = manager.get_engine(city_id)

                # Find place and record endorsement
                p = next((x for x in engine.places if x["id"] == place_id), None)
                if p:
                    p["endorsement_count"] = p.get("endorsement_count", 0) + 1
                    pos_count = (p.get("endorsement_positive_pct", 85) / 100.0) * (p["endorsement_count"] - 1)
                    if positive:
                        pos_count += 1
                    p["endorsement_positive_pct"] = int((pos_count / p["endorsement_count"]) * 100)
                    self.send_json({"success": True, "place": p})
                else:
                    self.send_json({"error": "Place not found"}, status=404)
            except Exception as e:
                self.send_json({"error": str(e)}, status=400)
            return

        self.send_json({"error": "Not found"}, status=404)

    def send_json(self, data, status=200, headers=None):
        body = json.dumps(data, ensure_ascii=False, default=str).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Access-Control-Allow-Origin", "*")
        if headers:
            for k, v in headers.items():
                self.send_header(k, v)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

def run(port=PORT):
    server_address = ("", port)
    httpd = ThreadingHTTPServer(server_address, PalateRequestHandler)
    print(f"==================================================")
    print(f" Palate / TasteOS Global Engine is RUNNING on {port}!")
    for c in manager.cities:
        print(f" - {c.get('flag', '🌐')} {c['name']}")
    print(f" Google API Cost: $0.00                           ")
    print(f"==================================================")
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        print("\nServer stopped.")

if __name__ == "__main__":
    run()