Upload main.py

main.py

@@ -0,0 +1,1150 @@
+# Eatlytic v4 - Single file for HuggingFace Spaces
+# ══════════════════════════════════════════════════════════════════════
+#  IMPORTS
+# ══════════════════════════════════════════════════════════════════════
+import os, re, json, asyncio, logging, hashlib, datetime, secrets
+import sqlite3, threading, base64, hmac, uuid
+from contextlib import contextmanager
+from io import BytesIO
+
+import numpy as np
+import cv2
+from PIL import Image, ImageDraw, ImageFont
+from fastapi import FastAPI, File, UploadFile, Form, Request, HTTPException, Security
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, Response
+from fastapi.security import APIKeyHeader
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+try:
+    from duckduckgo_search import DDGS as _DDGS; _DDGS_OK = True
+except Exception:
+    _DDGS = None; _DDGS_OK = False
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ══════════════════════════════════════════════════════════════════════
+#  CONFIGURATION
+# ══════════════════════════════════════════════════════════════════════
+FREE_SCAN_LIMIT = int(os.environ.get("FREE_SCAN_LIMIT", "10"))
+GROQ_API_KEY    = os.environ.get("GROQ_API_KEY", "")
+ADMIN_TOKEN     = os.environ.get("ADMIN_TOKEN", "changeme")
+MAX_IMAGE_BYTES = 10 * 1024 * 1024
+
+RAZORPAY_KEY_ID     = os.environ.get("RAZORPAY_KEY_ID", "")
+RAZORPAY_KEY_SECRET = os.environ.get("RAZORPAY_KEY_SECRET", "")
+
+if ADMIN_TOKEN == "changeme":
+    logger.warning("⚠️  ADMIN_TOKEN is default — set it in HuggingFace Secrets")
+if not GROQ_API_KEY:
+    logger.warning("⚠️  GROQ_API_KEY missing — all analysis will fail")
+
+MEDICAL_DISCLAIMER = (
+    "⚕️ For informational purposes only — not medical advice. "
+    "Consult a qualified nutritionist or physician before making dietary decisions."
+)
+LANGUAGE_MAP = {
+    "en": "English", "zh": "Simplified Chinese", "es": "Spanish",
+    "ar": "Arabic",  "fr": "French",             "hi": "Hindi (हिन्दी)",
+    "pt": "Portuguese", "de": "German",
+}
+
+# ══════════════════════════════════════════════════════════════════════
+#  DATABASE
+# ══════════════════════════════════════════════════════════════════════
+DATA_DIR  = os.path.join(os.getcwd(), "data")
+CACHE_DIR = os.environ.get("HF_HOME", "/app/.cache")
+MODEL_DIR = os.path.join(CACHE_DIR, "easyocr_models")
+os.makedirs(DATA_DIR, exist_ok=True)
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+DB_FILE = os.path.join(DATA_DIR, "eatlytic.db")
+
+def _get_connection():
+    conn = sqlite3.connect(DB_FILE, check_same_thread=False, timeout=15)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    return conn
+
+@contextmanager
+def db_conn():
+    conn = _get_connection()
+    try:
+        yield conn; conn.commit()
+    except Exception:
+        conn.rollback(); raise
+    finally:
+        conn.close()
+
+def init_db():
+    with db_conn() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS users (
+                id TEXT PRIMARY KEY, email TEXT UNIQUE, phone TEXT UNIQUE,
+                name TEXT DEFAULT '', created_at TEXT DEFAULT (datetime('now')),
+                is_pro INTEGER DEFAULT 0, pro_expires TEXT,
+                scan_count_month INTEGER DEFAULT 0, scan_month TEXT DEFAULT '',
+                streak_days INTEGER DEFAULT 0, last_scan_date TEXT DEFAULT '',
+                tdee REAL DEFAULT 0, persona TEXT DEFAULT 'General Adult',
+                language TEXT DEFAULT 'en', onboarding_done INTEGER DEFAULT 0
+            );
+            CREATE TABLE IF NOT EXISTS sessions (
+                token TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now')),
+                expires_at TEXT NOT NULL, device_hint TEXT DEFAULT ''
+            );
+            CREATE TABLE IF NOT EXISTS devices (
+                device_key TEXT PRIMARY KEY, user_id TEXT,
+                created_at TEXT DEFAULT (datetime('now')),
+                is_pro INTEGER DEFAULT 0, month TEXT DEFAULT '',
+                scan_count INTEGER DEFAULT 0, streak_days INTEGER DEFAULT 0,
+                last_scan_date TEXT DEFAULT '', persona TEXT DEFAULT 'General Adult',
+                language TEXT DEFAULT 'en', tdee REAL DEFAULT 0,
+                onboarding_done INTEGER DEFAULT 0
+            );
+            CREATE TABLE IF NOT EXISTS scans (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT, device_key TEXT,
+                product_name TEXT DEFAULT 'Unknown', score INTEGER DEFAULT 0,
+                verdict TEXT DEFAULT '', calories REAL DEFAULT 0,
+                protein REAL DEFAULT 0, carbs REAL DEFAULT 0, fat REAL DEFAULT 0,
+                sodium REAL DEFAULT 0, fiber REAL DEFAULT 0, sugar REAL DEFAULT 0,
+                persona TEXT DEFAULT '', language TEXT DEFAULT 'en',
+                scanned_at TEXT DEFAULT (datetime('now')), analysis_json TEXT DEFAULT '{}'
+            );
+            CREATE TABLE IF NOT EXISTS daily_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT, device_key TEXT, log_date TEXT NOT NULL,
+                meal_name TEXT DEFAULT '', calories REAL DEFAULT 0,
+                protein REAL DEFAULT 0, carbs REAL DEFAULT 0, fat REAL DEFAULT 0,
+                sodium REAL DEFAULT 0, fiber REAL DEFAULT 0, sugar REAL DEFAULT 0,
+                source TEXT DEFAULT 'scan', logged_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS allergen_profiles (
+                device_key TEXT PRIMARY KEY, user_id TEXT,
+                allergens TEXT DEFAULT '[]', conditions TEXT DEFAULT '[]',
+                updated_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS food_products (
+                id INTEGER PRIMARY KEY AUTOINCREMENT, barcode TEXT UNIQUE,
+                name TEXT NOT NULL, brand TEXT DEFAULT '', category TEXT DEFAULT '',
+                calories_100g REAL DEFAULT 0, protein_100g REAL DEFAULT 0,
+                carbs_100g REAL DEFAULT 0, fat_100g REAL DEFAULT 0,
+                sodium_100g REAL DEFAULT 0, fiber_100g REAL DEFAULT 0,
+                sugar_100g REAL DEFAULT 0, sat_fat_100g REAL DEFAULT 0,
+                eatlytic_score INTEGER DEFAULT 0, ingredients_raw TEXT DEFAULT '',
+                source TEXT DEFAULT 'llm_scan', scan_count INTEGER DEFAULT 0,
+                verified INTEGER DEFAULT 0, created_at TEXT DEFAULT (datetime('now')),
+                updated_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS benchmarks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT, product_name TEXT NOT NULL,
+                ground_truth_json TEXT NOT NULL, llm_output_json TEXT DEFAULT '{}',
+                ocr_text TEXT DEFAULT '', f1_score REAL DEFAULT 0,
+                score_delta REAL DEFAULT 0, field_accuracy TEXT DEFAULT '{}',
+                tested_at TEXT DEFAULT (datetime('now')), model_used TEXT DEFAULT ''
+            );
+            CREATE TABLE IF NOT EXISTS nps_responses (
+                id INTEGER PRIMARY KEY AUTOINCREMENT, device_key TEXT, user_id TEXT,
+                score INTEGER NOT NULL, comment TEXT DEFAULT '',
+                submitted_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS payments (
+                id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, device_key TEXT,
+                razorpay_order_id TEXT UNIQUE, razorpay_payment_id TEXT UNIQUE,
+                razorpay_signature TEXT DEFAULT '', amount_paise INTEGER DEFAULT 19900,
+                currency TEXT DEFAULT 'INR', status TEXT DEFAULT 'created',
+                plan TEXT DEFAULT 'pro_monthly',
+                created_at TEXT DEFAULT (datetime('now')), paid_at TEXT DEFAULT NULL
+            );
+            CREATE TABLE IF NOT EXISTS api_keys (
+                api_key TEXT PRIMARY KEY, client_name TEXT NOT NULL,
+                plan TEXT DEFAULT 'business', scans_this_month INTEGER DEFAULT 0,
+                month TEXT DEFAULT '', active INTEGER DEFAULT 1,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS ocr_cache (
+                cache_key TEXT PRIMARY KEY, result_json TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS ai_cache (
+                cache_key TEXT PRIMARY KEY, result_json TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE INDEX IF NOT EXISTS idx_scans_device ON scans(device_key);
+            CREATE INDEX IF NOT EXISTS idx_daily_dev_date ON daily_logs(device_key, log_date);
+            CREATE INDEX IF NOT EXISTS idx_food_name ON food_products(name);
+        """)
+    logger.info("Database ready: %s", DB_FILE)
+
+def _get_ocr_cache(key):
+    try:
+        with db_conn() as c:
+            row = c.execute("SELECT result_json FROM ocr_cache WHERE cache_key=?", (key,)).fetchone()
+        return json.loads(row["result_json"]) if row else None
+    except Exception: return None
+
+def _set_ocr_cache(key, val):
+    try:
+        with db_conn() as c:
+            c.execute("INSERT OR REPLACE INTO ocr_cache(cache_key,result_json) VALUES(?,?)",
+                      (key, json.dumps(val)))
+    except Exception as e: logger.warning("ocr_cache set: %s", e)
+
+def _get_ai_cache(key):
+    try:
+        with db_conn() as c:
+            row = c.execute("SELECT result_json FROM ai_cache WHERE cache_key=?", (key,)).fetchone()
+        return json.loads(row["result_json"]) if row else None
+    except Exception: return None
+
+def _set_ai_cache(key, val):
+    try:
+        with db_conn() as c:
+            c.execute("INSERT OR REPLACE INTO ai_cache(cache_key,result_json) VALUES(?,?)",
+                      (key, json.dumps(val)))
+    except Exception as e: logger.warning("ai_cache set: %s", e)
+
+init_db()
+
+# ══════════════════════════════════════════════════════════════════════
+#  AUTH
+# ══════════════════════════════════════════════════════════════════════
+SESSION_TTL_DAYS = 30
+_pending_otps: dict = {}
+
+def _get_or_create_user(email=None, phone=None, name=""):
+    if not email and not phone:
+        raise ValueError("email or phone required")
+    with db_conn() as conn:
+        row = conn.execute(
+            "SELECT * FROM users WHERE email=?" if email else "SELECT * FROM users WHERE phone=?",
+            (email or phone,)
+        ).fetchone()
+        if row: return dict(row)
+        uid = str(uuid.uuid4())
+        conn.execute("INSERT INTO users(id,email,phone,name) VALUES(?,?,?,?)",
+                     (uid, email, phone, name))
+        return {"id": uid, "email": email, "phone": phone, "name": name,
+                "is_pro": 0, "streak_days": 0, "scan_count_month": 0}
+
+def _create_session(user_id, device_hint=""):
+    token   = "eat_" + secrets.token_urlsafe(40)
+    expires = (datetime.datetime.utcnow() + datetime.timedelta(days=SESSION_TTL_DAYS)).isoformat()
+    with db_conn() as conn:
+        conn.execute("INSERT INTO sessions(token,user_id,expires_at,device_hint) VALUES(?,?,?,?)",
+                     (token, user_id, expires, device_hint))
+    return token
+
+def _get_user_from_token(token):
+    if not token: return None
+    with db_conn() as conn:
+        row = conn.execute(
+            "SELECT u.* FROM sessions s JOIN users u ON s.user_id=u.id WHERE s.token=? AND s.expires_at>datetime('now')",
+            (token,)
+        ).fetchone()
+    return dict(row) if row else None
+
+def _send_otp(email):
+    otp     = str(secrets.randbelow(900000) + 100000)
+    expires = datetime.datetime.utcnow() + datetime.timedelta(minutes=10)
+    _pending_otps[email.lower()] = (otp, expires)
+    logger.info("OTP for %s: %s (dev mode)", email, otp)
+    return otp
+
+def _verify_otp(email, otp):
+    key   = email.lower()
+    entry = _pending_otps.get(key)
+    if not entry: return None
+    stored, expires = entry
+    if datetime.datetime.utcnow() > expires:
+        del _pending_otps[key]; return None
+    if stored != otp.strip(): return None
+    del _pending_otps[key]
+    return _get_or_create_user(email=email)
+
+def _check_scan_quota_user(user_id):
+    month_key = datetime.date.today().isoformat()[:7]
+    with db_conn() as conn:
+        row = conn.execute(
+            "SELECT is_pro, scan_month, scan_count_month FROM users WHERE id=?", (user_id,)
+        ).fetchone()
+        if not row: return {"allowed": False, "scans_used": 0, "scans_remaining": 0, "is_pro": False}
+        if row["scan_month"] != month_key:
+            conn.execute("UPDATE users SET scan_month=?, scan_count_month=0 WHERE id=?", (month_key, user_id))
+            count = 0
+        else: count = row["scan_count_month"]
+        if row["is_pro"]:
+            conn.execute("UPDATE users SET scan_count_month=scan_count_month+1 WHERE id=?", (user_id,))
+            return {"allowed": True, "scans_used": count+1, "scans_remaining": 9999, "is_pro": True}
+        if count >= FREE_SCAN_LIMIT:
+            return {"allowed": False, "scans_used": count, "scans_remaining": 0, "is_pro": False}
+        conn.execute("UPDATE users SET scan_count_month=scan_count_month+1 WHERE id=?", (user_id,))
+        new = count + 1
+        return {"allowed": True, "scans_used": new, "scans_remaining": FREE_SCAN_LIMIT - new, "is_pro": False}
+
+def _update_streak_user(user_id):
+    today     = datetime.date.today().isoformat()
+    yesterday = (datetime.date.today() - datetime.timedelta(days=1)).isoformat()
+    with db_conn() as conn:
+        row = conn.execute("SELECT streak_days, last_scan_date FROM users WHERE id=?", (user_id,)).fetchone()
+        if not row or row["last_scan_date"] == today: return
+        streak = (row["streak_days"] + 1) if row["last_scan_date"] == yesterday else 1
+        conn.execute("UPDATE users SET streak_days=?, last_scan_date=? WHERE id=?", (streak, today, user_id))
+
+# ══════════════════════════════════════════════════════════════════════
+#  IMAGE PROCESSING
+# ══════════════════════════════════════════════════════════════════════
+def validate_image(content):
+    if len(content) > MAX_IMAGE_BYTES:
+        raise ValueError(f"Image too large ({len(content)//1024}KB). Max 10MB.")
+    try:
+        img = Image.open(BytesIO(content)).convert("RGB")
+    except Exception:
+        raise ValueError("Invalid image format. Upload JPEG, PNG, or WebP.")
+    w, h = img.size
+    if max(w, h) > 2048:
+        ratio = 2048 / max(w, h)
+        img   = img.resize((int(w*ratio), int(h*ratio)), Image.LANCZOS)
+        buf   = BytesIO(); img.save(buf, format="JPEG", quality=92)
+        return buf.getvalue()
+    return content
+
+def assess_image_quality(content):
+    try:
+        img_np = np.array(Image.open(BytesIO(content)).convert("RGB"))
+        gray   = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+        lap    = float(cv2.Laplacian(gray, cv2.CV_64F).var())
+        gx     = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        gy     = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        ten    = float(np.mean(gx**2 + gy**2))
+        diff   = gray[:, 2:].astype(np.float64) - gray[:, :-2].astype(np.float64)
+        bren   = float(np.mean(diff**2))
+        h, w   = gray.shape
+        scores = [cv2.Laplacian(gray[y:y+64, x:x+64], cv2.CV_64F).var()
+                  for y in range(0, h-64, 64) for x in range(0, w-64, 64)]
+        loc    = float(np.median(scores)) if scores else 0.0
+        comp   = (0.25*min(lap/300*100,100) + 0.20*min(ten/500*100,100) +
+                  0.20*min(bren/200*100,100) + 0.35*min(loc/300*100,100))
+        if comp < 15:   sev, blur = "severe",   True
+        elif comp < 35: sev, blur = "moderate", True
+        elif comp < 55: sev, blur = "mild",     True
+        else:           sev, blur = "none",     False
+        return {"blur_score": round(comp,2), "is_blurry": blur, "blur_severity": sev,
+                "quality": "poor" if comp<35 else ("fair" if comp<55 else "good")}
+    except Exception as e:
+        logger.error("Blur detection: %s", e)
+        return {"blur_score": 999, "is_blurry": False, "blur_severity": "unknown", "quality": "unknown"}
+
+def deblur_and_enhance(content, severity="moderate"):
+    img_np = np.array(Image.open(BytesIO(content)).convert("RGB"))
+    log    = []
+    h, w   = img_np.shape[:2]
+    if min(h, w) < 1200:
+        s = 1200/min(h,w)
+        img_np = cv2.resize(img_np, (int(w*s), int(h*s)), interpolation=cv2.INTER_LANCZOS4)
+        log.append("upscale")
+    if severity in ("severe","moderate"):
+        bgr    = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        img_np = cv2.cvtColor(cv2.fastNlMeansDenoisingColored(bgr, None, 8 if severity=="severe" else 5, 8 if severity=="severe" else 5, 7, 21), cv2.COLOR_BGR2RGB)
+        log.append("NLM")
+    if severity != "mild":
+        gray   = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+        psf_s  = 9 if severity=="severe" else 5
+        kr     = 0.01 if severity=="severe" else 0.025
+        psf    = cv2.getGaussianKernel(psf_s, psf_s/3.0); psf = psf@psf.T; psf/=psf.sum()
+        pad    = np.zeros_like(gray, dtype=np.float64)
+        pad[:psf.shape[0],:psf.shape[1]] = psf
+        pad    = np.roll(np.roll(pad, -psf.shape[0]//2, 0), -psf.shape[1]//2, 1)
+        Y = np.fft.fft2(gray.astype(np.float64)/255.0); H = np.fft.fft2(pad)
+        W = np.conj(H)/(np.abs(H)**2+kr)
+        rest = np.clip(np.real(np.fft.ifft2(W*Y))*255.0, 0, 255).astype(np.uint8)
+        lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB); lab[:,:,0]=rest
+        img_np = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB); log.append(f"Wiener(psf={psf_s})")
+    sm = {"severe":2.2,"moderate":1.8,"mild":1.2}; rm = {"severe":4,"moderate":3,"mild":2}
+    s  = sm.get(severity,1.8); r = rm.get(severity,3)
+    blurred = cv2.GaussianBlur(img_np,(r*2+1,r*2+1),0)
+    mask    = cv2.subtract(img_np.astype(np.int16), blurred.astype(np.int16))
+    img_np  = np.clip(img_np.astype(np.float32)+s*mask,0,255).astype(np.uint8); log.append("unsharp")
+    lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB)
+    cl  = cv2.createCLAHE(clipLimit={"severe":3.0,"moderate":2.5,"mild":1.8}.get(severity,2.5), tileGridSize=(8,8))
+    lab[:,:,0]=cl.apply(lab[:,:,0]); img_np=cv2.cvtColor(lab,cv2.COLOR_LAB2RGB); log.append("CLAHE")
+    buf = BytesIO(); Image.fromarray(img_np).save(buf, format="JPEG", quality=92)
+    return buf.getvalue(), " → ".join(log)
+
+def image_to_b64(content):
+    return "data:image/jpeg;base64," + base64.b64encode(content).decode()
+
+def ocr_quality_score(r):
+    return r.get("word_count",0)*0.6 + r.get("avg_confidence",0)*100*0.4
+
+# ══════════════════════════════════════════════════════════════════════
+#  OCR
+# ══════════════════════════════════════════════════════════════════════
+_LANG_READERS = {}; _READERS_LOCK = threading.Lock()
+_EASYOCR_LANG_MAP = {
+    "en":["en"],"hi":["en","hi"],"zh":["en","ch_sim"],
+    "ta":["en","ta"],"te":["en","te"],"bn":["en","bn"],
+}
+
+def _get_reader(lang_hint):
+    langs = _EASYOCR_LANG_MAP.get(lang_hint, ["en"])
+    key   = "_".join(sorted(langs))
+    if key not in _LANG_READERS:
+        with _READERS_LOCK:
+            if key not in _LANG_READERS:
+                import easyocr as _easyocr
+                logger.info("Loading EasyOCR for %s", langs)
+                _LANG_READERS[key] = _easyocr.Reader(langs, gpu=False, model_storage_directory=MODEL_DIR)
+    return _LANG_READERS[key]
+
+def run_ocr(content, lang_hint="en"):
+    cache_key = f"{hashlib.md5(content).hexdigest()}_{lang_hint}"
+    cached    = _get_ocr_cache(cache_key)
+    if cached: return cached
+    img = Image.open(BytesIO(content)).convert("RGB"); img.thumbnail((1200,1200))
+    results     = _get_reader(lang_hint).readtext(np.array(img), detail=1)
+    words       = [r[1] for r in results]
+    confidences = [r[2] for r in results]
+    avg_conf    = sum(confidences)/len(confidences) if confidences else 0.0
+    result      = {"text": " ".join(words), "word_count": len(words),
+                   "avg_confidence": round(avg_conf,3),
+                   "is_readable": len(words)>=3 and avg_conf>0.15}
+    _set_ocr_cache(cache_key, result)
+    return result
+
+LABEL_KEYWORDS = [
+    'ingredients','nutrition','nutritional','calories','calorie','protein','fat',
+    'carbohydrate','carbs','sodium','sugar','sugars','fiber','fibre','serving',
+    'cholesterol','saturated','trans','vitamin','calcium','iron','per 100g',
+    'per 100 g','daily value','daily values','amount per','total fat','contains',
+    'may contain','preservative','flavour','flavor','emulsifier','mg','mcg','kcal',
+    'kj','% dv','%dv','g per','per serving','fssai','best before','mfg','mrp',
+    'net wt','manufactured','packed','allergen','gluten','lactose','nuts',
+    'energy','carbohydrates','dietary','mineral','zinc','phosphorus',
+    # Indian label specific
+    'veg','non-veg','vegetarian','lic no','batch no','shelf life',
+    'use before','consume before','store in','keep dry',
+]
+
+# ONLY strong marketing-only phrases that NEVER appear on back labels
+# Removed: natural, organic, light, baked, roasted, flavoured — all appear in ingredient lists
+FRONT_PACK_SIGNALS = [
+    'new improved','now better','great taste','loved by','award winning',
+    'no.1 brand','number 1','trusted brand',
+]
+
+NUTRITION_TABLE_ANCHORS = [
+    'per 100g','per 100 g','per serving','serving size','amount per','daily value',
+    'daily values','% dv','%dv','calories','calorie','kcal','kj','energy',
+    'nutrition facts','nutritional information','nutritional value','total fat',
+    'saturated fat','trans fat','total carbohydrate','dietary fiber','ingredients:',
+    'ingredients list','fssai','best before','mfg','mrp','net wt','net weight',
+    # Indian label specific anchors
+    'veg ','non-veg','licence no','lic. no','batch no','mfg date',
+]
+
+
+def detect_label_presence(ocr_text):
+    """
+    Detect whether OCR text is from a nutrition/ingredients label (back of pack)
+    vs front-of-pack marketing content.
+
+    Fixed false-positive rate for Indian food labels:
+    - Removed common ingredient words (natural, organic, baked) from FRONT_PACK_SIGNALS
+    - Lowered anchor threshold: only 1 anchor needed if label keywords are strong
+    - Front-of-pack rejection only when there are ZERO nutrition keywords AND
+      the text is dominated by marketing language
+    - Added India-specific anchors (FSSAI, MFG, batch no, veg/non-veg)
+    """
+    if not ocr_text:
+        return {'has_label': False, 'confidence': 'high',
+                'label_hits': [], 'front_hits': [], 'suggestion': 'no_text'}
+
+    tl          = ocr_text.lower()
+    label_hits  = [kw for kw in LABEL_KEYWORDS          if kw in tl]
+    front_hits  = [kw for kw in FRONT_PACK_SIGNALS      if kw in tl]
+    anchor_hits = [kw for kw in NUTRITION_TABLE_ANCHORS if kw in tl]
+    ls           = len(label_hits)
+    fs           = len(front_hits)
+    num_anchors  = len(anchor_hits)
+
+    # ── PASS: strong nutrition evidence regardless of front signals ──────
+    # If we have multiple nutrition anchors + multiple label keywords → definite label
+    if num_anchors >= 2 and ls >= 3:
+        return {'has_label': True,
+                'confidence': 'high' if ls >= 6 else 'medium',
+                'label_hits': label_hits[:5], 'front_hits': front_hits[:3],
+                'suggestion': None}
+
+    # ── PASS: moderate evidence — 1 anchor + any label keyword ──────────
+    # Covers Indian labels with non-standard formatting
+    if num_anchors >= 1 and ls >= 2:
+        return {'has_label': True, 'confidence': 'medium',
+                'label_hits': label_hits[:5], 'front_hits': front_hits[:3],
+                'suggestion': None}
+
+    # ── PASS: weak evidence but plausible — several label keywords ───────
+    # e.g. label says "protein 8g fat 5g sugar 3g" without explicit headers
+    if ls >= 4 and fs == 0:
+        return {'has_label': True, 'confidence': 'low',
+                'label_hits': label_hits, 'front_hits': [],
+                'suggestion': None}
+
+    # ── PASS: any single anchor (fssai, best before, mfg) ───────────────
+    # These never appear on front-of-pack — their presence confirms back label
+    strong_anchors = ['fssai', 'best before', 'mfg', 'mrp', 'net wt', 'net weight',
+                      'batch no', 'lic no', 'manufactured', 'packed by']
+    if any(sa in tl for sa in strong_anchors):
+        return {'has_label': True, 'confidence': 'medium',
+                'label_hits': label_hits, 'front_hits': front_hits,
+                'suggestion': None}
+
+    # ── FAIL: only reject if truly no nutrition evidence ────────────────
+    # Must have: zero anchors AND less than 2 label keywords AND
+    # either dominated by marketing OR truly empty
+    if ls >= 2:
+        # Still has some label words — give benefit of the doubt, try analysis
+        return {'has_label': True, 'confidence': 'low',
+                'label_hits': label_hits, 'front_hits': front_hits,
+                'suggestion': 'partial'}
+
+    # Genuine front-of-pack: marketing words but zero nutrition content
+    sug = 'wrong_side' if fs > 0 else 'no_label'
+    return {'has_label': False, 'confidence': 'high',
+            'label_hits': label_hits, 'front_hits': front_hits[:3],
+            'suggestion': sug}
+
+# ══════════════════════════════════════════════════════════════════════
+#  LLM
+# ══════════════════════════════════════════════════════════════════════
+_groq_client = None
+if GROQ_API_KEY:
+    from groq import Groq
+    _groq_client = Groq(api_key=GROQ_API_KEY)
+
+def call_llm(prompt, max_tokens=2500):
+    if not _groq_client: raise RuntimeError("GROQ_API_KEY not set")
+    for model in ["llama-3.3-70b-versatile","llama-3.1-8b-instant"]:
+        try:
+            comp = _groq_client.chat.completions.create(
+                model=model, messages=[{"role":"user","content":prompt}],
+                temperature=0.1, max_tokens=max_tokens,
+                response_format={"type":"json_object"})
+            return comp.choices[0].message.content
+        except Exception as exc:
+            logger.warning("LLM %s failed: %s", model, exc)
+    raise RuntimeError("All LLM models failed")
+
+def _sanitise_result(result):
+    cd = result.get("chart_data")
+    if isinstance(cd,list) and len(cd)==3 and all(isinstance(x,(int,float)) for x in cd):
+        total = sum(cd)
+        if total > 0 and total != 100:
+            scaled = [round(v*100/total) for v in cd]
+            scaled[scaled.index(max(scaled))] += 100 - sum(scaled)
+            result["chart_data"] = scaled
+    else:
+        result["chart_data"] = [70,20,10]
+    for n in result.get("nutrient_breakdown",[]):
+        m = re.search(r"[\d]+\.?[\d]*", str(n.get("value","")).replace(",","."))
+        if m: n["value"] = float(m.group())
+    result.setdefault("score",5); result.setdefault("verdict","Analyzed")
+    result.setdefault("product_name","Unknown Product")
+    result.setdefault("nutrient_breakdown",[]); result.setdefault("pros",[])
+    result.setdefault("cons",[]); result.setdefault("age_warnings",[])
+    result.setdefault("is_low_confidence",False)
+    return result
+
+async def analyse_label(extracted_text, persona, age_group, product_category,
+                        language, web_context, blur_info, label_confidence):
+    cache_key = f"v4:{language}:{persona}:{age_group}:{extracted_text[:80]}"
+    cached    = _get_ai_cache(cache_key)
+    if cached: return cached
+    lang_name  = LANGUAGE_MAP.get(language, "English")
+    conf_note  = ("⚠️ Label text may be partial — only list nutrients you can read confidently."
+                  if label_confidence == "low" else "")
+    blur_ctx   = ""
+    if blur_info.get("detected"):
+        verb     = "enhanced via Wiener deconvolution" if blur_info.get("deblurred") else "blurry, used original"
+        blur_ctx = f"IMAGE: {blur_info['severity']}ly blurry ({verb}). Only report confident values."
+    prompt = f"""[INST]
+You are an expert nutritional scientist and food safety auditor.
+CRITICAL: Respond ENTIRELY in {lang_name}. Every text field MUST be in {lang_name}.
+Persona: {persona} | Age: {age_group} | Category: {product_category}
+{conf_note}
+{blur_ctx}
+Label Text: "{extracted_text}"
+Web Context: "{web_context}"
+
+Return ONLY valid JSON — no markdown, no preamble:
+{{
+  "product_name"      : "Short name from label",
+  "product_category"  : "Snack|Dairy|Beverage|Cereal|Supplement|etc.",
+  "score"             : <INTEGER 1-10 per SCORING RUBRIC — never default to 6 or 7>,
+  "verdict"           : "Two-word verdict in {lang_name}",
+  "chart_data"        : [<Safe%>, <Moderate%>, <Risky%>],
+  "summary"           : "2-sentence professional summary in {lang_name}.",
+  "eli5_explanation"  : "Child-friendly explanation with emojis in {lang_name}.",
+  "molecular_insight" : "1-2 sentences on biochemical impact in {lang_name}.",
+  "paragraph_benefits": "Full paragraph on genuine benefits in {lang_name}.",
+  "paragraph_uniqueness": "Unique characteristics OR 2 better alternatives in {lang_name}.",
+  "is_unique"         : true,
+  "nutrient_breakdown": [
+    {{"name":"Protein","value":<ACTUAL g>,"unit":"g","rating":"good","impact":"brief note in {lang_name}"}},
+    {{"name":"Sugar","value":<ACTUAL g>,"unit":"g","rating":"moderate","impact":"brief note"}},
+    {{"name":"Fat","value":<ACTUAL g>,"unit":"g","rating":"good","impact":"brief note"}},
+    {{"name":"Sodium","value":<ACTUAL mg>,"unit":"mg","rating":"caution","impact":"brief note"}},
+    {{"name":"Fiber","value":<ACTUAL g>,"unit":"g","rating":"good","impact":"brief note"}}
+  ],
+  "pros"           : ["Benefit 1 in {lang_name}", "Benefit 2", "Benefit 3"],
+  "cons"           : ["Risk 1 in {lang_name}", "Risk 2"],
+  "age_warnings"   : [
+    {{"group":"Children","emoji":"👶","status":"warning","message":"in {lang_name}"}},
+    {{"group":"Adults","emoji":"🧑","status":"good","message":"in {lang_name}"}},
+    {{"group":"Seniors","emoji":"👴","status":"caution","message":"in {lang_name}"}},
+    {{"group":"Pregnant","emoji":"🤰","status":"caution","message":"in {lang_name}"}}
+  ],
+  "better_alternative": "A specific healthier alternative in {lang_name}.",
+  "is_low_confidence" : false
+}}
+SCORING RUBRIC — MANDATORY, never use 6 or 7 as defaults:
+  9-10: Whole food, no added sugar, low sodium, high fibre/protein
+  7-8 : Mildly processed, sugar <5g/100g, reasonable sodium
+  5-6 : Processed, sugar 5-15g/100g OR sodium 400-700mg/100g
+  3-4 : High sugar >15g/100g OR sodium >700mg/100g OR poor profile
+  1-2 : Ultra-processed, very high sugar/sodium/sat-fat
+RULES: chart_data sums to 100 | rating: good|moderate|caution|bad | status: good|caution|warning
+[/INST]"""
+    raw    = await asyncio.to_thread(call_llm, prompt, 2500)
+    result = _sanitise_result(json.loads(raw))
+    result["disclaimer"] = MEDICAL_DISCLAIMER
+    cacheable = {k:v for k,v in result.items() if k not in ("blur_info","scan_meta","allergen_warning")}
+    _set_ai_cache(cache_key, cacheable)
+    return result
+
+def upsert_food_product(name, nutrients, score, ingredients_raw="",
+                         barcode=None, brand="", category="", source="llm_scan"):
+    def _get(key):
+        for n in nutrients:
+            if key in n.get("name","").lower():
+                v = n.get("value",0)
+                return float(v) if isinstance(v,(int,float)) else 0
+        return 0
+    cal=_get("calorie") or _get("energy"); prot=_get("protein")
+    carb=_get("carb"); fat=_get("fat"); sod=_get("sodium")
+    fib=_get("fiber") or _get("fibre"); sug=_get("sugar"); sat=_get("saturated")
+    with db_conn() as conn:
+        existing = conn.execute(
+            "SELECT id FROM food_products WHERE barcode=?" if barcode else "SELECT id FROM food_products WHERE name=? AND brand=?",
+            (barcode,) if barcode else (name.strip(), brand.strip())
+        ).fetchone()
+        if existing:
+            conn.execute("UPDATE food_products SET scan_count=scan_count+1, updated_at=datetime('now') WHERE id=?",
+                         (existing["id"],)); return existing["id"]
+        cursor = conn.execute(
+            "INSERT INTO food_products(name,brand,category,barcode,calories_100g,protein_100g,carbs_100g,fat_100g,sodium_100g,fiber_100g,sugar_100g,sat_fat_100g,eatlytic_score,ingredients_raw,source,scan_count) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1)",
+            (name.strip(),brand,category,barcode,cal,prot,carb,fat,sod,fib,sug,sat,score,ingredients_raw,source))
+        return cursor.lastrowid
+
+# ══════════════════════════════════════════════════════════════════════
+#  PAYMENTS
+# ══════════════════════════════════════════════════════════════════════
+PRO_AMOUNT_PAISE = 19900
+
+def _create_razorpay_order(user_id, device_key=""):
+    if not RAZORPAY_KEY_ID or not RAZORPAY_KEY_SECRET:
+        raise RuntimeError("RAZORPAY_KEY_ID and RAZORPAY_KEY_SECRET env vars required")
+    try:
+        import razorpay
+        client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET))
+    except ImportError:
+        raise RuntimeError("razorpay package not installed")
+    order = client.order.create({
+        "amount": PRO_AMOUNT_PAISE, "currency": "INR",
+        "receipt": f"eat_{user_id[:8]}_{datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S')}",
+        "notes": {"user_id": user_id, "product": "eatlytic_pro"},
+    })
+    with db_conn() as conn:
+        conn.execute("INSERT INTO payments(user_id,device_key,razorpay_order_id,amount_paise,status) VALUES(?,?,?,?,?)",
+                     (user_id, device_key, order["id"], PRO_AMOUNT_PAISE, "created"))
+    return {"order_id": order["id"], "amount": PRO_AMOUNT_PAISE, "currency": "INR",
+            "key_id": RAZORPAY_KEY_ID}
+
+def _verify_razorpay_payment(order_id, payment_id, signature):
+    expected = hmac.new(RAZORPAY_KEY_SECRET.encode(),
+                        f"{order_id}|{payment_id}".encode(), hashlib.sha256).hexdigest()
+    return hmac.compare_digest(expected, signature)
+
+def _activate_pro_payment(order_id, payment_id, signature):
+    if not _verify_razorpay_payment(order_id, payment_id, signature):
+        raise ValueError("Invalid payment signature — possible tampering")
+    expires = (datetime.datetime.utcnow() + datetime.timedelta(days=31)).isoformat()
+    with db_conn() as conn:
+        row = conn.execute("SELECT user_id, device_key FROM payments WHERE razorpay_order_id=?", (order_id,)).fetchone()
+        if not row: raise ValueError(f"Order {order_id} not found")
+        user_id    = row["user_id"]
+        device_key = row["device_key"]
+        conn.execute("UPDATE payments SET razorpay_payment_id=?,razorpay_signature=?,status='paid',paid_at=datetime('now') WHERE razorpay_order_id=?",
+                     (payment_id, signature, order_id))
+        if user_id:
+            conn.execute("UPDATE users SET is_pro=1, pro_expires=? WHERE id=?", (expires, user_id))
+        if device_key:
+            conn.execute("UPDATE devices SET is_pro=1 WHERE device_key=?", (device_key,))
+    return {"success": True, "user_id": user_id, "expires": expires}
+
+# ══════════════════════════════════════════════════════════════════════
+#  FASTAPI APP
+# ══════════════════════════════════════════════════════════════════════
+limiter = Limiter(key_func=get_remote_address)
+app     = FastAPI(title="Eatlytic v4 — Food Intelligence", version="4.0")
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["GET","POST","DELETE","PATCH"], allow_headers=["*"])
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+def _get_request_user(request):
+    auth  = request.headers.get("Authorization","")
+    token = auth.removeprefix("Bearer ").strip() if auth.startswith("Bearer ") else None
+    return _get_user_from_token(token) if token else None
+
+def _device_key(request):
+    ip = request.client.host if request.client else "unknown"
+    ua = request.headers.get("user-agent","")
+    return hashlib.md5(f"{ip}:{ua}".encode()).hexdigest()[:16]
+
+def _ensure_device(dk):
+    try:
+        with db_conn() as conn:
+            conn.execute("INSERT OR IGNORE INTO devices(device_key) VALUES(?)", (dk,))
+    except Exception: pass
+
+def _check_scan_quota(user, device_key):
+    if user: return _check_scan_quota_user(user["id"])
+    month_key = datetime.date.today().isoformat()[:7]
+    _ensure_device(device_key)
+    with db_conn() as conn:
+        row = conn.execute("SELECT is_pro, month, scan_count FROM devices WHERE device_key=?", (device_key,)).fetchone()
+        if not row: return {"allowed":False,"scans_used":0,"scans_remaining":0,"is_pro":False}
+        if row["month"] != month_key:
+            conn.execute("UPDATE devices SET month=?, scan_count=0 WHERE device_key=?", (month_key, device_key))
+            count = 0
+        else: count = row["scan_count"]
+        if row["is_pro"]:
+            conn.execute("UPDATE devices SET scan_count=scan_count+1 WHERE device_key=?", (device_key,))
+            return {"allowed":True,"scans_used":count+1,"scans_remaining":9999,"is_pro":True}
+        if count >= FREE_SCAN_LIMIT:
+            return {"allowed":False,"scans_used":count,"scans_remaining":0,"is_pro":False}
+        conn.execute("UPDATE devices SET scan_count=scan_count+1 WHERE device_key=?", (device_key,))
+        new = count + 1
+        return {"allowed":True,"scans_used":new,"scans_remaining":FREE_SCAN_LIMIT-new,"is_pro":False}
+
+def _get_live_search(query):
+    if not _DDGS_OK: return "Web search unavailable."
+    try:
+        with _DDGS() as ddgs:
+            results = [f"{r['title']}: {r['body']}" for r in ddgs.text(query, max_results=3)]
+        return "\n".join(results) if results else "No web data."
+    except Exception as exc:
+        logger.warning("Web search: %s", exc); return "No web data."
+
+# ── Core routes ────────────────────────────────────────────────────────
+@app.get("/")
+async def home(): return FileResponse("index.html")
+
+@app.get("/health")
+async def health(): return {"status":"ok","version":"4.0","db":"sqlite-wal"}
+
+@app.post("/check-image")
+@limiter.limit("30/minute")
+async def check_image(request: Request, image: UploadFile = File(...)):
+    content = validate_image(await image.read())
+    return assess_image_quality(content)
+
+@app.post("/enhance-preview")
+@limiter.limit("20/minute")
+async def enhance_preview(request: Request, image: UploadFile = File(...)):
+    content = validate_image(await image.read())
+    quality = assess_image_quality(content)
+    if not quality["is_blurry"]:
+        return JSONResponse({"deblurred":False,"message":"Image already clear.","quality":quality})
+    enhanced, method_log = deblur_and_enhance(content, quality["blur_severity"])
+    return JSONResponse({"deblurred":True,"image_b64":image_to_b64(enhanced),
+                         "method_log":method_log,"quality_before":quality})
+
+@app.post("/ocr")
+@limiter.limit("20/minute")
+async def perform_ocr(request: Request, image: UploadFile = File(...), language: str = Form("en")):
+    content = validate_image(await image.read())
+    return run_ocr(content, language)
+
+@app.post("/analyze")
+@limiter.limit("15/minute")
+async def analyze_product(
+    request: Request, persona: str = Form(...),
+    age_group: str = Form("adult"), product_category: str = Form("general"),
+    language: str = Form("en"), extracted_text: str = Form(None),
+    image: UploadFile = File(...),
+):
+    if not GROQ_API_KEY:
+        return JSONResponse({"error":"Server error: GROQ_API_KEY not set in Secrets"})
+    user       = _get_request_user(request)
+    device_key = _device_key(request)
+    scan_check = _check_scan_quota(user, device_key)
+    if not scan_check["allowed"]:
+        return JSONResponse(status_code=402, content={
+            "error":"scan_limit_reached",
+            "message":f"You've used all {FREE_SCAN_LIMIT} free scans this month.",
+            "upgrade_url":"/payments/create-order"})
+    try:
+        content   = validate_image(await image.read())
+        quality   = assess_image_quality(content)
+        blur_info = {"detected":quality["is_blurry"],"severity":quality["blur_severity"],
+                     "score":quality["blur_score"],"deblurred":False,
+                     "method_log":None,"image_b64":None,"ocr_source":"original"}
+        working   = content
+        if quality["is_blurry"]:
+            try:
+                enhanced, method_log = deblur_and_enhance(content, quality["blur_severity"])
+                if ocr_quality_score(run_ocr(enhanced,language)) >= ocr_quality_score(run_ocr(content,language))*0.85:
+                    working=enhanced; blur_info["deblurred"]=True
+                    blur_info["method_log"]=method_log; blur_info["image_b64"]=image_to_b64(enhanced)
+                    blur_info["ocr_source"]="deblurred"; extracted_text=None
+            except Exception as exc: logger.warning("Deblur: %s", exc)
+        if not extracted_text:
+            ocr_result=run_ocr(working,language); extracted_text=ocr_result["text"]; ocr_wc=ocr_result["word_count"]
+        else: ocr_wc=len(extracted_text.split())
+        if not extracted_text or ocr_wc==0:
+            return JSONResponse({"error":"no_text","message":"No text found. Make sure the label is facing the camera.","tip":"flip_product"})
+        label_check = detect_label_presence(extracted_text)
+        # Only block if truly no text at all — let LLM handle ambiguous cases
+        # The LLM is smarter than keyword matching for real product labels
+        if not label_check["has_label"] and label_check.get("suggestion") == "no_text":
+            return JSONResponse({"error":"no_text",
+                "message":"No text found in image. Make sure the label is facing the camera.",
+                "tip":"flip_product"})
+        # For everything else — even uncertain detections — proceed to LLM analysis
+        allergen_warning=""
+        try:
+            with db_conn() as conn:
+                row=conn.execute("SELECT allergens,conditions FROM allergen_profiles WHERE device_key=?",(device_key,)).fetchone()
+            if row:
+                tl=extracted_text.lower()
+                triggered=[a for a in json.loads(row["allergens"] or "[]") if a.lower() in tl]+\
+                           [c for c in json.loads(row["conditions"] or "[]") if c.lower() in tl]
+                if triggered: allergen_warning=f"⚠️ ALLERGEN ALERT — may contain: {', '.join(triggered)}"
+        except Exception: pass
+        web_context = await asyncio.to_thread(_get_live_search, f"health analysis ingredients {extracted_text[:120]}")
+        result = await analyse_label(extracted_text, persona, age_group, product_category,
+                                     language, web_context, blur_info, label_check.get("confidence","medium"))
+        result["allergen_warning"]=allergen_warning; result["blur_info"]=blur_info; result["scan_meta"]=scan_check
+        today=datetime.date.today().isoformat()
+        nutr={n["name"].lower():float(n.get("value",0)) for n in result.get("nutrient_breakdown",[]) if isinstance(n.get("value"),(int,float))}
+        cal=nutr.get("energy",nutr.get("calories",nutr.get("calorie",0))); prot=nutr.get("protein",0)
+        carb=nutr.get("carbohydrate",nutr.get("carbs",0)); fat=nutr.get("fat",0)
+        sod=nutr.get("sodium",0); fib=nutr.get("fiber",nutr.get("fibre",0)); sug=nutr.get("sugar",nutr.get("sugars",0))
+        owner_id=user["id"] if user else None
+        with db_conn() as conn:
+            conn.execute("INSERT INTO daily_logs(user_id,device_key,log_date,meal_name,calories,protein,carbs,fat,sodium,fiber,sugar,source) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (owner_id,device_key,today,result.get("product_name","Scanned item"),cal,prot,carb,fat,sod,fib,sug,"scan"))
+            conn.execute("INSERT INTO scans(user_id,device_key,product_name,score,verdict,calories,protein,carbs,fat,sodium,fiber,sugar,persona,language,analysis_json) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (owner_id,device_key,result.get("product_name","Unknown"),result.get("score",0),result.get("verdict",""),
+                          cal,prot,carb,fat,sod,fib,sug,persona,language,
+                          json.dumps({k:v for k,v in result.items() if k not in ("blur_info","scan_meta","allergen_warning")})))
+        try: upsert_food_product(name=result.get("product_name",""), nutrients=result.get("nutrient_breakdown",[]), score=result.get("score",0), ingredients_raw=extracted_text, category=result.get("product_category",""), source="llm_scan")
+        except Exception: pass
+        if user: _update_streak_user(user["id"])
+        else:
+            try:
+                _ensure_device(device_key); td=datetime.date.today().isoformat()
+                yd=(datetime.date.today()-datetime.timedelta(days=1)).isoformat()
+                with db_conn() as conn:
+                    row=conn.execute("SELECT streak_days,last_scan_date FROM devices WHERE device_key=?",(device_key,)).fetchone()
+                    if row and row["last_scan_date"]!=td:
+                        st=(row["streak_days"]+1) if row["last_scan_date"]==yd else 1
+                        conn.execute("UPDATE devices SET streak_days=?,last_scan_date=? WHERE device_key=?",(st,td,device_key))
+            except Exception: pass
+        return JSONResponse(result)
+    except ValueError as exc: return JSONResponse({"error":str(exc)}, status_code=400)
+    except Exception as exc:
+        logger.error("Analysis error: %s", exc, exc_info=True)
+        return JSONResponse({"error":f"Scan failed: {str(exc)[:140]}. Please try again."})
+
+@app.get("/scan-status")
+async def scan_status(request: Request):
+    user=_get_request_user(request); device_key=_device_key(request)
+    _ensure_device(device_key); month_key=datetime.date.today().isoformat()[:7]
+    if user:
+        with db_conn() as conn:
+            row=conn.execute("SELECT is_pro,scan_month,scan_count_month,streak_days FROM users WHERE id=?",(user["id"],)).fetchone()
+        if not row or row["scan_month"]!=month_key:
+            return {"scans_used":0,"scans_remaining":FREE_SCAN_LIMIT,"is_pro":False,"limit":FREE_SCAN_LIMIT,"streak":0,"authenticated":True}
+        used=row["scan_count_month"]
+        return {"scans_used":used,"scans_remaining":9999 if row["is_pro"] else max(0,FREE_SCAN_LIMIT-used),
+                "is_pro":bool(row["is_pro"]),"limit":FREE_SCAN_LIMIT,"streak":row["streak_days"],"authenticated":True}
+    with db_conn() as conn:
+        row=conn.execute("SELECT is_pro,month,scan_count,streak_days FROM devices WHERE device_key=?",(device_key,)).fetchone()
+    if not row or row["month"]!=month_key:
+        return {"scans_used":0,"scans_remaining":FREE_SCAN_LIMIT,"is_pro":False,"limit":FREE_SCAN_LIMIT,"streak":0,"authenticated":False}
+    used=row["scan_count"]
+    return {"scans_used":used,"scans_remaining":9999 if row["is_pro"] else max(0,FREE_SCAN_LIMIT-used),
+            "is_pro":bool(row["is_pro"]),"limit":FREE_SCAN_LIMIT,"streak":row["streak_days"],"authenticated":False}
+
+# ── Auth routes ────────────────────────────────────────────────────────
+@app.post("/auth/request-otp")
+async def request_otp(email: str = Form(...)):
+    otp = _send_otp(email)
+    return JSONResponse({"sent":True,"message":"OTP sent.","_dev_otp":otp})
+
+@app.post("/auth/verify-otp")
+async def verify_otp(request: Request, email: str = Form(...), otp: str = Form(...)):
+    user = _verify_otp(email, otp)
+    if not user: raise HTTPException(status_code=401, detail="Invalid or expired OTP")
+    token = _create_session(user["id"], request.headers.get("user-agent","")[:100])
+    return JSONResponse({"token":token,"user_id":user["id"],"email":user.get("email",""),"is_pro":bool(user.get("is_pro",0))})
+
+@app.post("/auth/logout")
+async def logout(request: Request):
+    auth=request.headers.get("Authorization","")
+    token=auth.removeprefix("Bearer ").strip() if auth.startswith("Bearer ") else None
+    if token:
+        with db_conn() as conn: conn.execute("DELETE FROM sessions WHERE token=?",(token,))
+    return JSONResponse({"logged_out":True})
+
+@app.get("/auth/me")
+async def get_me(request: Request):
+    user=_get_request_user(request)
+    if not user: raise HTTPException(status_code=401, detail="Not authenticated")
+    return JSONResponse({"user_id":user["id"],"email":user.get("email",""),"name":user.get("name",""),
+                         "is_pro":bool(user.get("is_pro",0)),"streak_days":user.get("streak_days",0),
+                         "persona":user.get("persona","General Adult"),"language":user.get("language","en")})
+
+# ── Payment routes ─────────────────────────────────────────────────────
+@app.post("/payments/create-order")
+async def create_order(request: Request):
+    user=_get_request_user(request)
+    if not user: raise HTTPException(status_code=401, detail="Login required. POST /auth/request-otp first.")
+    device_key=_device_key(request)
+    try:
+        return JSONResponse(_create_razorpay_order(user["id"], device_key))
+    except RuntimeError as exc: raise HTTPException(status_code=503, detail=str(exc))
+
+@app.post("/payments/verify")
+async def verify_payment(request: Request, razorpay_order_id: str = Form(...),
+                          razorpay_payment_id: str = Form(...), razorpay_signature: str = Form(...)):
+    try:
+        return JSONResponse(_activate_pro_payment(razorpay_order_id, razorpay_payment_id, razorpay_signature))
+    except ValueError as exc: raise HTTPException(status_code=400, detail=str(exc))
+
+@app.post("/activate-pro")
+async def activate_pro_legacy(request: Request, payment_id: str = Form(...)):
+    """Legacy endpoint — kept for backward compatibility."""
+    device_key=_device_key(request); _ensure_device(device_key)
+    with db_conn() as conn: conn.execute("UPDATE devices SET is_pro=1 WHERE device_key=?",(device_key,))
+    return {"status":"activated","message":"Pro activated. Use /payments/create-order for real billing."}
+
+# ── Food DB routes ─────────────────────────────────────────────────────
+@app.get("/food-search")
+@limiter.limit("30/minute")
+async def food_search(request: Request, q: str = ""):
+    if not q or len(q.strip())<2: return {"products":[],"source":"none"}
+    with db_conn() as conn:
+        rows=conn.execute("SELECT name,brand,category,calories_100g,protein_100g,carbs_100g,fat_100g,sodium_100g,fiber_100g,sugar_100g,eatlytic_score,verified FROM food_products WHERE (name LIKE ? OR brand LIKE ?) AND verified=1 ORDER BY scan_count DESC LIMIT 10",(f"%{q}%",f"%{q}%")).fetchall()
+    if rows: return {"products":[dict(r) for r in rows],"source":"eatlytic_db"}
+    try:
+        import httpx
+        async with httpx.AsyncClient(timeout=8) as hc:
+            resp=await hc.get("https://world.openfoodfacts.org/cgi/search.pl",
+                              params={"search_terms":q,"action":"process","json":1,"page_size":10,
+                                      "fields":"product_name,brands,nutriments"})
+        products=[]
+        for p in resp.json().get("products",[]):
+            n=p.get("nutriments",{})
+            products.append({"name":p.get("product_name",""),"brand":p.get("brands",""),
+                             "calories_100g":round(n.get("energy-kcal_100g",0),1),
+                             "protein_100g":round(n.get("proteins_100g",0),1),
+                             "carbs_100g":round(n.get("carbohydrates_100g",0),1),
+                             "fat_100g":round(n.get("fat_100g",0),1),
+                             "sodium_100g":round(n.get("sodium_100g",0)*1000,1),
+                             "fiber_100g":round(n.get("fiber_100g",0),1),
+                             "sugar_100g":round(n.get("sugars_100g",0),1),
+                             "eatlytic_score":0,"verified":0,"source":"openfoodfacts"})
+        return {"products":products,"source":"openfoodfacts"}
+    except Exception as exc:
+        logger.warning("Food search: %s", exc); return {"products":[],"source":"unavailable"}
+
+@app.get("/food-db/stats")
+async def food_db_stats():
+    with db_conn() as conn:
+        total   =conn.execute("SELECT COUNT(*) FROM food_products").fetchone()[0]
+        verified=conn.execute("SELECT COUNT(*) FROM food_products WHERE verified=1").fetchone()[0]
+    return {"total_products":total,"verified_products":verified,
+            "moat_status": "🔴 Early (<1K)" if total<1000 else "🟡 Growing (1K-10K)" if total<10000 else "🟢 Defensible (10K+)"}
+
+# ── Daily tracker routes ───────────────────────────────────────────────
+@app.get("/daily-summary")
+async def daily_summary(request: Request, date: str = None):
+    user=_get_request_user(request); device_key=_device_key(request)
+    target_date=date or datetime.date.today().isoformat(); user_id=user["id"] if user else None
+    with db_conn() as conn:
+        dev=conn.execute("SELECT tdee FROM users WHERE id=?" if user_id else "SELECT tdee FROM devices WHERE device_key=?",(user_id or device_key,)).fetchone()
+        clause="user_id=?" if user_id else "device_key=?"; param=user_id or device_key
+        row=conn.execute(f"SELECT SUM(calories) cal, SUM(protein) prot, SUM(carbs) carb, SUM(fat) fat, SUM(sodium) sod, SUM(fiber) fib, SUM(sugar) sug, COUNT(*) items FROM daily_logs WHERE {clause} AND log_date=?",(param,target_date)).fetchone()
+        log_items=conn.execute(f"SELECT id,meal_name,calories,protein,carbs,fat,sodium,source,logged_at FROM daily_logs WHERE {clause} AND log_date=? ORDER BY logged_at DESC",(param,target_date)).fetchall()
+    tdee=float((dev and dev["tdee"]) or 2000) or 2000
+    totals={k:round(row[k] or 0,1) for k in ("cal","prot","carb","fat","sod","fib","sug")}
+    t={"calories":round(tdee),"protein":56,"carbs":round(tdee*.5/4),"fat":round(tdee*.3/9),"sodium":2300,"fiber":28,"sugar":50}
+    cal_left=max(0,t["calories"]-totals["cal"]); prot_left=max(0,t["protein"]-totals["prot"])
+    suggestion=""
+    if cal_left<200: suggestion="🎯 Almost at your calorie target!"
+    elif prot_left>20: suggestion=f"💪 {round(prot_left)}g protein left. Try: eggs, dal, paneer."
+    elif cal_left>600: suggestion=f"🍽 {round(cal_left)} kcal remaining."
+    return {"date":target_date,"totals":totals,"targets":t,"suggestion":suggestion,
+            "items":row["items"] or 0,"log":[dict(r) for r in log_items]}
+
+@app.post("/daily-log")
+@limiter.limit("30/minute")
+async def daily_log(request: Request, meal_name: str=Form(...), calories: float=Form(0),
+                     protein: float=Form(0), carbs: float=Form(0), fat: float=Form(0),
+                     sodium: float=Form(0), fiber: float=Form(0), sugar: float=Form(0),
+                     source: str=Form("manual"), log_date: str=Form(None)):
+    user=_get_request_user(request); device_key=_device_key(request)
+    target_date=log_date or datetime.date.today().isoformat(); user_id=user["id"] if user else None
+    _ensure_device(device_key)
+    with db_conn() as conn:
+        conn.execute("INSERT INTO daily_logs(user_id,device_key,log_date,meal_name,calories,protein,carbs,fat,sodium,fiber,sugar,source) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)",
+                     (user_id,device_key,target_date,meal_name,calories,protein,carbs,fat,sodium,fiber,sugar,source))
+    return {"status":"logged","date":target_date,"meal":meal_name}
+
+@app.delete("/daily-log/{log_id}")
+async def delete_log(request: Request, log_id: int):
+    device_key=_device_key(request)
+    with db_conn() as conn: conn.execute("DELETE FROM daily_logs WHERE id=? AND device_key=?",(log_id,device_key))
+    return {"status":"deleted","id":log_id}
+
+# ── Profile routes ─────────────────────────────────────────────────────
+@app.post("/onboarding-complete")
+async def onboarding_complete(request: Request, persona: str=Form("General Adult"),
+                               language: str=Form("en"), tdee: float=Form(0), allergens: str=Form("[]")):
+    user=_get_request_user(request); device_key=_device_key(request)
+    _ensure_device(device_key); user_id=user["id"] if user else None
+    with db_conn() as conn:
+        conn.execute("UPDATE devices SET onboarding_done=1,persona=?,language=?,tdee=? WHERE device_key=?",(persona,language,tdee,device_key))
+        if user_id: conn.execute("UPDATE users SET onboarding_done=1,persona=?,language=?,tdee=? WHERE id=?",(persona,language,tdee,user_id))
+        conn.execute("INSERT OR REPLACE INTO allergen_profiles(device_key,user_id,allergens) VALUES(?,?,?)",(device_key,user_id,allergens))
+    return {"status":"ok"}
+
+@app.get("/allergen-profile")
+async def get_allergen_profile(request: Request):
+    device_key=_device_key(request)
+    with db_conn() as conn:
+        row=conn.execute("SELECT allergens,conditions FROM allergen_profiles WHERE device_key=?",(device_key,)).fetchone()
+    if not row: return {"allergens":[],"conditions":[]}
+    return {"allergens":json.loads(row["allergens"] or "[]"),"conditions":json.loads(row["conditions"] or "[]")}
+
+@app.post("/allergen-profile")
+async def set_allergen_profile(request: Request, allergens: str=Form("[]"), conditions: str=Form("[]")):
+    device_key=_device_key(request); _ensure_device(device_key)
+    with db_conn() as conn:
+        conn.execute("INSERT OR REPLACE INTO allergen_profiles(device_key,allergens,conditions,updated_at) VALUES(?,?,?,datetime('now'))",(device_key,allergens,conditions))
+    return {"status":"saved"}
+
+# ── Admin routes ───────────────────────────────────────────────────────
+@app.get("/admin/analytics")
+async def admin_analytics(request: Request):
+    token=request.headers.get("X-Admin-Token","")
+    if token != ADMIN_TOKEN: raise HTTPException(status_code=403, detail="Invalid token")
+    today=datetime.date.today().isoformat(); mkey=today[:7]
+    with db_conn() as conn:
+        dau =conn.execute("SELECT COUNT(DISTINCT COALESCE(user_id,device_key)) FROM scans WHERE DATE(scanned_at)=?",(today,)).fetchone()[0]
+        mau =conn.execute("SELECT COUNT(DISTINCT COALESCE(user_id,device_key)) FROM scans WHERE strftime('%Y-%m',scanned_at)=?",(mkey,)).fetchone()[0]
+        tot =conn.execute("SELECT COUNT(*) FROM scans").fetchone()[0]
+        avgs=conn.execute("SELECT AVG(score) FROM scans").fetchone()[0]
+        users=conn.execute("SELECT COUNT(*) FROM users").fetchone()[0]
+        food_ct=conn.execute("SELECT COUNT(*) FROM food_products").fetchone()[0]
+        verified=conn.execute("SELECT COUNT(*) FROM food_products WHERE verified=1").fetchone()[0]
+        top=conn.execute("SELECT product_name,COUNT(*) c FROM scans GROUP BY product_name ORDER BY c DESC LIMIT 10").fetchall()
+    return {"dau":dau,"mau":mau,"total_scans":tot,"total_users":users,
+            "avg_score":round(avgs or 0,2),"dau_mau":round(dau/mau*100,1) if mau else 0,
+            "food_db":{"total":food_ct,"verified":verified},
+            "top_products":[{"name":r[0],"scans":r[1]} for r in top]}
+
+@app.post("/admin/create-api-key")
+async def create_api_key_endpoint(request: Request, client_name: str=Form(...), plan: str=Form("business")):
+    token=request.headers.get("X-Admin-Token","")
+    if token != ADMIN_TOKEN: raise HTTPException(status_code=403, detail="Invalid admin token")
+    key="eak_"+secrets.token_urlsafe(32)
+    with db_conn() as conn: conn.execute("INSERT INTO api_keys(api_key,client_name,plan) VALUES(?,?,?)",(key,client_name,plan))
+    return {"api_key":key,"client":client_name,"plan":plan}
+
+# ── Misc routes ────────────────────────────────────────────────────────
+@app.post("/nps")
+async def submit_nps(request: Request, score: int=Form(...), comment: str=Form("")):
+    if not 0<=score<=10: return JSONResponse({"error":"Score must be 0-10"},status_code=400)
+    user=_get_request_user(request); device_key=_device_key(request)
+    with db_conn() as conn:
+        conn.execute("INSERT INTO nps_responses(device_key,user_id,score,comment) VALUES(?,?,?,?)",
+                     (device_key,user["id"] if user else None,score,comment[:500]))
+    return {"status":"thank_you"}
+
+@app.post("/generate-share-card")
+@limiter.limit("20/minute")
+async def generate_share_card(request: Request, product_name: str=Form(...), score: int=Form(...),
+                               verdict: str=Form(...), top_warning: str=Form(""), top_pro: str=Form("")):
+    W,H=1080,1080; img=Image.new("RGB",(W,H),(15,17,23)); draw=ImageDraw.Draw(img)
+    font=ImageFont.load_default()
+    s_rgb=(34,197,94) if score>=7 else (245,158,11) if score>=4 else (239,68,68)
+    def centered(text,y,fill):
+        try: tw=font.getbbox(text)[2]-font.getbbox(text)[0]
+        except: tw=len(text)*6
+        draw.text(((W-tw)//2,y),text,fill=fill,font=font)
+    draw.ellipse([340,160,740,560],outline=s_rgb,width=18)
+    centered(str(score),340,s_rgb); centered("/10",430,(100,116,139))
+    centered(product_name[:38]+("…" if len(product_name)>38 else ""),600,(255,255,255))
+    centered(verdict[:50],650,(148,163,184))
+    if top_pro: draw.rectangle([60,700,1020,760],fill=(15,60,40)); centered(f"✓ {top_pro[:65]}",718,(74,222,128))
+    if top_warning: draw.rectangle([60,775,1020,840],fill=(124,29,29)); centered(f"⚠ {top_warning[:65]}",795,(252,165,165))
+    centered("eatlytic.com  •  scan any food label, no barcode needed",1000,(71,85,105))
+    buf=BytesIO(); img.save(buf,format="PNG",optimize=True); buf.seek(0)
+    return Response(content=buf.getvalue(),media_type="image/png",
+                    headers={"Content-Disposition":"attachment; filename=eatlytic-scan.png"})
+
+@app.post("/export-pdf")
+@limiter.limit("10/minute")
+async def export_pdf(request: Request, analysis_json: str=Form(...)):
+    try: data=json.loads(analysis_json)
+    except Exception: return JSONResponse({"error":"Invalid JSON"},status_code=400)
+    try:
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+        from reportlab.lib import colors as rl; from reportlab.lib.units import cm
+    except ImportError: return JSONResponse({"error":"reportlab not installed"},status_code=501)
+    buf=BytesIO(); doc=SimpleDocTemplate(buf,pagesize=A4,rightMargin=2*cm,leftMargin=2*cm,topMargin=2*cm,bottomMargin=2*cm)
+    stys=getSampleStyleSheet(); story=[]
+    story.append(Paragraph("Eatlytic Food Label Analysis",stys["Title"]))
+    story.append(Paragraph(f"Product: {data.get('product_name','Unknown')}",stys["Heading2"]))
+    story.append(Paragraph(MEDICAL_DISCLAIMER,ParagraphStyle("d",parent=stys["Normal"],fontSize=8,textColor=rl.grey)))
+    story.append(Spacer(1,.4*cm))
+    score=data.get("score",0); sc="22c55e" if score>=7 else "f59e0b" if score>=4 else "ef4444"
+    story.append(Paragraph(f"<font color='#{sc}'>Health Score: {score}/10 — {data.get('verdict','')}</font>",stys["Heading1"]))
+    if data.get("summary"): story.append(Paragraph("Summary",stys["Heading2"])); story.append(Paragraph(data["summary"],stys["Normal"]))
+    nutrients=data.get("nutrient_breakdown",[])
+    if nutrients:
+        story.append(Paragraph("Nutrient Breakdown",stys["Heading2"]))
+        td=[["Nutrient","Amount","Rating"]]+[[str(n.get("name","")),f"{n.get('value','')} {n.get('unit','')}".strip(),str(n.get("rating","")).upper()] for n in nutrients]
+        tbl=Table(td,colWidths=[6*cm,4*cm,4*cm])
+        tbl.setStyle(TableStyle([("BACKGROUND",(0,0),(-1,0),rl.HexColor("1D9E75")),("TEXTCOLOR",(0,0),(-1,0),rl.white),("FONTSIZE",(0,0),(-1,-1),10),("BACKGROUND",(0,1),(-1,-1),rl.HexColor("f8faf8")),("GRID",(0,0),(-1,-1),.4,rl.HexColor("d0d8d4")),("TOPPADDING",(0,0),(-1,-1),6),("BOTTOMPADDING",(0,0),(-1,-1),6),("LEFTPADDING",(0,0),(-1,-1),8),("RIGHTPADDING",(0,0),(-1,-1),8)]))
+        story.append(tbl)
+    if data.get("pros"): story.append(Paragraph("Benefits",stys["Heading2"])); [story.append(Paragraph(f"✓ {p}",stys["Normal"])) for p in data["pros"]]
+    if data.get("cons"): story.append(Paragraph("Concerns",stys["Heading2"])); [story.append(Paragraph(f"✗ {c}",stys["Normal"])) for c in data["cons"]]
+    try: doc.build(story)
+    except Exception as exc: return JSONResponse({"error":f"PDF failed: {exc}"},status_code=500)
+    buf.seek(0); safe=data.get("product_name","scan").replace(" ","-")[:40]
+    return Response(content=buf.getvalue(),media_type="application/pdf",
+                    headers={"Content-Disposition":f"attachment; filename=eatlytic-{safe}.pdf"})