"""Web Panel kirish tokenlari.

Avval havola HMAC(BOT_TOKEN, uid) bilan imzolanar edi - u hech qachon eskirmas,
bekor qilib bo'lmas va token sizib chiqsa soxtalashtirilishi mumkin edi.

Endi:
  - Alohida maxfiy kalit (WEBAPP_SECRET yoki bazada avtomatik yaratilgan).
  - Token muddatli: "<uid>.<tugash_vaqti>.<imzo>" (standart 72 soat).
  - /panel_reset buyrug'i barcha eski havolalarni darhol bekor qiladi.
  - Token API so'rovlarida URL'da emas, sarlavhada (X-Auth) yuboriladi.
"""
import hashlib
import hmac
import json
import secrets
import time
from urllib.parse import parse_qsl

import config
import database

_secret_cache = None


def _secret() -> bytes:
    global _secret_cache
    if config.WEBAPP_SECRET:
        return config.WEBAPP_SECRET.encode()
    if _secret_cache is None:
        _secret_cache = database.get_or_create_secret("webapp_secret")
    return _secret_cache.encode()


def _version() -> str:
    return database.get_setting("webapp_token_version", "1")


def _sign(uid: int, exp: int, ver: str) -> str:
    return hmac.new(_secret(), f"{uid}.{exp}.{ver}".encode(), hashlib.sha256).hexdigest()[:40]


def make_token(uid: int, ttl_hours: int | None = None, now: float | None = None) -> str:
    ttl = (ttl_hours if ttl_hours is not None else config.WEBAPP_LINK_TTL_HOURS) * 3600
    exp = int((now or time.time()) + ttl)
    return f"{uid}.{exp}.{_sign(uid, exp, _version())}"


def verify_token(token: str, now: float | None = None) -> int | None:
    """To'g'ri va muddati o'tmagan bo'lsa admin uid, aks holda None."""
    try:
        uid_s, exp_s, sig = (token or "").split(".")
        uid, exp = int(uid_s), int(exp_s)
    except ValueError:
        return None
    if exp < (now or time.time()):
        return None
    if not hmac.compare_digest(_sign(uid, exp, _version()), sig):
        return None
    return uid if uid in config.ADMIN_IDS else None


def revoke_all() -> str:
    """Barcha chiqarilgan havolalarni va web sayt sessiyalarini bekor qiladi."""
    new = str(int(_version()) + 1)
    database.set_setting("webapp_token_version", new)
    with database.get_db() as conn:
        conn.execute("DELETE FROM sessions")
        conn.execute("DELETE FROM login_tokens")
    return new


# ================= WEB SAYT: BIR MARTALIK HAVOLA VA SESSIYA =================
LOGIN_TTL_SECONDS = 10 * 60
SESSION_TTL_SECONDS = 30 * 24 * 3600
SESSION_COOKIE = "kk_session"


def _h(raw: str) -> str:
    return hashlib.sha256(raw.encode()).hexdigest()


def create_login_token(admin_id: int, now: float | None = None) -> str:
    """Botdagi /login uchun 10 daqiqalik, BIR MARTALIK kirish tokeni."""
    raw = secrets.token_urlsafe(32)
    now = int(now or time.time())
    with database.get_db() as conn:
        conn.execute("DELETE FROM login_tokens WHERE expires_at < ?", (now,))
        conn.execute("INSERT INTO login_tokens (token_hash, admin_id, expires_at, used) VALUES (?, ?, ?, 0)",
                     (_h(raw), admin_id, now + LOGIN_TTL_SECONDS))
    return raw


def peek_login_token(raw: str, now: float | None = None) -> int | None:
    """Tokenni ishlatmasdan tekshiradi (tasdiqlash sahifasi uchun)."""
    with database.get_db() as conn:
        r = conn.execute("SELECT admin_id, expires_at, used FROM login_tokens WHERE token_hash = ?",
                         (_h(raw or ""),)).fetchone()
    if not r or r[2] or r[1] < (now or time.time()) or r[0] not in config.ADMIN_IDS:
        return None
    return r[0]


def consume_login_token(raw: str, now: float | None = None) -> int | None:
    now = int(now or time.time())
    with database.get_db() as conn:
        cur = conn.execute("UPDATE login_tokens SET used = 1 WHERE token_hash = ? AND used = 0 AND expires_at >= ?",
                           (_h(raw or ""), now))
        if cur.rowcount != 1:
            return None
        admin_id = conn.execute("SELECT admin_id FROM login_tokens WHERE token_hash = ?", (_h(raw),)).fetchone()[0]
    return admin_id if admin_id in config.ADMIN_IDS else None


def create_session(admin_id: int, user_agent: str = "", now: float | None = None) -> str:
    """Yangi brauzer sessiyasi. Cookie'ga yoziladigan maxfiy identifikatorni qaytaradi."""
    sid = secrets.token_urlsafe(32)
    now = int(now or time.time())
    with database.get_db() as conn:
        conn.execute("DELETE FROM sessions WHERE expires_at < ?", (now,))
        conn.execute("INSERT INTO sessions (sid_hash, admin_id, csrf, created_at, expires_at, last_seen, user_agent) "
                     "VALUES (?, ?, ?, ?, ?, ?, ?)",
                     (_h(sid), admin_id, secrets.token_urlsafe(24), now, now + SESSION_TTL_SECONDS, now,
                      (user_agent or "")[:200]))
    return sid


def get_session(sid: str, now: float | None = None):
    """(admin_id, csrf) yoki None. Har foydalanishda muddat 30 kunga uzayadi."""
    if not sid:
        return None
    now = int(now or time.time())
    with database.get_db() as conn:
        r = conn.execute("SELECT admin_id, csrf, expires_at, last_seen FROM sessions WHERE sid_hash = ?",
                         (_h(sid),)).fetchone()
        if not r or r[2] < now or r[0] not in config.ADMIN_IDS:
            return None
        if now - (r[3] or 0) > 3600:
            conn.execute("UPDATE sessions SET last_seen = ?, expires_at = ? WHERE sid_hash = ?",
                         (now, now + SESSION_TTL_SECONDS, _h(sid)))
    return r[0], r[1]


def delete_session(sid: str):
    with database.get_db() as conn:
        conn.execute("DELETE FROM sessions WHERE sid_hash = ?", (_h(sid or ""),))


def site_login_url(raw_token: str) -> str:
    return f"{config.WEBAPP_URL.rstrip('/')}/login/{raw_token}" if config.WEBAPP_URL else ""


def webapp_url_for(uid: int) -> str:
    if not config.WEBAPP_URL:
        return ""
    return f"{config.WEBAPP_URL.rstrip('/')}/a/{make_token(uid)}"


def validate_init_data(init_data: str, max_age_seconds: int = 86400):
    """Telegram WebApp initData (zaxira usul). Eskirgan (24 soatdan ortiq) rad etiladi."""
    if not init_data or not config.BOT_TOKEN:
        return None
    try:
        parsed = dict(parse_qsl(init_data, strict_parsing=True))
    except ValueError:
        return None
    received = parsed.pop("hash", None)
    if not received:
        return None
    dcs = "\n".join(f"{k}={v}" for k, v in sorted(parsed.items()))
    secret = hmac.new(b"WebAppData", config.BOT_TOKEN.encode(), hashlib.sha256).digest()
    if not hmac.compare_digest(hmac.new(secret, dcs.encode(), hashlib.sha256).hexdigest(), received):
        return None
    try:
        if time.time() - int(parsed.get("auth_date", "0")) > max_age_seconds:
            return None
        return json.loads(parsed.get("user") or "null")
    except (ValueError, TypeError):
        return None
