# -*- coding: utf-8 -*-
"""Telegram getUpdates long polling 与回调/文本消息分发。

回调按钮处理候选「入库 / 忽略 / 拉黑」；私聊文本消息按视频链接、BV 号或 av 号
手动入库。两类操作都只写本地库，不写 B 站收藏夹。
"""

from __future__ import annotations

import time
from typing import Any, Mapping

from ..notify.telegram import HELP_TEXT, format_ingest_result, format_manual_reply


class TelegramPoller:
    def __init__(self, bot, actions, *, logger=None, sleeper=time.sleep) -> None:
        self.bot = bot
        self.actions = actions
        self.logger = logger
        self._sleep = sleeper

    def _log(self, level: str, event: str, **fields) -> None:
        if self.logger is not None:
            getattr(self.logger, level)(event, **fields)

    def run_once(self, offset: int | None = None) -> int | None:
        updates = self.bot.get_updates(offset)
        for update in updates:
            update_id = update.get("update_id")
            if isinstance(update_id, int) and not isinstance(update_id, bool):
                offset = max(offset or 0, update_id + 1)
            callback = update.get("callback_query")
            if isinstance(callback, Mapping):
                self.handle_callback(callback)
                continue
            message = update.get("message")
            if isinstance(message, Mapping):
                self.handle_message(message)
        return offset

    def _authorized(self, chat_id, from_id) -> bool:
        return chat_id == self.bot.chat_id and from_id == self.bot.chat_id

    def handle_callback(self, callback: Mapping[str, Any]) -> None:
        callback_id = str(callback.get("id") or "")
        message = callback.get("message") or {}
        chat_id = (message.get("chat") or {}).get("id")
        from_id = (callback.get("from") or {}).get("id")
        if not self._authorized(chat_id, from_id):
            self._log(
                "warning", "telegram.unauthorized",
                chat_id=chat_id, from_id=from_id,
            )
            self._answer(callback_id, "无权限")
            return

        action, _, raw_aid = str(callback.get("data") or "").partition(":")
        try:
            aid = int(raw_aid)
        except (TypeError, ValueError):
            self._answer(callback_id, "未知操作")
            return

        if action in ("add", "fav"):
            # fav 为旧按钮回调，兼容已发出的历史消息。
            result = self.actions.ingest_candidate(aid)
        elif action == "ign":
            result = self.actions.ignore(aid)
        elif action == "blk":
            result = self.actions.blacklist(aid)
        else:
            self._answer(callback_id, "未知操作")
            return

        text = format_ingest_result(result)
        self._log(
            "info", "telegram.action",
            action=action, aid=aid, ok=result.ok, state=result.state,
        )
        if not self._answer(callback_id, text):
            # 回调 ID 过期时 answerCallbackQuery 会 400；改用普通消息告知结果。
            try:
                self.bot.send_text(text)
            except Exception as exc:  # noqa: BLE001
                self._log("warning", "telegram.fallback_failed", error=str(exc))
        message_id = message.get("message_id")
        if isinstance(message_id, int) and not isinstance(message_id, bool):
            try:
                self.bot.edit_reply_markup(message_id)
            except Exception as exc:  # noqa: BLE001
                self._log("warning", "telegram.edit_failed", error=str(exc))

    def handle_message(self, message: Mapping[str, Any]) -> None:
        chat_id = (message.get("chat") or {}).get("id")
        from_id = (message.get("from") or {}).get("id")
        if not self._authorized(chat_id, from_id):
            self._log(
                "warning", "telegram.unauthorized_message",
                chat_id=chat_id, from_id=from_id,
            )
            return
        text = message.get("text")
        if not isinstance(text, str) or not text.strip():
            return
        text = text.strip()
        if text.startswith("/start") or text.startswith("/help"):
            self._reply(HELP_TEXT)
            return
        try:
            result = self.actions.ingest_text(text)
        except Exception as exc:  # noqa: BLE001  单条消息失败不影响长轮询
            self._log("error", "telegram.ingest_error", error=str(exc))
            self._reply(f"入库失败：{exc}")
            return
        self._log(
            "info", "telegram.manual_ingest",
            refs=result.refs, added=result.added,
        )
        self._reply(format_manual_reply(result))

    def _reply(self, text: str) -> None:
        try:
            self.bot.send_text(text)
        except Exception as exc:  # noqa: BLE001
            self._log("warning", "telegram.reply_failed", error=str(exc))

    def _answer(self, callback_id: str, text: str) -> bool:
        try:
            self.bot.answer_callback(callback_id, text)
            return True
        except Exception as exc:  # noqa: BLE001  过期回调不应升级为错误
            self._log("warning", "telegram.answer_failed", error=str(exc))
            return False

    def run_forever(
        self,
        stop_event=None,
        *,
        initial_delay: float = 3.0,
        max_delay: float = 60.0,
        max_iterations: int | None = None,
    ) -> None:
        offset: int | None = None
        failures = 0
        delay = initial_delay
        iterations = 0
        while stop_event is None or not stop_event.is_set():
            try:
                offset = self.run_once(offset)
            except Exception as exc:  # noqa: BLE001  长轮询瞬时断连后退避重试
                failures += 1
                level = "error" if failures >= 5 else "warning"
                self._log(
                    level, "telegram.poll_failed",
                    error=str(exc), failures=failures, retry_in=delay,
                )
                if stop_event is not None:
                    if stop_event.wait(delay):
                        break
                else:
                    self._sleep(delay)
                delay = min(delay * 2, max_delay)
            else:
                if failures:
                    self._log(
                        "info", "telegram.poll_recovered", failures=failures
                    )
                failures = 0
                delay = initial_delay
            iterations += 1
            if max_iterations is not None and iterations >= max_iterations:
                break