import asyncio
import os
import re
import time

import aiohttp

from fastapi import APIRouter, Depends, Query
from sqlalchemy.ext.asyncio import AsyncSession

from api.depends import get_session

from config import (
    BALANCE_BUTTON,
    CAPTCHA_ENABLE,
    CHANNEL_EXISTS,
    CHANNEL_REQUIRED,
    DONATIONS_ENABLE,
    GIFT_BUTTON,
    HAPP_CRYPTOLINK,
    HWID_RESET_BUTTON,
    INSTRUCTIONS_BUTTON,
    PROJECT_NAME,
    REFERRAL_BUTTON,
    REFERRAL_QR,
    REMNAWAVE_WEBAPP,
    REMNAWAVE_WEBAPP_OPEN_IN_BROWSER,
    TELEGRAM_WEBAPP_DIRECT_LINK,
    TELEGRAM_WEBAPP_SHORT_NAME,
    TOP_REFERRAL_BUTTON,
    TRIAL_TIME_DISABLE,
    USERNAME_BOT,
    USE_COUNTRY_SELECTION,
)
from core.bootstrap import BUTTONS_CONFIG, MODES_CONFIG, MONEY_CONFIG, PAYMENTS_CONFIG
from core.settings.money_config import get_currency_mode
from core.settings.web_config import WEB_CONFIG
from services.payments.providers import PROVIDERS_BASE, TELEGRAM_ONLY_PROVIDER_IDS, WEB_LINK_PROVIDER_IDS


router = APIRouter(tags=["Root"])


def _telegram_web_app_return_base() -> str | None:
    direct = str(TELEGRAM_WEBAPP_DIRECT_LINK or "").strip().rstrip("/")
    if direct:
        if direct.lower().startswith("http://"):
            direct = "https://" + direct[7:]
        if direct.lower().startswith("https://t.me/"):
            return direct
    bot = USERNAME_BOT.replace("@", "").strip()
    sn = str(TELEGRAM_WEBAPP_SHORT_NAME or "").strip()
    if bot and sn:
        return f"https://t.me/{bot}/{sn}"
    if bot:
        return f"https://t.me/{bot}"
    return None


def _partner_feature_enabled() -> bool:
    try:
        from modules.partner_program import settings as partner_settings
    except Exception:
        return False
    for key in ("PARTNER_PROGRAM_ENABLED", "PARTNER_BUTTON_ENABLED", "PARTNER_ENABLED"):
        value = getattr(partner_settings, key, None)
        if isinstance(value, bool):
            return value
    return True


@router.get("/api", include_in_schema=False)
async def root():
    return {"message": "SoloBot API v2", "docs": "/api/docs"}


@router.get("/api/version", include_in_schema=True)
async def version():
    return {"version": 2, "api": "v2"}


@router.get("/api/telegram-widget-bot", include_in_schema=True)
async def telegram_widget_bot():
    """Имя бота и имя проекта для веб-клиента."""
    bot_username = str(USERNAME_BOT or "").replace("@", "").strip()
    project_name = (PROJECT_NAME or "Solo").strip() if isinstance(PROJECT_NAME, str) else "Solo"
    telegram_client_id = ""
    try:
        from config import TELEGRAM_CLIENT_ID
        telegram_client_id = str(TELEGRAM_CLIENT_ID).strip()
    except ImportError:
        pass
    return {
        "bot_username": bot_username,
        "project_name": project_name,
        "telegram_client_id": telegram_client_id,
    }


@router.get("/api/site/init-state", include_in_schema=True)
async def site_init_state(session: AsyncSession = Depends(get_session)):
    """Прошёл ли сайт первую настройку админом. Используется middleware веб-клиента."""
    from database.site_state import is_site_initialized

    initialized = await is_site_initialized(session)
    return {"initialized": bool(initialized)}


@router.get("/api/site/revision", include_in_schema=True)
async def site_revision(session: AsyncSession = Depends(get_session)):
    """Глобальный счётчик ревизии контента. Фронт опрашивает его в фоне и при
    изменении инвалидирует свои SWR-кэши, подтягивая свежие правки админа."""
    from database.site_revision import get_site_revision

    revision = await get_site_revision(session)
    return {"revision": int(revision)}


@router.get("/api/site-config", include_in_schema=True)
async def site_config():
    """Настройки витрины и кабинета для веб-клиента (флаги из runtime-конфигов бота)."""
    bot_username = USERNAME_BOT.replace("@", "").strip()
    pay_flags = {name: bool(PAYMENTS_CONFIG.get(name)) for name in PROVIDERS_BASE}
    any_pay = any(pay_flags.values())
    web_link_provider_ids = [provider_id for provider_id in WEB_LINK_PROVIDER_IDS if pay_flags.get(provider_id, False)]
    telegram_only_provider_ids = [
        provider_id for provider_id in TELEGRAM_ONLY_PROVIDER_IDS if pay_flags.get(provider_id, False)
    ]
    currency_mode, currency_one_screen = get_currency_mode()
    try:
        cb_raw = MONEY_CONFIG.get("CASHBACK", 0)
        cashback_percent = float(cb_raw) if cb_raw not in (None, False) else 0.0
    except (TypeError, ValueError):
        cashback_percent = 0.0

    webapp_short = str(TELEGRAM_WEBAPP_SHORT_NAME or "").strip() or None
    webapp_return_base = _telegram_web_app_return_base()
    return {
        "bot_username": bot_username or None,
        "telegram_web_app_short_name": webapp_short,
        "telegram_web_app_return_base": webapp_return_base,
        "project_name": (PROJECT_NAME or "Solo").strip() if isinstance(PROJECT_NAME, str) else "Solo",
        "site_mode": str(WEB_CONFIG.get("SITE_MODE", "full")).strip() or "full",
        "auth": {
            "telegram_login_enabled": bool(bot_username),
            "email_code_login_enabled": bool(MODES_CONFIG.get("WEB_EMAIL_CODE_LOGIN_ENABLED", True)),
        },
        "mobile": {
            "prefer_mini_app_on_telegram_mobile": bool(MODES_CONFIG.get("PREFER_MINI_APP_ON_TELEGRAM_MOBILE", False)),
        },
        "features": {
            "channel_enabled": bool(BUTTONS_CONFIG.get("CHANNEL_BUTTON_ENABLE", CHANNEL_EXISTS)),
            "donations_enabled": bool(BUTTONS_CONFIG.get("DONATIONS_BUTTON_ENABLE", DONATIONS_ENABLE)),
            "balance_enabled": bool(BUTTONS_CONFIG.get("BALANCE_BUTTON_ENABLE", BALANCE_BUTTON)),
            "referral_qr_enabled": bool(BUTTONS_CONFIG.get("REFERRAL_QR_BUTTON_ENABLE", REFERRAL_QR)),
            "instructions_enabled": bool(BUTTONS_CONFIG.get("INSTRUCTIONS_BUTTON_ENABLE", INSTRUCTIONS_BUTTON)),
            "gift_enabled": bool(BUTTONS_CONFIG.get("GIFT_BUTTON_ENABLE", GIFT_BUTTON)),
            "referral_enabled": bool(BUTTONS_CONFIG.get("REFERRAL_BUTTON_ENABLED", REFERRAL_BUTTON)),
            "top_referral_enabled": bool(BUTTONS_CONFIG.get("TOP_REFERRAL_BUTTON_ENABLE", TOP_REFERRAL_BUTTON)),
            "coupon_enabled": bool(BUTTONS_CONFIG.get("COUPON_BUTTON_ENABLE", True)),
            "qr_subscription_enabled": bool(MODES_CONFIG.get("HAPP_CRYPTOLINK_ENABLED", HAPP_CRYPTOLINK)),
            "hwid_reset_enabled": bool(BUTTONS_CONFIG.get("HWID_RESET_BUTTON_ENABLE", HWID_RESET_BUTTON)),
            "country_selection_enabled": bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION)),
            "captcha_enabled": bool(MODES_CONFIG.get("CAPTCHA_ENABLED", CAPTCHA_ENABLE)),
            "channel_check_enabled": bool(MODES_CONFIG.get("CHANNEL_CHECK_ENABLED", CHANNEL_REQUIRED)),
            "trial_enabled": not bool(MODES_CONFIG.get("TRIAL_TIME_DISABLED", TRIAL_TIME_DISABLE)),
            "mini_app_enabled": bool(MODES_CONFIG.get("REMNAWAVE_WEBAPP_ENABLED", REMNAWAVE_WEBAPP)),
            "mini_app_open_in_browser": bool(
                MODES_CONFIG.get("REMNAWAVE_WEBAPP_OPEN_IN_BROWSER", REMNAWAVE_WEBAPP_OPEN_IN_BROWSER)
            ),
            "partner_enabled": bool(_partner_feature_enabled()),
        },
        "payments": {
            "any_enabled": any_pay,
            "any_web_link_enabled": bool(web_link_provider_ids),
            "any_telegram_only_enabled": bool(telegram_only_provider_ids),
            "web_link_provider_ids": web_link_provider_ids,
            "telegram_only_provider_ids": telegram_only_provider_ids,
            "yookassa_enabled": pay_flags.get("YOOKASSA", False),
            "yoomoney_enabled": pay_flags.get("YOOMONEY", False),
            "robokassa_enabled": pay_flags.get("ROBOKASSA", False),
            "kassai_cards_enabled": pay_flags.get("KASSAI_CARDS", False),
            "kassai_sbp_enabled": pay_flags.get("KASSAI_SBP", False),
            "tribute_enabled": pay_flags.get("TRIBUTE", False),
            "heleket_enabled": pay_flags.get("HELEKET", False),
            "cryptobot_enabled": pay_flags.get("CRYPTOBOT", False),
            "freekassa_enabled": pay_flags.get("FREEKASSA", False),
            "stars_enabled": pay_flags.get("STARS", False),
        },
        "money": {
            "currency_mode": currency_mode,
            "currency_one_screen": currency_one_screen,
            "cashback_enabled": cashback_percent > 0,
            "cashback_percent": cashback_percent,
        },
    }


_UPDATE_CHECK_CACHE: dict[str, object] = {"fetched_at": 0.0, "data": None}
_UPDATE_CHECK_LOCK = asyncio.Lock()
_UPDATE_CHECK_TTL_SEC = 600
_SEMVER_RE = re.compile(
    r"^v?(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(?:-(?P<pre>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$"
)


def _parse_semver(tag: str) -> tuple[int, int, int, int, tuple[tuple[int, int | str], ...]] | None:
    """Returns a tuple comparable per semver spec.

    Release > prerelease (second-to-last slot: 1 for release, 0 for prerelease).
    Last slot — tuple of prerelease identifiers; numeric ids compare numerically,
    alphanumeric ids compare lexically, numeric < alphanumeric.
    """
    match = _SEMVER_RE.match(tag.strip())
    if not match:
        return None
    major = int(match.group("major"))
    minor = int(match.group("minor"))
    patch = int(match.group("patch"))
    pre_raw = match.group("pre")
    if not pre_raw:
        return (major, minor, patch, 1, ())
    identifiers: list[tuple[int, int | str]] = []
    for part in pre_raw.split("."):
        if part.isdigit():
            identifiers.append((0, int(part)))
        else:
            identifiers.append((1, part))
    return (major, minor, patch, 0, tuple(identifiers))


async def _fetch_ghcr_tags(image: str) -> list[str]:
    """Возвращает все теги образа в GHCR. Поддерживает paginate через Link header."""
    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=15)) as session:
        token_url = f"https://ghcr.io/token?scope=repository:{image}:pull"
        async with session.get(token_url) as token_resp:
            if token_resp.status != 200:
                return []
            token_data = await token_resp.json()
            token = str(token_data.get("token") or "").strip()
            if not token:
                return []
        headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
        all_tags: list[str] = []
        next_url: str | None = f"https://ghcr.io/v2/{image}/tags/list?n=1000"
        guard = 0
        while next_url and guard < 20:
            guard += 1
            async with session.get(next_url, headers=headers) as tags_resp:
                if tags_resp.status != 200:
                    break
                payload = await tags_resp.json()
                page_tags = payload.get("tags") or []
                if isinstance(page_tags, list):
                    all_tags.extend(str(t) for t in page_tags)
                link_header = tags_resp.headers.get("Link") or ""
            next_url = None
            for part in link_header.split(","):
                part = part.strip()
                if not part or 'rel="next"' not in part:
                    continue
                inner = part.split(";", 1)[0].strip()
                if inner.startswith("<") and inner.endswith(">"):
                    inner = inner[1:-1]
                if inner.startswith("/"):
                    next_url = f"https://ghcr.io{inner}"
                else:
                    next_url = inner
                break
        return all_tags


def _is_dev_version(v: str) -> bool:
    return "-dev" in v or "dev." in v


def _latest_for_channel(tags: list[str], dev: bool) -> str | None:
    versions = []
    for raw in tags:
        parsed = _parse_semver(str(raw))
        if parsed is None:
            continue
        is_dev = _is_dev_version(str(raw))
        if is_dev == dev:
            versions.append((parsed, str(raw)))
    if not versions:
        return None
    versions.sort(key=lambda item: item[0], reverse=True)
    return versions[0][1]


@router.get("/api/meta/update-check", include_in_schema=True)
async def update_check(current: str | None = Query(default=None)):
    """Сравнивает переданную версию с последним тегом в GHCR. Канал (dev/release) определяется по current."""
    current_v = (current or "").strip()
    image = (os.environ.get("GHCR_IMAGE") or "vladless/solo-brick").strip()
    if not image:
        return {"current": current_v or None, "latest": None, "hasUpdate": False}

    now = time.time()
    is_dev = _is_dev_version(current_v) if current_v else True
    cache_key = f"data-{'dev' if is_dev else 'release'}"

    cached = _UPDATE_CHECK_CACHE.get(cache_key)
    fetched_at = float(_UPDATE_CHECK_CACHE.get("fetched_at") or 0.0)
    if cached is not None and now - fetched_at < _UPDATE_CHECK_TTL_SEC:
        cached_resp = dict(cached)
        cached_resp["current"] = current_v or None
        if current_v:
            cur = _parse_semver(current_v)
            nxt = _parse_semver(str(cached_resp.get("latest") or ""))
            cached_resp["hasUpdate"] = bool(cur and nxt and nxt > cur)
        return cached_resp

    latest: str | None = None
    async with _UPDATE_CHECK_LOCK:
        fetched_at = float(_UPDATE_CHECK_CACHE.get("fetched_at") or 0.0)
        if now - fetched_at < _UPDATE_CHECK_TTL_SEC:
            cached = _UPDATE_CHECK_CACHE.get(cache_key)
            if cached is not None:
                cached_resp = dict(cached)
                cached_resp["current"] = current_v or None
                if current_v:
                    cur = _parse_semver(current_v)
                    nxt = _parse_semver(str(cached_resp.get("latest") or ""))
                    cached_resp["hasUpdate"] = bool(cur and nxt and nxt > cur)
                return cached_resp
        try:
            tags = await _fetch_ghcr_tags(image)
            latest_dev = _latest_for_channel(tags, dev=True)
            latest_rel = _latest_for_channel(tags, dev=False)
            _UPDATE_CHECK_CACHE["data-dev"] = {"latest": latest_dev, "hasUpdate": False, "image": image}
            _UPDATE_CHECK_CACHE["data-release"] = {"latest": latest_rel, "hasUpdate": False, "image": image}
            _UPDATE_CHECK_CACHE["fetched_at"] = now
            latest = latest_dev if is_dev else latest_rel
        except Exception:
            latest = None

    has_update = False
    if current_v and latest:
        cur = _parse_semver(current_v)
        nxt = _parse_semver(latest)
        if cur and nxt:
            has_update = nxt > cur

    return {
        "current": current_v or None,
        "latest": latest,
        "hasUpdate": has_update,
        "image": image or None,
        "channel": "dev" if is_dev else "release",
        "checkedAt": int(now),
    }