pasted_content.txt

"""
OmniParse AI — kompletní B2B SaaS pro zpracování faktur.
Architektura: CORE LOGIC (framework-agnostic, dá se volat i z FastAPI/HTML frontendu)
             + GRADIO UI LAYER (jen volá CORE funkce, žádná business logika v UI kódu).
Když budeš chtít přejít na vlastní HTML/JS frontend, stačí obalit CORE funkce
do FastAPI endpointů (viz sekce "CORE LOGIC" níže) — nic se v nich měnit nemusí.
"""

import os
import re
import io
import json
import time
import base64
import sqlite3
import secrets
import hashlib
import traceback
from datetime import datetime, timedelta, timezone

import gradio as gr
import requests
from PIL import Image

# ---------------------------------------------------------------------------
# VOLITELNÉ KNIHOVNY — nikdy nesmí spadnout celá appka, když chybí balíček
# ---------------------------------------------------------------------------
try:
    import bcrypt
    BCRYPT_OK = True
except Exception:
    BCRYPT_OK = False

try:
    import pytesseract
    TESSERACT_OK = True
except Exception:
    TESSERACT_OK = False

try:
    from pdf2image import convert_from_bytes
    PDF2IMAGE_OK = True
except Exception:
    PDF2IMAGE_OK = False

try:
    from groq import Groq
    GROQ_SDK_OK = True
except Exception:
    GROQ_SDK_OK = False

try:
    import stripe
    STRIPE_SDK_OK = True
except Exception:
    STRIPE_SDK_OK = False

try:
    from supabase import create_client
    SUPABASE_SDK_OK = True
except Exception:
    SUPABASE_SDK_OK = False


# ===========================================================================
# KONFIGURACE
# ===========================================================================
HF_TOKEN = os.environ.get("HF_TOKEN", "")
GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
SUPABASE_KEY = os.environ.get("SUPABASE_KEY", "")
GOOGLE_VISION_KEY = os.environ.get("GOOGLE_VISION_KEY", "")
STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY", "")
STRIPE_PRICE_BASIC = os.environ.get("STRIPE_PRICE_BASIC", "")
STRIPE_PRICE_PRO = os.environ.get("STRIPE_PRICE_PRO", "")
STRIPE_PRICE_ENTERPRISE = os.environ.get("STRIPE_PRICE_ENTERPRISE", "")
APP_URL = os.environ.get("APP_URL", "http://localhost:7860")

MAX_FILE_SIZE_MB = 20
MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024

PLAN_LIMITS = {
    "free": 20,
    "basic": 200,
    "pro": 2000,
    "enterprise": float("inf"),
}

PLAN_PRICE_IDS = {
    "basic": STRIPE_PRICE_BASIC,
    "pro": STRIPE_PRICE_PRO,
    "enterprise": STRIPE_PRICE_ENTERPRISE,
}

if STRIPE_SDK_OK and STRIPE_SECRET_KEY:
    try:
        stripe.api_key = STRIPE_SECRET_KEY
    except Exception:
        pass

# jednoduchý in-memory rate limiter: {key: [timestamps]}
_RATE_LIMIT_STORE = {}


def rate_limited(key: str, max_attempts: int = 5, window_seconds: int = 60) -> bool:
    """Vrátí True pokud je klíč (email/IP) aktuálně rate-limitovaný.
    Ochrana proti brute-force na login/signup/API endpointy."""
    try:
        now = time.time()
        attempts = _RATE_LIMIT_STORE.get(key, [])
        attempts = [t for t in attempts if now - t < window_seconds]
        if len(attempts) >= max_attempts:
            _RATE_LIMIT_STORE[key] = attempts
            return True
        attempts.append(now)
        _RATE_LIMIT_STORE[key] = attempts
        return False
    except Exception:
        return False  # radši nechat projít než appku spadnout


# ===========================================================================
# CORE LOGIC — DATABÁZOVÁ VRSTVA (Supabase primárně, SQLite fallback)
# ===========================================================================
class SQLiteDB:
    """Fallback databáze, pokud chybí Supabase secrets. Data jsou ephemeral
    (zmizí při restartu HF Space), ale appka díky tomu nikdy nespadne."""

    def __init__(self, path="omniparse.db"):
        self.path = path
        self.conn = sqlite3.connect(self.path, check_same_thread=False)
        self._init_schema()

    def _init_schema(self):
        c = self.conn.cursor()
        c.execute("""CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            email TEXT UNIQUE NOT NULL,
            name TEXT NOT NULL,
            password TEXT NOT NULL,
            plan TEXT NOT NULL DEFAULT 'free',
            stripe_cid TEXT,
            api_key TEXT,
            created_at TEXT
        )""")
        c.execute("""CREATE TABLE IF NOT EXISTS sessions (
            token TEXT PRIMARY KEY,
            user_id INTEGER NOT NULL,
            expires_at TEXT NOT NULL
        )""")
        c.execute("""CREATE TABLE IF NOT EXISTS invoices (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER NOT NULL,
            filename TEXT,
            vendor TEXT,
            inv_number TEXT,
            inv_date TEXT,
            due_date TEXT,
            amount REAL,
            vat_amount REAL,
            total REAL,
            currency TEXT DEFAULT 'USD',
            status TEXT DEFAULT 'done',
            is_duplicate INTEGER DEFAULT 0,
            confidence REAL,
            raw_json TEXT,
            created_at TEXT
        )""")
        self.conn.commit()

    def create_user(self, email, name, password_hash, plan="free", api_key=None):
        c = self.conn.cursor()
        c.execute(
            "INSERT INTO users (email, name, password, plan, api_key, created_at) VALUES (?,?,?,?,?,?)",
            (email, name, password_hash, plan, api_key, datetime.now(timezone.utc).isoformat()),
        )
        self.conn.commit()
        return c.lastrowid

    def get_user_by_email(self, email):
        c = self.conn.cursor()
        c.execute("SELECT id,email,name,password,plan,stripe_cid,api_key FROM users WHERE email=?", (email,))
        row = c.fetchone()
        if not row:
            return None
        keys = ["id", "email", "name", "password", "plan", "stripe_cid", "api_key"]
        return dict(zip(keys, row))

    def get_user_by_id(self, user_id):
        c = self.conn.cursor()
        c.execute("SELECT id,email,name,password,plan,stripe_cid,api_key FROM users WHERE id=?", (user_id,))
        row = c.fetchone()
        if not row:
            return None
        keys = ["id", "email", "name", "password", "plan", "stripe_cid", "api_key"]
        return dict(zip(keys, row))

    def update_user_plan(self, user_id, plan, stripe_cid=None):
        c = self.conn.cursor()
        if stripe_cid:
            c.execute("UPDATE users SET plan=?, stripe_cid=? WHERE id=?", (plan, stripe_cid, user_id))
        else:
            c.execute("UPDATE users SET plan=? WHERE id=?", (plan, user_id))
        self.conn.commit()

    def update_password(self, user_id, password_hash):
        c = self.conn.cursor()
        c.execute("UPDATE users SET password=? WHERE id=?", (password_hash, user_id))
        self.conn.commit()

    def delete_user(self, user_id):
        c = self.conn.cursor()
        c.execute("DELETE FROM users WHERE id=?", (user_id,))
        c.execute("DELETE FROM sessions WHERE user_id=?", (user_id,))
        c.execute("DELETE FROM invoices WHERE user_id=?", (user_id,))
        self.conn.commit()

    def create_session(self, token, user_id, expires_at):
        c = self.conn.cursor()
        c.execute("INSERT INTO sessions (token,user_id,expires_at) VALUES (?,?,?)", (token, user_id, expires_at))
        self.conn.commit()

    def get_session(self, token):
        c = self.conn.cursor()
        c.execute("SELECT token,user_id,expires_at FROM sessions WHERE token=?", (token,))
        row = c.fetchone()
        if not row:
            return None
        return {"token": row[0], "user_id": row[1], "expires_at": row[2]}

    def delete_session(self, token):
        c = self.conn.cursor()
        c.execute("DELETE FROM sessions WHERE token=?", (token,))
        self.conn.commit()

    def save_invoice(self, user_id, data):
        c = self.conn.cursor()
        c.execute("""INSERT INTO invoices
            (user_id,filename,vendor,inv_number,inv_date,due_date,amount,vat_amount,total,currency,status,is_duplicate,confidence,raw_json,created_at)
            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
            (user_id, data.get("filename"), data.get("vendor"), data.get("inv_number"),
             data.get("inv_date"), data.get("due_date"), data.get("amount"), data.get("vat_amount"),
             data.get("total"), data.get("currency", "USD"), data.get("status", "done"),
             int(data.get("is_duplicate", False)), data.get("confidence"),
             json.dumps(data.get("raw_json", {})), datetime.now(timezone.utc).isoformat()))
        self.conn.commit()
        return c.lastrowid

    def get_invoices(self, user_id):
        c = self.conn.cursor()
        c.execute("""SELECT id,filename,vendor,inv_number,inv_date,due_date,amount,vat_amount,total,
            currency,status,is_duplicate,confidence,raw_json,created_at FROM invoices
            WHERE user_id=? ORDER BY created_at DESC""", (user_id,))
        rows = c.fetchall()
        keys = ["id", "filename", "vendor", "inv_number", "inv_date", "due_date", "amount", "vat_amount",
                "total", "currency", "status", "is_duplicate", "confidence", "raw_json", "created_at"]
        return [dict(zip(keys, r)) for r in rows]

    def delete_invoice(self, invoice_id, user_id):
        c = self.conn.cursor()
        c.execute("DELETE FROM invoices WHERE id=? AND user_id=?", (invoice_id, user_id))
        self.conn.commit()

    def count_invoices_this_month(self, user_id):
        c = self.conn.cursor()
        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
        c.execute("SELECT COUNT(*) FROM invoices WHERE user_id=? AND created_at>=?", (user_id, start))
        return c.fetchone()[0]

    def count_duplicate(self, user_id, vendor, total):
        c = self.conn.cursor()
        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
        c.execute("""SELECT COUNT(*) FROM invoices WHERE user_id=? AND vendor=? AND ABS(total-?)<0.01
            AND created_at>=?""", (user_id, vendor, total, start))
        return c.fetchone()[0]


class SupabaseDB:
    """Wrapper nad Supabase se stejným rozhraním jako SQLiteDB, aby zbytek
    kódu vůbec nevěděl, která databáze běží pod kapotou."""

    def __init__(self, url, key):
        self.client = create_client(url, key)

    def create_user(self, email, name, password_hash, plan="free", api_key=None):
        res = self.client.table("users").insert({
            "email": email, "name": name, "password": password_hash,
            "plan": plan, "api_key": api_key,
        }).execute()
        return res.data[0]["id"]

    def get_user_by_email(self, email):
        res = self.client.table("users").select("*").eq("email", email).execute()
        return res.data[0] if res.data else None

    def get_user_by_id(self, user_id):
        res = self.client.table("users").select("*").eq("id", user_id).execute()
        return res.data[0] if res.data else None

    def update_user_plan(self, user_id, plan, stripe_cid=None):
        payload = {"plan": plan}
        if stripe_cid:
            payload["stripe_cid"] = stripe_cid
        self.client.table("users").update(payload).eq("id", user_id).execute()

    def update_password(self, user_id, password_hash):
        self.client.table("users").update({"password": password_hash}).eq("id", user_id).execute()

    def delete_user(self, user_id):
        self.client.table("invoices").delete().eq("user_id", user_id).execute()
        self.client.table("sessions").delete().eq("user_id", user_id).execute()
        self.client.table("users").delete().eq("id", user_id).execute()

    def create_session(self, token, user_id, expires_at):
        self.client.table("sessions").insert({
            "token": token, "user_id": user_id, "expires_at": expires_at
        }).execute()

    def get_session(self, token):
        res = self.client.table("sessions").select("*").eq("token", token).execute()
        return res.data[0] if res.data else None

    def delete_session(self, token):
        self.client.table("sessions").delete().eq("token", token).execute()

    def save_invoice(self, user_id, data):
        payload = dict(data)
        payload["user_id"] = user_id
        payload["raw_json"] = json.dumps(payload.get("raw_json", {}))
        res = self.client.table("invoices").insert(payload).execute()
        return res.data[0]["id"]

    def get_invoices(self, user_id):
        res = self.client.table("invoices").select("*").eq("user_id", user_id).order("created_at", desc=True).execute()
        return res.data

    def delete_invoice(self, invoice_id, user_id):
        self.client.table("invoices").delete().eq("id", invoice_id).eq("user_id", user_id).execute()

    def count_invoices_this_month(self, user_id):
        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
        res = self.client.table("invoices").select("id", count="exact").eq("user_id", user_id).gte("created_at", start).execute()
        return res.count or 0

    def count_duplicate(self, user_id, vendor, total):
        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
        res = self.client.table("invoices").select("id", count="exact").eq("user_id", user_id).eq("vendor", vendor).gte("created_at", start).execute()
        # Supabase nepodporuje ABS() přes REST snadno -> filtrujeme total v Pythonu
        rows = self.client.table("invoices").select("total").eq("user_id", user_id).eq("vendor", vendor).gte("created_at", start).execute()
        return sum(1 for r in rows.data if abs((r.get("total") or 0) - total) < 0.01)


def init_db():
    """Vybere Supabase pokud jsou secrets nastavené a SDK je dostupné,
    jinak spadne zpátky na SQLite. Appka nikdy nespadne na chybějícím secretu."""
    if SUPABASE_URL and SUPABASE_KEY and SUPABASE_SDK_OK:
        try:
            db = SupabaseDB(SUPABASE_URL, SUPABASE_KEY)
            db.client.table("users").select("id").limit(1).execute()
            print("[DB] Připojeno k Supabase.")
            return db
        except Exception as e:
            print(f"[DB] Supabase selhalo ({e}), padám na SQLite fallback.")
            return SQLiteDB()
    print("[DB] Supabase secrets nenalezeny, používám SQLite fallback (data jsou dočasná).")
    return SQLiteDB()


DB = init_db()


# ===========================================================================
# CORE LOGIC — HESLA, AUTH, VALIDACE (server-side, nikdy jen client-side)
# ===========================================================================
def hash_password(password: str) -> str:
    """Bcrypt pokud je dostupný (moderní, doporučený), jinak PBKDF2-SHA256
    se solí jako bezpečný fallback (rozhodně ne MD5/SHA1)."""
    try:
        if BCRYPT_OK:
            return "bcrypt$" + bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
        salt = secrets.token_hex(16)
        digest = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
        return f"pbkdf2${salt}${digest}"
    except Exception:
        salt = secrets.token_hex(16)
        digest = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
        return f"pbkdf2${salt}${digest}"


def verify_password(password: str, stored_hash: str) -> bool:
    try:
        if stored_hash.startswith("bcrypt$") and BCRYPT_OK:
            return bcrypt.checkpw(password.encode(), stored_hash[len("bcrypt$"):].encode())
        if stored_hash.startswith("pbkdf2$"):
            _, salt, digest = stored_hash.split("$")
            check = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
            return secrets.compare_digest(check, digest)
        return False
    except Exception:
        return False


def is_valid_email(email: str) -> bool:
    return bool(re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", email or ""))


def password_strength_ok(password: str) -> (bool, str):
    if not password or len(password) < 8:
        return False, "Heslo musí mít alespoň 8 znaků."
    if not re.search(r"[A-Za-z]", password) or not re.search(r"[0-9]", password):
        return False, "Heslo musí obsahovat písmena i čísla."
    return True, ""


def is_password_leaked(password: str) -> bool:
    """HaveIBeenPwned Pwned Passwords API — k-anonymity model, zdarma bez klíče.
    Když je síť nedostupná, prostě kontrolu přeskočíme (fail-open, appka nespadne)."""
    try:
        sha1 = hashlib.sha1(password.encode()).hexdigest().upper()
        prefix, suffix = sha1[:5], sha1[5:]
        resp = requests.get(f"https://api.pwnedpasswords.com/range/{prefix}", timeout=4)
        if resp.status_code == 200:
            return any(line.split(":")[0] == suffix for line in resp.text.splitlines())
        return False
    except Exception:
        return False


def generate_api_key() -> str:
    return "op_live_" + secrets.token_urlsafe(24)


def create_session_token(user_id: int) -> str:
    token = secrets.token_urlsafe(32)
    expires = (datetime.now(timezone.utc) + timedelta(days=7)).isoformat()
    try:
        DB.create_session(token, user_id, expires)
    except Exception as e:
        print(f"[AUTH] Session se nepovedlo uložit: {e}")
    return token


def resolve_session(token: str):
    """Vrátí user dict pokud je token platný a nevypršel, jinak None.
    Token žije v gr.State (server-side per-browser-tab paměť), NE v localStorage,
    což řeší XSS riziko klasického 'token v localStorage' problému."""
    if not token:
        return None
    try:
        sess = DB.get_session(token)
        if not sess:
            return None
        expires = datetime.fromisoformat(sess["expires_at"])
        if expires.tzinfo is None:
            expires = expires.replace(tzinfo=timezone.utc)
        if expires < datetime.now(timezone.utc):
            DB.delete_session(token)
            return None
        return DB.get_user_by_id(sess["user_id"])
    except Exception as e:
        print(f"[AUTH] resolve_session chyba: {e}")
        return None


def signup(name, email, password, accepted_terms) -> (bool, str, str):
    """Vrací (success, message, session_token)."""
    try:
        email = (email or "").strip().lower()
        name = (name or "").strip()
        if rate_limited(f"signup:{email}", max_attempts=5, window_seconds=300):
            return False, "Příliš mnoho pokusů o registraci. Zkus to za pár minut.", ""
        if not name:
            return False, "Vyplň prosím jméno.", ""
        if not is_valid_email(email):
            return False, "Zadej platný pracovní e-mail.", ""
        if not accepted_terms:
            return False, "Musíš souhlasit s Terms of Use a Privacy Policy.", ""
        ok, msg = password_strength_ok(password)
        if not ok:
            return False, msg, ""
        if is_password_leaked(password):
            return False, "Toto heslo bylo nalezeno v uniklých databázích. Zvol jiné.", ""
        if DB.get_user_by_email(email):
            return False, "Účet s tímto e-mailem už existuje.", ""
        pw_hash = hash_password(password)
        api_key = generate_api_key()
        user_id = DB.create_user(email, name, pw_hash, plan="free", api_key=api_key)
        token = create_session_token(user_id)
        return True, "Účet vytvořen!", token
    except Exception as e:
        traceback.print_exc()
        return False, f"Chyba při registraci: {e}", ""


def login(email, password) -> (bool, str, str):
    try:
        email = (email or "").strip().lower()
        if rate_limited(f"login:{email}", max_attempts=8, window_seconds=300):
            return False, "Příliš mnoho pokusů o přihlášení. Zkus to za pár minut.", ""
        if not email or not password:
            return False, "Vyplň e-mail i heslo.", ""
        user = DB.get_user_by_email(email)
        if not user or not verify_password(password, user["password"]):
            return False, "Nesprávný e-mail nebo heslo.", ""
        token = create_session_token(user["id"])
        return True, "Přihlášení úspěšné!", token
    except Exception as e:
        traceback.print_exc()
        return False, f"Chyba při přihlašování: {e}", ""


def logout(token):
    try:
        if token:
            DB.delete_session(token)
    except Exception as e:
        print(f"[AUTH] logout chyba: {e}")


def bootstrap_demo_account():
    try:
        if not DB.get_user_by_email("demo@omniparse.ai"):
            pw_hash = hash_password("demo1234")
            api_key = generate_api_key()
            DB.create_user("demo@omniparse.ai", "Demo User", pw_hash, plan="pro", api_key=api_key)
            print("[DEMO] Demo účet vytvořen: demo@omniparse.ai / demo1234")
    except Exception as e:
        print(f"[DEMO] Nepovedlo se vytvořit demo účet: {e}")


bootstrap_demo_account()


# ===========================================================================
# CORE LOGIC — AI PIPELINE (OCR -> LLM -> regex fallback)
# ===========================================================================
def ocr_google_vision(image_bytes: bytes) -> str:
    if not GOOGLE_VISION_KEY:
        return ""
    try:
        b64 = base64.b64encode(image_bytes).decode()
        url = f"https://vision.googleapis.com/v1/images:annotate?key={GOOGLE_VISION_KEY}"
        payload = {"requests": [{"image": {"content": b64}, "features": [{"type": "TEXT_DETECTION"}]}]}
        resp = requests.post(url, json=payload, timeout=15)
        data = resp.json()
        return data["responses"][0].get("fullTextAnnotation", {}).get("text", "")
    except Exception as e:
        print(f"[OCR] Google Vision selhalo: {e}")
        return ""


def ocr_tesseract(image: Image.Image) -> str:
    if not TESSERACT_OK:
        return ""
    try:
        gray = image.convert("L")
        return pytesseract.image_to_string(gray, lang="eng+ces")
    except Exception:
        try:
            return pytesseract.image_to_string(image.convert("L"), lang="eng")
        except Exception as e:
            print(f"[OCR] Tesseract selhalo: {e}")
            return ""


def file_to_images(file_bytes: bytes, filename: str):
    """Vrátí list PIL Image objektů — z PDF všechny stránky, z obrázku jednu."""
    try:
        ext = filename.lower().rsplit(".", 1)[-1] if "." in filename else ""
        if ext == "pdf":
            if not PDF2IMAGE_OK:
                raise RuntimeError("pdf2image / poppler není dostupný na tomto Space.")
            return convert_from_bytes(file_bytes, dpi=200)
        img = Image.open(io.BytesIO(file_bytes))
        img.load()
        return [img]
    except Exception as e:
        print(f"[FILE] Nepodařilo se otevřít soubor {filename}: {e}")
        return []


def extract_text_from_images(images) -> str:
    full_text = ""
    for img in images[:5]:  # bezpečnostní limit — max 5 stránek na fakturu
        buf = io.BytesIO()
        img.convert("RGB").save(buf, format="JPEG", quality=85)
        img_bytes = buf.getvalue()
        text = ""
        if GOOGLE_VISION_KEY:
            text = ocr_google_vision(img_bytes)
        if len(text.strip()) < 30:
            text = ocr_tesseract(img)
        full_text += text + "\n"
    return full_text.strip()


AI_SYSTEM_PROMPT = (
    "You are an invoice data extraction engine. Extract structured data from the raw OCR text "
    "of an invoice. Return ONLY valid JSON, no markdown, no explanation, with exactly these keys: "
    'vendor (string), inv_number (string), inv_date (YYYY-MM-DD or empty string), '
    'due_date (YYYY-MM-DD or empty string), amount (number, subtotal before tax), '
    'vat_amount (number), total (number), currency (3-letter code like USD/EUR/CZK), '
    'line_items (array of {description, quantity, unit_price, total}). '
    "If a field cannot be found, use empty string or 0. Never invent data you cannot find."
)


def ai_extract_groq(ocr_text: str):
    if not (GROQ_API_KEY and GROQ_SDK_OK):
        return None
    try:
        client = Groq(api_key=GROQ_API_KEY)
        resp = client.chat.completions.create(
            model="llama-3.1-8b-instant",
            messages=[
                {"role": "system", "content": AI_SYSTEM_PROMPT},
                {"role": "user", "content": ocr_text[:3000]},
            ],
            max_tokens=512,
            temperature=0.05,
            timeout=10,
        )
        content = resp.choices[0].message.content
        content = re.sub(r"^```json|```$", "", content.strip(), flags=re.MULTILINE).strip()
        return json.loads(content)
    except Exception as e:
        print(f"[AI] Groq selhalo: {e}")
        return None


def ai_extract_hf(ocr_text: str):
    if not HF_TOKEN:
        return None
    try:
        url = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
        prompt = f"<s>[INST] {AI_SYSTEM_PROMPT}\n\n{ocr_text[:3000]} [/INST]"
        payload = {"inputs": prompt, "parameters": {"max_new_tokens": 512, "temperature": 0.05, "return_full_text": False}}
        resp = requests.post(url, headers=headers, json=payload, timeout=45)
        if resp.status_code == 503:
            time.sleep(25)
            resp = requests.post(url, headers=headers, json=payload, timeout=45)
        data = resp.json()
        text = data[0]["generated_text"] if isinstance(data, list) else data.get("generated_text", "")
        text = re.sub(r"^```json|```$", "", text.strip(), flags=re.MULTILINE).strip()
        match = re.search(r"\{.*\}", text, re.DOTALL)
        return json.loads(match.group(0)) if match else None
    except Exception as e:
        print(f"[AI] HF Inference selhalo: {e}")
        return None


def regex_extract(ocr_text: str):
    try:
        inv_number_m = re.search(r"(?:invoice|inv)[#:\s]+([A-Z0-9\-]{4,24})", ocr_text, re.I)
        dates = re.findall(r"\d{1,2}[\/.\-]\d{1,2}[\/.\-]\d{4}", ocr_text)
        total_m = re.search(r"(?:total|amount due)[\s:$]+([0-9,\.]+)", ocr_text, re.I)
        vendor = next((l.strip() for l in ocr_text.splitlines() if l.strip()), "Unknown vendor")
        total = 0.0
        if total_m:
            try:
                total = float(total_m.group(1).replace(",", ""))
            except Exception:
                total = 0.0
        return {
            "vendor": vendor[:120],
            "inv_number": inv_number_m.group(1) if inv_number_m else "",
            "inv_date": dates[0] if dates else "",
            "due_date": dates[1] if len(dates) > 1 else "",
            "amount": total,
            "vat_amount": 0.0,
            "total": total,
            "currency": "USD",
            "line_items": [],
        }
    except Exception as e:
        print(f"[AI] Regex fallback selhalo: {e}")
        return {"vendor": "Unknown", "inv_number": "", "inv_date": "", "due_date": "",
                "amount": 0, "vat_amount": 0, "total": 0, "currency": "USD", "line_items": []}


def run_ai_pipeline(ocr_text: str):
    if not ocr_text.strip():
        data = regex_extract("")
        data["_ai_source"] = "empty_ocr"
        return data
    data = ai_extract_groq(ocr_text)
    if data:
        data["_ai_source"] = "groq"
        return data
    data = ai_extract_hf(ocr_text)
    if data:
        data["_ai_source"] = "huggingface"
        return data
    data = regex_extract(ocr_text)
    data["_ai_source"] = "regex_fallback"
    return data


def validate_invoice(data: dict) -> list:
    """Cross-field validace — vrací list textových warningů."""
    warnings = []
    try:
        amount = float(data.get("amount") or 0)
        vat = float(data.get("vat_amount") or 0)
        total = float(data.get("total") or 0)
        if total > 0 and abs((amount + vat) - total) > 0.10:
            warnings.append(f"Subtotal + DPH ({amount + vat:.2f}) neodpovídá total ({total:.2f}).")
        if amount > 0 and vat / amount > 0.30:
            warnings.append("DPH sazba vyšší než 30 % — zkontroluj ručně.")
        inv_date, due_date = data.get("inv_date"), data.get("due_date")
        if inv_date and due_date:
            try:
                d1 = datetime.fromisoformat(inv_date)
                d2 = datetime.fromisoformat(due_date)
                if d2 < d1:
                    warnings.append("Splatnost je dřív než datum vystavení faktury.")
            except Exception:
                pass
        if not data.get("vendor"):
            warnings.append("Nepodařilo se rozpoznat dodavatele.")
    except Exception as e:
        warnings.append(f"Validace selhala: {e}")
    return warnings


def process_invoice_file(user, file_path, filename) -> dict:
    """Kompletní pipeline pro jeden soubor. Vrací dict se všemi daty + warnings."""
    try:
        with open(file_path, "rb") as f:
            file_bytes = f.read()
        if len(file_bytes) > MAX_FILE_SIZE_BYTES:
            return {"error": f"Soubor {filename} přesahuje limit {MAX_FILE_SIZE_MB}MB."}

        images = file_to_images(file_bytes, filename)
        if not images:
            return {"error": f"Nepodařilo se otevřít soubor {filename} (nepodporovaný formát nebo poškozený soubor)."}

        ocr_text = extract_text_from_images(images)
        extracted = run_ai_pipeline(ocr_text)

        warnings = validate_invoice(extracted)
        plan = user.get("plan", "free")

        is_dup = False
        if plan in ("pro", "enterprise") and extracted.get("vendor") and extracted.get("total"):
            try:
                dup_count = DB.count_duplicate(user["id"], extracted["vendor"], float(extracted["total"] or 0))
                is_dup = dup_count > 0
            except Exception as e:
                print(f"[DUP] kontrola duplicit selhala: {e}")

        status = "review" if warnings else "done"
        if is_dup:
            status = "duplicate"

        record = {
            "filename": filename,
            "vendor": extracted.get("vendor", ""),
            "inv_number": extracted.get("inv_number", ""),
            "inv_date": extracted.get("inv_date", ""),
            "due_date": extracted.get("due_date", ""),
            "amount": float(extracted.get("amount") or 0),
            "vat_amount": float(extracted.get("vat_amount") or 0),
            "total": float(extracted.get("total") or 0),
            "currency": extracted.get("currency", "USD"),
            "status": status,
            "is_duplicate": is_dup,
            "confidence": 0.95 if extracted.get("_ai_source") in ("groq", "huggingface") else 0.55,
            "raw_json": extracted,
        }
        DB.save_invoice(user["id"], record)
        record["warnings"] = warnings
        return record
    except Exception as e:
        traceback.print_exc()
        return {"error": f"Zpracování {filename} selhalo: {e}"}


# ===========================================================================
# CORE LOGIC — AI CHAT AGENT (Pro+)
# ===========================================================================
def ai_chat_answer(user, question: str, history: list) -> str:
    try:
        if not question or not question.strip():
            return "Napiš prosím otázku k tvým fakturám."
        if user.get("plan") not in ("pro", "enterprise"):
            return "AI Chat je dostupný od plánu Pro. Upgraduj v sekci ⚡ Upgrade."
        invoices = DB.get_invoices(user["id"])[:200]
        context_rows = [
            f"- {inv.get('vendor')} | č.{inv.get('inv_number')} | {inv.get('inv_date')} | "
            f"total {inv.get('total')} {inv.get('currency')} | status {inv.get('status')}"
            for inv in invoices
        ]
        context = "\n".join(context_rows) if context_rows else "Uživatel zatím nemá žádné faktury."
        if GROQ_API_KEY and GROQ_SDK_OK:
            client = Groq(api_key=GROQ_API_KEY)
            resp = client.chat.completions.create(
                model="llama-3.1-8b-instant",
                messages=[
                    {"role": "system", "content": "You are a helpful assistant answering questions about the user's invoices based ONLY on the data provided below. Be concise."},
                    {"role": "user", "content": f"Invoices:\n{context}\n\nQuestion: {question}"},
                ],
                max_tokens=400,
                temperature=0.2,
                timeout=15,
            )
            return resp.choices[0].message.content
        return "AI chat momentálně není dostupný (chybí GROQ_API_KEY). Zkus to prosím později."
    except Exception as e:
        traceback.print_exc()
        return f"Chyba AI chatu: {e}"


# ===========================================================================
# CORE LOGIC — STRIPE PLATBY (bez webhooků, polling)
# ===========================================================================
def create_checkout_url(user, plan: str) -> (bool, str):
    try:
        if not (STRIPE_SDK_OK and STRIPE_SECRET_KEY):
            return False, f"Platby momentálně nejsou nastavené. Napiš prosím na support a domluvíme upgrade na {plan} ručně."
        price_id = PLAN_PRICE_IDS.get(plan)
        if not price_id:
            return False, "Neplatný plán."
        session = stripe.checkout.Session.create(
            payment_method_types=["card"],
            line_items=[{"price": price_id, "quantity": 1}],
            mode="subscription",
            success_url=f"{APP_URL}?checkout=success&session_id={{CHECKOUT_SESSION_ID}}",
            cancel_url=f"{APP_URL}?checkout=cancel",
            customer_email=user["email"],
            metadata={"plan": plan, "user_id": str(user["id"])},
        )
        return True, session.url
    except Exception as e:
        traceback.print_exc()
        return False, f"Chyba Stripe checkoutu: {e}"


def poll_payment_status(session_id: str, user_id: int, max_attempts=12, delay=5) -> str:
    if not (STRIPE_SDK_OK and STRIPE_SECRET_KEY):
        return "Platby nejsou nakonfigurované."
    try:
        for _ in range(max_attempts):
            session = stripe.checkout.Session.retrieve(session_id)
            if session.payment_status == "paid":
                plan = session.metadata.get("plan", "basic")
                DB.update_user_plan(user_id, plan, stripe_cid=session.customer)
                return f"✅ Upgradnuto na {plan}!"
            time.sleep(delay)
        return "⏳ Platba zatím nebyla potvrzena. Pokud jsi zaplatil/a, obnov stránku za chvíli."
    except Exception as e:
        traceback.print_exc()
        return f"Chyba při ověřování platby: {e}"


# ===========================================================================
# CORE LOGIC — EXPORT
# ===========================================================================
def export_csv(user) -> str:
    try:
        invoices = DB.get_invoices(user["id"])
        path = f"/tmp/export_{user['id']}_{int(time.time())}.csv"
        import csv
        with open(path, "w", newline="", encoding="utf-8") as f:
            writer = csv.writer(f)
            writer.writerow(["Vendor", "Invoice#", "Invoice Date", "Due Date", "Amount", "VAT", "Total", "Currency", "Status"])
            for inv in invoices:
                writer.writerow([inv.get("vendor"), inv.get("inv_number"), inv.get("inv_date"),
                                  inv.get("due_date"), inv.get("amount"), inv.get("vat_amount"),
                                  inv.get("total"), inv.get("currency"), inv.get("status")])
        return path
    except Exception as e:
        traceback.print_exc()
        raise gr.Error(f"Export CSV selhal: {e}")


def export_json(user) -> str:
    try:
        invoices = DB.get_invoices(user["id"])
        path = f"/tmp/export_{user['id']}_{int(time.time())}.json"
        with open(path, "w", encoding="utf-8") as f:
            json.dump(invoices, f, ensure_ascii=False, indent=2, default=str)
        return path
    except Exception as e:
        traceback.print_exc()
        raise gr.Error(f"Export JSON selhal: {e}")


# ===========================================================================
# GRADIO UI LAYER — od tohoto místa dolů JEN volání CORE funkcí
# ===========================================================================
CUSTOM_CSS = """
.gradio-container {max-width: 1200px !important; margin: auto;}
.op-hero {text-align:center; padding: 40px 20px;}
.op-card {border:1px solid #e5e7eb; border-radius:12px; padding:20px; background:white;}
footer {visibility:hidden}
"""

LANDING_HTML = """
<div style="font-family:Inter,sans-serif;">
  <div style="display:flex;justify-content:space-between;align-items:center;padding:16px 24px;border-bottom:1px solid #eee;">
    <div style="font-size:22px;font-weight:800;">⚡ OmniParse AI</div>
    <div style="color:#666;font-size:14px;">How it works · Features · Pricing · Legal</div>
  </div>
  <div class="op-hero">
    <h1 style="font-size:42px;font-weight:800;margin-bottom:8px;">Invoice processing in seconds, not hours.</h1>
    <p style="font-size:18px;color:#555;max-width:640px;margin:0 auto 20px;">
      AI extracts vendor, dates, amounts and line items from any PDF or image.
      Export to CSV, JSON or Excel. Connect via API.
    </p>
    <p style="color:#888;">99.2% accuracy · &lt;4s per invoice · 40+ formats</p>
  </div>

  <div class="op-card" style="margin:20px 0;">
    <h2>How it works</h2>
    <ol>
      <li>Upload PDF or image invoice</li>
      <li>AI extracts all data</li>
      <li>Export wherever you need</li>
    </ol>
  </div>

  <div class="op-card" style="margin:20px 0;">
    <h2>Features</h2>
    <ul>
      <li>🔍 OCR + LLM — Tesseract + Groq Llama 3.1</li>
      <li>🚫 Duplicate Detection — Pro+, catches double payments</li>
      <li>🤖 AI Chat Agent — ask about your invoices in plain English</li>
      <li>✅ Cross-field Validation — checks totals, dates, tax rates</li>
      <li>👥 Human-in-the-loop — Enterprise, manual review of uncertain invoices</li>
      <li>🔌 REST API — connect to your own ERP</li>
    </ul>
  </div>

  <div class="op-card" style="margin:20px 0;">
    <h2>FAQ</h2>
    <p><b>Is my data safe?</b> Yes — stored in EU (Frankfurt), encrypted at rest, GDPR compliant.</p>
    <p><b>Does it work on Czech invoices?</b> Yes, OCR supports Czech + English.</p>
    <p><b>How do payments work?</b> Monthly subscription via Stripe, cancel anytime.</p>
    <p><b>Can I cancel anytime?</b> Yes, no lock-in contracts.</p>
    <p><b>Do I get a tax invoice?</b> Yes, automatically generated by Stripe after each payment.</p>
  </div>

  <div style="text-align:center;color:#999;padding:20px;border-top:1px solid #eee;">
    © 2026 OmniParse AI — Terms · Privacy · Disclaimer (viz Legal tab)
  </div>
</div>
"""

LEGAL_TERMS = """
### Terms of Use
OmniParse AI je nástroj pro automatickou extrakci dat z faktur pomocí AI. Používáním služby souhlasíš,
že ji nebudeš zneužívat k nahrávání nelegálního obsahu, pokusům o přetížení systému (DoS) ani reverznímu
inženýrství. Platby probíhají měsíčně přes Stripe, zrušení kdykoliv v sekci Profile. Neposkytujeme záruku
100% přesnosti extrakce — viz Disclaimer.
"""

LEGAL_PRIVACY = """
### Privacy Policy / GDPR
**Co sbíráme:** e-mail, jméno, nahrané faktury a z nich extrahovaná data.
**Kde je to uloženo:** Supabase, EU region (Frankfurt).
**Jak dlouho:** faktury 30 dní, účetní/fakturační záznamy 10 let (zákonná lhůta).
**Tvá práva:** přístup k datům, výmaz (Profile → Delete account), přenositelnost dat (Export).
**Cookies:** pouze technické (session), žádný marketingový tracking.
"""

LEGAL_DISCLAIMER = """
### Disclaimer
AI extrakce není 100% přesná — vždy ověř data před zaúčtováním do tvého účetního systému.
OmniParse nenese odpovědnost za chyby vzniklé nesprávnou AI extrakcí. Toto je nástroj usnadňující práci,
nikoliv náhrada za kvalifikovaného účetního.
"""


def status_badge(status):
    return {"done": "✅ Done", "review": "⚠️ Review", "duplicate": "🔴 Duplicate", "processing": "⟳ Processing"}.get(status, status)


def invoices_to_dataframe(invoices):
    rows = []
    for inv in invoices:
        rows.append([
            inv.get("id"), inv.get("vendor"), inv.get("inv_number"), inv.get("inv_date"),
            f"{inv.get('total', 0):.2f} {inv.get('currency', '')}", status_badge(inv.get("status")),
        ])
    return rows


with gr.Blocks(css=CUSTOM_CSS, title="OmniParse AI") as demo:
    session_token = gr.State("")  # server-side (NE localStorage) — viz resolve_session()
    current_view = gr.State("landing")

    # ---- VIEW CONTAINERS ----
    with gr.Column(visible=True) as view_landing:
        gr.HTML(LANDING_HTML)
        with gr.Row():
            btn_landing_start = gr.Button("Start Free — 20 invoices →", variant="primary")
            btn_landing_login = gr.Button("Log In")
            btn_landing_pricing = gr.Button("Pricing")
            btn_landing_legal = gr.Button("Legal")

    with gr.Column(visible=False) as view_pricing:
        gr.Markdown("## Pricing")
        with gr.Row():
            with gr.Column():
                gr.Markdown("### Free — $0/mo\n- 20 invoices/mo\n- CSV export\n- 1 user")
            with gr.Column():
                gr.Markdown("### Basic — $29/mo\n- 200 invoices/mo\n- JSON+CSV+Excel export\n- Multi-currency")
            with gr.Column():
                gr.Markdown("### Pro — $129/mo\n- 2,000 invoices/mo\n- REST API + AI Chat\n- Duplicate detection\n- 3 users")
            with gr.Column():
                gr.Markdown("### Enterprise — $499/mo\n- Unlimited invoices\n- Human-in-the-loop\n- SLA 99.5%\n- Unlimited users")
        gr.Markdown("_Přihlaš se a v Dashboardu → ⚡ Upgrade vyber plán a zaplať kartou přes Stripe._")
        btn_pricing_back = gr.Button("← Back")

    with gr.Column(visible=False) as view_legal:
        gr.Markdown("## Legal")
        with gr.Tab("Terms of Use"):
            gr.Markdown(LEGAL_TERMS)
        with gr.Tab("Privacy Policy"):
            gr.Markdown(LEGAL_PRIVACY)
        with gr.Tab("Disclaimer"):
            gr.Markdown(LEGAL_DISCLAIMER)
        btn_legal_back = gr.Button("← Back")

    with gr.Column(visible=False) as view_auth:
        gr.Markdown("## Welcome to OmniParse AI")
        with gr.Tab("Log In"):
            login_email = gr.Textbox(label="Email")
            login_password = gr.Textbox(label="Password", type="password")
            login_btn = gr.Button("Log In", variant="primary")
            login_msg = gr.Markdown()
            gr.Markdown("_Demo účet: `demo@omniparse.ai` / `demo1234` (plán Pro)_")
        with gr.Tab("Sign Up"):
            signup_name = gr.Textbox(label="Full Name")
            signup_email = gr.Textbox(label="Work Email")
            signup_password = gr.Textbox(label="Password (min. 8 znaků)", type="password")
            signup_terms = gr.Checkbox(label="Souhlasím s Terms of Use a Privacy Policy")
            signup_btn = gr.Button("Sign Up", variant="primary")
            signup_msg = gr.Markdown()
        btn_auth_back = gr.Button("← Back to landing")

    with gr.Column(visible=False) as view_dashboard:
        with gr.Row():
            gr.Markdown("## Dashboard")
            btn_logout = gr.Button("🚪 Log Out", size="sm")
        user_info_md = gr.Markdown()

        with gr.Tab("📤 Upload"):
            upload_files = gr.File(label="Nahraj faktury (PDF/JPG/PNG/TIFF, max 20MB/soubor)", file_count="multiple")
            upload_btn = gr.Button("Zpracovat faktury", variant="primary")
            upload_status = gr.Markdown()
            upload_results = gr.Dataframe(headers=["ID", "Vendor", "Invoice#", "Date", "Total", "Status"], label="Výsledky")
            upload_raw_json = gr.JSON(label="Raw AI output (poslední soubor)")

        with gr.Tab("📋 My Invoices"):
            refresh_invoices_btn = gr.Button("🔄 Obnovit")
            invoices_table = gr.Dataframe(headers=["ID", "Vendor", "Invoice#", "Date", "Total", "Status"], label="Faktury")

        with gr.Tab("🤖 AI Chat (Pro+)"):
            chat_history = gr.Chatbot(label="Zeptej se na své faktury", type="messages")
            chat_input = gr.Textbox(label="Otázka", placeholder="What's the total unpaid amount?")
            chat_send = gr.Button("Odeslat")

        with gr.Tab("📊 Export"):
            gr.Markdown("CSV export je zdarma pro všechny. JSON od plánu Basic+.")
            export_csv_btn = gr.Button("Export CSV")
            export_csv_file = gr.File(label="Stáhnout CSV")
            export_json_btn = gr.Button("Export JSON (Basic+)")
            export_json_file = gr.File(label="Stáhnout JSON")
            gr.Markdown("Excel export a Google Sheets sync: **Coming soon** 🚧")

        with gr.Tab("⚡ Upgrade"):
            plan_dropdown = gr.Dropdown(["basic", "pro", "enterprise"], label="Vyber plán", value="basic")
            upgrade_btn = gr.Button("Přejít na platbu (Stripe)", variant="primary")
            upgrade_link = gr.Markdown()
            gr.Markdown("Test karta ve Stripe test mode: `4242 4242 4242 4242`, libovolné datum/CVC.")
            checkout_session_input = gr.Textbox(label="Po zaplacení: vlož session_id z URL a klikni níže", visible=True)
            confirm_payment_btn = gr.Button("Ověřit platbu")
            payment_status_md = gr.Markdown()

        with gr.Tab("🔌 API (Pro+)"):
            api_key_display = gr.Markdown()
            gr.Markdown("""
```bash
curl -X POST https://tvuj-space.hf.space/api/extract \\
  -H "Authorization: Bearer TVUJ_API_KLIC" \\
  -F "file=@faktura.pdf"
```
_(REST endpoint pro přímé API volání se zapojí při přechodu na FastAPI backend — business logika je už připravená v `process_invoice_file()`.)_
""")

        with gr.Tab("👤 Profile"):
            profile_info = gr.Markdown()
            new_password = gr.Textbox(label="Nové heslo", type="password")
            change_pw_btn = gr.Button("Změnit heslo")
            change_pw_msg = gr.Markdown()
            gr.Markdown("### ⚠️ Danger zone")
            delete_confirm = gr.Checkbox(label="Ano, opravdu chci smazat účet a všechna data")
            delete_btn = gr.Button("Smazat účet natrvalo", variant="stop")
            delete_msg = gr.Markdown()

    ALL_VIEWS = [view_landing, view_pricing, view_legal, view_auth, view_dashboard]

    def switch_view(target):
        return [gr.update(visible=(v == target)) for v in ["landing", "pricing", "legal", "auth", "dashboard"]]

    # ---- NAVIGACE ----
    btn_landing_start.click(lambda: switch_view("auth"), outputs=ALL_VIEWS)
    btn_landing_login.click(lambda: switch_view("auth"), outputs=ALL_VIEWS)
    btn_landing_pricing.click(lambda: switch_view("pricing"), outputs=ALL_VIEWS)
    btn_landing_legal.click(lambda: switch_view("legal"), outputs=ALL_VIEWS)
    btn_pricing_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)
    btn_legal_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)
    btn_auth_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)

    # ---- AUTH HANDLERY ----
    def handle_signup(name, email, password, terms):
        ok, msg, token = signup(name, email, password, terms)
        if ok:
            user = resolve_session(token)
            info = f"✅ Přihlášen jako **{user['name']}** ({user['email']}) — plán **{user['plan']}**"
            views = switch_view("dashboard")
            return [msg, token, info] + views
        views = switch_view("auth")
        return [msg, "", ""] + views

    signup_btn.click(
        handle_signup,
        inputs=[signup_name, signup_email, signup_password, signup_terms],
        outputs=[signup_msg, session_token, user_info_md] + ALL_VIEWS,
    )

    def handle_login(email, password):
        ok, msg, token = login(email, password)
        if ok:
            user = resolve_session(token)
            info = f"✅ Přihlášen jako **{user['name']}** ({user['email']}) — plán **{user['plan']}**"
            views = switch_view("dashboard")
            return [msg, token, info] + views
        views = switch_view("auth")
        return [msg, "", ""] + views

    login_btn.click(
        handle_login,
        inputs=[login_email, login_password],
        outputs=[login_msg, session_token, user_info_md] + ALL_VIEWS,
    )

    def handle_logout(token):
        logout(token)
        views = switch_view("landing")
        return [""] + views

    btn_logout.click(handle_logout, inputs=[session_token], outputs=[session_token] + ALL_VIEWS)

    # ---- UPLOAD ----
    def handle_upload(token, files):
        user = resolve_session(token)
        if not user:
            return "❌ Nejsi přihlášen/a. Přihlas se prosím znovu.", [], {}
        if not files:
            return "⚠️ Nevybral/a jsi žádný soubor.", [], {}
        used = DB.count_invoices_this_month(user["id"])
        limit = PLAN_LIMITS.get(user["plan"], 20)
        if used >= limit:
            return f"🔴 Vyčerpal/a jsi měsíční limit ({int(limit) if limit != float('inf') else '∞'} faktur). Upgraduj v sekci ⚡ Upgrade.", [], {}

        results, last_json, errors = [], {}, []
        for f in files:
            if used >= limit:
                errors.append(f"Limit dosažen, {os.path.basename(f.name)} přeskočen.")
                break
            record = process_invoice_file(user, f.name, os.path.basename(f.name))
            if "error" in record:
                errors.append(record["error"])
                continue
            used += 1
            last_json = record.get("raw_json", {})
            results.append([None, record["vendor"], record["inv_number"], record["inv_date"],
                             f"{record['total']:.2f} {record['currency']}", status_badge(record["status"])])

        msg = f"✅ Zpracováno {len(results)} faktur. Použito {used}/{int(limit) if limit != float('inf') else '∞'} tento měsíc."
        if errors:
            msg += "\n\n⚠️ Chyby:\n" + "\n".join(f"- {e}" for e in errors)
        return msg, results, last_json

    upload_btn.click(handle_upload, inputs=[session_token, upload_files],
                      outputs=[upload_status, upload_results, upload_raw_json])

    # ---- MY INVOICES ----
    def handle_refresh_invoices(token):
        user = resolve_session(token)
        if not user:
            return []
        return invoices_to_dataframe(DB.get_invoices(user["id"]))

    refresh_invoices_btn.click(handle_refresh_invoices, inputs=[session_token], outputs=[invoices_table])

    # ---- AI CHAT ----
    def handle_chat(token, message, history):
        user = resolve_session(token)
        if not user:
            history = history or []
            history.append({"role": "assistant", "content": "Nejsi přihlášen/a."})
            return history, ""
        answer = ai_chat_answer(user, message, history)
        history = history or []
        history.append({"role": "user", "content": message})
        history.append({"role": "assistant", "content": answer})
        return history, ""

    chat_send.click(handle_chat, inputs=[session_token, chat_input, chat_history], outputs=[chat_history, chat_input])

    # ---- EXPORT ----
    def handle_export_csv(token):
        user = resolve_session(token)
        if not user:
            raise gr.Error("Nejsi přihlášen/a.")
        return export_csv(user)

    export_csv_btn.click(handle_export_csv, inputs=[session_token], outputs=[export_csv_file])

    def handle_export_json(token):
        user = resolve_session(token)
        if not user:
            raise gr.Error("Nejsi přihlášen/a.")
        if user["plan"] == "free":
            raise gr.Error("JSON export je dostupný od plánu Basic. Upgraduj v sekci ⚡ Upgrade.")
        return export_json(user)

    export_json_btn.click(handle_export_json, inputs=[session_token], outputs=[export_json_file])

    # ---- UPGRADE / STRIPE ----
    def handle_upgrade(token, plan):
        user = resolve_session(token)
        if not user:
            return "❌ Nejsi přihlášen/a."
        ok, result = create_checkout_url(user, plan)
        if ok:
            return f"[Klikni pro dokončení platby ve Stripe →]({result})"
        return f"⚠️ {result}"

    upgrade_btn.click(handle_upgrade, inputs=[session_token, plan_dropdown], outputs=[upgrade_link])

    def handle_confirm_payment(token, session_id):
        user = resolve_session(token)
        if not user:
            return "❌ Nejsi přihlášen/a."
        if not session_id:
            return "Vlož prosím session_id z URL po návratu ze Stripe."
        return poll_payment_status(session_id, user["id"])

    confirm_payment_btn.click(handle_confirm_payment, inputs=[session_token, checkout_session_input], outputs=[payment_status_md])

    # ---- API KEY DISPLAY ----
    def handle_show_api_key(token):
        user = resolve_session(token)
        if not user:
            return "Nejsi přihlášen/a."
        if user["plan"] not in ("pro", "enterprise"):
            return "🔒 API přístup je dostupný od plánu Pro. Upgraduj v sekci ⚡ Upgrade."
        return f"**Tvůj API klíč:** `{user.get('api_key', 'N/A')}`\n\n⚠️ Nikdy ho nesdílej veřejně."

    # ---- PROFILE ----
    def handle_change_password(token, new_pw):
        user = resolve_session(token)
        if not user:
            return "❌ Nejsi přihlášen/a."
        ok, msg = password_strength_ok(new_pw)
        if not ok:
            return f"⚠️ {msg}"
        if is_password_leaked(new_pw):
            return "⚠️ Toto heslo bylo nalezeno v uniklých databázích. Zvol jiné."
        try:
            DB.update_password(user["id"], hash_password(new_pw))
            return "✅ Heslo změněno."
        except Exception as e:
            return f"❌ Chyba: {e}"

    change_pw_btn.click(handle_change_password, inputs=[session_token, new_password], outputs=[change_pw_msg])

    def handle_delete_account(token, confirmed):
        user = resolve_session(token)
        if not user:
            return "❌ Nejsi přihlášen/a.", token
        if not confirmed:
            return "⚠️ Zaškrtni prosím potvrzení.", token
        try:
            DB.delete_user(user["id"])
            return "✅ Účet smazán. Sbohem!", ""
        except Exception as e:
            return f"❌ Chyba při mazání: {e}", token

    delete_btn.click(handle_delete_account, inputs=[session_token, delete_confirm], outputs=[delete_msg, session_token])

    # ---- Při vstupu do dashboardu doplníme profil / API klíč / faktury ----
    def on_dashboard_enter(token):
        user = resolve_session(token)
        if not user:
            return "", "", []
        profile = f"**Jméno:** {user['name']}\n\n**Email:** {user['email']}\n\n**Plán:** {user['plan']}"
        api_txt = handle_show_api_key(token)
        invoices = invoices_to_dataframe(DB.get_invoices(user["id"]))
        return profile, api_txt, invoices

    session_token.change(on_dashboard_enter, inputs=[session_token], outputs=[profile_info, api_key_display, invoices_table])


if __name__ == "__main__":
    try:
        demo.queue(max_size=20).launch(server_name="0.0.0.0", server_port=7860)
    except Exception as e:
        print(f"[FATAL] Aplikace se nepodařila spustit: {e}")
        traceback.print_exc()