Datasets:

TIGER-Lab
/

WebsiteBench

from __future__ import annotations

import json
import os
import re
import sqlite3
import hashlib
import hmac
import secrets
import shutil
from datetime import datetime, timedelta, timezone
from http.cookies import CookieError, SimpleCookie
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse
from zoneinfo import ZoneInfo

ROOT = Path(__file__).resolve().parent
if "WEBSITEBENCH_SITE_BACKEND_DATABASE" not in os.environ:
    data_dir = Path(
        os.environ.get("WEBSITEBENCH_DATA_DIR")
        or os.environ.get("DATA_DIR")
        or f"/tmp/websitebench-breakoutgames-2-{os.getuid()}"
    ).resolve()
    data_dir.mkdir(parents=True, exist_ok=True)
    database_path = data_dir / "breakoutgames-2.sqlite3"
    if database_path.exists() and database_path.stat().st_size == 0:
        stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
        database_path.rename(data_dir / f"breakoutgames-2.invalid-empty-{stamp}.sqlite3")
    os.environ["WEBSITEBENCH_SITE_BACKEND_DATABASE"] = str(database_path)
# These imports must follow deployment database-path initialization above.
from backend.site_backend_integration import open_site_services  # noqa: E402
from websitebench.local_clone_auth import (  # noqa: E402
    AuthConflict,
    AuthError,
    AuthRejected,
    AuthValidationError,
)

backend, _auth = open_site_services()
DB = backend.lifecycle.database_path
with sqlite3.connect(DB) as con:
    con.execute("PRAGMA journal_mode=WAL")
    con.execute("PRAGMA foreign_keys=ON")
    con.execute("CREATE TABLE IF NOT EXISTS booking_interest (id INTEGER PRIMARY KEY, location TEXT NOT NULL, room TEXT NOT NULL, party_size INTEGER NOT NULL, visit_date TEXT NOT NULL, created_at TEXT DEFAULT CURRENT_TIMESTAMP)")
    con.execute("""CREATE TABLE IF NOT EXISTS local_draft (
        id INTEGER PRIMARY KEY, kind TEXT NOT NULL, fingerprint TEXT NOT NULL UNIQUE,
        payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'draft',
        created_at TEXT DEFAULT CURRENT_TIMESTAMP
    )""")
    con.execute("""CREATE TABLE IF NOT EXISTS gift_card_plan (
        id INTEGER PRIMARY KEY, fingerprint TEXT NOT NULL UNIQUE, location TEXT NOT NULL,
        amount_cents INTEGER NOT NULL, recipient_name TEXT NOT NULL DEFAULT '',
        status TEXT NOT NULL DEFAULT 'review', created_at TEXT DEFAULT CURRENT_TIMESTAMP
    )""")
    con.execute("""CREATE TABLE IF NOT EXISTS local_booking (
        id INTEGER PRIMARY KEY, location_id TEXT NOT NULL, room_id TEXT NOT NULL,
        party_size INTEGER NOT NULL, visit_date TEXT NOT NULL, time_slot TEXT NOT NULL,
        unit_price_cents INTEGER NOT NULL, total_cents INTEGER NOT NULL,
        idempotency_key TEXT NOT NULL UNIQUE, confirmation_code TEXT NOT NULL UNIQUE,
        manage_token_hash TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'confirmed',
        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
        updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
    )""")
    columns = {row[1] for row in con.execute("PRAGMA table_info(local_booking)")}
    booking_columns = {
        "account_id": "TEXT",
        "package_id": "TEXT NOT NULL DEFAULT 'standard'",
        "customer_name": "TEXT NOT NULL DEFAULT ''",
        "customer_email": "TEXT NOT NULL DEFAULT ''",
        "customer_phone": "TEXT NOT NULL DEFAULT ''",
        "special_requests": "TEXT NOT NULL DEFAULT ''",
        "payment_scenario": "TEXT NOT NULL DEFAULT 'sandbox-approved'",
    }
    for name, declaration in booking_columns.items():
        if name not in columns:
            con.execute(f"ALTER TABLE local_booking ADD COLUMN {name} {declaration}")
    con.execute("""CREATE UNIQUE INDEX IF NOT EXISTS one_active_booking_per_slot
        ON local_booking(location_id, room_id, visit_date, time_slot)
        WHERE status = 'confirmed'""")
    con.execute("CREATE TABLE IF NOT EXISTS local_profile (account_id TEXT PRIMARY KEY, phone TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)")
    con.execute("CREATE TABLE IF NOT EXISTS local_favorite (owner_key TEXT NOT NULL, location_id TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(owner_key, location_id))")
    con.execute("CREATE TABLE IF NOT EXISTS local_booking_action (id INTEGER PRIMARY KEY, booking_id INTEGER NOT NULL, action TEXT NOT NULL, message TEXT NOT NULL DEFAULT '', rating INTEGER, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY(booking_id) REFERENCES local_booking(id) ON DELETE CASCADE)")


EMAIL = re.compile(r"^[^\s@]+@[^\s@]+\.[^\s@]+$")
IDEMPOTENCY_KEY = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$")
TORONTO = ZoneInfo("America/Toronto")
UNIT_PRICE_CENTS = 3999
CSRF_SECRET = secrets.token_bytes(32)
LOCATIONS = {
    "pittsburgh": {"id": "pittsburgh", "name": "Pittsburgh", "distance_km": 328.0},
    "columbus": {"id": "columbus", "name": "Columbus", "distance_km": 510.0},
    "cincinnati": {"id": "cincinnati", "name": "Cincinnati", "distance_km": 665.0},
}
BOOKING_ROOMS = {
    "the-kidnapping": {"id": "the-kidnapping", "name": "The Kidnapping", "theme": "thriller", "capacity": 8},
    "mystery-mansion": {"id": "mystery-mansion", "name": "Mystery Mansion", "theme": "horror", "capacity": 8},
}
EXPERIENCES = {
    "pittsburgh": {
        **LOCATIONS["pittsburgh"], "rating": 4.9, "review_count": 1842,
        "price_cents": UNIT_PRICE_CENTS, "themes": ["horror", "thriller"],
        "description": "Private, story-driven escape rooms nearest to Downtown Toronto among this clone's available locations.",
        "pricing": "$39.99 per person; local sandbox total is calculated by the server.",
        "reviews": "4.9 from 1,842 representative local fixture reviews.",
        "policies": "Arrive 15 minutes early. Changes and cancellations remain local sandbox actions.",
        "availability": "Upcoming Saturday evening slots from 7 PM through 9 PM in America/Toronto.",
        "available": True,
    },
    "columbus": {
        **LOCATIONS["columbus"], "rating": 4.8, "review_count": 1230,
        "price_cents": 4299, "themes": ["mystery", "adventure"],
        "description": "Private escape-room experiences in Columbus.",
        "pricing": "$42.99 per person.", "reviews": "4.8 from 1,230 representative local fixture reviews.",
        "policies": "Local sandbox policies only.", "availability": "Evening fixture availability.", "available": True,
    },
    "cincinnati": {
        **LOCATIONS["cincinnati"], "rating": 4.7, "review_count": 940,
        "price_cents": 4599, "themes": ["mystery"],
        "description": "Private escape-room experiences in Cincinnati.",
        "pricing": "$45.99 per person.", "reviews": "4.7 from 940 representative local fixture reviews.",
        "policies": "Local sandbox policies only.", "availability": "Limited fixture availability.", "available": False,
    },
}
PACKAGES = {
    "standard": {"id": "standard", "name": "Standard private room"},
    "private-room": {"id": "private-room", "name": "Private room package"},
}
PAYMENT_SCENARIOS = {
    "sandbox-approved": "approved",
    "sandbox-declined": "declined",
    "sandbox-retry": "retryable",
}
TIME_SLOTS = (
    {"id": "19:00-20:00", "start": "19:00", "end": "20:00"},
    {"id": "20:00-21:00", "start": "20:00", "end": "21:00"},
)
DRAFT_FIELDS = {
    "contact": ("first_name", "last_name", "email", "location", "message"),
    "team-building": ("name", "email", "location", "group_type", "organization", "phone", "max_players", "preferred_start", "preferred_end", "message"),
    "celebration": ("name", "email", "location", "occasion", "party_size", "message"),
    "newsletter": ("email",),
}


def upcoming_saturday():
    today = datetime.now(TORONTO).date()
    offset = (5 - today.weekday()) % 7
    return today + timedelta(days=offset or 7)


def booking_catalog():
    location = {
        **LOCATIONS["pittsburgh"],
        "explanation": (
            "Pittsburgh is the nearest available Breakout Games location to Downtown "
            "Toronto by straight-line distance among the locations in this clone."
        ),
        "candidate_distances_km": {
            key: item["distance_km"] for key, item in LOCATIONS.items()
        },
    }
    return {
        "timezone": "America/Toronto",
        "reference_location": "Downtown Toronto",
        "recommended_location": location,
        "upcoming_saturday": upcoming_saturday().isoformat(),
        "rooms": list(BOOKING_ROOMS.values()),
        "time_slots": list(TIME_SLOTS),
        "packages": list(PACKAGES.values()),
        "payment_scenarios": [
            {"id": key, "outcome": value}
            for key, value in PAYMENT_SCENARIOS.items()
        ],
    }

def validate_selection(data):
    try:
        party_size = int(data.get("party_size", 0))
    except (TypeError, ValueError):
        raise ValueError("Party size must be a whole number.")
    location = LOCATIONS.get(str(data.get("location_id", "")))
    room = BOOKING_ROOMS.get(str(data.get("room_id", "")))
    slot = next((item for item in TIME_SLOTS if item["id"] == data.get("time_slot")), None)
    if not location or location["id"] != "pittsburgh":
        raise ValueError("Choose the recommended Pittsburgh location.")
    if not room or room["theme"] not in {"horror", "thriller"}:
        raise ValueError("Choose a horror or thriller room.")
    if not 2 <= party_size <= room["capacity"]:
        raise ValueError(f"Party size must be between 2 and {room['capacity']}.")
    if str(data.get("visit_date", "")) != upcoming_saturday().isoformat():
        raise ValueError("Choose the upcoming Saturday in America/Toronto.")
    if not slot:
        raise ValueError("Choose an evening time slot between 7 PM and 9 PM.")
    return location, room, slot, party_size


def booking_preview(data):
    location, room, slot, party_size = validate_selection(data)
    package = PACKAGES.get(str(data.get("package_id", "standard")))
    scenario = str(data.get("payment_scenario", "sandbox-approved"))
    if not package:
        raise ValueError("Choose a supported package.")
    if scenario not in PAYMENT_SCENARIOS:
        raise ValueError("Choose a local sandbox payment scenario.")
    customer = {
        "name": str(data.get("customer_name", "")).strip()[:120],
        "email": str(data.get("customer_email", "")).strip()[:254],
        "phone": str(data.get("customer_phone", "")).strip()[:60],
        "special_requests": str(data.get("special_requests", "")).strip()[:1000],
    }
    if customer["email"] and not EMAIL.fullmatch(customer["email"]):
        raise ValueError("Enter a valid customer email address.")
    return {
        "location": location,
        "room": room,
        "party_size": party_size,
        "visit_date": upcoming_saturday().isoformat(),
        "time_slot": slot,
        "timezone": "America/Toronto",
        "unit_price_cents": UNIT_PRICE_CENTS,
        "total_cents": UNIT_PRICE_CENTS * party_size,
        "currency": "USD",
        "sandbox": True,
        "package": package,
        "customer": customer,
        "payment": {
            "adapter": "local-sandbox",
            "scenario": scenario,
            "outcome": PAYMENT_SCENARIOS[scenario],
            "collects_real_payment": False,
        },
    }

def canonical(value):
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True)


def fingerprint(kind, value):
    return hashlib.sha256((kind + ":" + canonical(value)).encode()).hexdigest()


class Handler(SimpleHTTPRequestHandler):
    server_version = "BreakoutLocal/1.0"

    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=str(ROOT / "static"), **kwargs)

    def end_headers(self):
        self.send_header("Content-Security-Policy", "default-src 'self'; connect-src 'self'; img-src 'self' data:; media-src 'self'; style-src 'self'; script-src 'self'; object-src 'none'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'")
        self.send_header("X-Content-Type-Options", "nosniff")
        self.send_header("Referrer-Policy", "no-referrer")
        self.send_header("X-Frame-Options", "DENY")
        super().end_headers()

    def cookie_token(self):
        cookie = SimpleCookie()
        try:
            cookie.load(self.headers.get("Cookie", ""))
        except CookieError:
            return None
        morsel = cookie.get("wb_session")
        return morsel.value if morsel else None

    def session_context(self):
        return _auth.ensure_session(self.cookie_token())

    @staticmethod
    def session_cookie(token):
        return f"wb_session={token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=2592000"

    @staticmethod
    def csrf_token(token):
        return hmac.new(CSRF_SECRET, token.encode(), hashlib.sha256).hexdigest()

    @staticmethod
    def account_id(session):
        account = session.get("account")
        return str(account["account_id"]) if account else None

    def owner_key(self, token, session):
        account_id = self.account_id(session)
        return f"account:{account_id}" if account_id else f"session:{_auth.session_owner_digest(token)}"

    def require_csrf(self):
        token, session = self.session_context()
        supplied = self.headers.get("X-CSRF-Token", "")
        if not hmac.compare_digest(supplied, self.csrf_token(token)):
            self.send_json(
                {"ok": False, "error": "A valid session CSRF token is required."},
                403,
                {"Set-Cookie": self.session_cookie(token)},
            )
            return None
        return token, session

    def search_experiences(self, query):
        term = query.get("q", [""])[0].strip().lower()
        available_only = query.get("available", [""])[0].lower() == "true"
        try:
            max_price = int(query.get("max_price_cents", ["0"])[0])
        except ValueError:
            return self.send_json({"ok": False, "error": "Maximum price must be a whole number."}, 422)
        results = []
        for item in EXPERIENCES.values():
            haystack = " ".join([item["name"], item["description"], *item["themes"]]).lower()
            if term and term not in haystack:
                continue
            if available_only and not item["available"]:
                continue
            if max_price and item["price_cents"] > max_price:
                continue
            results.append(item)
        sort = query.get("sort", ["distance"])[0]
        sort_key = {"distance": "distance_km", "price": "price_cents", "rating": "rating"}.get(sort, "distance_km")
        results.sort(key=lambda item: item[sort_key], reverse=sort == "rating")
        return self.send_json({
            "count": len(results), "results": results,
            "no_results": not results, "return_path": "/experiences",
        })

    def get_availability(self, query):
        location_id = query.get("location_id", [""])[0]
        room_id = query.get("room_id", [""])[0]
        visit_date = query.get("visit_date", [""])[0]
        try:
            party_size = int(query.get("party_size", ["0"])[0])
            parsed_date = datetime.strptime(visit_date, "%Y-%m-%d").date()
        except (TypeError, ValueError):
            return self.send_json({"ok": False, "error": "Provide a valid date and party size."}, 422)
        room = BOOKING_ROOMS.get(room_id)
        if location_id != "pittsburgh" or not room or not 2 <= party_size <= room["capacity"] or parsed_date <= datetime.now(TORONTO).date():
            return self.send_json({"ok": False, "error": "Choose a supported future experience and party size."}, 422)
        with sqlite3.connect(DB) as con:
            taken = {row[0] for row in con.execute(
                "SELECT time_slot FROM local_booking WHERE location_id=? AND room_id=? AND visit_date=? AND status='confirmed'",
                (location_id, room_id, visit_date),
            )}
        return self.send_json({
            "timezone": "America/Toronto", "visit_date": visit_date,
            "party_size": party_size,
            "slots": [{**slot, "available": slot["id"] not in taken} for slot in TIME_SLOTS],
        })
    def do_GET(self):
        parsed = urlparse(self.path)
        path = parsed.path
        query = parse_qs(parsed.query)
        if path in {"/api/health", "/healthz"}:
            return self.send_json({"ok": True, "site_id": "breakoutgames-2"})
        if path == "/api/session":
            token, session = self.session_context()
            return self.send_json(
                {**session, "csrf_token": self.csrf_token(token)},
                headers={"Set-Cookie": self.session_cookie(token)},
            )
        if path == "/api/booking-catalog":
            try:
                party_size = int(query.get("party_size", ["4"])[0])
            except ValueError:
                return self.send_json({"ok": False, "error": "Party size must be a whole number."}, 422)
            if party_size != 4:
                return self.send_json({"ok": False, "error": "This task requires exactly 4 people."}, 422)
            return self.send_json(booking_catalog())
        if path == "/api/experiences":
            return self.search_experiences(query)
        if path.startswith("/api/experiences/"):
            experience = EXPERIENCES.get(path.rsplit("/", 1)[-1])
            return self.send_json(experience) if experience else self.send_json({"ok": False, "error": "Experience not found."}, 404)
        if path == "/api/availability":
            return self.get_availability(query)
        if path == "/api/favorites":
            token, session = self.session_context()
            owner = self.owner_key(token, session)
            with sqlite3.connect(DB) as con:
                ids = [row[0] for row in con.execute(
                    "SELECT location_id FROM local_favorite WHERE owner_key=? ORDER BY created_at DESC",
                    (owner,),
                )]
            return self.send_json(
                {"results": [EXPERIENCES[item] for item in ids if item in EXPERIENCES]},
                headers={"Set-Cookie": self.session_cookie(token)},
            )
        if path == "/api/booking-interest":
            with sqlite3.connect(DB) as con:
                saved = con.execute(
                    "SELECT location,room,party_size,visit_date FROM booking_interest ORDER BY id"
                ).fetchall()
            return self.send_json({
                "ok": True,
                "count": len(saved),
                "results": [
                    {"location": row[0], "room": row[1], "party_size": row[2], "visit_date": row[3]}
                    for row in saved
                ],
                "message": "Local game plans saved in this sandbox. No booking or payment was made.",
            })
        if path == "/api/account/bookings":
            token, session = self.session_context()
            account_id = self.account_id(session)
            headers = {"Set-Cookie": self.session_cookie(token)}
            if not account_id:
                return self.send_json({"ok": False, "error": "Sign in to view private booking history."}, 401, headers)
            with sqlite3.connect(DB) as con:
                con.row_factory = sqlite3.Row
                rows = con.execute(
                    "SELECT * FROM local_booking WHERE account_id=? ORDER BY created_at DESC, id DESC",
                    (account_id,),
                ).fetchall()
            return self.send_json(
                {"results": [self.history_response(row) for row in rows], "return_path": "/experiences"},
                headers=headers,
            )
        if path.startswith("/api/"):
            return self.send_json({"ok": False, "error": "Not found."}, 404)
        if path == "/assets/hero-video-v2.mp4":
            return self.serve_hero_video(head_only=False)
        if path in {"/app.css", "/app.js", "/index.html", "/catalog.json"} or path.startswith("/assets/"):
            return super().do_GET()
        expanded = {
            "/experiences", "/experiences/pittsburgh", "/account/sign-in",
            "/account/register", "/account/recovery", "/account/bookings",
        }
        known = path == "/" or path in {"/book", "/team-building", "/escape-rooms", "/company/gift-cards", "/company/jobs", "/waiver"} | expanded
        if not known:
            try:
                catalog = json.loads((ROOT / "static/catalog.json").read_text())
                first = path.strip("/").split("/", 1)[0]
                known = path in catalog.get("routes", []) or (path == f"/{first}" and first in catalog.get("locations", []))
            except (OSError, json.JSONDecodeError):
                known = False
        return self.serve_index(200 if known else 404)
    def serve_index(self, status):
        body = (ROOT / "static/index.html").read_bytes()
        self.send_response(status)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_HEAD(self):
        path = urlparse(self.path).path
        if path == "/assets/hero-video-v2.mp4":
            return self.serve_hero_video(head_only=True)
        return super().do_HEAD()

    def serve_hero_video(self, head_only):
        asset = ROOT / "static/assets/hero-video-v2.mp4"
        size = asset.stat().st_size
        start, end, status = 0, size - 1, 200
        requested = self.headers.get("Range")
        if requested:
            match = re.fullmatch(r"bytes=(\d*)-(\d*)", requested.strip())
            if not match or (not match.group(1) and not match.group(2)):
                return self.send_range_error(size)
            if match.group(1):
                start = int(match.group(1))
                end = min(int(match.group(2)), size - 1) if match.group(2) else size - 1
            else:
                suffix = int(match.group(2))
                if suffix <= 0:
                    return self.send_range_error(size)
                start = max(0, size - suffix)
            if start >= size or start > end:
                return self.send_range_error(size)
            status = 206

        length = end - start + 1
        self.send_response(status)
        self.send_header("Content-Type", "video/mp4")
        self.send_header("Accept-Ranges", "bytes")
        self.send_header("Content-Length", str(length))
        self.send_header("Last-Modified", self.date_time_string(asset.stat().st_mtime))
        if status == 206:
            self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
        self.end_headers()
        if head_only:
            return
        try:
            with asset.open("rb") as source:
                source.seek(start)
                shutil.copyfileobj(source, self.wfile, length=64 * 1024) if length == size else self.copy_bounded(source, length)
        except (BrokenPipeError, ConnectionResetError):
            return

    def copy_bounded(self, source, remaining):
        while remaining:
            chunk = source.read(min(64 * 1024, remaining))
            if not chunk:
                break
            self.wfile.write(chunk)
            remaining -= len(chunk)

    def send_range_error(self, size):
        self.send_response(416)
        self.send_header("Content-Range", f"bytes */{size}")
        self.send_header("Accept-Ranges", "bytes")
        self.send_header("Content-Length", "0")
        self.end_headers()

    def local_action_allowed(self):
        if self.headers.get("X-WebsiteBench-Action") != "local-sandbox":
            self.send_json({"ok": False, "error": "Local sandbox action header required."}, 403)
            return False
        origin = self.headers.get("Origin")
        if origin:
            parsed = urlparse(origin)
            if parsed.scheme not in {"http", "https"} or parsed.hostname not in {"127.0.0.1", "localhost", "::1"}:
                self.send_json({"ok": False, "error": "Cross-origin actions are not allowed."}, 403)
                return False
        return True

    def do_POST(self):
        path = urlparse(self.path).path
        if not self.local_action_allowed():
            return
        try:
            size = int(self.headers.get("Content-Length", "0"))
        except ValueError:
            return self.send_json({"ok": False, "error": "Invalid content length."}, 400)
        if size > 32_768:
            return self.send_json({"ok": False, "error": "Draft is too large."}, 413)
        try:
            data = json.loads(self.rfile.read(size) or b"{}")
        except (json.JSONDecodeError, UnicodeDecodeError):
            return self.send_json({"ok": False, "error": "Invalid JSON."}, 400)
        if not isinstance(data, dict):
            return self.send_json({"ok": False, "error": "JSON body must be an object."}, 400)
        if path == "/api/reset":
            with sqlite3.connect(DB) as con:
                con.execute("DELETE FROM local_booking_action")
                con.execute("DELETE FROM booking_interest")
                con.execute("DELETE FROM local_draft")
                con.execute("DELETE FROM gift_card_plan")
                con.execute("DELETE FROM local_booking")
                con.execute("DELETE FROM local_favorite")
            return self.send_json({"ok": True, "message": "Local fixtures reset."})
        if path == "/api/favorites":
            return self.save_favorite(data)
        if path == "/api/auth/register":
            return self.register_account(data)
        if path == "/api/auth/sign-in":
            return self.sign_in_account(data)
        if path == "/api/auth/sign-out":
            return self.sign_out_account()
        if path == "/api/auth/recovery":
            return self.recover_account(data)
        if path == "/api/account/seed-history":
            return self.seed_history()
        if path == "/api/bookings/preview":
            try:
                return self.send_json(booking_preview(data))
            except ValueError as error:
                return self.send_json({"ok": False, "error": str(error)}, 422)
        if path == "/api/bookings":
            return self.create_booking(data)
        if path == "/api/bookings/manage":
            return self.manage_booking(data)
        if path == "/api/bookings/cancel":
            return self.change_booking_status(data, "canceled")
        if path == "/api/bookings/restore":
            return self.change_booking_status(data, "confirmed")
        if path == "/api/bookings/reschedule":
            return self.reschedule_booking(data)
        if path == "/api/bookings/post-action":
            return self.post_booking_action(data)
        if path.startswith("/api/drafts/"):
            return self.save_draft(path.rsplit("/", 1)[-1], data)
        if path == "/api/gift-card-plan":
            return self.save_gift_plan(data)
        if path != "/api/booking-interest":
            return self.send_json({"ok": False, "error": "Not found."}, 404)
        required = ("location", "room", "party_size", "visit_date")
        if any(not data.get(key) for key in required):
            return self.send_json({"ok": False, "error": "Complete every field."}, 422)
        try:
            party = int(data["party_size"])
        except (TypeError, ValueError):
            return self.send_json({"ok": False, "error": "Party size must be a whole number."}, 422)
        if not 2 <= party <= 12:
            return self.send_json({"ok": False, "error": "Party size must be between 2 and 12."}, 422)
        valid_locations = set(LOCATIONS) | {item["name"] for item in LOCATIONS.values()}
        valid_rooms = {item["name"] for item in BOOKING_ROOMS.values()}
        if data["location"] not in valid_locations or data["room"] not in valid_rooms:
            return self.send_json({"ok": False, "error": "Choose a listed location and room."}, 422)
        try:
            visit_date = datetime.strptime(str(data["visit_date"]), "%Y-%m-%d").date()
        except ValueError:
            return self.send_json({"ok": False, "error": "Enter a valid visit date."}, 422)
        if visit_date <= datetime.now(TORONTO).date():
            return self.send_json({"ok": False, "error": "Visit date must be in the future."}, 422)
        con = sqlite3.connect(DB, timeout=5)
        try:
            with con:
                con.execute(
                    "INSERT INTO booking_interest(location,room,party_size,visit_date) VALUES (?,?,?,?)",
                    (data["location"], data["room"], party, data["visit_date"]),
                )
            # The schema runs in WAL mode, so a committed plan lives in the
            # sidecar log until it is checkpointed.  Fold it into the database
            # file itself so the saved plan is durable on its own.
            con.execute("PRAGMA wal_checkpoint(TRUNCATE)")
        finally:
            con.close()
        return self.send_json({"ok": True, "message": "Your local game plan is saved. No booking or payment was made."}, 201)

    def create_booking(self, data):
        try:
            preview = booking_preview(data)
        except ValueError as error:
            return self.send_json({"ok": False, "error": str(error)}, 422)
        outcome = preview["payment"]["outcome"]
        if outcome == "declined":
            return self.send_json({
                "ok": False, "sandbox": True, "payment_status": "declined",
                "error": "Simulated payment decline. No booking or charge was created.",
            }, 402)
        if outcome == "retryable":
            return self.send_json({
                "ok": False, "sandbox": True, "payment_status": "retryable",
                "error": "Simulated temporary failure. Retry is safe and no charge was created.",
            }, 503)
        key = str(data.get("idempotency_key", ""))
        if not IDEMPOTENCY_KEY.fullmatch(key):
            return self.send_json({"ok": False, "error": "Provide a valid idempotency key."}, 422)
        token = secrets.token_urlsafe(32)
        confirmation = "BG-" + secrets.token_hex(6).upper()
        session = _auth.resolve_session(self.cookie_token())
        account_id = self.account_id(session or {})
        customer = preview["customer"]
        con = sqlite3.connect(DB, timeout=5, isolation_level=None)
        con.row_factory = sqlite3.Row
        try:
            con.execute("BEGIN IMMEDIATE")
            existing = con.execute("SELECT * FROM local_booking WHERE idempotency_key = ?", (key,)).fetchone()
            if existing:
                con.commit()
                return self.send_json(self.booking_response(existing), 200)
            con.execute(
                """INSERT INTO local_booking(
                    location_id,room_id,party_size,visit_date,time_slot,
                    unit_price_cents,total_cents,idempotency_key,confirmation_code,
                    manage_token_hash,account_id,package_id,customer_name,
                    customer_email,customer_phone,special_requests,payment_scenario
                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                (
                    preview["location"]["id"], preview["room"]["id"], preview["party_size"],
                    preview["visit_date"], preview["time_slot"]["id"], preview["unit_price_cents"],
                    preview["total_cents"], key, confirmation, hashlib.sha256(token.encode()).hexdigest(),
                    account_id, preview["package"]["id"], customer["name"], customer["email"],
                    customer["phone"], customer["special_requests"], preview["payment"]["scenario"],
                ),
            )
            row = con.execute("SELECT * FROM local_booking WHERE idempotency_key = ?", (key,)).fetchone()
            con.commit()
        except sqlite3.IntegrityError:
            con.rollback()
            return self.send_json({"ok": False, "error": "That room and time slot is no longer available."}, 409)
        finally:
            con.close()
        return self.send_json({**self.booking_response(row), "manage_token": token}, 201)

    def find_managed_booking(self, con, data):
        confirmation = str(data.get("confirmation_code", ""))
        token = str(data.get("manage_token", ""))
        if not confirmation or not token:
            return None
        row = con.execute("SELECT * FROM local_booking WHERE confirmation_code = ?", (confirmation,)).fetchone()
        if not row:
            return None
        supplied = hashlib.sha256(token.encode()).hexdigest()
        return row if hmac.compare_digest(row["manage_token_hash"], supplied) else None

    def manage_booking(self, data):
        with sqlite3.connect(DB) as con:
            con.row_factory = sqlite3.Row
            row = self.find_managed_booking(con, data)
        if not row:
            return self.send_json({"ok": False, "error": "Booking not found."}, 404)
        return self.send_json(self.booking_response(row))

    def change_booking_status(self, data, target):
        con = sqlite3.connect(DB, timeout=5, isolation_level=None)
        con.row_factory = sqlite3.Row
        try:
            con.execute("BEGIN IMMEDIATE")
            row = self.find_managed_booking(con, data)
            if not row:
                con.rollback()
                return self.send_json({"ok": False, "error": "Booking not found."}, 404)
            if row["status"] != target:
                con.execute("UPDATE local_booking SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?", (target, row["id"]))
            row = con.execute("SELECT * FROM local_booking WHERE id = ?", (row["id"],)).fetchone()
            con.commit()
        except sqlite3.IntegrityError:
            con.rollback()
            return self.send_json({"ok": False, "error": "The slot was taken while this booking was canceled."}, 409)
        finally:
            con.close()
        return self.send_json(self.booking_response(row))

    def booking_response(self, row):
        keys = set(row.keys())
        return {
            "ok": True,
            "sandbox": True,
            "status": row["status"],
            "confirmation_code": row["confirmation_code"],
            "location_id": row["location_id"],
            "room_id": row["room_id"],
            "party_size": row["party_size"],
            "visit_date": row["visit_date"],
            "time_slot": row["time_slot"],
            "unit_price_cents": row["unit_price_cents"],
            "total_cents": row["total_cents"],
            "currency": "USD",
            "package_id": row["package_id"] if "package_id" in keys else "standard",
            "customer_name": row["customer_name"] if "customer_name" in keys else "",
            "customer_email": row["customer_email"] if "customer_email" in keys else "",
            "customer_phone": row["customer_phone"] if "customer_phone" in keys else "",
            "special_requests": row["special_requests"] if "special_requests" in keys else "",
            "payment_scenario": row["payment_scenario"] if "payment_scenario" in keys else "sandbox-approved",
            "message": "Confirmed in the local sandbox only. No real booking or payment was made.",
        }

    def save_favorite(self, data):
        context = self.require_csrf()
        if not context:
            return
        token, session = context
        location_id = str(data.get("location_id", ""))
        if location_id not in EXPERIENCES:
            return self.send_json({"ok": False, "error": "Choose a listed location."}, 422)
        owner = self.owner_key(token, session)
        with sqlite3.connect(DB) as con:
            con.execute(
                "INSERT OR IGNORE INTO local_favorite(owner_key,location_id) VALUES (?,?)",
                (owner, location_id),
            )
        return self.send_json(
            {"ok": True, "location_id": location_id, "saved": True},
            201,
            {"Set-Cookie": self.session_cookie(token)},
        )

    def register_account(self, data):
        context = self.require_csrf()
        if not context:
            return
        token, session = context
        if self.account_id(session):
            return self.send_json({"ok": False, "error": "Sign out before creating another account."}, 409)
        display_name = str(data.get("display_name", "")).strip()
        email = str(data.get("email", "")).strip()
        password = str(data.get("password", ""))
        phone = str(data.get("phone", "")).strip()[:60]
        if data.get("accepted_terms") is not True:
            return self.send_json({"ok": False, "error": "Accept the local sandbox terms to continue.", "fields": ["accepted_terms"]}, 422)
        if not phone:
            return self.send_json({"ok": False, "error": "Enter a contact phone number.", "fields": ["phone"]}, 422)
        try:
            _auth.seed_account(
                subject_id="local-profile-" + secrets.token_hex(16),
                email=email,
                display_name=display_name,
                password=password,
                email_verified=True,
            )
            signed_in = _auth.sign_in(token, email=email, password=password)
        except AuthConflict:
            return self.send_json({"ok": False, "error": "That email already belongs to a local account."}, 409)
        except AuthValidationError as error:
            return self.send_json({"ok": False, "error": str(error)}, 422)
        except AuthError:
            return self.send_json({"ok": False, "error": "Local account creation failed."}, 400)
        account = signed_in["account"]
        with sqlite3.connect(DB) as con:
            con.execute(
                "INSERT OR REPLACE INTO local_profile(account_id,phone,updated_at) VALUES (?,?,CURRENT_TIMESTAMP)",
                (account["account_id"], phone),
            )
        new_token = signed_in["session_token"]
        return self.send_json(
            {"ok": True, "authenticated": True, "account": account, "profile": {"phone": phone},
             "message": "Local sandbox account created. No email or message was sent."},
            201,
            {"Set-Cookie": self.session_cookie(new_token)},
        )

    def sign_in_account(self, data):
        context = self.require_csrf()
        if not context:
            return
        token, _ = context
        try:
            signed_in = _auth.sign_in(
                token,
                email=str(data.get("email", "")),
                password=str(data.get("password", "")),
            )
        except (AuthRejected, AuthValidationError):
            return self.send_json({"ok": False, "error": "Credentials are invalid."}, 401)
        new_token = signed_in["session_token"]
        return self.send_json(
            {"ok": True, "authenticated": True, "account": signed_in["account"]},
            headers={"Set-Cookie": self.session_cookie(new_token)},
        )

    def sign_out_account(self):
        context = self.require_csrf()
        if not context:
            return
        token, _ = context
        _auth.sign_out(token)
        new_token, session = _auth.ensure_session(None)
        return self.send_json(
            {**session, "ok": True, "csrf_token": self.csrf_token(new_token)},
            headers={"Set-Cookie": self.session_cookie(new_token)},
        )

    def recover_account(self, data):
        context = self.require_csrf()
        if not context:
            return
        token, _ = context
        try:
            result = _auth.start_password_reset(token, email=str(data.get("email", "")))
        except AuthError:
            result = {"accepted": True, "message": "If a matching local account exists, recovery guidance is available locally."}
        return self.send_json({**result, "ok": True, "delivery": "disabled-local-only"}, 202)

    def seed_history(self):
        context = self.require_csrf()
        if not context:
            return
        _, session = context
        account_id = self.account_id(session)
        if not account_id:
            return self.send_json({"ok": False, "error": "Sign in before loading private demo history."}, 401)
        key = f"seed-history-{account_id}"
        with sqlite3.connect(DB) as con:
            con.execute(
                """INSERT OR IGNORE INTO local_booking(
                    location_id,room_id,party_size,visit_date,time_slot,unit_price_cents,
                    total_cents,idempotency_key,confirmation_code,manage_token_hash,status,
                    account_id,package_id,customer_name,payment_scenario
                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
                (
                    "pittsburgh", "mystery-mansion", 4, "2026-01-10", "19:00-20:00",
                    UNIT_PRICE_CENTS, UNIT_PRICE_CENTS * 4, key,
                    "BG-HISTORY-" + hashlib.sha256(account_id.encode()).hexdigest()[:8].upper(),
                    hashlib.sha256(("history:" + account_id).encode()).hexdigest(), "completed",
                    account_id, "private-room", "Seeded Local Guest", "sandbox-approved",
                ),
            )
        return self.send_json({"ok": True, "seeded": True, "sandbox": True}, 201)

    def reschedule_booking(self, data):
        visit_date = str(data.get("visit_date", ""))
        time_slot = str(data.get("time_slot", ""))
        if visit_date != upcoming_saturday().isoformat() or time_slot not in {item["id"] for item in TIME_SLOTS}:
            return self.send_json({"ok": False, "error": "Choose an offered upcoming Saturday slot."}, 422)
        con = sqlite3.connect(DB, timeout=5, isolation_level=None)
        con.row_factory = sqlite3.Row
        try:
            con.execute("BEGIN IMMEDIATE")
            row = self.find_managed_booking(con, data)
            if not row:
                con.rollback()
                return self.send_json({"ok": False, "error": "Booking not found."}, 404)
            if row["status"] != "confirmed":
                con.rollback()
                return self.send_json({"ok": False, "error": "Only confirmed bookings can be rescheduled."}, 409)
            con.execute(
                "UPDATE local_booking SET visit_date=?,time_slot=?,updated_at=CURRENT_TIMESTAMP WHERE id=?",
                (visit_date, time_slot, row["id"]),
            )
            row = con.execute("SELECT * FROM local_booking WHERE id=?", (row["id"],)).fetchone()
            con.commit()
        except sqlite3.IntegrityError:
            con.rollback()
            return self.send_json({"ok": False, "error": "That replacement slot is no longer available."}, 409)
        finally:
            con.close()
        return self.send_json(self.booking_response(row))

    def post_booking_action(self, data):
        action = str(data.get("action", ""))
        if action not in {"contact", "review", "book-again"}:
            return self.send_json({"ok": False, "error": "Choose a supported post-booking action."}, 422)
        message = str(data.get("message", "")).strip()[:1000]
        rating = data.get("rating")
        if action in {"contact", "review"} and not message:
            return self.send_json({"ok": False, "error": "Enter a message for this local action."}, 422)
        if action == "review":
            try:
                rating = int(rating)
            except (TypeError, ValueError):
                rating = 0
            if not 1 <= rating <= 5:
                return self.send_json({"ok": False, "error": "Rating must be between 1 and 5."}, 422)
        else:
            rating = None
        with sqlite3.connect(DB) as con:
            con.row_factory = sqlite3.Row
            row = self.find_managed_booking(con, data)
            if not row:
                return self.send_json({"ok": False, "error": "Booking not found."}, 404)
            con.execute(
                "INSERT INTO local_booking_action(booking_id,action,message,rating) VALUES (?,?,?,?)",
                (row["id"], action, message, rating),
            )
        response = {"ok": True, "sandbox": True, "action": action,
                    "message": "Saved locally. Nothing was sent to the venue."}
        if action == "book-again":
            response["selection"] = self.booking_response(row)
            response["return_path"] = "/book"
        return self.send_json(response, 201)

    def history_response(self, row):
        response = self.booking_response(row)
        response.update({
            "detail_path": f"/account/bookings#{row['confirmation_code']}",
            "can_edit": row["status"] == "confirmed",
            "can_cancel": row["status"] == "confirmed",
        })
        return response

    def save_draft(self, kind, data):
        required = DRAFT_FIELDS.get(kind)
        if not required:
            return self.send_json({"ok": False, "error": "Unknown draft type."}, 404)
        clean = {key: str(data.get(key, "")).strip()[:2000] for key in required}
        missing = [key for key in required if not clean[key]]
        if missing:
            return self.send_json({"ok": False, "error": "Complete every required field.", "fields": missing}, 422)
        if "email" in clean and not EMAIL.match(clean["email"]):
            return self.send_json({"ok": False, "error": "Enter a valid email address.", "fields": ["email"]}, 422)
        if kind in {"team-building", "celebration"}:
            try:
                count = int(clean["max_players"] if kind == "team-building" else clean["party_size"])
            except ValueError:
                count = 0
            if not 2 <= count <= 200:
                return self.send_json({"ok": False, "error": "Group size must be between 2 and 200."}, 422)
        token = fingerprint(kind, clean)
        try:
            with sqlite3.connect(DB) as con:
                con.execute("INSERT INTO local_draft(kind,fingerprint,payload_json) VALUES (?,?,?)", (kind, token, canonical(clean)))
        except sqlite3.IntegrityError:
            return self.send_json({"ok": False, "error": "This identical local draft already exists."}, 409)
        return self.send_json({"ok": True, "status": "draft", "message": "Saved locally as a draft. Nothing was sent."}, 201)

    def save_gift_plan(self, data):
        location = str(data.get("location", "")).strip()
        recipient = str(data.get("recipient_name", "")).strip()[:200]
        try:
            amount = int(data.get("amount_cents", 0))
        except (TypeError, ValueError):
            amount = 0
        if not location or amount not in {2500, 5000, 7500, 10000, 15000, 20000}:
            return self.send_json({"ok": False, "error": "Choose a location and supported gift amount."}, 422)
        token = fingerprint("gift-card-plan", {"location": location, "amount_cents": amount, "recipient_name": recipient})
        try:
            with sqlite3.connect(DB) as con:
                con.execute("INSERT INTO gift_card_plan(fingerprint,location,amount_cents,recipient_name) VALUES (?,?,?,?)", (token, location, amount, recipient))
        except sqlite3.IntegrityError:
            return self.send_json({"ok": False, "error": "This identical gift-card plan already exists."}, 409)
        return self.send_json({"ok": True, "status": "review", "message": "Local review plan saved. No gift card was issued and no payment was taken."}, 201)

    def send_json(self, value, status=200, headers=None):
        body = json.dumps(value).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Cache-Control", "no-store")
        for name, header_value in (headers or {}).items():
            self.send_header(name, header_value)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)


if __name__ == "__main__":
    port = int(os.environ.get("PORT", "8762"))
    ThreadingHTTPServer(("127.0.0.1", port), Handler).serve_forever()