# -*- coding: utf-8 -*-
"""
KI-Zusatzguthaben: Ledger, Stripe-Checkout (Phase 1), Auto-Aufladung (vorbereitet, nicht produktiv).

Keine Secrets loggen. Keine Live-Charges ohne AZA_AI_TOPUP_ALLOW_LIVE=1.
"""

from __future__ import annotations

import json
import os
import sqlite3
import time
import uuid
from dataclasses import dataclass
from typing import Any, Dict, List, Optional, Tuple

DEFAULT_TOPUP_CHF = 30.0
DEFAULT_INTERNAL_USD = 10.0
DEFAULT_TOPUP_SUCCESS_URL = "https://aza-medwork.ch/succes2"
DEFAULT_TOPUP_CANCEL_URL = "https://aza-medwork.ch"
DEFAULT_SETUP_SUCCESS_URL = "https://aza-medwork.ch/ki-topup-setup-success/"
DEFAULT_SETUP_CANCEL_URL = "https://aza-medwork.ch"
CHF_TO_INTERNAL_RATIO = 1.0 / 3.0  # CHF 30 → USD 10 (+50 % Monatskontingent)
MIN_TOPUP_CHF = 10.0
MAX_TOPUP_CHF = 300.0
DEFAULT_TRIGGER_PERCENT = 5
DEFAULT_MONTHLY_LIMIT_CHF = 300.0
AUTO_TOPUP_MONTHLY_LIMIT_MESSAGE = (
    "Das Monatslimit für automatische Aufladungen ist erreicht. "
    "Sie können weiterhin manuell Zusatzguthaben kaufen."
)
AUTO_TOPUP_COOLDOWN_SEC = 24 * 3600
AUTO_TOPUP_PENDING_STALE_SEC = 15 * 60
AUTO_TOPUP_CONSENT_TEXT = (
    "Automatische Aufladung: CHF 30 (+10 USD Zusatzguthaben), sobald KI-Guthaben unter 5 % fällt, "
    "maximal CHF 300 automatische Aufladungen pro Monat. Jederzeit deaktivierbar."
)

LEDGER_TOPUP_TYPES = ("topup_purchase", "auto_topup_purchase", "adjustment", "refund")
LEDGER_DEBIT_TYPES = ("usage",)
USER_HISTORY_EVENT_TYPES = ("topup_purchase", "auto_topup_purchase", "refund")


def _auto_topup_enabled_env() -> bool:
    return os.environ.get("AZA_AI_AUTO_TOPUP_ENABLED", "0").strip() == "1"


def _topup_allow_live_env() -> bool:
    return os.environ.get("AZA_AI_TOPUP_ALLOW_LIVE", "0").strip() == "1"


def _topup_dry_run_env() -> bool:
    return os.environ.get("AZA_AI_TOPUP_DRY_RUN", "1").strip() == "1"


AUTO_TOPUP_ENABLED_ENV = _auto_topup_enabled_env()
TOPUP_ALLOW_LIVE = _topup_allow_live_env()


def _format_date_de(ts: int) -> str:
    from datetime import datetime, timezone

    return datetime.fromtimestamp(int(ts), tz=timezone.utc).strftime("%d.%m.%Y")


def mask_stripe_reference(ref: Optional[str]) -> Optional[str]:
    rid = (ref or "").strip()
    if not rid:
        return None
    if len(rid) <= 8:
        return rid[:2] + "…"
    return rid[:3] + "…" + rid[-4:]


def _fetch_stripe_receipt_url(payment_intent_id: Optional[str]) -> Optional[str]:
    """Read-only: receipt_url vom Charge, falls verfügbar."""
    pid = (payment_intent_id or "").strip()
    if not pid:
        return None
    try:
        import stripe

        stripe.api_key = os.environ.get("STRIPE_SECRET_KEY", "")
        pi = stripe.PaymentIntent.retrieve(pid, expand=["latest_charge"])
        charge = getattr(pi, "latest_charge", None)
        if charge is None:
            return None
        if isinstance(charge, str):
            charge = stripe.Charge.retrieve(charge)
        url = getattr(charge, "receipt_url", None)
        if url is None and isinstance(charge, dict):
            url = charge.get("receipt_url")
        cleaned = (str(url).strip() if url else "") or None
        if cleaned and cleaned.startswith("https://"):
            return cleaned
    except Exception:
        return None
    return None


def _meta_with_receipt(
    base: Optional[Dict[str, Any]],
    *,
    payment_intent_id: Optional[str],
) -> Dict[str, Any]:
    meta = dict(base or {})
    receipt = _fetch_stripe_receipt_url(payment_intent_id)
    if receipt:
        meta["receipt_url"] = receipt
    return meta


def chf_to_internal_usd(paid_chf: float) -> float:
    """Internes Zusatzguthaben: paid_chf / 3 (CHF 30 → 10 USD)."""
    chf = max(0.0, float(paid_chf))
    return round(chf * CHF_TO_INTERNAL_RATIO, 4)


def _now() -> int:
    return int(time.time())


def _month_start_ts(ts: Optional[int] = None) -> int:
    from datetime import datetime, timezone

    t = ts or _now()
    dt = datetime.fromtimestamp(t, tz=timezone.utc)
    start = dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
    return int(start.timestamp())


def _sanitize_meta(meta: Optional[Dict[str, Any]]) -> str:
    clean: Dict[str, Any] = {}
    if meta:
        for k, v in meta.items():
            kl = str(k).lower()
            if any(x in kl for x in ("secret", "token", "password", "key", "payment_method")):
                continue
            clean[str(k)[:64]] = v
    return json.dumps(clean, ensure_ascii=False)[:4000]


def ensure_ai_credit_schema(con: sqlite3.Connection) -> None:
    con.execute(
        """
        CREATE TABLE IF NOT EXISTS ai_credit_ledger (
          id TEXT PRIMARY KEY,
          practice_id TEXT,
          subscription_id TEXT,
          customer_email TEXT,
          event_type TEXT NOT NULL,
          amount_internal_usd REAL NOT NULL DEFAULT 0,
          amount_paid_chf REAL,
          stripe_checkout_session_id TEXT,
          stripe_payment_intent_id TEXT,
          stripe_customer_id TEXT,
          stripe_subscription_id TEXT,
          status TEXT NOT NULL DEFAULT 'pending',
          period_start INTEGER,
          period_end INTEGER,
          meta_json TEXT,
          created_at INTEGER NOT NULL,
          updated_at INTEGER NOT NULL
        )
        """
    )
    con.execute(
        "CREATE INDEX IF NOT EXISTS idx_ai_credit_ledger_practice "
        "ON ai_credit_ledger(practice_id, status, event_type)"
    )
    con.execute(
        "CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_credit_checkout_session "
        "ON ai_credit_ledger(stripe_checkout_session_id) "
        "WHERE stripe_checkout_session_id IS NOT NULL AND stripe_checkout_session_id != ''"
    )
    con.execute(
        "CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_credit_payment_intent "
        "ON ai_credit_ledger(stripe_payment_intent_id) "
        "WHERE stripe_payment_intent_id IS NOT NULL AND stripe_payment_intent_id != ''"
    )
    con.execute(
        """
        CREATE TABLE IF NOT EXISTS ai_topup_settings (
          practice_id TEXT PRIMARY KEY,
          auto_topup_enabled INTEGER NOT NULL DEFAULT 0,
          topup_amount_chf REAL NOT NULL DEFAULT 30,
          internal_credit_usd REAL NOT NULL DEFAULT 10,
          trigger_below_percent INTEGER NOT NULL DEFAULT 5,
          monthly_limit_chf REAL NOT NULL DEFAULT 300,
          stripe_customer_id TEXT,
          default_payment_method_id TEXT,
          updated_at INTEGER NOT NULL
        )
        """
    )
    con.commit()


def sum_extra_credit_topups(con: sqlite3.Connection, *, practice_id: str) -> float:
    pid = (practice_id or "").strip()
    if not pid:
        return 0.0
    row = con.execute(
        """
        SELECT COALESCE(SUM(amount_internal_usd), 0)
        FROM ai_credit_ledger
        WHERE practice_id = ?
          AND status = 'succeeded'
          AND event_type IN ('topup_purchase', 'auto_topup_purchase', 'adjustment', 'refund')
        """,
        (pid,),
    ).fetchone()
    return max(0.0, float(row[0] or 0.0))


def _count_usage_periods(con: sqlite3.Connection, subscription_id: str) -> int:
    row = con.execute(
        """
        SELECT COUNT(DISTINCT period_start || ':' || period_end)
        FROM ai_usage_events
        WHERE subscription_id = ? AND status = 'success'
        """,
        (subscription_id,),
    ).fetchone()
    n = int(row[0] or 0)
    return max(1, n)


def sum_total_usage_usd(con: sqlite3.Connection, subscription_id: str) -> float:
    row = con.execute(
        """
        SELECT COALESCE(SUM(estimated_cost_usd), 0)
        FROM ai_usage_events
        WHERE subscription_id = ? AND status = 'success'
        """,
        (subscription_id,),
    ).fetchone()
    return float(row[0] or 0.0)


def compute_extra_credit_remaining(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    subscription_id: str,
    monthly_budget_usd: float,
) -> float:
    """Zusatzguthaben = Topups minus Verbrauch über kumuliertes Monatskontingent."""
    topups = sum_extra_credit_topups(con, practice_id=practice_id)
    if topups <= 0:
        return 0.0
    total_used = sum_total_usage_usd(con, subscription_id)
    periods = _count_usage_periods(con, subscription_id)
    allocated = max(0.0, float(monthly_budget_usd)) * periods
    consumed_from_extra = max(0.0, total_used - allocated)
    return max(0.0, round(topups - consumed_from_extra, 4))


def apply_extra_credit_to_snapshot(
    snap: Dict[str, Any],
    *,
    extra_remaining: float,
    monthly_budget: float,
) -> Dict[str, Any]:
    monthly_remaining = max(0.0, float(snap.get("remaining_usd", 0) or 0))
    extra = max(0.0, float(extra_remaining))
    total_available = monthly_remaining + extra
    budget = max(0.01, float(monthly_budget))
    pct = int((total_available / budget) * 100.0)
    pct = max(0, pct)
    label = f"KI-Kontingent: {pct} % verfügbar"
    out = dict(snap)
    out["available_percent"] = pct
    out["remaining_usd"] = round(monthly_remaining, 4)
    out["extra_credit_remaining_usd"] = round(extra, 4)
    out["total_available_usd"] = round(total_available, 4)
    out["show_warning"] = pct <= 20 and pct > 0
    out["user_label"] = label
    out["extra_credit_active"] = extra > 0 and monthly_remaining <= 0
    return out


def budget_allows_with_extra(
    snap: Dict[str, Any],
    *,
    extra_remaining: float,
) -> bool:
    monthly_remaining = max(0.0, float(snap.get("remaining_usd", 0) or 0))
    extra = max(0.0, float(extra_remaining))
    return (monthly_remaining + extra) > 1e-9


@dataclass
class TopupSettings:
    practice_id: str
    auto_topup_enabled: bool
    topup_amount_chf: float
    internal_credit_usd: float
    trigger_below_percent: int
    monthly_limit_chf: float
    stripe_customer_id: Optional[str]
    default_payment_method_id: Optional[str]


def get_topup_settings(con: sqlite3.Connection, practice_id: str) -> TopupSettings:
    pid = (practice_id or "").strip()
    row = con.execute(
        "SELECT * FROM ai_topup_settings WHERE practice_id = ?",
        (pid,),
    ).fetchone()
    if not row:
        return TopupSettings(
            practice_id=pid,
            auto_topup_enabled=False,
            topup_amount_chf=DEFAULT_TOPUP_CHF,
            internal_credit_usd=DEFAULT_INTERNAL_USD,
            trigger_below_percent=DEFAULT_TRIGGER_PERCENT,
            monthly_limit_chf=DEFAULT_MONTHLY_LIMIT_CHF,
            stripe_customer_id=None,
            default_payment_method_id=None,
        )
    cols = [d[1] for d in con.execute("PRAGMA table_info(ai_topup_settings)").fetchall()]
    d = dict(zip(cols, row))
    return TopupSettings(
        practice_id=pid,
        auto_topup_enabled=bool(int(d.get("auto_topup_enabled") or 0)),
        topup_amount_chf=float(d.get("topup_amount_chf") or DEFAULT_TOPUP_CHF),
        internal_credit_usd=float(d.get("internal_credit_usd") or DEFAULT_INTERNAL_USD),
        trigger_below_percent=int(d.get("trigger_below_percent") or DEFAULT_TRIGGER_PERCENT),
        monthly_limit_chf=float(d.get("monthly_limit_chf") or DEFAULT_MONTHLY_LIMIT_CHF),
        stripe_customer_id=(d.get("stripe_customer_id") or None),
        default_payment_method_id=(d.get("default_payment_method_id") or None),
    )


def save_topup_settings(con: sqlite3.Connection, settings: TopupSettings, *, commit: bool = True) -> None:
    now = _now()
    con.execute(
        """
        INSERT INTO ai_topup_settings(
          practice_id, auto_topup_enabled, topup_amount_chf, internal_credit_usd,
          trigger_below_percent, monthly_limit_chf, stripe_customer_id,
          default_payment_method_id, updated_at
        ) VALUES (?,?,?,?,?,?,?,?,?)
        ON CONFLICT(practice_id) DO UPDATE SET
          auto_topup_enabled=excluded.auto_topup_enabled,
          topup_amount_chf=excluded.topup_amount_chf,
          internal_credit_usd=excluded.internal_credit_usd,
          trigger_below_percent=excluded.trigger_below_percent,
          monthly_limit_chf=excluded.monthly_limit_chf,
          stripe_customer_id=COALESCE(excluded.stripe_customer_id, ai_topup_settings.stripe_customer_id),
          default_payment_method_id=COALESCE(excluded.default_payment_method_id, ai_topup_settings.default_payment_method_id),
          updated_at=excluded.updated_at
        """,
        (
            settings.practice_id,
            1 if settings.auto_topup_enabled else 0,
            settings.topup_amount_chf,
            settings.internal_credit_usd,
            settings.trigger_below_percent,
            settings.monthly_limit_chf,
            settings.stripe_customer_id,
            settings.default_payment_method_id,
            now,
        ),
    )
    if commit:
        con.commit()


def apply_auto_topup_user_settings(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    enabled: bool,
    amount_chf: Optional[float] = None,
    trigger_below_percent: Optional[int] = None,
    monthly_limit_chf: Optional[float] = None,
) -> Dict[str, Any]:
    existing = get_topup_settings(con, practice_id)
    if enabled and not auto_topup_is_fully_configured(existing):
        return {"ok": False, "error_code": "AUTO_TOPUP_NO_PAYMENT_METHOD"}
    amt = amount_chf if amount_chf is not None else existing.topup_amount_chf
    trig = trigger_below_percent if trigger_below_percent is not None else existing.trigger_below_percent
    monthly = monthly_limit_chf if monthly_limit_chf is not None else existing.monthly_limit_chf
    settings = TopupSettings(
        practice_id=practice_id,
        auto_topup_enabled=enabled,
        topup_amount_chf=amt,
        internal_credit_usd=chf_to_internal_usd(amt),
        trigger_below_percent=trig,
        monthly_limit_chf=monthly,
        stripe_customer_id=existing.stripe_customer_id,
        default_payment_method_id=existing.default_payment_method_id,
    )
    save_topup_settings(con, settings)
    return {"ok": True, "auto_topup_enabled": settings.auto_topup_enabled}


def auto_topup_settings_status(con: sqlite3.Connection, *, practice_id: str) -> Dict[str, Any]:
    settings = get_topup_settings(con, practice_id)
    return {
        "ok": True,
        "auto_topup_enabled": settings.auto_topup_enabled,
        "topup_amount_chf": settings.topup_amount_chf,
        "trigger_below_percent": settings.trigger_below_percent,
        "monthly_limit_chf": settings.monthly_limit_chf,
        "payment_method_configured": auto_topup_is_fully_configured(settings),
    }


def insert_ledger_event(
    con: sqlite3.Connection,
    *,
    practice_id: Optional[str],
    subscription_id: Optional[str],
    customer_email: Optional[str],
    event_type: str,
    amount_internal_usd: float,
    amount_paid_chf: Optional[float] = None,
    stripe_checkout_session_id: Optional[str] = None,
    stripe_payment_intent_id: Optional[str] = None,
    stripe_customer_id: Optional[str] = None,
    stripe_subscription_id: Optional[str] = None,
    status: str = "pending",
    period_start: Optional[int] = None,
    period_end: Optional[int] = None,
    meta: Optional[Dict[str, Any]] = None,
    ledger_id: Optional[str] = None,
    commit: bool = True,
) -> str:
    eid = ledger_id or str(uuid.uuid4())
    now = _now()
    con.execute(
        """
        INSERT INTO ai_credit_ledger(
          id, practice_id, subscription_id, customer_email, event_type,
          amount_internal_usd, amount_paid_chf, stripe_checkout_session_id,
          stripe_payment_intent_id, stripe_customer_id, stripe_subscription_id,
          status, period_start, period_end, meta_json, created_at, updated_at
        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
        """,
        (
            eid,
            practice_id,
            subscription_id,
            customer_email,
            event_type,
            float(amount_internal_usd),
            amount_paid_chf,
            stripe_checkout_session_id,
            stripe_payment_intent_id,
            stripe_customer_id,
            stripe_subscription_id,
            status,
            period_start,
            period_end,
            _sanitize_meta(meta),
            now,
            now,
        ),
    )
    if commit:
        con.commit()
    return eid


def update_ledger_event(
    con: sqlite3.Connection,
    ledger_id: str,
    *,
    status: Optional[str] = None,
    stripe_payment_intent_id: Optional[str] = None,
    meta: Optional[Dict[str, Any]] = None,
    commit: bool = True,
) -> None:
    parts: List[str] = ["updated_at = ?"]
    vals: List[Any] = [_now()]
    if status is not None:
        parts.append("status = ?")
        vals.append(status)
    if stripe_payment_intent_id is not None:
        parts.append("stripe_payment_intent_id = ?")
        vals.append(stripe_payment_intent_id)
    if meta is not None:
        parts.append("meta_json = ?")
        vals.append(_sanitize_meta(meta))
    vals.append(ledger_id)
    con.execute(
        f"UPDATE ai_credit_ledger SET {', '.join(parts)} WHERE id = ?",
        tuple(vals),
    )
    if commit:
        con.commit()


def ledger_exists_for_checkout(con: sqlite3.Connection, session_id: str) -> bool:
    sid = (session_id or "").strip()
    if not sid:
        return False
    row = con.execute(
        "SELECT 1 FROM ai_credit_ledger WHERE stripe_checkout_session_id = ? LIMIT 1",
        (sid,),
    ).fetchone()
    return bool(row)


def ledger_exists_for_payment_intent(con: sqlite3.Connection, payment_intent_id: str) -> bool:
    pid = (payment_intent_id or "").strip()
    if not pid:
        return False
    row = con.execute(
        """
        SELECT 1 FROM ai_credit_ledger
        WHERE stripe_payment_intent_id = ?
          AND status = 'succeeded'
        LIMIT 1
        """,
        (pid,),
    ).fetchone()
    return bool(row)


def has_pending_auto_topup(con: sqlite3.Connection, practice_id: str) -> bool:
    pid = (practice_id or "").strip()
    if not pid:
        return False
    cutoff = _now() - AUTO_TOPUP_PENDING_STALE_SEC
    row = con.execute(
        """
        SELECT 1 FROM ai_credit_ledger
        WHERE practice_id = ?
          AND event_type = 'auto_topup_purchase'
          AND status = 'pending'
          AND created_at >= ?
        LIMIT 1
        """,
        (pid, cutoff),
    ).fetchone()
    return bool(row)


def last_successful_auto_topup_ts(con: sqlite3.Connection, practice_id: str) -> Optional[int]:
    pid = (practice_id or "").strip()
    if not pid:
        return None
    row = con.execute(
        """
        SELECT MAX(created_at) FROM ai_credit_ledger
        WHERE practice_id = ?
          AND event_type = 'auto_topup_purchase'
          AND status = 'succeeded'
        """,
        (pid,),
    ).fetchone()
    if not row or row[0] is None:
        return None
    return int(row[0])


def _auto_topup_idempotency_key(practice_id: str) -> str:
    from datetime import datetime, timezone

    dt = datetime.fromtimestamp(_now(), tz=timezone.utc)
    return f"aza_auto_topup_{practice_id}_{dt.strftime('%Y%m')}_{dt.strftime('%d')}"


def _pause_auto_topup_on_failure(
    con: sqlite3.Connection,
    settings: TopupSettings,
    *,
    reason: str,
    payment_intent_id: Optional[str] = None,
    commit: bool = True,
) -> None:
    settings.auto_topup_enabled = False
    save_topup_settings(con, settings, commit=commit)
    insert_ledger_event(
        con,
        practice_id=settings.practice_id,
        subscription_id=None,
        customer_email=None,
        event_type="failed_auto_topup",
        amount_internal_usd=0,
        amount_paid_chf=settings.topup_amount_chf,
        stripe_payment_intent_id=payment_intent_id,
        stripe_customer_id=settings.stripe_customer_id,
        status="failed",
        meta={"reason": reason},
        commit=commit,
    )


def process_topup_checkout_completed(
    con: sqlite3.Connection,
    *,
    session: Dict[str, Any],
) -> Dict[str, Any]:
    """Idempotent: checkout.session.completed für aza_purpose=ai_topup."""
    md = session.get("metadata") or {}
    if (md.get("aza_purpose") or "").strip() != "ai_topup":
        return {"handled": False, "reason": "not_ai_topup"}
    sid = str(session.get("id") or "")
    if ledger_exists_for_checkout(con, sid):
        return {"handled": True, "duplicate": True, "session_id": sid}
    pi_from_session = str(session.get("payment_intent") or "") or None
    if pi_from_session and ledger_exists_for_payment_intent(con, pi_from_session):
        return {"handled": True, "duplicate": True, "payment_intent_id": pi_from_session}
    practice_id = (md.get("practice_id") or "").strip() or None
    subscription_id = (md.get("subscription_id") or "").strip() or None
    try:
        internal_usd = float(md.get("internal_credit_usd") or 0)
        paid_chf = float(md.get("paid_chf") or 0)
    except (TypeError, ValueError):
        return {"handled": False, "reason": "invalid_metadata_amounts"}
    if internal_usd <= 0 or paid_chf <= 0:
        return {"handled": False, "reason": "zero_amounts"}
    payment_status = (session.get("payment_status") or "").strip()
    if payment_status != "paid":
        insert_ledger_event(
            con,
            practice_id=practice_id,
            subscription_id=subscription_id,
            customer_email=(session.get("customer_email") or None),
            event_type="topup_purchase",
            amount_internal_usd=0,
            amount_paid_chf=paid_chf,
            stripe_checkout_session_id=sid,
            stripe_payment_intent_id=str(session.get("payment_intent") or "") or None,
            stripe_customer_id=str(session.get("customer") or "") or None,
            status="failed",
            meta={"payment_status": payment_status},
        )
        return {"handled": True, "credited": False, "reason": "not_paid"}
    pi_id = str(session.get("payment_intent") or "") or None
    insert_ledger_event(
        con,
        practice_id=practice_id,
        subscription_id=subscription_id,
        customer_email=(session.get("customer_email") or None),
        event_type="topup_purchase",
        amount_internal_usd=internal_usd,
        amount_paid_chf=paid_chf,
        stripe_checkout_session_id=sid,
        stripe_payment_intent_id=pi_id,
        stripe_customer_id=str(session.get("customer") or "") or None,
        status="succeeded",
        meta=_meta_with_receipt({"source": "checkout.session.completed"}, payment_intent_id=pi_id),
    )
    return {"handled": True, "credited": True, "session_id": sid}


def normalize_stripe_id(value: Any, prefix: str) -> Optional[str]:
    """Extrahiert eine Stripe-ID (z. B. pm_..., cus_...) aus String, Dict oder StripeObject."""
    if value is None:
        return None
    pfx = (prefix or "").strip()
    if isinstance(value, str):
        raw = value.strip()
        if not raw:
            return None
        if raw.startswith(pfx):
            return raw
        if raw.startswith("{"):
            try:
                obj = json.loads(raw)
            except Exception:
                return None
            if isinstance(obj, dict):
                return normalize_stripe_id(obj.get("id"), pfx)
            return None
        return None
    if isinstance(value, dict):
        if value.get("object") and value.get("id"):
            return normalize_stripe_id(value.get("id"), pfx)
        return normalize_stripe_id(value.get("id"), pfx)
    obj_id = getattr(value, "id", None)
    if obj_id:
        return normalize_stripe_id(str(obj_id), pfx)
    return None


def auto_topup_is_fully_configured(settings: TopupSettings) -> bool:
    cus = normalize_stripe_id(settings.stripe_customer_id, "cus_")
    pm = normalize_stripe_id(settings.default_payment_method_id, "pm_")
    return bool(cus and pm)


def _retrieve_setup_intent_obj(setup_intent_ref: Any) -> Any:
    si_id = normalize_stripe_id(setup_intent_ref, "seti_")
    if not si_id and isinstance(setup_intent_ref, dict):
        si_id = normalize_stripe_id(setup_intent_ref.get("id"), "seti_")
    if not si_id:
        return None
    try:
        import stripe

        return stripe.SetupIntent.retrieve(si_id, expand=["payment_method", "customer"])
    except Exception:
        return None


def resolve_auto_topup_setup_ids(
    *,
    session: Optional[Dict[str, Any]] = None,
    setup_intent: Optional[Dict[str, Any]] = None,
) -> Tuple[Optional[str], Optional[str]]:
    customer_id: Optional[str] = None
    pm_id: Optional[str] = None

    def _from_setup_dict(si: Any) -> Tuple[Optional[str], Optional[str]]:
        if not isinstance(si, dict):
            return None, None
        c = normalize_stripe_id(si.get("customer"), "cus_")
        p = normalize_stripe_id(si.get("payment_method"), "pm_")
        return c, p

    if session:
        customer_id = normalize_stripe_id(session.get("customer"), "cus_")
        si_ref = session.get("setup_intent")
        c2, p2 = _from_setup_dict(si_ref)
        customer_id = customer_id or c2
        pm_id = pm_id or p2
        si = _retrieve_setup_intent_obj(si_ref)
        if si is not None:
            pm_id = pm_id or normalize_stripe_id(getattr(si, "payment_method", None), "pm_")
            customer_id = customer_id or normalize_stripe_id(getattr(si, "customer", None), "cus_")
            if pm_id and not customer_id:
                customer_id = normalize_stripe_id(getattr(getattr(si, "payment_method", None), "customer", None), "cus_")
        cs_id = normalize_stripe_id(session.get("id"), "cs_")
        if cs_id and (not customer_id or not pm_id):
            try:
                import stripe

                cs = stripe.checkout.Session.retrieve(
                    cs_id,
                    expand=["setup_intent", "setup_intent.payment_method", "customer"],
                )
                if not customer_id:
                    customer_id = normalize_stripe_id(getattr(cs, "customer", None), "cus_")
                si2 = getattr(cs, "setup_intent", None)
                if si2 is not None:
                    if not pm_id:
                        pm_id = normalize_stripe_id(getattr(si2, "payment_method", None), "pm_")
                    if not customer_id:
                        customer_id = normalize_stripe_id(getattr(si2, "customer", None), "cus_")
                    if pm_id and not customer_id:
                        customer_id = normalize_stripe_id(
                            getattr(getattr(si2, "payment_method", None), "customer", None),
                            "cus_",
                        )
            except Exception:
                pass

    if setup_intent:
        if not customer_id:
            customer_id = normalize_stripe_id(setup_intent.get("customer"), "cus_")
        if not pm_id:
            pm_id = normalize_stripe_id(setup_intent.get("payment_method"), "pm_")
        c3, p3 = _from_setup_dict(setup_intent)
        customer_id = customer_id or c3
        pm_id = pm_id or p3
        if not customer_id or not pm_id:
            si = _retrieve_setup_intent_obj(setup_intent)
            if si is not None:
                if not pm_id:
                    pm_id = normalize_stripe_id(getattr(si, "payment_method", None), "pm_")
                if not customer_id:
                    customer_id = normalize_stripe_id(getattr(si, "customer", None), "cus_")
                if pm_id and not customer_id:
                    customer_id = normalize_stripe_id(
                        getattr(getattr(si, "payment_method", None), "customer", None),
                        "cus_",
                    )

    return (
        normalize_stripe_id(customer_id, "cus_"),
        normalize_stripe_id(pm_id, "pm_"),
    )


def _apply_auto_topup_setup_settings(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    customer_id: Optional[str],
    payment_method_id: Optional[str],
) -> Tuple[TopupSettings, bool]:
    cus = normalize_stripe_id(customer_id, "cus_")
    pm = normalize_stripe_id(payment_method_id, "pm_")
    settings = get_topup_settings(con, practice_id)
    if cus:
        settings.stripe_customer_id = cus
    if pm:
        settings.default_payment_method_id = pm
    complete = bool(cus and pm)
    if complete:
        settings.auto_topup_enabled = True
        settings.topup_amount_chf = DEFAULT_TOPUP_CHF
        settings.internal_credit_usd = DEFAULT_INTERNAL_USD
        settings.trigger_below_percent = DEFAULT_TRIGGER_PERCENT
        settings.monthly_limit_chf = DEFAULT_MONTHLY_LIMIT_CHF
    else:
        settings.auto_topup_enabled = False
    save_topup_settings(con, settings)
    return settings, complete


def process_setup_checkout_completed(
    con: sqlite3.Connection,
    *,
    session: Dict[str, Any],
) -> Dict[str, Any]:
    md = session.get("metadata") or {}
    if (md.get("aza_purpose") or "").strip() != "ai_topup_setup":
        return {"handled": False}
    practice_id = (md.get("practice_id") or "").strip()
    if not practice_id:
        return {"handled": False, "reason": "no_practice_id"}
    customer_id, pm_id = resolve_auto_topup_setup_ids(session=session)
    _, complete = _apply_auto_topup_setup_settings(
        con,
        practice_id=practice_id,
        customer_id=customer_id,
        payment_method_id=pm_id,
    )
    if not complete:
        return {
            "handled": True,
            "practice_id": practice_id,
            "auto_topup_enabled": False,
            "reason": "AUTO_TOPUP_SETUP_INCOMPLETE",
            "has_customer": bool(customer_id),
            "has_payment_method": bool(pm_id),
        }
    return {
        "handled": True,
        "practice_id": practice_id,
        "auto_topup_enabled": True,
        "default_payment_method_id": pm_id,
        "stripe_customer_id": customer_id,
    }


def process_setup_intent_succeeded(
    con: sqlite3.Connection,
    *,
    setup_intent: Dict[str, Any],
) -> Dict[str, Any]:
    md = setup_intent.get("metadata") or {}
    if (md.get("aza_purpose") or "").strip() != "ai_topup_setup":
        return {"handled": False}
    practice_id = (md.get("practice_id") or "").strip()
    if not practice_id:
        return {"handled": False, "reason": "no_practice_id"}
    customer_id, pm_id = resolve_auto_topup_setup_ids(setup_intent=setup_intent)
    _, complete = _apply_auto_topup_setup_settings(
        con,
        practice_id=practice_id,
        customer_id=customer_id,
        payment_method_id=pm_id,
    )
    if not complete:
        return {
            "handled": True,
            "practice_id": practice_id,
            "auto_topup_enabled": False,
            "reason": "AUTO_TOPUP_SETUP_INCOMPLETE",
            "has_customer": bool(customer_id),
            "has_payment_method": bool(pm_id),
        }
    return {
        "handled": True,
        "practice_id": practice_id,
        "auto_topup_enabled": True,
        "default_payment_method_id": pm_id,
        "stripe_customer_id": customer_id,
    }


def repair_auto_topup_settings_from_checkout_session(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    checkout_session_id: str,
) -> Dict[str, Any]:
    """Read-only Stripe-Abfrage + lokales Settings-Update (keine Zahlung)."""
    key = (os.environ.get("STRIPE_SECRET_KEY") or "").strip()
    if not key:
        return {"ok": False, "reason": "no_stripe_key"}
    import stripe

    stripe.api_key = key
    cs_id = normalize_stripe_id(checkout_session_id, "cs_")
    if not cs_id:
        return {"ok": False, "reason": "invalid_checkout_session_id"}
    try:
        cs = stripe.checkout.Session.retrieve(
            cs_id,
            expand=["setup_intent", "setup_intent.payment_method", "customer"],
        )
    except Exception:
        return {"ok": False, "reason": "session_retrieve_failed"}
    session = {
        "id": getattr(cs, "id", None),
        "customer": getattr(cs, "customer", None),
        "setup_intent": getattr(cs, "setup_intent", None),
        "metadata": getattr(cs, "metadata", None) or {},
    }
    customer_id, pm_id = resolve_auto_topup_setup_ids(session=session)
    if pm_id and not customer_id:
        try:
            pm_obj = stripe.PaymentMethod.retrieve(pm_id)
            customer_id = normalize_stripe_id(getattr(pm_obj, "customer", None), "cus_")
        except Exception:
            pass
    _, complete = _apply_auto_topup_setup_settings(
        con,
        practice_id=practice_id,
        customer_id=customer_id,
        payment_method_id=pm_id,
    )
    if not complete:
        return {
            "ok": False,
            "reason": "AUTO_TOPUP_SETUP_INCOMPLETE",
            "has_customer": bool(customer_id),
            "has_payment_method": bool(pm_id),
        }
    return {
        "ok": True,
        "auto_topup_enabled": True,
        "has_customer": True,
        "has_payment_method": True,
    }


def process_topup_payment_intent_succeeded(
    con: sqlite3.Connection,
    *,
    payment_intent: Dict[str, Any],
) -> Dict[str, Any]:
    """Idempotent backup wenn checkout.session.completed noch nicht lief."""
    md = payment_intent.get("metadata") or {}
    if (md.get("aza_purpose") or "").strip() != "ai_topup":
        return {"handled": False, "reason": "not_ai_topup"}
    pi_id = str(payment_intent.get("id") or "")
    if ledger_exists_for_payment_intent(con, pi_id):
        return {"handled": True, "duplicate": True, "payment_intent_id": pi_id}
    practice_id = (md.get("practice_id") or "").strip() or None
    subscription_id = (md.get("subscription_id") or "").strip() or None
    try:
        internal_usd = float(md.get("internal_credit_usd") or 0)
        paid_chf = float(md.get("paid_chf") or 0)
    except (TypeError, ValueError):
        return {"handled": False, "reason": "invalid_metadata_amounts"}
    if internal_usd <= 0 or paid_chf <= 0:
        return {"handled": False, "reason": "zero_amounts"}
    insert_ledger_event(
        con,
        practice_id=practice_id,
        subscription_id=subscription_id,
        customer_email=None,
        event_type="topup_purchase",
        amount_internal_usd=internal_usd,
        amount_paid_chf=paid_chf,
        stripe_payment_intent_id=pi_id,
        stripe_customer_id=str(payment_intent.get("customer") or "") or None,
        status="succeeded",
        meta=_meta_with_receipt({"source": "payment_intent.succeeded"}, payment_intent_id=pi_id),
    )
    return {"handled": True, "credited": True, "payment_intent_id": pi_id}


def process_auto_topup_payment_intent_succeeded(
    con: sqlite3.Connection,
    *,
    payment_intent: Dict[str, Any],
) -> Dict[str, Any]:
    """Idempotent: payment_intent.succeeded für aza_purpose=ai_auto_topup."""
    md = payment_intent.get("metadata") or {}
    if (md.get("aza_purpose") or "").strip() != "ai_auto_topup":
        return {"handled": False, "reason": "not_ai_auto_topup"}
    pi_id = str(payment_intent.get("id") or "")
    if ledger_exists_for_payment_intent(con, pi_id):
        return {"handled": True, "duplicate": True, "payment_intent_id": pi_id}
    practice_id = (md.get("practice_id") or "").strip() or None
    subscription_id = (md.get("subscription_id") or "").strip() or None
    try:
        internal_usd = float(md.get("internal_credit_usd") or 0)
        paid_chf = float(md.get("paid_chf") or 0)
    except (TypeError, ValueError):
        return {"handled": False, "reason": "invalid_metadata_amounts"}
    if internal_usd <= 0 or paid_chf <= 0:
        return {"handled": False, "reason": "zero_amounts"}
    insert_ledger_event(
        con,
        practice_id=practice_id,
        subscription_id=subscription_id,
        customer_email=None,
        event_type="auto_topup_purchase",
        amount_internal_usd=internal_usd,
        amount_paid_chf=paid_chf,
        stripe_payment_intent_id=pi_id,
        stripe_customer_id=str(payment_intent.get("customer") or "") or None,
        status="succeeded",
        meta=_meta_with_receipt({"source": "payment_intent.succeeded"}, payment_intent_id=pi_id),
    )
    return {"handled": True, "credited": True, "payment_intent_id": pi_id}


def sum_topups_chf_this_month(con: sqlite3.Connection, practice_id: str) -> float:
    """Summe aller erfolgreichen Topups (manuell + auto) im Kalendermonat."""
    start = _month_start_ts()
    row = con.execute(
        """
        SELECT COALESCE(SUM(amount_paid_chf), 0)
        FROM ai_credit_ledger
        WHERE practice_id = ?
          AND status = 'succeeded'
          AND event_type IN ('topup_purchase', 'auto_topup_purchase')
          AND created_at >= ?
        """,
        (practice_id, start),
    ).fetchone()
    return float(row[0] or 0.0)


def sum_auto_topups_chf_this_month(con: sqlite3.Connection, practice_id: str) -> float:
    """Nur automatische Aufladungen – für Auto-Monatslimit CHF 300."""
    start = _month_start_ts()
    row = con.execute(
        """
        SELECT COALESCE(SUM(amount_paid_chf), 0)
        FROM ai_credit_ledger
        WHERE practice_id = ?
          AND status = 'succeeded'
          AND event_type = 'auto_topup_purchase'
          AND created_at >= ?
        """,
        (practice_id, start),
    ).fetchone()
    return float(row[0] or 0.0)


def maybe_run_auto_topup_for_practice(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    available_percent: int,
    dry_run: bool = True,
    subscription_id: Optional[str] = None,
    customer_email: Optional[str] = None,
) -> Dict[str, Any]:
    """
    Auto-Aufladung nur wenn alle Schutzbedingungen erfüllt sind.
    Live-Charge nur bei AZA_AI_AUTO_TOPUP_ENABLED=1, AZA_AI_TOPUP_ALLOW_LIVE=1,
    AZA_AI_TOPUP_DRY_RUN=0.
    """
    pid = (practice_id or "").strip()
    if not pid:
        return {"ok": False, "reason": "no_practice_id"}
    settings = get_topup_settings(con, pid)
    if not settings.auto_topup_enabled:
        return {"ok": False, "reason": "auto_topup_not_enabled"}
    if available_percent >= settings.trigger_below_percent:
        return {"ok": False, "reason": "above_trigger"}
    if not normalize_stripe_id(settings.stripe_customer_id, "cus_") or not normalize_stripe_id(
        settings.default_payment_method_id, "pm_"
    ):
        return {"ok": False, "reason": "no_payment_method"}
    if settings.topup_amount_chf < MIN_TOPUP_CHF or settings.topup_amount_chf > MAX_TOPUP_CHF:
        return {"ok": False, "reason": "invalid_amount"}
    spent = sum_auto_topups_chf_this_month(con, pid)
    if spent + settings.topup_amount_chf > settings.monthly_limit_chf + 1e-9:
        return {
            "ok": False,
            "reason": "auto_topup_monthly_limit_reached",
            "error_code": "AUTO_TOPUP_MONTHLY_LIMIT_REACHED",
            "message_user": AUTO_TOPUP_MONTHLY_LIMIT_MESSAGE,
        }
    last_ts = last_successful_auto_topup_ts(con, pid)
    if last_ts and (_now() - last_ts) < AUTO_TOPUP_COOLDOWN_SEC:
        return {"ok": False, "reason": "cooldown_24h"}
    if has_pending_auto_topup(con, pid):
        return {"ok": False, "reason": "pending_auto_topup"}
    if dry_run or not _topup_allow_live_env() or not _auto_topup_enabled_env():
        return {
            "ok": True,
            "dry_run": True,
            "would_charge_chf": settings.topup_amount_chf,
            "would_credit_usd": settings.internal_credit_usd,
        }
    if _topup_dry_run_env():
        return {
            "ok": True,
            "dry_run": True,
            "would_charge_chf": settings.topup_amount_chf,
            "would_credit_usd": settings.internal_credit_usd,
        }
    return _execute_live_auto_topup(
        con,
        settings=settings,
        subscription_id=subscription_id,
        customer_email=customer_email,
    )


def _execute_live_auto_topup(
    con: sqlite3.Connection,
    *,
    settings: TopupSettings,
    subscription_id: Optional[str],
    customer_email: Optional[str],
) -> Dict[str, Any]:
    pid = settings.practice_id
    try:
        con.execute("BEGIN IMMEDIATE")
        if has_pending_auto_topup(con, pid):
            con.execute("ROLLBACK")
            return {"ok": False, "reason": "pending_auto_topup"}
        last_ts = last_successful_auto_topup_ts(con, pid)
        if last_ts and (_now() - last_ts) < AUTO_TOPUP_COOLDOWN_SEC:
            con.execute("ROLLBACK")
            return {"ok": False, "reason": "cooldown_24h"}
        spent = sum_auto_topups_chf_this_month(con, pid)
        if spent + settings.topup_amount_chf > settings.monthly_limit_chf + 1e-9:
            con.execute("ROLLBACK")
            return {
                "ok": False,
                "reason": "auto_topup_monthly_limit_reached",
                "error_code": "AUTO_TOPUP_MONTHLY_LIMIT_REACHED",
                "message_user": AUTO_TOPUP_MONTHLY_LIMIT_MESSAGE,
            }
        ledger_id = insert_ledger_event(
            con,
            practice_id=pid,
            subscription_id=subscription_id,
            customer_email=customer_email,
            event_type="auto_topup_purchase",
            amount_internal_usd=settings.internal_credit_usd,
            amount_paid_chf=settings.topup_amount_chf,
            stripe_customer_id=settings.stripe_customer_id,
            status="pending",
            meta={"source": "auto_topup_off_session"},
            commit=False,
        )
        import stripe

        stripe.api_key = os.environ.get("STRIPE_SECRET_KEY", "")
        amount_rappen = int(round(settings.topup_amount_chf * 100))
        idempotency_key = _auto_topup_idempotency_key(pid)
        try:
            pi = stripe.PaymentIntent.create(
                amount=amount_rappen,
                currency="chf",
                customer=normalize_stripe_id(settings.stripe_customer_id, "cus_"),
                payment_method=normalize_stripe_id(settings.default_payment_method_id, "pm_"),
                off_session=True,
                confirm=True,
                metadata={
                    "aza_purpose": "ai_auto_topup",
                    "practice_id": pid,
                    "subscription_id": subscription_id or "",
                    "internal_credit_usd": str(settings.internal_credit_usd),
                    "paid_chf": str(settings.topup_amount_chf),
                },
                idempotency_key=idempotency_key,
            )
        except stripe.error.CardError as exc:
            pi_obj = getattr(exc, "error", None)
            pi_id = None
            if pi_obj is not None:
                pi_id = getattr(getattr(pi_obj, "payment_intent", None), "id", None)
            update_ledger_event(con, ledger_id, status="failed", commit=False)
            _pause_auto_topup_on_failure(
                con,
                settings,
                reason="card_error",
                payment_intent_id=None,
                commit=False,
            )
            con.commit()
            return {"ok": False, "reason": "payment_failed", "charged": False, "paused": True}
        except Exception:
            update_ledger_event(con, ledger_id, status="failed", commit=False)
            _pause_auto_topup_on_failure(
                con,
                settings,
                reason="stripe_error",
                commit=False,
            )
            con.commit()
            return {"ok": False, "reason": "payment_failed", "charged": False, "paused": True}

        pi_id = str(getattr(pi, "id", "") or "")
        pi_status = str(getattr(pi, "status", "") or "")
        if pi_status == "succeeded":
            update_ledger_event(
                con,
                ledger_id,
                status="succeeded",
                stripe_payment_intent_id=pi_id or None,
                meta=_meta_with_receipt({"source": "auto_topup_off_session"}, payment_intent_id=pi_id or None),
                commit=False,
            )
            con.commit()
            return {
                "ok": True,
                "charged": True,
                "amount_chf": settings.topup_amount_chf,
                "internal_credit_usd": settings.internal_credit_usd,
                "payment_intent_id": pi_id,
            }
        update_ledger_event(
            con,
            ledger_id,
            status="failed",
            stripe_payment_intent_id=pi_id or None,
            meta={"stripe_status": pi_status},
            commit=False,
        )
        _pause_auto_topup_on_failure(
            con,
            settings,
            reason=pi_status or "requires_action",
            payment_intent_id=None,
            commit=False,
        )
        con.commit()
        return {"ok": False, "reason": "payment_failed", "charged": False, "paused": True}
    except Exception:
        try:
            con.execute("ROLLBACK")
        except Exception:
            pass
        return {"ok": False, "reason": "internal_error", "charged": False}


def _stripe_live_key() -> bool:
    key = (os.environ.get("STRIPE_SECRET_KEY") or "").strip()
    return key.startswith("sk_live")


def create_topup_checkout_session(
    *,
    practice_id: str,
    subscription_id: str,
    customer_email: str,
    paid_chf: float,
    internal_usd: float,
    save_payment_method: bool = False,
    success_url: str,
    cancel_url: str,
) -> Dict[str, Any]:
    if _stripe_live_key() and not _topup_allow_live_env():
        return {"ok": False, "error_code": "LIVE_TOPUP_BLOCKED", "dry_run": True}
    if _topup_dry_run_env():
        pending_id = f"dry_chk_{uuid.uuid4().hex[:16]}"
        return {
            "ok": True,
            "dry_run": True,
            "checkout_url": None,
            "session_id": pending_id,
            "paid_chf": paid_chf,
            "internal_credit_usd": internal_usd,
        }
    import stripe

    stripe.api_key = os.environ.get("STRIPE_SECRET_KEY", "")
    amount_rappen = int(round(paid_chf * 100))
    params: Dict[str, Any] = {
        "mode": "payment",
        "success_url": success_url,
        "cancel_url": cancel_url,
        "customer_email": customer_email,
        "line_items": [
            {
                "price_data": {
                    "currency": "chf",
                    "product_data": {"name": "AzA KI-Zusatzguthaben"},
                    "unit_amount": amount_rappen,
                },
                "quantity": 1,
            }
        ],
        "metadata": {
            "aza_purpose": "ai_topup",
            "practice_id": practice_id,
            "subscription_id": subscription_id,
            "internal_credit_usd": str(internal_usd),
            "paid_chf": str(paid_chf),
        },
    }
    if save_payment_method:
        params["payment_intent_data"] = {"setup_future_usage": "off_session"}
    session = stripe.checkout.Session.create(**params)
    return {
        "ok": True,
        "dry_run": False,
        "checkout_url": session.url,
        "session_id": session.id,
        "paid_chf": paid_chf,
        "internal_credit_usd": internal_usd,
    }


def create_setup_checkout_session(
    *,
    practice_id: str,
    customer_email: str,
    success_url: str,
    cancel_url: str,
) -> Dict[str, Any]:
    if _topup_dry_run_env():
        return {
            "ok": True,
            "dry_run": True,
            "checkout_url": None,
            "session_id": f"dry_setup_{uuid.uuid4().hex[:12]}",
        }
    if _stripe_live_key() and not _topup_allow_live_env():
        return {"ok": False, "error_code": "LIVE_SETUP_BLOCKED", "dry_run": True}
    import stripe

    stripe.api_key = os.environ.get("STRIPE_SECRET_KEY", "")
    session = stripe.checkout.Session.create(
        mode="setup",
        currency="chf",
        payment_method_types=["card"],
        customer_creation="always",
        success_url=success_url,
        cancel_url=cancel_url,
        customer_email=customer_email,
        custom_text={
            "submit": {"message": AUTO_TOPUP_CONSENT_TEXT},
        },
        metadata={
            "aza_purpose": "ai_topup_setup",
            "practice_id": practice_id,
            "consent_text": AUTO_TOPUP_CONSENT_TEXT[:500],
        },
        setup_intent_data={
            "metadata": {
                "aza_purpose": "ai_topup_setup",
                "practice_id": practice_id,
            },
        },
    )
    return {
        "ok": True,
        "dry_run": False,
        "checkout_url": session.url,
        "session_id": session.id,
    }


def admin_credit_overview_row(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    subscription_id: str,
    monthly_budget: float,
    snap: Dict[str, Any],
) -> Dict[str, Any]:
    settings = get_topup_settings(con, practice_id)
    extra = compute_extra_credit_remaining(
        con,
        practice_id=practice_id,
        subscription_id=subscription_id,
        monthly_budget_usd=monthly_budget,
    )
    topups_month = sum_topups_chf_this_month(con, practice_id)
    failed = con.execute(
        """
        SELECT COUNT(*) FROM ai_credit_ledger
        WHERE practice_id = ? AND status = 'failed'
          AND event_type IN ('topup_purchase', 'auto_topup_purchase', 'failed_auto_topup')
        """,
        (practice_id,),
    ).fetchone()[0]
    sub_m = subscription_id[:10] + "…" if len(subscription_id) > 12 else subscription_id
    return {
        "practice_id": practice_id,
        "subscription_id_masked": sub_m,
        "monthly_budget_usd": round(monthly_budget, 2),
        "used_current_period_usd": snap.get("used_usd"),
        "monthly_remaining_usd": snap.get("remaining_usd"),
        "extra_credit_remaining_usd": extra,
        "available_percent": snap.get("available_percent"),
        "auto_topup_enabled": settings.auto_topup_enabled,
        "topups_chf_this_month": round(topups_month, 2),
        "failed_topup_events": int(failed or 0),
    }


def list_ledger_for_practice(
    con: sqlite3.Connection,
    practice_id: str,
    *,
    limit: int = 100,
) -> List[Dict[str, Any]]:
    rows = con.execute(
        """
        SELECT id, event_type, amount_internal_usd, amount_paid_chf, status,
               stripe_checkout_session_id, created_at, updated_at
        FROM ai_credit_ledger
        WHERE practice_id = ?
        ORDER BY created_at DESC
        LIMIT ?
        """,
        (practice_id, limit),
    ).fetchall()
    out = []
    for r in rows:
        sid = r[5] or ""
        out.append(
            {
                "id": r[0],
                "event_type": r[1],
                "amount_internal_usd": r[2],
                "amount_paid_chf": r[3],
                "status": r[4],
                "checkout_session_masked": (sid[:12] + "…") if len(sid) > 14 else sid,
                "created_at": r[6],
            }
        )
    return out


def list_user_credit_history(
    con: sqlite3.Connection,
    *,
    practice_id: str,
    limit: int = 100,
) -> List[Dict[str, Any]]:
    """Benutzer-Historie: nur eigene practice_id, maskierte Stripe-Referenzen."""
    pid = (practice_id or "").strip()
    placeholders = ",".join("?" for _ in USER_HISTORY_EVENT_TYPES)
    rows = con.execute(
        f"""
        SELECT event_type, amount_internal_usd, amount_paid_chf, status,
               stripe_payment_intent_id, stripe_checkout_session_id, meta_json, created_at
        FROM ai_credit_ledger
        WHERE practice_id = ?
          AND event_type IN ({placeholders})
        ORDER BY created_at DESC
        LIMIT ?
        """,
        (pid, *USER_HISTORY_EVENT_TYPES, limit),
    ).fetchall()
    out: List[Dict[str, Any]] = []
    for r in rows:
        meta: Dict[str, Any] = {}
        if r[6]:
            try:
                parsed = json.loads(r[6])
                if isinstance(parsed, dict):
                    meta = parsed
            except (TypeError, ValueError, json.JSONDecodeError):
                meta = {}
        stripe_ref = mask_stripe_reference(r[4]) or mask_stripe_reference(r[5])
        item: Dict[str, Any] = {
            "created_at": int(r[7]),
            "date_de": _format_date_de(int(r[7])),
            "event_type": r[0],
            "amount_paid_chf": r[2],
            "amount_internal_usd": r[1],
            "status": r[3],
            "stripe_payment_reference": stripe_ref,
        }
        receipt = meta.get("receipt_url")
        if isinstance(receipt, str) and receipt.startswith("https://"):
            item["receipt_url"] = receipt
        out.append(item)
    return out