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


class GenericWebhookChannelAdapter(BaseChannelAdapter):
    """
    Channel adapter for Generic Webhooks (Enterprise systems, Zapier, Make, Slack incoming webhooks).
    Features HMAC-SHA256 request signing and generic payload normalization.
    """

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

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

    async def send_message(self, request: ChannelMessageRequest) -> ChannelMessageResult:
        try:
            target_url = request.recipient_id
            payload = {
                "text": request.text,
                "buttons": [
                    [{"text": b.text, "type": b.action_type, "value": b.value} for b in row]
                    for row in request.buttons
                ],
                "extra": request.extra_metadata,
                "timestamp": datetime.now(timezone.utc).isoformat(),
            }

            headers = {
                "Content-Type": "application/json",
                "User-Agent": "Astraea-Universal-Bot-Cloud/1.0",
            }

            secret = request.extra_metadata.get("webhook_secret") or self.secret
            if secret:
                import json
                body_bytes = json.dumps(payload, separators=(",", ":")).encode("utf-8")
                sig = hmac.new(secret.encode("utf-8"), body_bytes, hashlib.sha256).hexdigest()
                headers["X-Hub-Signature-256"] = f"sha256={sig}"

            async with httpx.AsyncClient(timeout=10.0) as client:
                resp = await client.post(target_url, json=payload, headers=headers)
                success = 200 <= resp.status_code < 300
                return ChannelMessageResult(
                    success=success,
                    channel=self.channel_type,
                    message_id=f"wh_{resp.status_code}",
                    delivered_at=datetime.now(timezone.utc).isoformat(),
                    raw_response={"status_code": resp.status_code, "body": resp.text[:500]},
                    error_message=None if success else f"Webhook delivery returned HTTP {resp.status_code}",
                )

        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:
        """
        Verifies HMAC-SHA256 signature from 'X-Hub-Signature-256' or 'X-Signature-256'.
        """
        sig_header = (
            headers.get("x-hub-signature-256")
            or headers.get("X-Hub-Signature-256")
            or headers.get("x-signature-256")
            or ""
        )
        if not sig_header or not secret:
            return False

        sig = sig_header.removeprefix("sha256=").strip()
        expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest()
        return hmac.compare_digest(sig, expected)

    async def normalize_incoming_event(self, raw_payload: dict[str, Any]) -> dict[str, Any]:
        """
        Normalizes arbitrary inbound webhook payload into platform event structure.
        """
        text = (
            raw_payload.get("text")
            or raw_payload.get("message")
            or raw_payload.get("content")
            or raw_payload.get("prompt")
            or ""
        )
        sender_id = (
            raw_payload.get("user_id")
            or raw_payload.get("sender_id")
            or raw_payload.get("email")
            or "external_client"
        )
        return {
            "event_type": raw_payload.get("event") or "webhook_event",
            "channel": ChannelType.WEBHOOK.value,
            "sender_id": str(sender_id),
            "sender_name": raw_payload.get("user_name") or raw_payload.get("sender_name") or str(sender_id),
            "chat_id": raw_payload.get("chat_id") or raw_payload.get("channel_id") or "webhook_channel",
            "text": str(text),
            "data": raw_payload.get("data") or raw_payload,
            "timestamp": raw_payload.get("timestamp") or datetime.now(timezone.utc).isoformat(),
        }
