import hmac
import hashlib
from typing import Any, Optional
from datetime import datetime, timezone
from infrastructure.telegram.service import TelegramApiService
from modules.channels.base import (
    BaseChannelAdapter,
    ChannelType,
    ChannelMessageRequest,
    ChannelMessageResult,
)


class TelegramChannelAdapter(BaseChannelAdapter):
    """
    Channel adapter for Telegram Bot API.
    Handles message dispatch, inline button matrices, and webhook event normalization.
    """

    def __init__(self, bot_token: Optional[str] = None):
        self.bot_token = bot_token

    @property
    def channel_type(self) -> ChannelType:
        return ChannelType.TELEGRAM

    async def send_message(self, request: ChannelMessageRequest) -> ChannelMessageResult:
        try:
            token = request.extra_metadata.get("bot_token") or self.bot_token
            if not token:
                return ChannelMessageResult(
                    success=False,
                    channel=self.channel_type,
                    error_message="Missing Telegram bot token in request metadata or adapter initialization.",
                )

            reply_markup = None
            if request.buttons:
                inline_keyboard = []
                for row in request.buttons:
                    btn_row = []
                    for b in row:
                        if b.action_type == "url":
                            btn_row.append({"text": b.text, "url": b.value})
                        else:
                            btn_row.append({"text": b.text, "callback_data": b.value})
                    inline_keyboard.append(btn_row)
                reply_markup = {"inline_keyboard": inline_keyboard}

            res = await TelegramApiService.send_message_with_retry(
                raw_token=token,
                chat_id=request.recipient_id,
                text=request.text,
                parse_mode=request.parse_mode,
                reply_markup=reply_markup,
            )

            msg_id = str(res.get("result", {}).get("message_id", "msg_simulated"))
            return ChannelMessageResult(
                success=True,
                channel=self.channel_type,
                message_id=msg_id,
                delivered_at=datetime.now(timezone.utc).isoformat(),
                raw_response=res,
            )
        except Exception as e:
            return ChannelMessageResult(
                success=False,
                channel=self.channel_type,
                error_message=str(e),
            )

    async def verify_webhook_signature(
        self, headers: dict[str, str], body: bytes, secret: str
    ) -> bool:
        """
        Telegram delivers an X-Telegram-Bot-Api-Secret-Token header.
        We perform a constant-time comparison against the tenant secret.
        """
        received_header = headers.get("x-telegram-bot-api-secret-token") or headers.get("X-Telegram-Bot-Api-Secret-Token", "")
        if not received_header or not secret:
            return False
        return hmac.compare_digest(received_header.strip(), secret.strip())

    async def normalize_incoming_event(self, raw_payload: dict[str, Any]) -> dict[str, Any]:
        """
        Normalizes Telegram Update object into standard dictionary:
        {
            "event_type": "message" | "callback_query",
            "channel": "telegram",
            "sender_id": str,
            "sender_name": str,
            "text": str,
            "callback_data": str,
            "chat_id": str
        }
        """
        if "message" in raw_payload:
            msg = raw_payload["message"]
            from_user = msg.get("from", {})
            return {
                "event_type": "message",
                "channel": ChannelType.TELEGRAM.value,
                "update_id": raw_payload.get("update_id"),
                "sender_id": str(from_user.get("id", "")),
                "sender_name": f"{from_user.get('first_name', '')} {from_user.get('last_name', '')}".strip() or from_user.get("username", ""),
                "username": from_user.get("username"),
                "chat_id": str(msg.get("chat", {}).get("id", "")),
                "text": msg.get("text", ""),
                "timestamp": msg.get("date"),
            }
        elif "callback_query" in raw_payload:
            cb = raw_payload["callback_query"]
            from_user = cb.get("from", {})
            msg = cb.get("message", {})
            return {
                "event_type": "callback_query",
                "channel": ChannelType.TELEGRAM.value,
                "update_id": raw_payload.get("update_id"),
                "sender_id": str(from_user.get("id", "")),
                "sender_name": f"{from_user.get('first_name', '')} {from_user.get('last_name', '')}".strip(),
                "username": from_user.get("username"),
                "chat_id": str(msg.get("chat", {}).get("id", "")),
                "text": msg.get("text", ""),
                "callback_data": cb.get("data", ""),
                "callback_query_id": cb.get("id"),
            }
        return {
            "event_type": "unknown",
            "channel": ChannelType.TELEGRAM.value,
            "raw": raw_payload,
        }
