#!/usr/bin/env python3
import hashlib
import hmac
import json
import os
import base64
import random
import re
import secrets
import smtplib
import sqlite3
import subprocess
import tempfile
import time
import urllib.error
import urllib.request
from email.mime.text import MIMEText
from email.utils import formataddr, formatdate, make_msgid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse

from auction_live import (
    admin_auction_detail,
    clear_auto_bid,
    ensure_auction_tables,
    list_auctions_admin,
    live_state,
    normalize_auction_rules,
    place_bid as live_place_bid,
    set_auto_bid,
    upsert_auction,
)

ROOT = Path(os.environ.get("BIRDS_API_ROOT", "/opt/migrated/iis/PigeonPro/api"))
STORE = ROOT / "codes.json"
CONFIG = ROOT / "config.json"
DB = ROOT / "app.db"
TTL = int(os.environ.get("BIRDS_OTP_TTL", str(15 * 60)))
# Admin API login token lifetime. Override on the server without an app store build:
# Environment=BIRDS_SESSION_TTL=2592000  (seconds; default 30 days)
SESSION_TTL = int(os.environ.get("BIRDS_SESSION_TTL", str(30 * 24 * 3600)))
ADMIN_USER = os.environ.get("BIRDS_ADMIN_USER", "admin")
ADMIN_PASS = os.environ.get("BIRDS_ADMIN_PASS", "BeeBirds@2026")


def _as_int(value, default, minimum=0, maximum=None):
    try:
        n = int(value)
    except Exception:
        n = default
    if n < minimum:
        n = minimum
    if maximum is not None and n > maximum:
        n = maximum
    return n


def default_auth_settings() -> dict:
    return {
        "otpTtlSeconds": TTL,
        "otpLength": 6,
        "otpResendSeconds": 45,
        "emailOtp": True,
        "phoneOtp": True,
        "adminSessionTtlSeconds": SESSION_TTL,
        # 0 = keep user session until logout
        "userSessionTtlSeconds": 0,
        "passwordMinLength": 6,
        "guestEnabled": True,
        "guestAiLimit": 3,
    }


def normalize_auth_settings(raw=None) -> dict:
    base = default_auth_settings()
    data = raw if isinstance(raw, dict) else {}
    out = {
        "otpTtlSeconds": _as_int(data.get("otpTtlSeconds", base["otpTtlSeconds"]), base["otpTtlSeconds"], 60, 24 * 3600),
        "otpLength": _as_int(data.get("otpLength", base["otpLength"]), base["otpLength"], 4, 8),
        "otpResendSeconds": _as_int(
            data.get("otpResendSeconds", base["otpResendSeconds"]), base["otpResendSeconds"], 10, 3600
        ),
        "emailOtp": bool(data["emailOtp"]) if "emailOtp" in data else bool(base["emailOtp"]),
        "phoneOtp": bool(data["phoneOtp"]) if "phoneOtp" in data else bool(base["phoneOtp"]),
        "adminSessionTtlSeconds": _as_int(
            data.get("adminSessionTtlSeconds", base["adminSessionTtlSeconds"]),
            base["adminSessionTtlSeconds"],
            300,
            365 * 24 * 3600,
        ),
        "userSessionTtlSeconds": _as_int(
            data.get("userSessionTtlSeconds", base["userSessionTtlSeconds"]),
            base["userSessionTtlSeconds"],
            0,
            365 * 24 * 3600,
        ),
        "passwordMinLength": _as_int(
            data.get("passwordMinLength", base["passwordMinLength"]), base["passwordMinLength"], 4, 32
        ),
        "guestEnabled": bool(data["guestEnabled"]) if "guestEnabled" in data else bool(base["guestEnabled"]),
        "guestAiLimit": _as_int(data.get("guestAiLimit", base["guestAiLimit"]), base["guestAiLimit"], 0, 100),
    }
    return out


def auth_settings() -> dict:
    return normalize_auth_settings(kv_get("authSettings", default_auth_settings()))


def otp_ttl_seconds() -> int:
    return int(auth_settings()["otpTtlSeconds"])


def admin_session_ttl_seconds() -> int:
    return int(auth_settings()["adminSessionTtlSeconds"])

ROOT.mkdir(parents=True, exist_ok=True)
if not CONFIG.exists():
    CONFIG.write_text(json.dumps({"googleWebClientId": ""}, indent=2) + "\n", encoding="utf-8")


def load_json(path: Path, fallback):
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except Exception:
        return fallback


def save_json(path: Path, data) -> None:
    path.write_text(json.dumps(data), encoding="utf-8")


def hash_pass(password: str, salt: str) -> str:
    return hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode("utf-8"), 120000).hex()


def db():
    conn = sqlite3.connect(DB)
    conn.row_factory = sqlite3.Row
    return conn


def init_db():
    conn = db()
    conn.executescript(
        """
        CREATE TABLE IF NOT EXISTS admins (
          user TEXT PRIMARY KEY,
          salt TEXT NOT NULL,
          pass_hash TEXT NOT NULL
        );
        CREATE TABLE IF NOT EXISTS sessions (
          token TEXT PRIMARY KEY,
          admin_user TEXT NOT NULL,
          exp REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS kv (
          key TEXT PRIMARY KEY,
          value TEXT NOT NULL
        );
        CREATE TABLE IF NOT EXISTS notices (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          title TEXT NOT NULL,
          body TEXT NOT NULL,
          active INTEGER NOT NULL DEFAULT 1,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS hidden_listings (
          listing_id TEXT PRIMARY KEY,
          reason TEXT,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS blocked_emails (
          email TEXT PRIMARY KEY,
          reason TEXT,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS vip_emails (
          email TEXT PRIMARY KEY,
          created REAL NOT NULL,
          admin_user TEXT
        );
        CREATE TABLE IF NOT EXISTS events (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT NOT NULL,
          email TEXT,
          payload TEXT,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS app_users (
          email TEXT PRIMARY KEY,
          name TEXT,
          last_seen REAL NOT NULL,
          created REAL NOT NULL,
          terms_accepted_at TEXT,
          terms_version TEXT
        );
        CREATE TABLE IF NOT EXISTS audit (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          admin_user TEXT NOT NULL,
          action TEXT NOT NULL,
          detail TEXT,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS catalog (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          kind TEXT NOT NULL,
          label_ar TEXT NOT NULL,
          label_en TEXT NOT NULL DEFAULT '',
          extra TEXT,
          active INTEGER NOT NULL DEFAULT 1,
          sort INTEGER NOT NULL DEFAULT 0,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS seller_profiles (
          email TEXT PRIMARY KEY,
          full_name TEXT,
          nationality TEXT,
          residence TEXT,
          phone TEXT,
          phone_verified INTEGER NOT NULL DEFAULT 0,
          id_type TEXT,
          id_number TEXT,
          id_expires TEXT,
          id_photo_path TEXT,
          experience_years TEXT,
          favorite_breed TEXT,
          bank_account TEXT,
          ship_pledge INTEGER NOT NULL DEFAULT 0,
          completed_at TEXT,
          updated REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS bird_serials (
          prefix TEXT PRIMARY KEY,
          n INTEGER NOT NULL
        );
        CREATE TABLE IF NOT EXISTS hub_rings (
          code TEXT PRIMARY KEY,
          year INTEGER NOT NULL,
          email TEXT,
          bird_name TEXT,
          bird_id TEXT,
          city TEXT,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS master_rings (
          code TEXT PRIMARY KEY,
          email TEXT NOT NULL,
          breeder_name TEXT NOT NULL DEFAULT '',
          notes TEXT NOT NULL DEFAULT '',
          created REAL NOT NULL,
          admin_user TEXT
        );
        CREATE TABLE IF NOT EXISTS company_requests (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          created REAL NOT NULL,
          updated REAL NOT NULL,
          email TEXT NOT NULL,
          company_name TEXT NOT NULL,
          country_code TEXT NOT NULL DEFAULT '',
          city TEXT NOT NULL DEFAULT '',
          dial_code TEXT NOT NULL DEFAULT '',
          phone TEXT NOT NULL DEFAULT '',
          contact_method TEXT NOT NULL DEFAULT 'whatsapp',
          category TEXT NOT NULL DEFAULT 'delivery',
          services TEXT NOT NULL DEFAULT '',
          status TEXT NOT NULL DEFAULT 'pending',
          admin_note TEXT NOT NULL DEFAULT '',
          reviewer TEXT NOT NULL DEFAULT ''
        );
        CREATE TABLE IF NOT EXISTS otp_senders (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          kind TEXT NOT NULL,
          label TEXT NOT NULL DEFAULT '',
          value TEXT NOT NULL,
          token TEXT NOT NULL DEFAULT '',
          extra TEXT,
          active INTEGER NOT NULL DEFAULT 1,
          created REAL NOT NULL
        );
        CREATE TABLE IF NOT EXISTS change_log (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          created REAL NOT NULL,
          email TEXT,
          user_name TEXT,
          entity TEXT NOT NULL,
          entity_id TEXT,
          entity_label TEXT,
          action TEXT NOT NULL,
          before_json TEXT,
          after_json TEXT,
          diff_json TEXT
        );
        CREATE INDEX IF NOT EXISTS idx_change_log_created ON change_log(created DESC);
        CREATE INDEX IF NOT EXISTS idx_change_log_email ON change_log(email);
        CREATE INDEX IF NOT EXISTS idx_change_log_entity ON change_log(entity);
        CREATE TABLE IF NOT EXISTS public_edits (
          id TEXT PRIMARY KEY,
          created REAL NOT NULL,
          kind TEXT NOT NULL,
          entity_id TEXT NOT NULL,
          email TEXT,
          user_name TEXT,
          title TEXT,
          patch_json TEXT,
          before_json TEXT,
          status TEXT NOT NULL,
          reviewed_at REAL,
          reviewer TEXT,
          note TEXT
        );
        CREATE INDEX IF NOT EXISTS idx_public_edits_status ON public_edits(status, created DESC);
        CREATE TABLE IF NOT EXISTS payments (
          id TEXT PRIMARY KEY,
          kind TEXT NOT NULL,
          email TEXT NOT NULL,
          ref TEXT,
          aed REAL,
          status TEXT NOT NULL,
          checkout_id TEXT,
          payment_id TEXT,
          webhook_id TEXT,
          payload TEXT,
          created REAL NOT NULL,
          updated REAL NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_payments_email ON payments(email, created DESC);
        CREATE INDEX IF NOT EXISTS idx_payments_ref ON payments(kind, ref, email);
        CREATE TABLE IF NOT EXISTS oauth_handoff (
          state TEXT PRIMARY KEY,
          token TEXT NOT NULL,
          created REAL NOT NULL
        );
        """
    )
    try:
        conn.execute("ALTER TABLE payments ADD COLUMN currency TEXT")
    except Exception:
        pass
    row = conn.execute("SELECT user FROM admins WHERE user=?", (ADMIN_USER,)).fetchone()
    if not row:
        salt = secrets.token_hex(16)
        conn.execute(
            "INSERT INTO admins(user, salt, pass_hash) VALUES(?,?,?)",
            (ADMIN_USER, salt, hash_pass(ADMIN_PASS, salt)),
        )
    if not conn.execute("SELECT key FROM kv WHERE key='flags'").fetchone():
        conn.execute(
            "INSERT INTO kv(key, value) VALUES('flags', ?)",
            (json.dumps({"donate": False, "googleSignIn": True, "maintenance": False}),),
        )
    if not conn.execute("SELECT key FROM kv WHERE key='banner'").fetchone():
        conn.execute(
            "INSERT INTO kv(key, value) VALUES('banner', ?)",
            (json.dumps({"active": False, "ar": "", "en": ""}),),
        )
    if not conn.execute("SELECT key FROM kv WHERE key='appUpdate'").fetchone():
        conn.execute(
            "INSERT INTO kv(key, value) VALUES('appUpdate', ?)",
            (
                json.dumps(
                    {
                        "force": False,
                        "minVersion": "",
                        "minBuild": 0,
                        "iosUrl": "",
                        "androidUrl": "https://play.google.com/store/apps/details?id=net.beedevelopments.birds",
                    }
                ),
            ),
        )
    conn.commit()
    if conn.execute("SELECT COUNT(*) n FROM catalog").fetchone()["n"] == 0:
        now = time.time()
        seed = [
            ("shows", "معرض القاهرة 2026", "Cairo Show 2026", {"city": "القاهرة", "date": "2026-03-15", "venue": "أرض المعارض"}),
            ("shows", "معرض الإسكندرية", "Alexandria Show", {"city": "الإسكندرية", "venue": "نادي سموحة"}),
            ("breeds", "زاجل", "Racing Homer", {}),
            ("breeds", "هامر عملاق", "Giant Homer", {}),
            ("breeds", "شو هومر", "Show Homer", {}),
            ("breeds", "مودينا", "Modena", {}),
            ("breeds", "تمبلر", "Tumbler", {}),
            ("breeds", "فانتيل", "Fantail", {}),
            ("breeds", "هاي فلاير", "Highflyer", {}),
            ("colors", "أزرق", "Blue", {}),
            ("colors", "أزرق بار", "Blue bar", {}),
            ("colors", "أحمر", "Red", {}),
            ("colors", "أشقر", "Mealy", {}),
            ("colors", "أبيض", "White", {}),
            ("colors", "أسود", "Black", {}),
            ("colors", "رمادي", "Grey", {}),
            ("strains", "جانسن", "Janssen", {}),
            ("strains", "نايل", "Nile", {}),
            ("strains", "هومر", "Homer", {}),
            ("clubs", "نادي القاهرة", "Cairo Club", {}),
            ("clubs", "الاتحاد المصري", "Egyptian Federation", {}),
            ("races", "سباق الإسماعيلية", "Ismailia race", {"city": "الإسماعيلية"}),
            ("races", "سباق السويس", "Suez race", {"city": "السويس"}),
            ("medicines", "لقاح باراميوكسو", "Paramyxo vaccine", {}),
            ("medicines", "مضاد كوكسيديا", "Coccidiosis treatment", {}),
            ("feed", "علف تربية", "Breeding mix", {}),
            ("feed", "علف سباق", "Racing mix", {}),
            ("cities", "القاهرة", "Cairo", {}),
            ("cities", "الإسكندرية", "Alexandria", {}),
            ("cities", "الجيزة", "Giza", {}),
            ("cities", "الرياض", "Riyadh", {}),
            ("cities", "لندن", "London", {}),
        ]
        for kind, ar, en, extra in seed:
            conn.execute(
                "INSERT INTO catalog(kind, label_ar, label_en, extra, active, sort, created) VALUES(?,?,?,?,1,0,?)",
                (kind, ar, en, json.dumps(extra, ensure_ascii=False), now),
            )
        conn.commit()
    conn.close()


def save_id_photo(email: str, data_url: str):
    if not data_url or "base64," not in data_url:
        return None
    try:
        raw = base64.b64decode(data_url.split("base64,", 1)[1], validate=False)
        if len(raw) > 2_500_000:
            raw = raw[:2_500_000]
        folder = ROOT / "seller_docs"
        folder.mkdir(parents=True, exist_ok=True)
        name = hashlib.sha256(email.encode("utf-8")).hexdigest()[:20] + ".jpg"
        path = folder / name
        path.write_bytes(raw)
        return str(path)
    except Exception:
        return None


def is_guest_email(email: str) -> bool:
    e = (email or "").strip().lower()
    return e == "__guest__" or e.endswith("@guest.pigeonshub.local")


def guest_code_of(email: str, raw: str = "") -> str:
    code = re.sub(r"[^A-Za-z0-9]", "", str(raw or ""))[:12].upper()
    if code:
        return code[-6:] if len(code) > 6 else code
    e = (email or "").strip().lower()
    local = e.split("@")[0] if "@" in e else e
    if local.startswith("guest."):
        local = local.split(".", 1)[1]
    local = re.sub(r"[^a-z0-9]", "", local)
    return local[-6:].upper() if local else ""


def ensure_columns():
    conn = db()
    cols = {r[1] for r in conn.execute("PRAGMA table_info(app_users)")}
    extras = {
        "terms_accepted_at": "TEXT",
        "terms_version": "TEXT",
        "kind": "TEXT",
        "platform": "TEXT",
        "os_version": "TEXT",
        "model": "TEXT",
        "device_name": "TEXT",
        "app_version": "TEXT",
        "locale": "TEXT",
        "country": "TEXT",
        "loft_json": "TEXT",
        "converted_to": "TEXT",
        "converted_from": "TEXT",
        "guest_code": "TEXT",
        "device_id": "TEXT",
        "phone": "TEXT",
        "phone_verified": "INTEGER",
    }
    for name, typ in extras.items():
        if name not in cols:
            conn.execute(f"ALTER TABLE app_users ADD COLUMN {name} {typ}")
    conn.commit()
    conn.close()


init_db()
ensure_columns()


def ensure_auction_live():
    conn = db()
    ensure_auction_tables(conn)
    conn.commit()
    conn.close()


ensure_auction_live()


def auction_rules():
    saved = kv_get("auctionRules", {})
    return normalize_auction_rules(saved if isinstance(saved, dict) else {})


def kv_get(key: str, fallback):
    conn = db()
    row = conn.execute("SELECT value FROM kv WHERE key=?", (key,)).fetchone()
    conn.close()
    if not row:
        return fallback
    try:
        return json.loads(row["value"])
    except Exception:
        return fallback


def kv_set(key: str, value) -> None:
    conn = db()
    conn.execute(
        "INSERT INTO kv(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",
        (key, json.dumps(value, ensure_ascii=False)),
    )
    conn.commit()
    conn.close()


DEFAULT_APP_UPDATE = {
    "force": False,
    "minVersion": "",
    "minBuild": 0,
    "iosUrl": "",
    "androidUrl": "https://play.google.com/store/apps/details?id=net.beedevelopments.birds",
}


def app_update():
    data = kv_get("appUpdate", DEFAULT_APP_UPDATE) or {}
    out = dict(DEFAULT_APP_UPDATE)
    out.update(data)
    out["force"] = bool(out.get("force"))
    out["minVersion"] = str(out.get("minVersion") or "").strip()
    try:
        out["minBuild"] = int(out.get("minBuild") or 0)
    except (TypeError, ValueError):
        out["minBuild"] = 0
    out["iosUrl"] = str(out.get("iosUrl") or "").strip()
    out["androidUrl"] = str(out.get("androidUrl") or DEFAULT_APP_UPDATE["androidUrl"]).strip()
    return out


DEFAULT_VIDEO_RULES = {
    "enabled": True,
    "minSec": 4,
    "maxSec": 90,
    "maxMb": 0,
    "rejectLinks": True,
    "requireMovement": True,
    "requireLight": True,
    "requireSubject": True,
    "requireRing": False,
    "minBrightness": 32,
    "maxBrightness": 230,
    "minMovement": 5.5,
    "minVariance": 16,
    "passAr": "مطابق تماماً. جاري الرفع.",
    "failAr": "ما زال غير مطابق. صوّر فيديو آخر وفق معايير Pigeons Hub.",
    "passEn": "This matches. Uploading now.",
    "failEn": "Not a match yet. Record another video using Pigeons Hub standards.",
    "briefAr": "صوّر الطائر من الهاتف وهو يتحرك، بإضاءة واضحة، من ٤ إلى ٩٠ ثانية، من دون رابط يوتيوب.",
    "briefEn": "Film the live bird on your phone, in good light, 4–90 seconds, no YouTube link.",
}


def video_rules():
    saved = kv_get("videoRules", {})
    if not isinstance(saved, dict):
        saved = {}
    out = dict(DEFAULT_VIDEO_RULES)
    out.update({k: saved[k] for k in DEFAULT_VIDEO_RULES if k in saved})
    return out


def public_video_rules():
    rules = video_rules()
    return {
        "enabled": bool(rules.get("enabled", True)),
        "minSec": int(rules.get("minSec") if rules.get("minSec") is not None else 4),
        "maxSec": int(rules.get("maxSec") if rules.get("maxSec") is not None else 90),
        "maxMb": int(rules.get("maxMb") if rules.get("maxMb") is not None else 0),
        "briefAr": str(rules.get("briefAr") or DEFAULT_VIDEO_RULES["briefAr"]),
        "briefEn": str(rules.get("briefEn") or DEFAULT_VIDEO_RULES["briefEn"]),
    }


def _write_data_url(data_url: str, suffix: str):
    raw = data_url.split(",", 1)[-1] if "," in data_url else data_url
    try:
        blob = base64.b64decode(raw)
    except Exception:
        return None
    if not blob or len(blob) > 3_500_000:
        return None
    fh = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
    fh.write(blob)
    fh.close()
    return fh.name


def _gray_pixels(path: str, size: int = 48):
    try:
        from PIL import Image

        im = Image.open(path).convert("L")
        im.thumbnail((size, size))
        w, h = im.size
        return list(im.getdata()), w, h
    except Exception:
        pass
    try:
        proc = subprocess.run(
            [
                "ffmpeg",
                "-hide_banner",
                "-loglevel",
                "error",
                "-i",
                path,
                "-vf",
                f"scale={size}:{size}",
                "-f",
                "rawvideo",
                "-pix_fmt",
                "gray",
                "pipe:1",
            ],
            capture_output=True,
            timeout=12,
        )
        if proc.returncode == 0 and proc.stdout:
            data = list(proc.stdout[: size * size])
            if data:
                return data, size, size
    except Exception:
        pass
    return None, 0, 0


def _stats(pixels):
    if not pixels:
        return 0.0, 0.0
    n = len(pixels)
    mean = sum(pixels) / n
    var = sum((p - mean) ** 2 for p in pixels) / n
    return mean, var ** 0.5


def review_video_payload(body: dict):
    rules = video_rules()
    reasons = []
    uri = str(body.get("uri") or body.get("url") or "")
    duration = body.get("durationSec")
    try:
        duration = float(duration) if duration is not None and duration != "" else None
    except (TypeError, ValueError):
        duration = None
    size = body.get("fileSize")
    try:
        size = float(size) if size is not None and size != "" else None
    except (TypeError, ValueError):
        size = None
    source = str(body.get("source") or "").lower()
    frames = body.get("frames") if isinstance(body.get("frames"), list) else []
    frames = [str(f) for f in frames if isinstance(f, str) and f.startswith("data:image")][:6]

    if not rules.get("enabled", True):
        return {"ok": True, "pass": True, "reasons": [], "messageAr": rules["passAr"], "messageEn": rules["passEn"]}

    if rules.get("rejectLinks", True):
        low = uri.lower()
        if low.startswith("http://") or low.startswith("https://") or "youtube.com" in low or "youtu.be" in low:
            reasons.append("link")

    min_sec = float(rules.get("minSec") or 4)
    max_sec = float(rules.get("maxSec") or 90)
    if duration is not None:
        if duration < min_sec:
            reasons.append("too_short")
        if duration > max_sec:
            reasons.append("too_long")

    try:
        max_mb = float(rules.get("maxMb"))
    except (TypeError, ValueError):
        max_mb = 0
    if max_mb > 0 and size is not None and size > max_mb * 1024 * 1024:
        reasons.append("too_heavy")

    brightnesses = []
    spreads = []
    grids = []
    paths = []
    ocr_hits = []
    try:
        for frame in frames:
            path = _write_data_url(frame, ".jpg")
            if not path:
                continue
            paths.append(path)
            pixels, _w, _h = _gray_pixels(path)
            if pixels:
                mean, spread = _stats(pixels)
                brightnesses.append(mean)
                spreads.append(spread)
                grids.append(pixels)
            text = ocr_image(frame)
            if text and RING_RE.search(text.replace(" ", "")):
                ocr_hits.append(text)
        if rules.get("requireLight", True) and brightnesses:
            avg_b = sum(brightnesses) / len(brightnesses)
            if avg_b < float(rules.get("minBrightness") or 32):
                reasons.append("too_dark")
            if avg_b > float(rules.get("maxBrightness") or 230):
                reasons.append("too_bright")
        if rules.get("requireSubject", True) and frames:
            if not spreads:
                reasons.append("no_subject")
            elif max(spreads) < float(rules.get("minVariance") or 16):
                reasons.append("empty_frame")
        if rules.get("requireMovement", True) and (len(grids) >= 2 or frames):
            if len(grids) < 2:
                reasons.append("no_movement")
            else:
                diffs = []
                for a, b in zip(grids, grids[1:]):
                    n = min(len(a), len(b))
                    if n:
                        diffs.append(sum(abs(a[i] - b[i]) for i in range(n)) / n)
                if not diffs or max(diffs) < float(rules.get("minMovement") or 5.5):
                    reasons.append("still")
        if rules.get("requireRing") and frames and not ocr_hits:
            reasons.append("no_ring")
    finally:
        for path in paths:
            try:
                os.unlink(path)
            except OSError:
                pass

    passed = not reasons
    return {
        "ok": True,
        "pass": passed,
        "reasons": reasons,
        "source": source,
        "messageAr": rules["passAr"] if passed else rules["failAr"],
        "messageEn": rules["passEn"] if passed else rules["failEn"],
        "rules": public_video_rules(),
    }


def clean_kind(raw: str) -> str:
    kind = re.sub(r"[^a-z0-9_]", "", str(raw or "").lower())[:40]
    return kind or "custom"


def normalize_hub_ring(raw: str) -> str:
    text = re.sub(r"[^A-Za-z0-9]", "", str(raw or "").upper())
    match = re.match(r"PH(\d{2})(\d+)$", text)
    if not match:
        return ""
    return f"PH-{match.group(1)}-{int(match.group(2)):06d}"


def normalize_master_ring(raw: str) -> str:
    """VIP Master Breeder serial: MB-000100."""
    text = re.sub(r"[^A-Za-z0-9]", "", str(raw or "").upper())
    match = re.match(r"MB(\d+)$", text)
    if not match:
        return ""
    return f"MB-{int(match.group(1)):06d}"


COMPANY_STATUSES = ("pending", "in_review", "accepted", "rejected", "needs_info")


def company_request_item(row) -> dict:
    return {
        "id": int(row["id"]),
        "created": row["created"],
        "updated": row["updated"],
        "email": row["email"] or "",
        "companyName": row["company_name"] or "",
        "countryCode": row["country_code"] or "",
        "city": row["city"] or "",
        "dialCode": row["dial_code"] or "",
        "phone": row["phone"] or "",
        "contactMethod": row["contact_method"] or "whatsapp",
        "category": row["category"] or "delivery",
        "services": row["services"] or "",
        "status": row["status"] or "pending",
        "adminNote": row["admin_note"] or "",
    }


def ring_lookup_payload(code: str):
    """Public ring/serial card for Find bird (PH hub rings or MB master rings)."""
    hub = normalize_hub_ring(code)
    if hub:
        conn = db()
        row = conn.execute(
            "SELECT code, year, bird_name, city, created FROM hub_rings WHERE code=?",
            (hub,),
        ).fetchone()
        conn.close()
        if not row:
            return {"ok": True, "ring": None}
        return {
            "ok": True,
            "ring": {
                "code": row["code"],
                "year": row["year"],
                "name": row["bird_name"] or "",
                "city": row["city"] or "",
                "created": row["created"],
                "kind": "hub",
            },
        }
    mb = normalize_master_ring(code)
    if mb:
        conn = db()
        row = conn.execute(
            "SELECT code, email, breeder_name, notes, created FROM master_rings WHERE code=?",
            (mb,),
        ).fetchone()
        conn.close()
        if not row:
            return {"ok": True, "ring": None}
        breeder = (row["breeder_name"] or "").strip() or (row["email"] or "").strip()
        return {
            "ok": True,
            "ring": {
                "code": row["code"],
                "year": None,
                "name": "Master Breeder",
                "city": breeder,
                "created": row["created"],
                "kind": "master",
                "breederName": row["breeder_name"] or "",
                "breederEmail": row["email"] or "",
                "notes": row["notes"] or "",
            },
        }
    return None


def parse_extra(raw) -> dict:
    if isinstance(raw, dict):
        out = {}
        for key in ("city", "date", "venue", "notes", "category", "phone", "country", "countryCode", "reach"):
            val = str(raw.get(key) or "").strip()[:160]
            if key == "countryCode":
                val = val.upper().replace("UK", "GB")[:8]
                if len(val) != 2:
                    continue
            if key == "reach" and val not in ("local", "worldwide"):
                continue
            if val:
                out[key] = val
        return out
    if isinstance(raw, str):
        try:
            return parse_extra(json.loads(raw))
        except Exception:
            return {}
    return {}


def ensure_catalog_defaults():
    conn = db()
    now = time.time()
    extras = [
        ("base_colors", "أزرق", "Blue", {}),
        ("base_colors", "رمادي محمر", "Ash-Red", {}),
        ("base_colors", "بني", "Brown", {}),
        ("base_colors", "فضي", "Silver", {}),
        ("base_colors", "ميلي", "Mealy", {}),
        ("base_colors", "كاكي", "Khaki", {}),
        ("patterns", "سادة", "Barless", {}),
        ("patterns", "بار", "Bar", {}),
        ("patterns", "شطرنجي", "Checker", {}),
        ("patterns", "تي-باترن", "T-Pattern", {}),
        ("patterns", "سبريد", "Spread", {}),
        ("modifiers", "لوزي", "Almond", {}),
        ("modifiers", "إنديجو", "Indigo", {}),
        ("modifiers", "أوبال", "Opal", {}),
        ("modifiers", "مخفف", "Reduced", {}),
        ("modifiers", "أندلسي", "Andalusian", {}),
        ("modifiers", "جريزل", "Grizzle", {}),
        ("modifiers", "أبقع", "Pied", {}),
        ("modifiers", "سبلاش", "Splash", {}),
        ("molt", "لا يوجد", "None", {}),
        ("molt", "خفيف", "Light", {}),
        ("molt", "كثيف", "Heavy", {}),
        ("categories", "حمام سباق", "Racing Pigeons", {}),
        ("categories", "حمام زينة", "Show Pigeons", {}),
        ("categories", "حمام آسيوي", "Asiatic Pigeons", {}),
        ("categories", "هاي فلاير", "Highflyers", {}),
        ("categories", "تمبلر", "Tumblers", {}),
        ("categories", "نفعي", "Utility", {}),
        ("colors", "أزرق شطرنجي", "Blue check", {"aliases": ["blue checker", "blue chequer", "checker"]}),
        ("colors", "أزرق تي-باترن", "Blue T-pattern", {"aliases": ["t-pattern", "dark check", "أزرق نقش T"]}),
        ("colors", "فضي", "Silver", {"aliases": ["dilute blue"]}),
        ("colors", "فضي بار", "Silver bar", {}),
        ("colors", "فضي شطرنجي", "Silver check", {}),
        ("colors", "سبريد", "Spread", {"aliases": ["spread black", "منتشر"]}),
        ("colors", "أحمر", "Recessive red", {"aliases": ["red", "rec red", "أحمر متنحي"]}),
        ("colors", "رمادي محمر", "Ash-red", {"aliases": ["ash red", "dominant red", "أشقر محمر"]}),
        ("colors", "رمادي بار", "Ash-red bar", {"aliases": ["أشقر بار"]}),
        ("colors", "رمادي شطرنجي", "Ash-red check", {"aliases": ["أشقر شطرنجي"]}),
        ("colors", "ميلي", "Mealy", {"aliases": ["mealey", "أشقر"]}),
        ("colors", "كريمي", "Cream", {}),
        ("colors", "أصفر", "Yellow", {"aliases": ["gold"]}),
        ("colors", "بني", "Brown", {}),
        ("colors", "كاكي", "Khaki", {}),
        ("colors", "دن", "Dun", {"aliases": ["دون"]}),
        ("colors", "أبقع", "Pied", {"aliases": ["piebald"]}),
        ("colors", "جريزل", "Grizzle", {"aliases": ["grizzel", "شيب"]}),
        ("colors", "تايجر جريزل", "Tiger grizzle", {"aliases": ["تايجر شيب"]}),
        ("colors", "أندلسي", "Andalusian", {}),
        ("colors", "إنديجو", "Indigo", {"aliases": ["نيلي"]}),
        ("colors", "أوبال", "Opal", {}),
        ("colors", "لوزي", "Almond", {}),
        ("colors", "مخفف", "Reduced", {}),
        ("colors", "ديليوت", "Dilute", {"aliases": ["فاتح"]}),
        ("colors", "سبلاش", "Splash", {}),
        ("colors", "موتلد", "Mottled", {"aliases": ["أرقط"]}),
        ("colors", "برونز", "Bronze", {"aliases": ["برونزي"]}),
        ("colors", "لافندر", "Lavender", {"aliases": ["milky", "حليبي"]}),
        ("colors", "باهت", "Faded", {}),
        ("colors", "جراي", "Grey", {"aliases": ["gray", "رمادي"]}),
        ("colors", "سوتي", "Sooty", {}),
        ("colors", "إندونيسي", "Indonesian", {}),
        ("strains", "فان لون", "Van Loon", {}),
        ("strains", "جاستون فان دي ووير", "Gaston van de Wouwer", {}),
        ("strains", "هوبين", "Houben", {}),
        ("strains", "ديلبار", "Delbar", {}),
        ("strains", "ستيشلباوت", "Stichelbaut", {}),
        ("strains", "آردن", "Aarden", {}),
        ("strains", "سونتين", "Soontjen", {}),
        ("strains", "هيرمانز كوسترز", "Heremans-Ceusters", {"aliases": ["heremans", "ceusters"]}),
        ("strains", "كوبمان", "Koopman", {}),
        ("strains", "كلاك", "Klak", {}),
        ("strains", "كاتريس", "Cattrysse", {}),
        ("strains", "موليمانز", "Meulemans", {}),
        ("strains", "جرونديليرز", "Grondelaers", {}),
        ("strains", "فاندينابيل", "Vandenabeele", {}),
        ("strains", "سيون", "Sion", {}),
        ("strains", "توي", "Silvere Toye", {}),
        ("strains", "جانسن فان لون", "Janssen-Van Loon", {}),
        ("strains", "محلي مصري", "Egyptian local", {"aliases": ["baladi", "nile"]}),
        ("strains", "إسكندراني", "Alexandrian", {}),
        ("breeds", "كينج", "King", {"category": "Utility"}),
        ("breeds", "مونداين", "Mondain", {"category": "Utility"}),
        ("breeds", "فانتيل إنجليزي", "English Fantail", {"category": "Show Pigeons"}),
        ("breeds", "فانتيل هندي", "Indian Fantail", {"category": "Show Pigeons"}),
        ("breeds", "جاكوبين", "Jacobin", {"category": "Show Pigeons"}),
        ("breeds", "برمنجهام رولر", "Birmingham Roller", {"category": "Tumblers"}),
        ("breeds", "تيبلر", "Tippler", {"category": "Highflyers"}),
        ("breeds", "إيراني هاي فلاير", "Iranian Highflyer", {"category": "Highflyers"}),
        ("breeds", "سويفت مصري", "Egyptian Swift", {"category": "Highflyers"}),
        ("breeds", "لاهور", "Lahore", {"category": "Asiatic Pigeons"}),
        ("services", "توصيل الطيور الحية", "Live bird delivery", {"category": "delivery", "notes": "نقل آمن للحمام الحي بين المحافظات والدول. أضيفوا رقم التواصل من لوحة التحكم."}),
        ("services", "أقرب عيادة بيطرية مختصة", "Specialist pigeon vet", {"category": "vet", "notes": "عيادات وبياطرة متخصصون في الحمام. أضيفوا المدينة ورقم العيادة."}),
        ("services", "الأعلاف", "Pigeon feed", {"category": "feed", "notes": "علف تربية وسباق من موردين معتمدين. أضيفوا المورد والمدينة."}),
        ("services", "أدوات للحمام", "Loft tools and equipment", {"category": "tools", "notes": "حجول، سقايات، أعشاش، ومستلزمات العشة. أضيفوا تفاصيل المورد."}),
    ]
    for kind, ar, en, extra in extras:
        row = conn.execute(
            "SELECT id FROM catalog WHERE kind=? AND (label_en=? OR label_ar=?)",
            (kind, en, ar),
        ).fetchone()
        if not row:
            conn.execute(
                "INSERT INTO catalog(kind, label_ar, label_en, extra, active, sort, created) VALUES(?,?,?,?,1,0,?)",
                (kind, ar, en, json.dumps(extra, ensure_ascii=False), now),
            )
        conn.execute("UPDATE catalog SET label_ar=? WHERE kind=? AND label_en=?", (ar, kind, en))
    conn.execute(
        "UPDATE catalog SET label_ar=?, label_en=? WHERE kind='colors' AND (label_en='Milky' OR label_ar IN ('حليبي','حليب'))",
        ("لافندر", "Lavender"),
    )
    breed_cat = {
        "Racing Homer": "Racing Pigeons",
        "زاجل": "Racing Pigeons",
        "Giant Homer": "Racing Pigeons",
        "هامر عملاق": "Racing Pigeons",
        "Show Homer": "Show Pigeons",
        "شو هومر": "Show Pigeons",
        "Modena": "Show Pigeons",
        "مودينا": "Show Pigeons",
        "Tumbler": "Tumblers",
        "تمبلر": "Tumblers",
        "Fantail": "Show Pigeons",
        "فانتيل": "Show Pigeons",
        "Highflyer": "Highflyers",
        "هاي فلاير": "Highflyers",
        "Syrian Dewlap": "Asiatic Pigeons",
        "غلصم سوري": "Asiatic Pigeons",
    }
    for row in conn.execute("SELECT id, label_ar, label_en, extra FROM catalog WHERE kind='breeds'"):
        extra = parse_extra(row["extra"])
        if extra.get("category"):
            continue
        cat = breed_cat.get(row["label_en"] or "") or breed_cat.get(row["label_ar"] or "")
        if cat:
            extra["category"] = cat
            conn.execute(
                "UPDATE catalog SET extra=? WHERE id=?",
                (json.dumps(extra, ensure_ascii=False), row["id"]),
            )
    conn.commit()
    conn.close()


ensure_catalog_defaults()


def catalog_item(row) -> dict:
    return {
        "id": row["id"],
        "kind": row["kind"],
        "labelAr": row["label_ar"],
        "labelEn": row["label_en"],
        "extra": parse_extra(row["extra"]),
        "active": bool(row["active"]),
        "sort": row["sort"],
    }


def catalog_grouped(active_only: bool = True):
    conn = db()
    query = "SELECT id, kind, label_ar, label_en, extra, active, sort FROM catalog"
    if active_only:
        query += " WHERE active=1"
    query += " ORDER BY kind, sort, id"
    groups = {}
    for row in conn.execute(query):
        item = catalog_item(row)
        groups.setdefault(item["kind"], []).append(item)
    conn.close()
    return groups


def dump_json(value, limit: int = 180_000) -> str:
    raw = json.dumps(value, ensure_ascii=False, default=str)
    if len(raw) > limit:
        return raw[:limit] + "…"
    return raw


def parse_json(raw, fallback=None):
    if raw in (None, ""):
        return fallback
    try:
        return json.loads(raw)
    except Exception:
        return fallback if fallback is not None else raw


def change_item(row) -> dict:
    return {
        "id": row["id"],
        "created": row["created"],
        "email": row["email"] or "",
        "userName": row["user_name"] or "",
        "entity": row["entity"],
        "entityId": row["entity_id"] or "",
        "entityLabel": row["entity_label"] or "",
        "action": row["action"],
        "before": parse_json(row["before_json"]),
        "after": parse_json(row["after_json"]),
        "diff": parse_json(row["diff_json"], []),
    }


def public_edit_item(row) -> dict:
    created = row["created"] or 0
    reviewed = row["reviewed_at"]
    return {
        "id": row["id"],
        "kind": row["kind"],
        "entityId": row["entity_id"],
        "email": row["email"] or "",
        "userName": row["user_name"] or "",
        "title": row["title"] or "",
        "patch": parse_json(row["patch_json"], {}),
        "before": parse_json(row["before_json"], {}),
        "status": row["status"],
        "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(created)),
        "reviewedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(reviewed)) if reviewed else "",
        "reviewer": row["reviewer"] or "",
        "note": row["note"] or "",
    }


def insert_change_log(conn, body: dict) -> None:
    conn.execute(
        """
        INSERT INTO change_log(created, email, user_name, entity, entity_id, entity_label, action, before_json, after_json, diff_json)
        VALUES(?,?,?,?,?,?,?,?,?,?)
        """,
        (
            time.time(),
            str(body.get("email") or "").strip().lower()[:120],
            str(body.get("userName") or "").strip()[:80],
            str(body.get("entity") or "").strip()[:40],
            str(body.get("entityId") or "").strip()[:80],
            str(body.get("entityLabel") or "").strip()[:160],
            str(body.get("action") or "").strip()[:16],
            dump_json(body.get("before")),
            dump_json(body.get("after")),
            dump_json(body.get("diff") or []),
        ),
    )


def audit(admin_user: str, action: str, detail: str = "") -> None:
    conn = db()
    conn.execute(
        "INSERT INTO audit(admin_user, action, detail, created) VALUES(?,?,?,?)",
        (admin_user, action, detail, time.time()),
    )
    conn.commit()
    conn.close()


LOCAL_PER_USD = {
    "USD": 1.0,
    "AED": 3.67,
    "SAR": 3.75,
    "EGP": 48.0,
    "EUR": 0.92,
    "GBP": 0.79,
    "KWD": 0.31,
    "QAR": 3.64,
    "BHD": 0.38,
    "OMR": 0.39,
    "JOD": 0.71,
    "IQD": 1310.0,
    "MAD": 10.0,
    "TND": 3.1,
    "LYD": 4.8,
    "INR": 83.0,
    "PKR": 278.0,
    "BDT": 110.0,
    "TRY": 34.0,
    "PLN": 4.0,
    "RON": 4.6,
    "CNY": 7.2,
    "THB": 36.0,
    "CAD": 1.36,
    "AUD": 1.52,
    "ILS": 3.7,
}

COUNTRY_FOR_CURRENCY = {
    "AED": "AE",
    "SAR": "SA",
    "EGP": "EG",
    "EUR": "DE",
    "GBP": "GB",
    "USD": "US",
    "KWD": "KW",
    "QAR": "QA",
    "BHD": "BH",
    "OMR": "OM",
    "JOD": "JO",
    "IQD": "IQ",
    "MAD": "MA",
    "TND": "TN",
    "LYD": "LY",
    "INR": "IN",
    "PKR": "PK",
    "BDT": "BD",
    "TRY": "TR",
    "PLN": "PL",
    "RON": "RO",
    "CNY": "CN",
    "THB": "TH",
    "CAD": "CA",
    "AUD": "AU",
    "ILS": "PS",
}

CURRENCY_FOR_COUNTRY = {v: k for k, v in COUNTRY_FOR_CURRENCY.items()}
CURRENCY_FOR_COUNTRY["DE"] = "EUR"
CURRENCY_FOR_COUNTRY["FR"] = "EUR"
CURRENCY_FOR_COUNTRY["NL"] = "EUR"
CURRENCY_FOR_COUNTRY["IT"] = "EUR"
CURRENCY_FOR_COUNTRY["ES"] = "EUR"
CURRENCY_FOR_COUNTRY["BE"] = "EUR"
CURRENCY_FOR_COUNTRY["AT"] = "EUR"


def dodo_cfg():
    file_cfg = load_json(CONFIG, {})
    raw = file_cfg.get("dodo") if isinstance(file_cfg.get("dodo"), dict) else {}
    mode = str(raw.get("mode") or "test").strip().lower()
    if mode not in ("test", "live"):
        mode = "test"
    try:
        fee_usd = float(raw.get("feeUsd") or 0)
    except (TypeError, ValueError):
        fee_usd = 0
    if fee_usd <= 0:
        try:
            fee_usd = float(raw.get("feeAed") or 25) / 3.67
        except (TypeError, ValueError):
            fee_usd = 7.0
    donate_min = 1.0
    if raw.get("donateMinUsd") not in (None, ""):
        try:
            donate_min = float(raw.get("donateMinUsd"))
        except (TypeError, ValueError):
            donate_min = 1.0
    elif raw.get("donateMinAed") not in (None, ""):
        try:
            donate_min = float(raw.get("donateMinAed")) / 3.67
        except (TypeError, ValueError):
            donate_min = 1.0
    return {
        "apiKey": str(raw.get("apiKey") or "").strip(),
        "webhookKey": str(raw.get("webhookKey") or "").strip(),
        "mode": mode,
        "donateProductId": str(raw.get("donateProductId") or "").strip(),
        "feeProductId": str(raw.get("feeProductId") or "").strip(),
        "feeUsd": max(1.0, fee_usd),
        "donateMinUsd": max(1.0, donate_min),
    }


def dodo_public():
    cfg = dodo_cfg()
    ready = bool(cfg["apiKey"])
    return {
        "enabled": ready and bool(cfg["donateProductId"]),
        "feesEnabled": ready and bool(cfg["feeProductId"]),
        "mode": cfg["mode"],
        "feeUsd": cfg["feeUsd"],
        "donateMinUsd": cfg["donateMinUsd"],
    }


def dodo_admin_public():
    cfg = dodo_cfg()
    key = cfg["apiKey"]
    hook = cfg["webhookKey"]
    return {
        "mode": cfg["mode"],
        "donateProductId": cfg["donateProductId"],
        "feeProductId": cfg["feeProductId"],
        "feeUsd": cfg["feeUsd"],
        "donateMinUsd": cfg["donateMinUsd"],
        "apiKeySet": bool(key),
        "webhookKeySet": bool(hook),
        "apiKeyHint": (key[:6] + "…" + key[-4:]) if len(key) > 12 else ("set" if key else ""),
        "webhookUrl": "https://birds.pigeonshub.net/api/auth/pay/webhook",
    }


def normalize_pay_currency(code: str) -> str:
    cur = str(code or "").strip().upper()
    if cur in LOCAL_PER_USD:
        return cur
    return ""


def normalize_pay_country(code: str, currency: str) -> str:
    iso = str(code or "").strip().upper()
    if iso == "UK":
        iso = "GB"
    if len(iso) == 2:
        return iso
    return COUNTRY_FOR_CURRENCY.get(currency) or ""


def local_to_usd_cents(amount: float, currency: str) -> int:
    per = LOCAL_PER_USD.get(currency) or 1.0
    return max(100, int(round(float(amount) / per * 100)))


def usd_to_local(usd: float, currency: str) -> float:
    n = float(usd) * (LOCAL_PER_USD.get(currency) or 1.0)
    if n >= 100:
        return float(int(round(n / 5.0) * 5))
    if n >= 20:
        return float(int(round(n)))
    return round(n, 1)


def allowed_return_url(url: str) -> bool:
    u = str(url or "").strip()
    return u.startswith(
        (
            "pigeonhub://",
            "https://mail.pigeonshub.net",
            "https://pigeonshub.net",
            "https://www.pigeonshub.net",
            "https://birds.pigeonshub.net",
            "https://birds.beedevelopments.net",
            "http://localhost",
            "http://127.0.0.1",
            "exp://",
        )
    )


def dodo_request(method, path, payload=None):
    cfg = dodo_cfg()
    if not cfg["apiKey"]:
        return None, "not_configured"
    host = "https://live.dodopayments.com" if cfg["mode"] == "live" else "https://test.dodopayments.com"
    req = urllib.request.Request(
        host + path,
        data=json.dumps(payload).encode("utf-8") if payload is not None else None,
        method=method,
        headers={
            "Authorization": "Bearer " + cfg["apiKey"],
            "Content-Type": "application/json",
        },
    )
    try:
        with urllib.request.urlopen(req, timeout=25) as resp:
            body = resp.read().decode("utf-8")
            return json.loads(body) if body else {}, ""
    except urllib.error.HTTPError as exc:
        err = exc.read().decode("utf-8", errors="replace")[:400]
        return None, err or str(exc.code)
    except Exception as exc:
        return None, str(exc)[:200]


def verify_dodo_webhook(raw: bytes, headers) -> bool:
    secret = dodo_cfg()["webhookKey"]
    if not secret:
        return False
    wid = headers.get("Webhook-Id") or ""
    ts = headers.get("Webhook-Timestamp") or ""
    sigs = headers.get("Webhook-Signature") or ""
    if not (wid and ts and sigs):
        return False
    try:
        if abs(time.time() - int(ts)) > 300:
            return False
    except ValueError:
        return False
    key = secret[6:] if secret.startswith("whsec_") else secret
    try:
        signing_key = base64.b64decode(key)
    except Exception:
        signing_key = key.encode("utf-8")
    signed = f"{wid}.{ts}.".encode("utf-8") + raw
    expected = base64.b64encode(hmac.new(signing_key, signed, hashlib.sha256).digest()).decode("ascii")
    for part in sigs.split(" "):
        if "," not in part:
            continue
        ver, val = part.split(",", 1)
        if ver == "v1" and hmac.compare_digest(val, expected):
            return True
    return False


def payment_row(row) -> dict:
    currency = ""
    try:
        currency = str(row["currency"] or "")
    except Exception:
        currency = ""
    return {
        "id": row["id"],
        "kind": row["kind"],
        "email": row["email"],
        "ref": row["ref"] or "",
        "aed": row["aed"],
        "amount": row["aed"],
        "currency": currency,
        "status": row["status"],
        "checkoutId": row["checkout_id"] or "",
        "paymentId": row["payment_id"] or "",
        "created": row["created"],
        "updated": row["updated"],
    }


def mark_payment_paid(payment_id: str, checkout_id: str, metadata: dict, email: str, webhook_id: str, payload: str):
    kind = str((metadata or {}).get("kind") or "").strip()
    ref = str((metadata or {}).get("ref") or "").strip()[:80]
    email = str(email or (metadata or {}).get("email") or "").strip().lower()[:120]
    now = time.time()
    conn = db()
    if webhook_id:
        seen = conn.execute("SELECT id FROM payments WHERE webhook_id=?", (webhook_id,)).fetchone()
        if seen:
            conn.close()
            return
    row = None
    pay_id = str((metadata or {}).get("pay_id") or "")
    if pay_id:
        row = conn.execute("SELECT id FROM payments WHERE id=?", (pay_id,)).fetchone()
    if not row and checkout_id:
        row = conn.execute("SELECT id FROM payments WHERE checkout_id=?", (checkout_id,)).fetchone()
    if not row and payment_id:
        row = conn.execute("SELECT id FROM payments WHERE payment_id=?", (payment_id,)).fetchone()
    if row:
        conn.execute(
            "UPDATE payments SET status=?, payment_id=?, webhook_id=?, payload=?, updated=? WHERE id=?",
            ("paid", payment_id or "", webhook_id or None, payload[:4000], now, row["id"]),
        )
    else:
        conn.execute(
            "INSERT INTO payments(id, kind, email, ref, aed, status, checkout_id, payment_id, webhook_id, payload, created, updated) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)",
            (
                secrets.token_urlsafe(12),
                kind or "donate",
                email,
                ref,
                0,
                "paid",
                checkout_id or "",
                payment_id or "",
                webhook_id or None,
                payload[:4000],
                now,
                now,
            ),
        )
    conn.execute(
        "INSERT INTO events(name, email, payload, created) VALUES(?,?,?,?)",
        ("payment_paid", email, json.dumps({"kind": kind, "ref": ref, "paymentId": payment_id})[:2000], now),
    )
    conn.commit()
    conn.close()


def is_vip_email(email: str) -> bool:
    e = str(email or "").strip().lower()
    if "@" not in e:
        return False
    conn = db()
    row = conn.execute("SELECT email FROM vip_emails WHERE email=?", (e,)).fetchone()
    conn.close()
    return bool(row)


def vip_public():
    conn = db()
    try:
        emails = [str(r["email"]).strip().lower() for r in conn.execute("SELECT email FROM vip_emails")]
    except Exception:
        conn.close()
        return [], []
    names = []
    if emails:
        ph = ",".join("?" * len(emails))
        for r in conn.execute(f"SELECT full_name FROM seller_profiles WHERE lower(email) IN ({ph})", emails):
            n = str(r["full_name"] or "").strip()
            if n:
                names.append(n)
        for r in conn.execute(f"SELECT name FROM app_users WHERE lower(email) IN ({ph})", emails):
            n = str(r["name"] or "").strip()
            if n:
                names.append(n)
    conn.close()
    uniq = []
    seen = set()
    for n in names:
        key = n.lower()
        if key in seen:
            continue
        seen.add(key)
        uniq.append(n)
    return emails, uniq


def public_config():
    file_cfg = load_json(CONFIG, {})
    hidden = []
    blocked = []
    conn = db()
    for row in conn.execute("SELECT listing_id FROM hidden_listings"):
        hidden.append(row["listing_id"])
    for row in conn.execute("SELECT email FROM blocked_emails"):
        blocked.append(row["email"])
    notice = conn.execute(
        "SELECT title, body FROM notices WHERE active=1 ORDER BY id DESC LIMIT 1"
    ).fetchone()
    wa_phone = ""
    try:
        wa = conn.execute(
            "SELECT COUNT(*) n FROM otp_senders WHERE kind='whatsapp' AND active=1 AND IFNULL(token,'')!=''"
        ).fetchone()["n"]
        mail_n = conn.execute(
            "SELECT COUNT(*) n FROM otp_senders WHERE kind='email' AND active=1"
        ).fetchone()["n"]
        wa_row = conn.execute(
            "SELECT value FROM otp_senders WHERE kind='whatsapp' AND active=1 ORDER BY id DESC LIMIT 1"
        ).fetchone()
        wa_phone = str((wa_row["value"] if wa_row else "") or "").strip()
    except Exception:
        wa = 0
        mail_n = 0
        wa_phone = ""
    conn.close()
    vip_emails, vip_names = vip_public()
    return {
        "googleWebClientId": file_cfg.get("googleWebClientId", ""),
        "facebookAppId": file_cfg.get("facebookAppId", ""),
        "banner": kv_get("banner", {"active": False, "ar": "", "en": ""}),
        "flags": kv_get("flags", {"donate": False, "googleSignIn": True, "facebookSignIn": True, "maintenance": False}),
        "notice": {"title": notice["title"], "body": notice["body"]} if notice else None,
        "hiddenListingIds": hidden,
        "blockedEmails": blocked,
        "vipEmails": vip_emails,
        "vipNames": vip_names,
        "catalogs": catalog_grouped(True),
        "supportWhatsapp": wa_phone,
        "videoRules": public_video_rules(),
        "auctionRules": auction_rules(),
        "appUpdate": app_update(),
        "auth": _public_auth(wa, mail_n),
        "payments": dodo_public(),
    }


def _public_auth(wa_count: int, mail_count: int) -> dict:
    settings = auth_settings()
    return {
        **settings,
        "emailOtp": bool(settings.get("emailOtp", True)),
        "phoneOtp": bool(settings.get("phoneOtp", True)) and bool(wa_count),
        "emailSenders": mail_count,
        "whatsappSenders": wa_count,
    }


def load_codes():
    now = time.time()
    data = load_json(STORE, {})
    cleaned = {k: v for k, v in data.items() if v.get("exp", 0) > now}
    if cleaned != data:
        save_json(STORE, cleaned)
    return cleaned


def sender_row(row) -> dict:
    extra = {}
    try:
        extra = json.loads(row["extra"] or "{}")
    except Exception:
        extra = {}
    token = row["token"] or ""
    return {
        "id": row["id"],
        "kind": row["kind"],
        "label": row["label"],
        "value": row["value"],
        "token": "",
        "tokenSet": bool(token),
        "provider": str(extra.get("provider") or ("wasl" if token.startswith("wsl_") else "meta")),
        "phoneNumberId": str(extra.get("phoneNumberId") or ""),
        "template": str(extra.get("template") or ""),
        "templateLang": str(extra.get("templateLang") or "ar"),
        "active": bool(row["active"]),
        "created": row["created"],
    }


def list_senders(kind=None, active_only=False):
    conn = db()
    sql = "SELECT id, kind, label, value, token, extra, active, created FROM otp_senders"
    args = []
    where = []
    if kind:
        where.append("kind=?")
        args.append(kind)
    if active_only:
        where.append("active=1")
    if where:
        sql += " WHERE " + " AND ".join(where)
    sql += " ORDER BY active DESC, id DESC"
    try:
        rows = [sender_row(r) for r in conn.execute(sql, args)]
    except Exception:
        rows = []
    conn.close()
    return rows


def first_sender(kind: str):
    rows = list_senders(kind, True)
    return rows[0] if rows else None


WASL_BASE = "https://pmtmolflfuzwqxmvvgty.supabase.co/functions/v1"


def e164(raw: str) -> str:
    digits = normalize_phone(raw)
    return f"+{digits}" if digits else ""


def activate_sender(sid: int, kind: str = "") -> None:
    conn = db()
    row = conn.execute("SELECT id, kind FROM otp_senders WHERE id=?", (sid,)).fetchone()
    if not row:
        conn.close()
        raise ValueError("missing")
    kind = kind or str(row["kind"] or "")
    conn.execute("UPDATE otp_senders SET active=0 WHERE kind=?", (kind,))
    conn.execute("UPDATE otp_senders SET active=1 WHERE id=?", (sid,))
    conn.commit()
    conn.close()


def http_json_post(url: str, token: str, payload: dict) -> dict:
    req = urllib.request.Request(
        url,
        data=json.dumps(payload).encode("utf-8"),
        method="POST",
        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    )
    try:
        with urllib.request.urlopen(req, timeout=15) as resp:
            raw = resp.read().decode("utf-8") or "{}"
            if resp.status >= 300:
                raise RuntimeError(f"whatsapp_http:{resp.status}")
            try:
                return json.loads(raw)
            except Exception:
                return {}
    except urllib.error.HTTPError as err:
        detail = ""
        try:
            detail = err.read().decode("utf-8")[:300]
        except Exception:
            detail = ""
        raise RuntimeError(f"whatsapp_http:{err.code}:{detail}") from err


def normalize_phone(raw: str) -> str:
    s = re.sub(r"\D", "", raw or "")
    if s.startswith("00"):
        s = s[2:]
    if s.startswith("0") and len(s) in (10, 11):
        s = "20" + s[1:]
    return s


def send_whatsapp(to_digits: str, code: str, text: str) -> None:
    sender = first_sender("whatsapp")
    if not sender:
        raise RuntimeError("whatsapp_unconfigured")
    to = e164(to_digits)
    if not to:
        raise RuntimeError("whatsapp_unconfigured")
    extra = {}
    conn = db()
    row = conn.execute("SELECT token, extra, value FROM otp_senders WHERE id=?", (sender["id"],)).fetchone()
    conn.close()
    token = (row["token"] if row else "") or ""
    if not token:
        raise RuntimeError("whatsapp_unconfigured")
    try:
        extra = json.loads((row["extra"] if row else "") or "{}")
    except Exception:
        extra = {}
    template = str(extra.get("template") or sender.get("template") or "").strip()
    lang = str(extra.get("templateLang") or sender.get("templateLang") or "ar").strip() or "ar"
    provider = str(extra.get("provider") or "").strip().lower()
    phone_id = str(extra.get("phoneNumberId") or sender.get("phoneNumberId") or "").strip()
    use_wasl = provider == "wasl" or token.startswith("wsl_") or not phone_id
    from_n = e164(str((row["value"] if row else "") or sender.get("value") or ""))
    if use_wasl:
        base = str(extra.get("waslBase") or WASL_BASE).rstrip("/")
        if template:
            payload = {
                "to": to,
                "template_name": template,
                "language_code": lang,
                "components": [
                    {"type": "body", "parameters": [{"type": "text", "text": code}]},
                    {
                        "type": "button",
                        "sub_type": "url",
                        "index": "0",
                        "parameters": [{"type": "text", "text": code}],
                    },
                ],
            }
            if from_n:
                payload["from"] = from_n
            http_json_post(f"{base}/messages-send-template", token, payload)
            return
        payload = {"to": to, "message": text}
        if from_n:
            payload["from"] = from_n
        http_json_post(f"{base}/messages-send", token, payload)
        return
    if not phone_id:
        raise RuntimeError("whatsapp_unconfigured")
    url = f"https://graph.facebook.com/v21.0/{phone_id}/messages"
    if template:
        payload = {
            "messaging_product": "whatsapp",
            "to": to_digits,
            "type": "template",
            "template": {
                "name": template,
                "language": {"code": lang},
                "components": [{"type": "body", "parameters": [{"type": "text", "text": code}]}],
            },
        }
    else:
        payload = {
            "messaging_product": "whatsapp",
            "to": to_digits,
            "type": "text",
            "text": {"preview_url": False, "body": text},
        }
    http_json_post(url, token, payload)


def send_mail(to: str, subject: str, body: str) -> None:
    sender = first_sender("email")
    from_email = (sender or {}).get("value") or "noreply@pigeonshub.net"
    from_name = (sender or {}).get("label") or "pigeonshub.net"
    msg = MIMEText(body, "plain", "utf-8")
    msg["Subject"] = subject
    msg["From"] = formataddr((from_name, from_email))
    msg["To"] = to
    msg["Date"] = formatdate(localtime=True)
    domain = from_email.split("@")[-1] if "@" in from_email else "pigeonshub.net"
    msg["Message-ID"] = make_msgid(domain=domain)
    msg["Reply-To"] = from_email
    msg["Auto-Submitted"] = "auto-generated"
    with smtplib.SMTP("localhost", 25, timeout=8) as smtp:
        smtp.sendmail(from_email, [to], msg.as_string())


def read_body(handler: BaseHTTPRequestHandler, max_bytes: int = 5_000_000):
    length = int(handler.headers.get("Content-Length") or 0)
    if length > max_bytes:
        return None
    raw = handler.rfile.read(length) if length else b"{}"
    try:
        return json.loads(raw or b"{}")
    except Exception:
        return None


def bearer(handler: BaseHTTPRequestHandler):
    header = handler.headers.get("Authorization") or ""
    if header.lower().startswith("bearer "):
        return header.split(" ", 1)[1].strip()
    return ""


RING_RE = re.compile(r"[A-Za-z]{1,4}[- ]?\d{2,4}[- ]?\d{3,6}")


def ocr_image(data_url: str) -> str:
    raw = data_url.split(",", 1)[-1] if "," in data_url else data_url
    try:
        blob = base64.b64decode(raw)
    except Exception:
        return ""
    if not blob or len(blob) > 3_500_000:
        return ""
    tmp = None
    try:
        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as fh:
            fh.write(blob)
            tmp = fh.name
        texts = []
        for psm in ("7", "6", "11"):
            proc = subprocess.run(
                ["tesseract", tmp, "stdout", "-l", "eng+ara", "--psm", psm],
                capture_output=True,
                text=True,
                timeout=20,
            )
            text = (proc.stdout or "").strip()
            if not text:
                continue
            match = RING_RE.search(text)
            if match:
                return match.group(0).replace(" ", "-")
            texts.append(text)
        return texts[0] if texts else ""
    except Exception:
        return ""
    finally:
        if tmp:
            Path(tmp).unlink(missing_ok=True)


OAUTH_STATE_RE = re.compile(r"^[A-Za-z0-9._-]{8,80}$")
OAUTH_HANDOFF_TTL = 8 * 60


def prune_oauth_handoff(conn) -> None:
    conn.execute("DELETE FROM oauth_handoff WHERE created < ?", (time.time() - OAUTH_HANDOFF_TTL,))


def admin_from_token(token: str):
    if not token:
        return None
    conn = db()
    row = conn.execute("SELECT admin_user, exp FROM sessions WHERE token=?", (token,)).fetchone()
    conn.close()
    if not row or row["exp"] < time.time():
        return None
    return row["admin_user"]


class Handler(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        return

    def _cors(self):
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
        self.send_header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS")

    def _json(self, code: int, payload: dict):
        raw = json.dumps(payload, ensure_ascii=False).encode("utf-8")
        self.send_response(code)
        self._cors()
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(raw)))
        self.end_headers()
        self.wfile.write(raw)

    def do_OPTIONS(self):
        self.send_response(204)
        self._cors()
        self.end_headers()

    def do_GET(self):
        parsed = urlparse(self.path)
        path = parsed.path.rstrip("/") or "/"
        if path.endswith("/config") and "/admin" not in path:
            self._json(200, public_config())
            return
        m_auc = re.search(r"/auctions/([^/]+)$", path)
        if m_auc and "/admin/" not in path and m_auc.group(1) not in ("sync", "bid", "auto-bid"):
            conn = db()
            ensure_auction_tables(conn)
            try:
                state = live_state(conn, m_auc.group(1), auction_rules())
                conn.commit()
            except ValueError:
                conn.close()
                self._json(404, {"ok": False, "error": "missing"})
                return
            conn.close()
            self._json(200, state)
            return
        if path.endswith("/oauth-handoff"):
            state = (parse_qs(parsed.query).get("state") or [""])[0].strip()
            if not OAUTH_STATE_RE.match(state):
                self._json(400, {"ok": False})
                return
            conn = db()
            prune_oauth_handoff(conn)
            row = conn.execute("SELECT token FROM oauth_handoff WHERE state=?", (state,)).fetchone()
            if not row:
                conn.close()
                self._json(200, {"ok": True, "token": ""})
                return
            token = str(row["token"] or "")
            conn.execute("DELETE FROM oauth_handoff WHERE state=?", (state,))
            conn.commit()
            conn.close()
            self._json(200, {"ok": True, "token": token})
            return
        if path.endswith("/admin/dashboard") or path.endswith("/admin/me"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            if path.endswith("/me"):
                self._json(200, {"ok": True, "user": user})
                return
            conn = db()
            now = time.time()
            day = now - 86400
            week = now - 7 * 86400
            users = conn.execute("SELECT COUNT(*) n FROM app_users").fetchone()["n"]
            guests = conn.execute(
                "SELECT COUNT(*) n FROM app_users WHERE kind='guest' OR email LIKE '%@guest.pigeonshub.local'"
            ).fetchone()["n"]
            opens_today = conn.execute(
                "SELECT COUNT(*) n FROM events WHERE name='app_open' AND created>=?", (day,)
            ).fetchone()["n"]
            events_week = conn.execute(
                "SELECT COUNT(*) n FROM events WHERE created>=?", (week,)
            ).fetchone()["n"]
            hidden = conn.execute("SELECT COUNT(*) n FROM hidden_listings").fetchone()["n"]
            notices = conn.execute("SELECT COUNT(*) n FROM notices WHERE active=1").fetchone()["n"]
            try:
                recent_users = [
                    dict(r)
                    for r in conn.execute(
                        """
                        SELECT email, name, last_seen, created, terms_accepted_at, terms_version,
                               kind, platform, os_version, model, device_name, app_version, locale, country,
                               loft_json, converted_to, converted_from, guest_code, device_id, phone, phone_verified
                        FROM app_users ORDER BY last_seen DESC LIMIT 400
                        """
                    )
                ]
            except Exception:
                recent_users = [
                    dict(r)
                    for r in conn.execute(
                        """
                        SELECT email, name, last_seen, created, terms_accepted_at, terms_version,
                               kind, platform, os_version, model, device_name, app_version, locale, country,
                               loft_json, converted_to, converted_from, guest_code, device_id
                        FROM app_users ORDER BY last_seen DESC LIMIT 400
                        """
                    )
                ]
            recent_events = [
                dict(r)
                for r in conn.execute(
                    "SELECT name, email, payload, created FROM events ORDER BY id DESC LIMIT 500"
                )
            ]
            hidden_rows = [
                dict(r) for r in conn.execute("SELECT listing_id, reason, created FROM hidden_listings")
            ]
            blocked_set = {str(r["email"]).lower() for r in conn.execute("SELECT email FROM blocked_emails")}
            for u in recent_users:
                u["blocked"] = 1 if str(u.get("email") or "").lower() in blocked_set else 0
            notice_rows = [
                dict(r)
                for r in conn.execute(
                    "SELECT id, title, body, active, created FROM notices ORDER BY id DESC LIMIT 20"
                )
            ]
            event_counts = [
                dict(r)
                for r in conn.execute(
                    "SELECT name, COUNT(*) n FROM events WHERE created>=? GROUP BY name ORDER BY n DESC",
                    (week,),
                )
            ]
            seller_rows = []
            try:
                vip_set = {str(r["email"]).lower() for r in conn.execute("SELECT email FROM vip_emails")}
            except Exception:
                vip_set = set()
            for r in conn.execute(
                "SELECT email, full_name, nationality, residence, phone, phone_verified, id_type, id_number, id_expires, id_photo_path, experience_years, favorite_breed, bank_account, ship_pledge, completed_at, updated FROM seller_profiles ORDER BY updated DESC LIMIT 200"
            ):
                item = dict(r)
                num = str(item.get("id_number") or "")
                item["id_last4"] = num[-4:] if num else ""
                item["has_photo"] = bool(item.get("id_photo_path"))
                item["vip"] = 1 if str(item.get("email") or "").lower() in vip_set else 0
                item.pop("id_number", None)
                item.pop("id_photo_path", None)
                seller_rows.append(item)
            vip_rows = [{"email": e} for e in sorted(vip_set)]
            conn.close()
            self._json(
                200,
                {
                    "ok": True,
                    "stats": {
                        "users": users,
                        "guests": guests,
                        "opensToday": opens_today,
                        "eventsWeek": events_week,
                        "hiddenListings": hidden,
                        "activeNotices": notices,
                    },
                    "flags": kv_get("flags", {}),
                    "banner": kv_get("banner", {}),
                    "users": recent_users,
                    "events": recent_events,
                    "eventCounts": event_counts,
                    "hidden": hidden_rows,
                    "notices": notice_rows,
                    "catalogs": catalog_grouped(False),
                    "sellers": seller_rows,
                    "vips": vip_rows,
                    "videoRules": video_rules(),
                    "auctionRules": auction_rules(),
                    "appUpdate": app_update(),
                    "dodo": dodo_admin_public(),
                    "senders": list_senders(),
                    "authSettings": auth_settings(),
                },
            )
            return
        if path.endswith("/admin/auction-rules"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            self._json(200, {"ok": True, "auctionRules": auction_rules()})
            return
        m_admin_auc = re.search(r"/admin/auctions(?:/([^/]+))?$", path)
        if m_admin_auc:
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            conn = db()
            ensure_auction_tables(conn)
            auction_key = (m_admin_auc.group(1) or "").strip()
            qs = parse_qs(parsed.query)
            if auction_key:
                try:
                    detail = admin_auction_detail(conn, auction_key, auction_rules())
                    conn.commit()
                except ValueError:
                    conn.close()
                    self._json(404, {"ok": False, "error": "missing"})
                    return
                conn.close()
                self._json(200, detail)
                return
            data = list_auctions_admin(
                conn,
                status=(qs.get("status") or ["all"])[0],
                query=(qs.get("q") or [""])[0],
                limit=int((qs.get("limit") or ["200"])[0] or 200),
            )
            conn.close()
            self._json(200, data)
            return
        if path.endswith("/admin/catalog"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            self._json(200, {"ok": True, "catalogs": catalog_grouped(False)})
            return
        if path.endswith("/admin/senders"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            self._json(200, {"ok": True, "senders": list_senders()})
            return
        if path.endswith("/admin/changelog"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            qs = parse_qs(parsed.query)
            q = str((qs.get("q") or [""])[0]).strip()
            entity = str((qs.get("entity") or [""])[0]).strip()
            email = str((qs.get("email") or [""])[0]).strip().lower()
            action = str((qs.get("action") or [""])[0]).strip()
            try:
                limit = min(200, max(1, int((qs.get("limit") or ["80"])[0])))
            except Exception:
                limit = 80
            try:
                offset = max(0, int((qs.get("offset") or ["0"])[0]))
            except Exception:
                offset = 0
            where = ["1=1"]
            args = []
            if entity:
                where.append("entity=?")
                args.append(entity)
            if email:
                where.append("email=?")
                args.append(email)
            if action:
                where.append("action=?")
                args.append(action)
            if q:
                like = f"%{q}%"
                where.append(
                    "(email LIKE ? OR user_name LIKE ? OR entity_label LIKE ? OR entity_id LIKE ? OR diff_json LIKE ? OR before_json LIKE ? OR after_json LIKE ?)"
                )
                args.extend([like] * 7)
            clause = " AND ".join(where)
            conn = db()
            total = conn.execute(f"SELECT COUNT(*) n FROM change_log WHERE {clause}", args).fetchone()["n"]
            rows = conn.execute(
                f"SELECT id, created, email, user_name, entity, entity_id, entity_label, action, before_json, after_json, diff_json FROM change_log WHERE {clause} ORDER BY id DESC LIMIT ? OFFSET ?",
                (*args, limit, offset),
            ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "total": total, "items": [change_item(r) for r in rows]})
            return
        if path.endswith("/admin/public-edits"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            qs = parse_qs(parsed.query)
            status = str((qs.get("status") or ["pending"])[0]).strip() or "pending"
            conn = db()
            if status == "all":
                rows = conn.execute(
                    "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits ORDER BY created DESC LIMIT 300"
                ).fetchall()
            else:
                rows = conn.execute(
                    "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits WHERE status=? ORDER BY created DESC LIMIT 300",
                    (status,),
                ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "items": [public_edit_item(r) for r in rows]})
            return
        if path.endswith("/public-edits/mine"):
            qs = parse_qs(parsed.query)
            email = str((qs.get("email") or [""])[0]).strip().lower()
            if "@" not in email:
                self._json(400, {"ok": False})
                return
            conn = db()
            rows = conn.execute(
                "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits WHERE email=? ORDER BY created DESC LIMIT 200",
                (email,),
            ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "items": [public_edit_item(r) for r in rows]})
            return
        if path.endswith("/rings"):
            qs = parse_qs(parsed.query)
            raw = str((qs.get("code") or qs.get("q") or [""])[0])
            payload = ring_lookup_payload(raw)
            if payload is None:
                self._json(400, {"ok": False, "error": "code"})
                return
            self._json(200, payload)
            return
        if path.endswith("/admin/mb-rings"):
            admin_user = admin_from_token(bearer(self))
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            conn = db()
            rows = conn.execute(
                "SELECT code, email, breeder_name, notes, created, admin_user FROM master_rings ORDER BY created DESC LIMIT 300"
            ).fetchall()
            conn.close()
            self._json(
                200,
                {
                    "ok": True,
                    "items": [
                        {
                            "code": r["code"],
                            "email": r["email"] or "",
                            "breederName": r["breeder_name"] or "",
                            "notes": r["notes"] or "",
                            "created": r["created"],
                            "adminUser": r["admin_user"] or "",
                        }
                        for r in rows
                    ],
                },
            )
            return
        if path.endswith("/company-requests"):
            qs = parse_qs(parsed.query)
            email = str((qs.get("email") or [""])[0]).strip().lower()
            if "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            conn = db()
            rows = conn.execute(
                "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                "FROM company_requests WHERE email=? ORDER BY created DESC LIMIT 100",
                (email,),
            ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "items": [company_request_item(r) for r in rows]})
            return
        if path.endswith("/admin/company-requests"):
            admin_user = admin_from_token(bearer(self))
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            qs = parse_qs(parsed.query)
            status = str((qs.get("status") or ["all"])[0]).strip().lower()
            conn = db()
            if status in COMPANY_STATUSES:
                rows = conn.execute(
                    "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                    "FROM company_requests WHERE status=? ORDER BY created DESC LIMIT 300",
                    (status,),
                ).fetchall()
            else:
                rows = conn.execute(
                    "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                    "FROM company_requests ORDER BY created DESC LIMIT 300"
                ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "items": [company_request_item(r) for r in rows]})
            return
        if path.endswith("/pay/access"):
            qs = parse_qs(parsed.query)
            kind = str((qs.get("kind") or [""])[0]).strip()
            ref = str((qs.get("ref") or [""])[0]).strip()[:80]
            email = str((qs.get("email") or [""])[0]).strip().lower()[:120]
            if kind not in ("auction_fee", "market_fee") or not ref or "@" not in email:
                self._json(400, {"ok": False, "error": "params"})
                return
            conn = db()
            row = conn.execute(
                "SELECT id FROM payments WHERE kind=? AND ref=? AND email=? AND status='paid' LIMIT 1",
                (kind, ref, email),
            ).fetchone()
            conn.close()
            self._json(200, {"ok": True, "paid": bool(row), "feeUsd": dodo_cfg()["feeUsd"]})
            return
        if path.endswith("/pay/mine"):
            qs = parse_qs(parsed.query)
            email = str((qs.get("email") or [""])[0]).strip().lower()[:120]
            if "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            conn = db()
            rows = conn.execute(
                "SELECT id, kind, email, ref, aed, currency, status, checkout_id, payment_id, webhook_id, payload, created, updated FROM payments WHERE email=? ORDER BY created DESC LIMIT 50",
                (email,),
            ).fetchall()
            conn.close()
            self._json(200, {"ok": True, "items": [payment_row(r) for r in rows]})
            return
        if path.endswith("/pay/status"):
            qs = parse_qs(parsed.query)
            checkout_id = str((qs.get("checkout") or qs.get("id") or [""])[0]).strip()
            payment_id = str((qs.get("payment") or [""])[0]).strip()
            local_id = str((qs.get("local") or [""])[0]).strip()
            if not checkout_id and not payment_id and not local_id:
                self._json(400, {"ok": False})
                return
            conn = db()
            row = None
            if local_id:
                row = conn.execute(
                    "SELECT id, kind, email, ref, aed, currency, status, checkout_id, payment_id, webhook_id, payload, created, updated FROM payments WHERE id=?",
                    (local_id,),
                ).fetchone()
            elif checkout_id:
                row = conn.execute(
                    "SELECT id, kind, email, ref, aed, currency, status, checkout_id, payment_id, webhook_id, payload, created, updated FROM payments WHERE checkout_id=? OR id=?",
                    (checkout_id, checkout_id),
                ).fetchone()
            else:
                row = conn.execute(
                    "SELECT id, kind, email, ref, aed, currency, status, checkout_id, payment_id, webhook_id, payload, created, updated FROM payments WHERE payment_id=?",
                    (payment_id,),
                ).fetchone()
            conn.close()
            if row and row["status"] == "paid":
                self._json(200, {"ok": True, "paid": True, "item": payment_row(row)})
                return
            if payment_id:
                remote, _err = dodo_request("GET", "/payments/" + payment_id)
                status = str((remote or {}).get("status") or "").lower()
                if remote and status in ("succeeded", "paid"):
                    meta = remote.get("metadata") if isinstance(remote.get("metadata"), dict) else {}
                    customer = remote.get("customer") if isinstance(remote.get("customer"), dict) else {}
                    mark_payment_paid(
                        payment_id,
                        str((meta or {}).get("checkout_id") or (row["checkout_id"] if row else "")),
                        meta or ({"kind": row["kind"], "email": row["email"], "ref": row["ref"], "pay_id": row["id"]} if row else {}),
                        str((customer or {}).get("email") or (row["email"] if row else "")),
                        "",
                        json.dumps(remote)[:4000],
                    )
                    self._json(200, {"ok": True, "paid": True})
                    return
            self._json(200, {"ok": True, "paid": False, "item": payment_row(row) if row else None})
            return
        self._json(404, {"ok": False})

    def do_PUT(self):
        path = urlparse(self.path).path.rstrip("/")
        user = admin_from_token(bearer(self))
        if not user:
            self._json(401, {"ok": False, "error": "auth"})
            return
        body = read_body(self)
        if body is None:
            self._json(400, {"ok": False, "error": "bad_json"})
            return
        if path.endswith("/admin/flags"):
            flags = kv_get("flags", {})
            for key in ("donate", "googleSignIn", "facebookSignIn", "maintenance"):
                if key in body:
                    flags[key] = bool(body[key])
            kv_set("flags", flags)
            audit(user, "flags", json.dumps(flags))
            self._json(200, {"ok": True, "flags": flags})
            return
        if path.endswith("/admin/auth-settings"):
            current = auth_settings()
            merged = {**current, **(body if isinstance(body, dict) else {})}
            next_settings = normalize_auth_settings(merged)
            kv_set("authSettings", next_settings)
            audit(user, "auth_settings", json.dumps(next_settings))
            self._json(200, {"ok": True, "authSettings": next_settings})
            return
        if path.endswith("/admin/vip"):
            email = str(body.get("email") or "").strip().lower()
            on = body.get("vip")
            if on is None:
                on = True
            if "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            conn = db()
            if on:
                conn.execute(
                    "INSERT INTO vip_emails(email, created, admin_user) VALUES(?,?,?) ON CONFLICT(email) DO UPDATE SET admin_user=excluded.admin_user",
                    (email, time.time(), user),
                )
                audit(user, "vip_on", email)
            else:
                conn.execute("DELETE FROM vip_emails WHERE email=?", (email,))
                audit(user, "vip_off", email)
            conn.commit()
            conn.close()
            emails, names = vip_public()
            self._json(200, {"ok": True, "vipEmails": emails, "vipNames": names})
            return
        if path.endswith("/admin/company-requests"):
            rid = int(body.get("id") or 0)
            status = str(body.get("status") or "").strip().lower()
            note = str(body.get("note") or "").strip()[:300]
            if not rid or status not in COMPANY_STATUSES:
                self._json(400, {"ok": False, "error": "params"})
                return
            conn = db()
            row = conn.execute(
                "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                "FROM company_requests WHERE id=?",
                (rid,),
            ).fetchone()
            if not row:
                conn.close()
                self._json(404, {"ok": False})
                return
            now = time.time()
            prev_status = str(row["status"] or "pending")
            conn.execute(
                "UPDATE company_requests SET status=?, admin_note=?, reviewer=?, updated=? WHERE id=?",
                (status, note, user, now, rid),
            )
            if status == "accepted" and prev_status != "accepted":
                phone = str(row["phone"] or "")
                dial = str(row["dial_code"] or "").lstrip("+")
                full_phone = f"+{dial}{phone}" if dial and phone and not str(phone).startswith("+") else (phone or f"+{dial}")
                extra = {
                    "phone": full_phone,
                    "city": row["city"] or "",
                    "country": row["country_code"] or "",
                    "countryCode": row["country_code"] or "",
                    "notes": row["services"] or "",
                    "category": row["category"] or "delivery",
                    "reach": "local",
                    "contactMethod": row["contact_method"] or "whatsapp",
                }
                conn.execute(
                    "INSERT INTO catalog(kind, label_ar, label_en, extra, active, sort, created) VALUES(?,?,?,?,1,?,?)",
                    (
                        "services",
                        row["company_name"],
                        row["company_name"],
                        json.dumps(extra, ensure_ascii=False),
                        0,
                        now,
                    ),
                )
            conn.commit()
            updated = conn.execute(
                "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                "FROM company_requests WHERE id=?",
                (rid,),
            ).fetchone()
            conn.close()
            audit(user, "company_request", f"{rid}:{status}")
            self._json(200, {"ok": True, "item": company_request_item(updated)})
            return
        if path.endswith("/admin/banner"):
            banner = {
                "active": bool(body.get("active")),
                "ar": str(body.get("ar") or ""),
                "en": str(body.get("en") or ""),
            }
            kv_set("banner", banner)
            audit(user, "banner", json.dumps(banner, ensure_ascii=False))
            self._json(200, {"ok": True, "banner": banner})
            return
        if path.endswith("/admin/senders"):
            sid = int(body.get("id") or 0)
            if not sid:
                self._json(400, {"ok": False, "error": "id"})
                return
            try:
                activate_sender(sid)
            except ValueError:
                self._json(404, {"ok": False, "error": "missing"})
                return
            audit(user, "sender_active", str(sid))
            self._json(200, {"ok": True, "senders": list_senders()})
            return
        if path.endswith("/admin/app-update"):
            current = app_update()
            if "force" in body:
                current["force"] = bool(body.get("force"))
            if "minVersion" in body:
                current["minVersion"] = str(body.get("minVersion") or "").strip()[:20]
            if "minBuild" in body:
                try:
                    current["minBuild"] = max(0, int(body.get("minBuild") or 0))
                except (TypeError, ValueError):
                    pass
            if "iosUrl" in body:
                current["iosUrl"] = str(body.get("iosUrl") or "").strip()[:300]
            if "androidUrl" in body:
                current["androidUrl"] = str(body.get("androidUrl") or "").strip()[:300]
            kv_set("appUpdate", current)
            audit(user, "app_update", json.dumps(current))
            self._json(200, {"ok": True, "appUpdate": current})
            return
        if path.endswith("/admin/dodo"):
            file_cfg = load_json(CONFIG, {})
            current = file_cfg.get("dodo") if isinstance(file_cfg.get("dodo"), dict) else {}
            next_cfg = dict(current)
            if "mode" in body:
                mode = str(body.get("mode") or "test").strip().lower()
                next_cfg["mode"] = mode if mode in ("test", "live") else "test"
            if "donateProductId" in body:
                next_cfg["donateProductId"] = str(body.get("donateProductId") or "").strip()[:80]
            if "feeProductId" in body:
                next_cfg["feeProductId"] = str(body.get("feeProductId") or "").strip()[:80]
            if "feeUsd" in body or "feeAed" in body:
                try:
                    next_cfg["feeUsd"] = max(1.0, float(body.get("feeUsd") or body.get("feeAed") or 7))
                except (TypeError, ValueError):
                    pass
            if "donateMinUsd" in body or "donateMinAed" in body:
                try:
                    next_cfg["donateMinUsd"] = max(1.0, float(body.get("donateMinUsd") or 1))
                except (TypeError, ValueError):
                    pass
            api_key = str(body.get("apiKey") or "").strip()
            webhook_key = str(body.get("webhookKey") or "").strip()
            if api_key:
                next_cfg["apiKey"] = api_key
            if webhook_key:
                next_cfg["webhookKey"] = webhook_key
            file_cfg["dodo"] = next_cfg
            save_json(CONFIG, file_cfg)
            audit(user, "dodo", json.dumps({k: next_cfg.get(k) for k in ("mode", "donateProductId", "feeProductId", "feeUsd", "donateMinUsd")}))
            self._json(200, {"ok": True, "dodo": dodo_admin_public()})
            return
        if path.endswith("/admin/video-rules"):
            current = video_rules()
            for key, default in DEFAULT_VIDEO_RULES.items():
                if key not in body:
                    continue
                val = body[key]
                if isinstance(default, bool):
                    current[key] = bool(val)
                elif isinstance(default, (int, float)):
                    try:
                        current[key] = type(default)(val)
                    except (TypeError, ValueError):
                        continue
                else:
                    current[key] = str(val)[:240]
            kv_set("videoRules", current)
            audit(user, "video_rules", json.dumps(current, ensure_ascii=False)[:500])
            self._json(200, {"ok": True, "videoRules": current})
            return
        if path.endswith("/admin/auction-rules"):
            current = auction_rules()
            merged = dict(current)
            if isinstance(body, dict):
                merged.update(body)
                if isinstance(body.get("prayerWindows"), list):
                    merged["prayerWindows"] = body["prayerWindows"]
            for key in (
                "softCloseEnabled",
                "prayerEnabled",
                "autoBidEnabled",
                "serverAuthoritative",
            ):
                if key in body:
                    val = body[key]
                    merged[key] = False if val in (False, 0, "0", "false", "False", "off", "no") else bool(val)
            rules = normalize_auction_rules(merged)
            kv_set("auctionRules", rules)
            audit(user, "auction_rules", json.dumps(rules, ensure_ascii=False)[:800])
            self._json(200, {"ok": True, "auctionRules": rules})
            return
        if path.endswith("/admin/catalog"):
            cid = int(body.get("id") or 0)
            if not cid:
                self._json(400, {"ok": False})
                return
            kind = clean_kind(body.get("kind") or "")
            label_ar = str(body.get("labelAr") or "").strip()[:120]
            label_en = str(body.get("labelEn") or "").strip()[:120]
            extra = parse_extra(body.get("extra") or {})
            if not kind or not label_ar:
                self._json(400, {"ok": False})
                return
            conn = db()
            conn.execute(
                "UPDATE catalog SET kind=?, label_ar=?, label_en=?, extra=?, active=?, sort=? WHERE id=?",
                (
                    kind,
                    label_ar,
                    label_en,
                    json.dumps(extra, ensure_ascii=False),
                    1 if body.get("active", True) else 0,
                    int(body.get("sort") or 0),
                    cid,
                ),
            )
            conn.commit()
            conn.close()
            audit(user, "catalog_edit", f"{kind}:{label_ar}")
            self._json(200, {"ok": True, "catalogs": catalog_grouped(False)})
            return
        self._json(404, {"ok": False})

    def do_DELETE(self):
        parsed = urlparse(self.path)
        path = parsed.path.rstrip("/")
        qs = parse_qs(parsed.query)
        if path.endswith("/auctions/auto-bid"):
            auction_id = str((qs.get("auctionId") or [""])[0]).strip()
            email = str((qs.get("email") or [""])[0]).strip().lower()
            if not auction_id or "@" not in email:
                self._json(400, {"ok": False, "error": "params"})
                return
            conn = db()
            ensure_auction_tables(conn)
            try:
                auction = clear_auto_bid(conn, auction_id, email)
                conn.commit()
            except ValueError as err:
                conn.close()
                self._json(404 if str(err) == "missing" else 400, {"ok": False, "error": str(err)})
                return
            conn.close()
            self._json(200, {"ok": True, "auction": auction})
            return
        user = admin_from_token(bearer(self))
        if not user:
            self._json(401, {"ok": False, "error": "auth"})
            return
        conn = db()
        if path.endswith("/admin/notice"):
            nid = int((qs.get("id") or ["0"])[0])
            conn.execute("DELETE FROM notices WHERE id=?", (nid,))
            conn.commit()
            audit(user, "notice_delete", str(nid))
            conn.close()
            self._json(200, {"ok": True})
            return
        if path.endswith("/admin/hidden"):
            listing_id = str((qs.get("id") or [""])[0])
            conn.execute("DELETE FROM hidden_listings WHERE listing_id=?", (listing_id,))
            conn.commit()
            audit(user, "unhide", listing_id)
            conn.close()
            self._json(200, {"ok": True})
            return
        if path.endswith("/admin/block"):
            email = str((qs.get("email") or [""])[0]).strip().lower()
            conn.execute("DELETE FROM blocked_emails WHERE email=?", (email,))
            conn.commit()
            audit(user, "unblock", email)
            conn.close()
            self._json(200, {"ok": True})
            return
        if path.endswith("/admin/vip"):
            email = str((qs.get("email") or [""])[0]).strip().lower()
            conn.execute("DELETE FROM vip_emails WHERE email=?", (email,))
            conn.commit()
            audit(user, "vip_off", email)
            conn.close()
            self._json(200, {"ok": True})
            return
        if path.endswith("/admin/catalog"):
            cid = int((qs.get("id") or ["0"])[0])
            conn.execute("DELETE FROM catalog WHERE id=?", (cid,))
            conn.commit()
            audit(user, "catalog_delete", str(cid))
            conn.close()
            self._json(200, {"ok": True})
            return
        if path.endswith("/admin/senders"):
            sid = int((qs.get("id") or ["0"])[0])
            conn.execute("DELETE FROM otp_senders WHERE id=?", (sid,))
            conn.commit()
            audit(user, "sender_delete", str(sid))
            conn.close()
            self._json(200, {"ok": True})
            return
        conn.close()
        self._json(404, {"ok": False})

    def do_POST(self):
        path = urlparse(self.path).path.rstrip("/")
        if path.endswith("/auctions/sync"):
            body = read_body(self, 2_000_000)
            if body is None:
                self._json(400, {"ok": False, "error": "bad_json"})
                return
            auction = body.get("auction") if isinstance(body, dict) else None
            if not isinstance(auction, dict) or not auction.get("id"):
                self._json(400, {"ok": False, "error": "auction"})
                return
            rules = auction_rules()
            conn = db()
            ensure_auction_tables(conn)
            try:
                saved = upsert_auction(conn, auction, rules)
                conn.commit()
            except ValueError as err:
                conn.close()
                self._json(400, {"ok": False, "error": str(err)})
                return
            conn.close()
            self._json(200, {"ok": True, "auction": saved, "rules": rules})
            return
        if path.endswith("/auctions/bid"):
            body = read_body(self)
            if body is None:
                self._json(400, {"ok": False, "error": "bad_json"})
                return
            auction_id = str(body.get("auctionId") or body.get("id") or "").strip()
            try:
                amount = float(body.get("amount") or 0)
            except (TypeError, ValueError):
                amount = 0
            bidder = str(body.get("bidder") or "Bidder").strip() or "Bidder"
            email = str(body.get("email") or "").strip().lower()
            if not auction_id or amount <= 0:
                self._json(400, {"ok": False, "error": "params"})
                return
            rules = auction_rules()
            conn = db()
            ensure_auction_tables(conn)
            try:
                # Seed from client payload if first sync missed.
                seed = body.get("auction")
                if isinstance(seed, dict) and seed.get("id"):
                    upsert_auction(conn, seed, rules)
                auction = live_place_bid(conn, auction_id, amount, bidder, email, rules)
                conn.commit()
            except ValueError as err:
                conn.close()
                code = str(err)
                status = 404 if code == "missing" else 400
                self._json(status, {"ok": False, "error": code})
                return
            conn.close()
            self._json(200, {"ok": True, "auction": auction, "rules": rules})
            return
        if path.endswith("/auctions/auto-bid"):
            body = read_body(self)
            if body is None:
                self._json(400, {"ok": False, "error": "bad_json"})
                return
            auction_id = str(body.get("auctionId") or body.get("id") or "").strip()
            email = str(body.get("email") or "").strip().lower()
            bidder = str(body.get("bidder") or email).strip()
            try:
                max_amount = float(body.get("maxAmount") or 0)
            except (TypeError, ValueError):
                max_amount = 0
            try:
                step = float(body.get("step") or 0)
            except (TypeError, ValueError):
                step = 0
            if not auction_id or max_amount <= 0:
                self._json(400, {"ok": False, "error": "params"})
                return
            rules = auction_rules()
            conn = db()
            ensure_auction_tables(conn)
            try:
                seed = body.get("auction")
                if isinstance(seed, dict) and seed.get("id"):
                    upsert_auction(conn, seed, rules)
                auction = set_auto_bid(conn, auction_id, email, max_amount, step, bidder, rules)
                conn.commit()
            except ValueError as err:
                conn.close()
                code = str(err)
                status = 404 if code == "missing" else 400
                self._json(status, {"ok": False, "error": code})
                return
            conn.close()
            self._json(200, {"ok": True, "auction": auction, "rules": rules})
            return
        if path.endswith("/pay/webhook"):
            length = int(self.headers.get("Content-Length") or 0)
            if length > 1_000_000:
                self._json(400, {"ok": False})
                return
            raw = self.rfile.read(length) if length else b"{}"
            if not verify_dodo_webhook(raw, self.headers):
                self._json(401, {"ok": False, "error": "sig"})
                return
            try:
                event = json.loads(raw.decode("utf-8") or "{}")
            except Exception:
                self._json(400, {"ok": False})
                return
            etype = str(event.get("type") or "")
            data = event.get("data") if isinstance(event.get("data"), dict) else event
            if etype in ("payment.succeeded", "payment.succeeded".upper()) or str(data.get("status") or "") == "succeeded":
                meta = data.get("metadata") if isinstance(data.get("metadata"), dict) else {}
                customer = data.get("customer") if isinstance(data.get("customer"), dict) else {}
                mark_payment_paid(
                    str(data.get("payment_id") or data.get("id") or ""),
                    str((meta or {}).get("checkout_id") or data.get("checkout_id") or ""),
                    meta or {},
                    str(customer.get("email") or ""),
                    self.headers.get("Webhook-Id") or "",
                    raw.decode("utf-8", errors="replace")[:4000],
                )
            self._json(200, {"ok": True})
            return
        body = read_body(self, 8_000_000 if path.endswith("/video/review") else 5_000_000)
        if body is None:
            self._json(400, {"ok": False, "error": "bad_json"})
            return

        if path.endswith("/oauth-handoff"):
            state = str(body.get("state") or "").strip()
            token = str(body.get("token") or "").strip()
            if not OAUTH_STATE_RE.match(state) or len(token) < 20 or len(token) > 4096:
                self._json(400, {"ok": False})
                return
            conn = db()
            prune_oauth_handoff(conn)
            conn.execute(
                "INSERT OR REPLACE INTO oauth_handoff(state, token, created) VALUES(?,?,?)",
                (state, token, time.time()),
            )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True})
            return

        if path.endswith("/video/review"):
            result = review_video_payload(body)
            email = str(body.get("email") or "").strip().lower()[:120]
            conn = db()
            conn.execute(
                "INSERT INTO events(name, email, payload, created) VALUES(?,?,?,?)",
                (
                    "video_review_pass" if result.get("pass") else "video_review_fail",
                    email,
                    json.dumps({"reasons": result.get("reasons") or []}, ensure_ascii=False)[:2000],
                    time.time(),
                ),
            )
            conn.commit()
            conn.close()
            self._json(200, result)
            return

        if path.endswith("/admin/login"):
            user = str(body.get("user") or "").strip()
            password = str(body.get("pass") or "")
            conn = db()
            row = conn.execute("SELECT salt, pass_hash FROM admins WHERE user=?", (user,)).fetchone()
            if not row or hash_pass(password, row["salt"]) != row["pass_hash"]:
                conn.close()
                self._json(401, {"ok": False, "error": "creds"})
                return
            token = secrets.token_urlsafe(32)
            admin_ttl = admin_session_ttl_seconds()
            exp = time.time() + admin_ttl
            conn.execute(
                "INSERT INTO sessions(token, admin_user, exp) VALUES(?,?,?)",
                (token, user, exp),
            )
            conn.commit()
            conn.close()
            audit(user, "login", "")
            self._json(
                200,
                {
                    "ok": True,
                    "token": token,
                    "user": user,
                    "expiresAt": int(exp),
                    "ttlSeconds": admin_ttl,
                },
            )
            return

        if path.endswith("/pay/checkout"):
            cfg = dodo_cfg()
            kind = str(body.get("kind") or "").strip()
            email = str(body.get("email") or "").strip().lower()[:120]
            name = str(body.get("name") or email.split("@")[0] or "Fancier").strip()[:80]
            ref = str(body.get("ref") or "").strip()[:80]
            return_url = str(body.get("returnUrl") or "").strip()[:400]
            if kind not in ("donate", "auction_fee", "market_fee"):
                self._json(400, {"ok": False, "error": "kind"})
                return
            if "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            if not allowed_return_url(return_url):
                self._json(400, {"ok": False, "error": "return"})
                return
            country = normalize_pay_country(str(body.get("countryCode") or ""), "")
            currency = normalize_pay_currency(str(body.get("currency") or "")) or CURRENCY_FOR_COUNTRY.get(
                country, "USD"
            )
            country = normalize_pay_country(str(body.get("countryCode") or ""), currency)
            if kind == "donate":
                product = cfg["donateProductId"]
                try:
                    amount = float(body.get("amount") or body.get("amountAed") or 0)
                except (TypeError, ValueError):
                    amount = 0
                min_local = usd_to_local(cfg["donateMinUsd"], currency)
                if amount < min_local:
                    self._json(400, {"ok": False, "error": "amount"})
                    return
            else:
                product = cfg["feeProductId"]
                amount = usd_to_local(cfg["feeUsd"], currency)
                if not ref:
                    self._json(400, {"ok": False, "error": "ref"})
                    return
            if not cfg["apiKey"] or not product:
                self._json(503, {"ok": False, "error": "not_configured"})
                return
            pay_id = secrets.token_urlsafe(12)
            now = time.time()
            checkout_body = {
                "product_cart": [
                    {
                        "product_id": product,
                        "quantity": 1,
                        "amount": local_to_usd_cents(amount, currency),
                    }
                ],
                "customer": {"email": email, "name": name},
                "return_url": return_url,
                "metadata": {
                    "kind": kind,
                    "email": email,
                    "ref": ref,
                    "amount": str(int(amount) if amount == int(amount) else amount),
                    "currency": currency,
                    "country": country,
                    "pay_id": pay_id,
                },
                "feature_flags": {
                    "single_page": True,
                    "allow_customer_editing_country": True,
                },
            }
            if country:
                checkout_body["billing_currency"] = currency
                checkout_body["billing_address"] = {"country": country}
                checkout_body["minimal_address"] = True
            session, err = dodo_request("POST", "/checkouts", checkout_body)
            if not session:
                self._json(502, {"ok": False, "error": "dodo", "detail": err[:180]})
                return
            checkout_url = str(session.get("checkout_url") or "")
            checkout_id = str(session.get("session_id") or session.get("id") or "")
            if not checkout_url:
                self._json(502, {"ok": False, "error": "dodo"})
                return
            conn = db()
            conn.execute(
                "INSERT INTO payments(id, kind, email, ref, aed, currency, status, checkout_id, payment_id, payload, created, updated) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)",
                (
                    pay_id,
                    kind,
                    email,
                    ref,
                    amount,
                    currency,
                    "pending",
                    checkout_id,
                    "",
                    json.dumps({"checkout_url": checkout_url, "currency": currency})[:2000],
                    now,
                    now,
                ),
            )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True, "checkoutUrl": checkout_url, "id": pay_id, "amount": amount, "currency": currency})
            return

        if path.endswith("/events"):
            name = str(body.get("name") or "").strip()[:80]
            if not name:
                self._json(400, {"ok": False})
                return
            email = str(body.get("email") or "").strip().lower()[:120]
            payload = json.dumps(body.get("meta") or {}, ensure_ascii=False)[:2000]
            conn = db()
            conn.execute(
                "INSERT INTO events(name, email, payload, created) VALUES(?,?,?,?)",
                (name, email, payload, time.time()),
            )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True})
            return

        if path.endswith("/changelog"):
            entity = str(body.get("entity") or "").strip()[:40]
            action = str(body.get("action") or "").strip()[:16]
            if not entity or action not in ("add", "edit", "delete"):
                self._json(400, {"ok": False})
                return
            conn = db()
            insert_change_log(conn, body)
            conn.commit()
            conn.close()
            self._json(200, {"ok": True})
            return

        if path.endswith("/public-edits") and "/admin/" not in path:
            kind = str(body.get("kind") or "").strip()
            entity_id = str(body.get("entityId") or "").strip()[:80]
            patch = body.get("patch") if isinstance(body.get("patch"), dict) else {}
            if kind not in ("listing", "auction") or not entity_id or not patch:
                self._json(400, {"ok": False})
                return
            edit_id = str(body.get("id") or "").strip() or f"ped_{secrets.token_hex(8)}"
            email = str(body.get("email") or "").strip().lower()[:120]
            user_name = str(body.get("userName") or "").strip()[:80]
            title = str(body.get("title") or "").strip()[:160]
            now = time.time()
            status = "approved" if is_vip_email(email) and kind == "auction" else "pending"
            conn = db()
            conn.execute(
                """
                INSERT INTO public_edits(id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status)
                VALUES(?,?,?,?,?,?,?,?,?,?)
                """,
                (
                    edit_id,
                    now,
                    kind,
                    entity_id,
                    email,
                    user_name,
                    title,
                    dump_json(patch),
                    dump_json(body.get("before") or {}),
                    status,
                ),
            )
            before_obj = body.get("before") if isinstance(body.get("before"), dict) else {}
            insert_change_log(
                conn,
                {
                    "email": email,
                    "userName": user_name,
                    "entity": kind,
                    "entityId": entity_id,
                    "entityLabel": title,
                    "action": "edit",
                    "before": before_obj,
                    "after": {**before_obj, **patch, "_review": status},
                    "diff": body.get("diff") or [],
                },
            )
            conn.commit()
            row = conn.execute(
                "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits WHERE id=?",
                (edit_id,),
            ).fetchone()
            conn.close()
            self._json(200, {"ok": True, "item": public_edit_item(row)})
            return

        if path.endswith("/admin/public-edits"):
            user = admin_from_token(bearer(self))
            if not user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            edit_id = str(body.get("id") or "").strip()
            status = str(body.get("status") or "").strip()
            note = str(body.get("note") or "").strip()[:240]
            if not edit_id or status not in ("approved", "rejected"):
                self._json(400, {"ok": False})
                return
            conn = db()
            row = conn.execute(
                "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits WHERE id=?",
                (edit_id,),
            ).fetchone()
            if not row:
                conn.close()
                self._json(404, {"ok": False})
                return
            conn.execute(
                "UPDATE public_edits SET status=?, reviewed_at=?, reviewer=?, note=? WHERE id=?",
                (status, time.time(), user, note, edit_id),
            )
            insert_change_log(
                conn,
                {
                    "email": row["email"],
                    "userName": user,
                    "entity": row["kind"],
                    "entityId": row["entity_id"],
                    "entityLabel": row["title"],
                    "action": "edit",
                    "before": parse_json(row["before_json"], {}),
                    "after": {"_review": status, "note": note, "patch": parse_json(row["patch_json"], {})},
                    "diff": [{"field": "_review", "from": row["status"], "to": status}],
                },
            )
            audit(user, f"public_edit_{status}", f"{row['kind']}:{row['entity_id']}")
            conn.commit()
            next_row = conn.execute(
                "SELECT id, created, kind, entity_id, email, user_name, title, patch_json, before_json, status, reviewed_at, reviewer, note FROM public_edits WHERE id=?",
                (edit_id,),
            ).fetchone()
            conn.close()
            self._json(200, {"ok": True, "item": public_edit_item(next_row)})
            return

        if path.endswith("/users/ping"):
            email = str(body.get("email") or "").strip().lower()
            name = str(body.get("name") or "").strip()[:80]
            terms_at = str(body.get("termsAcceptedAt") or "").strip()[:40]
            terms_ver = str(body.get("termsVersion") or "").strip()[:32]
            if "@" not in email:
                self._json(400, {"ok": False})
                return
            guest = is_guest_email(email) or str(body.get("kind") or "") == "guest"
            kind = "guest" if guest else "account"
            guest_code = guest_code_of(email, str(body.get("guestCode") or ""))
            device_id = str(body.get("deviceId") or "")[:40]
            platform = str(body.get("platform") or "")[:20]
            os_version = str(body.get("osVersion") or "")[:40]
            model = str(body.get("model") or "")[:80]
            device_name = str(body.get("deviceName") or "")[:80]
            app_version = str(body.get("appVersion") or "")[:20]
            locale = str(body.get("locale") or "")[:20]
            country = str(body.get("country") or "")[:8]
            converted_to = str(body.get("convertedTo") or "").strip().lower()[:120]
            converted_from = str(body.get("convertedFrom") or "").strip().lower()[:120]
            loft_json = json.dumps(body.get("loft") or {}, ensure_ascii=False)[:500]
            phone = normalize_phone(str(body.get("phone") or ""))[:40]
            phone_verified = 1 if body.get("phoneVerified") else 0
            now = time.time()
            conn = db()
            try:
                row = conn.execute(
                    "SELECT email, name, terms_accepted_at, terms_version, converted_to, converted_from, phone, phone_verified FROM app_users WHERE email=?",
                    (email,),
                ).fetchone()
            except Exception:
                row = conn.execute(
                    "SELECT email, name, terms_accepted_at, terms_version, converted_to, converted_from FROM app_users WHERE email=?",
                    (email,),
                ).fetchone()
            if row:
                next_name = name or row["name"] or ("ضيف" if guest else email.split("@")[0])
                next_at = row["terms_accepted_at"]
                next_ver = row["terms_version"]
                if terms_at and terms_ver and (not next_at or next_ver != terms_ver):
                    next_at = terms_at
                    next_ver = terms_ver
                keep_to = converted_to or row["converted_to"]
                keep_from = converted_from or row["converted_from"]
                keep_phone = phone or (row["phone"] if "phone" in row.keys() else None)
                keep_verified = phone_verified if phone else int((row["phone_verified"] if "phone_verified" in row.keys() else 0) or 0)
                conn.execute(
                    """
                    UPDATE app_users SET
                      name=?, last_seen=?, terms_accepted_at=?, terms_version=?,
                      kind=?, platform=?, os_version=?, model=?, device_name=?,
                      app_version=?, locale=?, country=?, loft_json=?,
                      converted_to=?, converted_from=?, guest_code=?, device_id=?,
                      phone=?, phone_verified=?
                    WHERE email=?
                    """,
                    (
                        next_name, now, next_at, next_ver,
                        kind, platform, os_version, model, device_name,
                        app_version, locale, country, loft_json,
                        keep_to, keep_from, guest_code or None, device_id or None,
                        keep_phone, keep_verified,
                        email,
                    ),
                )
            else:
                conn.execute(
                    """
                    INSERT INTO app_users(
                      email, name, last_seen, created, terms_accepted_at, terms_version,
                      kind, platform, os_version, model, device_name, app_version, locale, country,
                      loft_json, converted_to, converted_from, guest_code, device_id, phone, phone_verified
                    ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
                    """,
                    (
                        email,
                        name or ("ضيف" if guest else email.split("@")[0]),
                        now, now, terms_at or None, terms_ver or None,
                        kind, platform, os_version, model, device_name,
                        app_version, locale, country, loft_json,
                        converted_to or None, converted_from or None,
                        guest_code or None, device_id or None,
                        phone or None, phone_verified,
                    ),
                )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True})
            return

        if path.endswith("/users/seller"):
            email = str(body.get("email") or "").strip().lower()
            if "@" not in email:
                self._json(400, {"ok": False})
                return
            photo_path = save_id_photo(email, str(body.get("idPhoto") or ""))
            now = time.time()
            conn = db()
            conn.execute(
                """
                INSERT INTO seller_profiles(
                  email, full_name, nationality, residence, phone, phone_verified,
                  id_type, id_number, id_expires, id_photo_path, experience_years,
                  favorite_breed, bank_account, ship_pledge, completed_at, updated
                ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
                ON CONFLICT(email) DO UPDATE SET
                  full_name=excluded.full_name,
                  nationality=excluded.nationality,
                  residence=excluded.residence,
                  phone=excluded.phone,
                  phone_verified=excluded.phone_verified,
                  id_type=excluded.id_type,
                  id_number=excluded.id_number,
                  id_expires=excluded.id_expires,
                  id_photo_path=COALESCE(excluded.id_photo_path, seller_profiles.id_photo_path),
                  experience_years=excluded.experience_years,
                  favorite_breed=excluded.favorite_breed,
                  bank_account=excluded.bank_account,
                  ship_pledge=excluded.ship_pledge,
                  completed_at=excluded.completed_at,
                  updated=excluded.updated
                """,
                (
                    email,
                    str(body.get("fullName") or "")[:80],
                    str(body.get("nationality") or "")[:80],
                    str(body.get("residence") or "")[:120],
                    str(body.get("phone") or "")[:40],
                    1 if body.get("phoneVerified") else 0,
                    str(body.get("idType") or "passport")[:20],
                    str(body.get("idNumber") or "")[:80],
                    str(body.get("idExpiresAt") or "")[:20],
                    photo_path,
                    str(body.get("experienceYears") or "")[:12],
                    str(body.get("favoriteBreed") or "")[:80],
                    str(body.get("bankAccount") or "")[:120],
                    1 if body.get("shipWorldwidePledge") else 0,
                    str(body.get("completedAt") or "")[:40],
                    now,
                ),
            )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True})
            return

        if path.endswith("/ocr"):
            text = ocr_image(str(body.get("image") or ""))
            self._json(200, {"ok": True, "text": text})
            return

        if path.endswith("/serial"):
            raw_prefix = re.sub(r"[^A-Za-z]", "", str(body.get("prefix") or "BA")).upper()[:4]
            prefix = raw_prefix or "BA"
            email = str(body.get("email") or "").strip().lower()[:120]
            breeder_name = str(body.get("breederName") or body.get("name") or "").strip()[:80]
            register_master = bool(body.get("registerMaster")) and prefix == "MB"
            conn = db()
            row = conn.execute("SELECT n FROM bird_serials WHERE prefix=?", (prefix,)).fetchone()
            n = int(row["n"]) + 1 if row else 1
            conn.execute(
                "INSERT INTO bird_serials(prefix, n) VALUES(?,?) ON CONFLICT(prefix) DO UPDATE SET n=excluded.n",
                (prefix, n),
            )
            serial = f"{prefix}-{n:06d}"
            if register_master and email and "@" in email:
                conn.execute(
                    "INSERT INTO vip_emails(email, created, admin_user) VALUES(?,?,?) ON CONFLICT(email) DO UPDATE SET admin_user=excluded.admin_user",
                    (email, time.time(), "serial"),
                )
                conn.execute(
                    "INSERT INTO master_rings(code, email, breeder_name, notes, created, admin_user) VALUES(?,?,?,?,?,?) "
                    "ON CONFLICT(code) DO UPDATE SET email=excluded.email, breeder_name=excluded.breeder_name",
                    (serial, email, breeder_name, "auto", time.time(), "serial"),
                )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True, "serial": serial})
            return

        if path.endswith("/rings"):
            email = str(body.get("email") or "").strip().lower()[:120]
            name = str(body.get("name") or "").strip()[:80]
            city = str(body.get("city") or "").strip()[:80]
            bird_id = str(body.get("birdId") or "").strip()[:80]
            year = time.localtime().tm_year % 100
            prefix = f"PH{year:02d}"
            conn = db()
            row = conn.execute("SELECT n FROM bird_serials WHERE prefix=?", (prefix,)).fetchone()
            n = int(row["n"]) + 1 if row else 1
            conn.execute(
                "INSERT INTO bird_serials(prefix, n) VALUES(?,?) ON CONFLICT(prefix) DO UPDATE SET n=excluded.n",
                (prefix, n),
            )
            code = f"PH-{year:02d}-{n:06d}"
            conn.execute(
                "INSERT INTO hub_rings(code, year, email, bird_name, bird_id, city, created) VALUES(?,?,?,?,?,?,?)",
                (code, 2000 + year, email, name, bird_id, city, time.time()),
            )
            conn.commit()
            conn.close()
            self._json(200, {"ok": True, "code": code, "year": 2000 + year})
            return

        if path.endswith("/admin/mb-rings"):
            admin_user = admin_from_token(bearer(self))
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            email = str(body.get("email") or "").strip().lower()[:120]
            breeder_name = str(body.get("breederName") or body.get("name") or "").strip()[:80]
            notes = str(body.get("notes") or "").strip()[:160]
            try:
                count = int(body.get("count") or 1)
            except Exception:
                count = 1
            count = max(1, min(count, 50))
            mark_vip = body.get("vip") is not False
            if not email or "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            conn = db()
            if mark_vip:
                conn.execute(
                    "INSERT INTO vip_emails(email, created, admin_user) VALUES(?,?,?) ON CONFLICT(email) DO UPDATE SET admin_user=excluded.admin_user",
                    (email, time.time(), admin_user),
                )
            row = conn.execute("SELECT n FROM bird_serials WHERE prefix=?", ("MB",)).fetchone()
            n = int(row["n"]) if row else 0
            issued = []
            now = time.time()
            for _ in range(count):
                n += 1
                code = f"MB-{n:06d}"
                conn.execute(
                    "INSERT INTO master_rings(code, email, breeder_name, notes, created, admin_user) VALUES(?,?,?,?,?,?)",
                    (code, email, breeder_name, notes, now, admin_user),
                )
                issued.append(code)
            conn.execute(
                "INSERT INTO bird_serials(prefix, n) VALUES(?,?) ON CONFLICT(prefix) DO UPDATE SET n=excluded.n",
                ("MB", n),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "mb_rings", f"{email}:{len(issued)}")
            emails, names = vip_public()
            self._json(
                200,
                {
                    "ok": True,
                    "codes": issued,
                    "email": email,
                    "breederName": breeder_name,
                    "vipEmails": emails,
                    "vipNames": names,
                },
            )
            return

        if path.endswith("/company-requests"):
            email = str(body.get("email") or "").strip().lower()[:120]
            company_name = str(body.get("companyName") or "").strip()[:120]
            country_code = str(body.get("countryCode") or "").strip().upper()[:8]
            city = str(body.get("city") or "").strip()[:80]
            dial_code = re.sub(r"\D", "", str(body.get("dialCode") or ""))[:8]
            phone = re.sub(r"\D", "", str(body.get("phone") or ""))[:20]
            contact_method = str(body.get("contactMethod") or "whatsapp").strip().lower()
            category = clean_kind(body.get("category") or "delivery") or "delivery"
            services = str(body.get("services") or "").strip()[:400]
            if contact_method not in ("phone", "whatsapp"):
                contact_method = "whatsapp"
            if "@" not in email or not company_name or not country_code or not city or not dial_code or len(phone) < 5:
                self._json(400, {"ok": False, "error": "fields"})
                return
            now = time.time()
            conn = db()
            cur = conn.execute(
                "INSERT INTO company_requests(created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer) "
                "VALUES(?,?,?,?,?,?,?,?,?,?,?,'pending','','')",
                (now, now, email, company_name, country_code, city, dial_code, phone, contact_method, category, services),
            )
            rid = int(cur.lastrowid)
            conn.commit()
            row = conn.execute(
                "SELECT id, created, updated, email, company_name, country_code, city, dial_code, phone, contact_method, category, services, status, admin_note, reviewer "
                "FROM company_requests WHERE id=?",
                (rid,),
            ).fetchone()
            conn.close()
            self._json(200, {"ok": True, "item": company_request_item(row)})
            return

        admin_user = admin_from_token(bearer(self))
        if path.endswith("/admin/notice"):
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            title = str(body.get("title") or "").strip()
            text = str(body.get("body") or "").strip()
            if not title or not text:
                self._json(400, {"ok": False})
                return
            conn = db()
            conn.execute(
                "INSERT INTO notices(title, body, active, created) VALUES(?,?,1,?)",
                (title, text, time.time()),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "notice", title)
            self._json(200, {"ok": True})
            return

        if path.endswith("/admin/hidden"):
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            listing_id = str(body.get("listingId") or "").strip()
            reason = str(body.get("reason") or "").strip()
            if not listing_id:
                self._json(400, {"ok": False})
                return
            conn = db()
            conn.execute(
                "INSERT INTO hidden_listings(listing_id, reason, created) VALUES(?,?,?) ON CONFLICT(listing_id) DO UPDATE SET reason=excluded.reason",
                (listing_id, reason, time.time()),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "hide", listing_id)
            self._json(200, {"ok": True})
            return

        if path.endswith("/admin/block"):
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            email = str(body.get("email") or "").strip().lower()
            reason = str(body.get("reason") or "").strip()
            if "@" not in email:
                self._json(400, {"ok": False})
                return
            conn = db()
            conn.execute(
                "INSERT INTO blocked_emails(email, reason, created) VALUES(?,?,?) ON CONFLICT(email) DO UPDATE SET reason=excluded.reason",
                (email, reason, time.time()),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "block", email)
            self._json(200, {"ok": True})
            return

        if path.endswith("/admin/catalog"):
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            kind = clean_kind(body.get("kind") or "")
            label_ar = str(body.get("labelAr") or "").strip()[:120]
            label_en = str(body.get("labelEn") or "").strip()[:120]
            extra = parse_extra(body.get("extra") or {})
            if not kind or not label_ar:
                self._json(400, {"ok": False})
                return
            conn = db()
            conn.execute(
                "INSERT INTO catalog(kind, label_ar, label_en, extra, active, sort, created) VALUES(?,?,?,?,1,?,?)",
                (
                    kind,
                    label_ar,
                    label_en,
                    json.dumps(extra, ensure_ascii=False),
                    int(body.get("sort") or 0),
                    time.time(),
                ),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "catalog_add", f"{kind}:{label_ar}")
            self._json(200, {"ok": True, "catalogs": catalog_grouped(False)})
            return

        if path.endswith("/admin/senders"):
            admin_user = admin_from_token(bearer(self))
            if not admin_user:
                self._json(401, {"ok": False, "error": "auth"})
                return
            kind = str(body.get("kind") or "").strip().lower()
            if kind not in ("email", "whatsapp"):
                self._json(400, {"ok": False, "error": "kind"})
                return
            value = str(body.get("value") or "").strip()[:120]
            if kind == "email" and "@" not in value:
                self._json(400, {"ok": False, "error": "email"})
                return
            if kind == "whatsapp":
                value = normalize_phone(value) or value
            provider = str(body.get("provider") or "").strip().lower()
            if kind == "whatsapp" and provider not in ("wasl", "meta"):
                token_guess = str(body.get("token") or "")
                provider = "meta" if str(body.get("phoneNumberId") or "").strip() and not token_guess.startswith("wsl_") else "wasl"
            extra = {
                "provider": provider or ("wasl" if kind == "whatsapp" else ""),
                "phoneNumberId": str(body.get("phoneNumberId") or "").strip()[:80],
                "template": str(body.get("template") or "").strip()[:80],
                "templateLang": str(body.get("templateLang") or "ar").strip()[:8],
                "waslBase": str(body.get("waslBase") or "").strip()[:200],
            }
            token = str(body.get("token") or "").strip()[:2000]
            if kind == "whatsapp" and not token:
                self._json(400, {"ok": False, "error": "token"})
                return
            conn = db()
            if kind == "whatsapp":
                conn.execute("UPDATE otp_senders SET active=0 WHERE kind='whatsapp'")
            cur = conn.execute(
                "INSERT INTO otp_senders(kind, label, value, token, extra, active, created) VALUES(?,?,?,?,?,1,?)",
                (
                    kind,
                    str(body.get("label") or "").strip()[:80],
                    value,
                    token,
                    json.dumps(extra, ensure_ascii=False),
                    time.time(),
                ),
            )
            conn.commit()
            conn.close()
            audit(admin_user, "sender_add", f"{kind}:{value}")
            self._json(200, {"ok": True, "senders": list_senders()})
            return

        channel = str(body.get("channel") or "").strip().lower()
        phone = normalize_phone(str(body.get("phone") or body.get("target") or ""))
        email = str(body.get("email") or body.get("target") or "").strip().lower()
        purpose = str(body.get("purpose") or "login")
        if purpose not in ("verify", "reset", "phone", "login"):
            purpose = "login"
        if not channel:
            channel = "phone" if phone and "@" not in email else "email"
        if channel == "phone":
            if len(phone) < 8:
                self._json(400, {"ok": False, "error": "phone"})
                return
            target_key = f"phone:{phone}"
        else:
            if "@" not in email:
                self._json(400, {"ok": False, "error": "email"})
                return
            target_key = f"email:{email}"
        if path.endswith("/send"):
            settings = auth_settings()
            if channel == "phone" and not settings.get("phoneOtp", True):
                self._json(403, {"ok": False, "error": "phone_otp_disabled"})
                return
            if channel == "email" and not settings.get("emailOtp", True):
                self._json(403, {"ok": False, "error": "email_otp_disabled"})
                return
            otp_len = int(settings.get("otpLength") or 6)
            code = f"{random.randint(0, (10 ** otp_len) - 1):0{otp_len}d}"
            ttl = otp_ttl_seconds()
            codes = load_codes()
            codes[f"{purpose}:{target_key}"] = {"code": code, "exp": time.time() + ttl}
            save_json(STORE, codes)
            mins = max(1, int(round(ttl / 60)))
            text = (
                f"رمز Pigeons Hub هو {code}. صالح لمدة {mins} دقيقة.\n\n"
                f"Your Pigeons Hub code is {code}. It expires in {mins} minutes."
            )
            try:
                if channel == "phone":
                    send_whatsapp(phone, code, text)
                else:
                    if purpose == "reset":
                        subject = "Pigeons Hub password reset"
                    else:
                        subject = "Pigeons Hub verification code"
                    send_mail(email, subject, text)
            except Exception as err:
                print(f"otp_fail {channel}:{target_key}: {err}", flush=True)
                err_name = "whatsapp" if channel == "phone" else "mail"
                self._json(502, {"ok": False, "error": err_name})
                return
            print(f"otp_ok {purpose}:{target_key}", flush=True)
            self._json(200, {"ok": True, "channel": channel})
            return
        if path.endswith("/confirm"):
            code = str(body.get("code") or "").strip()
            codes = load_codes()
            item = codes.get(f"{purpose}:{target_key}")
            if not item or item.get("code") != code:
                self._json(400, {"ok": False})
                return
            del codes[f"{purpose}:{target_key}"]
            save_json(STORE, codes)
            self._json(200, {"ok": True, "channel": channel})
            return
        self._json(404, {"ok": False})


if __name__ == "__main__":
    port = int(os.environ.get("PORT", "8788"))
    hosts = [os.environ.get("HOST", "172.17.0.1"), "0.0.0.0"]
    last = None
    for host in hosts:
        try:
            print(f"birds-auth listening on {host}:{port}", flush=True)
            ThreadingHTTPServer((host, port), Handler).serve_forever()
            break
        except OSError as err:
            last = err
    else:
        raise last
