"""Danbooru API 的共享客户端:限速、退避、以及「抓不到就报错」。

两个同步脚本原本各写了一套重试,各自带着不同的 bug:update_wiki 把 429 当成普通
错误按 2**attempt 干等,update_danbooru 重试三次之后直接 break —— 那一页 200 条
投稿就永远不在存档里了,而且不打印任何东西。存档缺一页在成品里看不出来,只能靠
下次全量刷新撞上。合并到这里,顺便让缺页变成硬错误。
"""

import random
import threading
import time
from typing import Any

import requests

# Danbooru 拒绝默认的 python-requests User-Agent(返回 403),必须带描述性 UA
HEADERS = {
    "User-Agent": "danbooru-metadata/1.0 (https://github.com/Jannchie/danbooru_metadata)",
}

# Danbooru 文档写的上限是 10 req/s。贴着上限跑意味着任何抖动都会撞 429,所以起步
# 定在 5 —— 慢一倍,但不会陷入「429 -> 退避 -> 再撞」的循环,实测反而更快。
DEFAULT_RATE = 5.0
MIN_RATE = 0.5
MAX_RETRIES = 6


class RateLimiter:
    """跨线程共享的发牌器,撞到 429 会自动降速。

    限速是按账号算的,不是按连接:16 个 worker 各自限速等于超发 16 倍。所以间隔必须
    在一个共享的锁里推进,而不是每个线程各睡各的。

    降速用 AIMD(撞墙就减半,顺利就慢慢加回来),因为 Danbooru 的实际配额随时段和
    认证状态变化,写死一个数字迟早会错。让它自己收敛到当下能跑的速度。
    """

    def __init__(self, rate: float = DEFAULT_RATE) -> None:
        self._ceiling = 1.0 / rate
        self._interval = 1.0 / rate
        self._lock = threading.Lock()
        self._next = 0.0

    def acquire(self) -> None:
        with self._lock:
            now = time.monotonic()
            wait = self._next - now
            self._next = max(now, self._next) + self._interval
        if wait > 0:
            time.sleep(wait)

    def penalise(self, pause: float) -> None:
        """撞到 429:所有 worker 一起停 pause 秒,并把稳态速率减半。

        惩罚必须是全局的。只让倒霉的那个线程睡觉,其余 15 个会立刻把配额再耗光,
        于是每个线程轮流挨罚,总速率一点没降。
        """
        with self._lock:
            self._interval = min(self._interval * 2, 1.0 / MIN_RATE)
            self._next = max(self._next, time.monotonic() + pause)

    def reward(self) -> None:
        """连续成功时把间隔慢慢收回上限,免得一次偶发 429 让后面几小时都慢一半。"""
        with self._lock:
            if self._interval > self._ceiling:
                self._interval = max(self._ceiling, self._interval * 0.99)

    @property
    def rate(self) -> float:
        return 1.0 / self._interval


MAX_BACKOFF = 60.0


def backoff(attempt: int) -> float:
    """指数退避 + 抖动,封顶 MAX_BACKOFF。

    抖动是必须的:多个 worker 同时挨 429 会算出同一个延迟,不打散就会在同一毫秒
    一起重试,复现刚才那次超发。

    先抖动再封顶。反过来写(先 min 再乘抖动)会让上限变成 1.5 倍 —— 封顶 60 秒的
    退避实际能睡 90 秒。
    """
    return min(2**attempt * (0.5 + random.random()), MAX_BACKOFF)


def retry_after(response: requests.Response, attempt: int) -> float:
    """服务端说等多久就等多久,没说才自己猜。"""
    header = response.headers.get("Retry-After")
    if header:
        try:
            return float(header)
        except ValueError:
            # Retry-After 也允许是 HTTP 日期。解析它不值得,退避猜一个就够了。
            pass
    return backoff(attempt)


def get_json(
    session: requests.Session,
    url: str,
    params: dict[str, Any] | None = None,
    limiter: RateLimiter | None = None,
    timeout: int = 60,
) -> list[dict[str, Any]]:
    """取回一页 JSON 列表,失败到底就抛异常 —— 绝不返回空列表冒充「这页没有数据」。

    空列表是同步循环的终止信号。一次失败的请求返回 [] 会让调用方以为抓完了,于是
    静默地少存几百万条。
    """
    last_error = ""
    for attempt in range(MAX_RETRIES):
        if limiter:
            limiter.acquire()
        try:
            response = session.get(url, params=params, headers=HEADERS, timeout=timeout)
            if response.status_code == 200:
                payload = response.json()
                if isinstance(payload, list):
                    if limiter:
                        limiter.reward()
                    return payload
                # Danbooru 用 200 + {"success": false} 回报某些错误,不能当成数据。
                last_error = f"unexpected payload: {str(payload)[:200]}"
            elif response.status_code == 429:
                pause = retry_after(response, attempt)
                if limiter:
                    limiter.penalise(pause)
                    last_error = f"429, backing off {pause:.1f}s (now {limiter.rate:.1f} req/s)"
                else:
                    time.sleep(pause)
                    last_error = f"429, waited {pause:.1f}s"
                continue
            elif 400 <= response.status_code < 500:
                # 认证/参数错误重试无意义,而且会把 429 之外的问题拖成几分钟的假死。
                raise RuntimeError(f"{url} returned {response.status_code}: {response.text[:200]}")
            else:
                last_error = f"status {response.status_code}"
        except requests.RequestException as exc:
            last_error = str(exc)
        if attempt < MAX_RETRIES - 1:
            time.sleep(backoff(attempt))
    raise RuntimeError(f"{url} failed after {MAX_RETRIES} attempts: {last_error}")