import hashlib
import hmac
import uuid
from typing import Any, Optional
import httpx
from core.config import get_settings
from core.exceptions import PaymentError
from core.logging import get_logger
from infrastructure.payments.gateways.base import PaymentGateway

logger = get_logger(__name__)


class RazorpayGateway(PaymentGateway):
    """
    Razorpay payment gateway implementation.
    Supports Order creation, payment signature verification, webhook HMAC verification, and refunds.
    """

    def __init__(
        self,
        key_id: Optional[str] = None,
        key_secret: Optional[str] = None,
        webhook_secret: Optional[str] = None,
    ):
        settings = get_settings()
        self.key_id = key_id or settings.RAZORPAY_KEY_ID or "rzp_test_mock_key_id"
        self.key_secret = key_secret or settings.RAZORPAY_KEY_SECRET or "rzp_test_mock_secret"
        self.webhook_secret = webhook_secret or settings.RAZORPAY_WEBHOOK_SECRET or "rzp_test_webhook_secret"
        self.base_url = "https://api.razorpay.com/v1"

    async def create_order(
        self,
        amount: int,
        currency: str,
        receipt: str,
        notes: dict[str, Any],
        idempotency_key: Optional[str] = None,
    ) -> dict[str, Any]:
        """
        Creates a Razorpay Order.
        If using mock/test placeholder credentials, returns simulated order without external network call.
        """
        if self.key_id.startswith("rzp_test_placeholder") or self.key_id.startswith("rzp_test_mock"):
            mock_order_id = f"order_{uuid.uuid4().hex[:14]}"
            return {
                "id": mock_order_id,
                "entity": "order",
                "amount": amount,
                "amount_paid": 0,
                "amount_due": amount,
                "currency": currency.upper(),
                "receipt": receipt,
                "status": "created",
                "attempts": 0,
                "notes": notes,
                "key_id": self.key_id,
            }

        headers = {}
        if idempotency_key:
            headers["X-Razorpay-Idempotency-Key"] = idempotency_key

        payload = {
            "amount": amount,
            "currency": currency.upper(),
            "receipt": receipt,
            "notes": notes,
        }

        async with httpx.AsyncClient(auth=(self.key_id, self.key_secret), timeout=15.0) as client:
            try:
                resp = await client.post(f"{self.base_url}/orders", json=payload, headers=headers)
                if resp.status_code != 200:
                    logger.error("razorpay_order_create_failed", status_code=resp.status_code, body=resp.text)
                    raise PaymentError(f"Razorpay order creation failed: {resp.text}")
                data = resp.json()
                data["key_id"] = self.key_id
                return data
            except httpx.RequestError as exc:
                logger.error("razorpay_network_error", error=str(exc))
                raise PaymentError(f"Network error connecting to Razorpay: {exc}")

    def verify_payment_signature(
        self,
        order_id: str,
        payment_id: str,
        signature: str,
    ) -> bool:
        """
        Cryptographically verifies the payment signature returned by the client.
        Formula: HMAC-SHA256(order_id + "|" + payment_id, key_secret) == signature
        """
        if not order_id or not payment_id or not signature:
            return False

        message = f"{order_id}|{payment_id}".encode("utf-8")
        generated_signature = hmac.new(
            self.key_secret.encode("utf-8"),
            message,
            hashlib.sha256,
        ).hexdigest()

        return hmac.compare_digest(generated_signature, signature)

    def verify_webhook_signature(
        self,
        payload: bytes,
        signature: str,
        headers: Optional[dict[str, str]] = None,
    ) -> bool:
        """
        Verifies incoming Razorpay webhook payload signature from 'X-Razorpay-Signature'.
        Formula: HMAC-SHA256(raw_payload_bytes, webhook_secret) == signature
        """
        if not payload or not signature:
            return False

        generated_signature = hmac.new(
            self.webhook_secret.encode("utf-8"),
            payload,
            hashlib.sha256,
        ).hexdigest()

        return hmac.compare_digest(generated_signature, signature)

    async def create_refund(
        self,
        payment_id: str,
        amount: int,
        currency: str,
        reason: str,
    ) -> dict[str, Any]:
        """
        Issues a refund against a captured payment.
        """
        if self.key_id.startswith("rzp_test_placeholder") or self.key_id.startswith("rzp_test_mock"):
            return {
                "id": f"rfnd_{uuid.uuid4().hex[:14]}",
                "entity": "refund",
                "amount": amount,
                "currency": currency.upper(),
                "payment_id": payment_id,
                "status": "processed",
                "notes": {"reason": reason},
            }

        payload = {
            "amount": amount,
            "reverse_all": False,
            "notes": {"reason": reason},
        }

        async with httpx.AsyncClient(auth=(self.key_id, self.key_secret), timeout=15.0) as client:
            try:
                resp = await client.post(f"{self.base_url}/payments/{payment_id}/refund", json=payload)
                if resp.status_code != 200:
                    logger.error("razorpay_refund_failed", status_code=resp.status_code, body=resp.text)
                    raise PaymentError(f"Razorpay refund failed: {resp.text}")
                return resp.json()
            except httpx.RequestError as exc:
                logger.error("razorpay_refund_network_error", error=str(exc))
                raise PaymentError(f"Network error processing refund: {exc}")
