import urllib.parse
import urllib.request
import json
import time
import re
from typing import Optional, Dict, Any

class LightningInvoiceBot:
    def __init__(self, lightning_address: str, amount_msat: int, comment: str = ""):
        """
        Initialize the bot with a Lightning Address, amount in msat, and optional comment.

        :param lightning_address: Lightning Address (e.g., `user@domain.com`)
        :param amount_msat: Amount to invoice in millisatoshis
        :param comment: Optional comment for the invoice
        """
        self._validate_lightning_address(lightning_address)
        self._validate_amount(amount_msat)
        self.lightning_address = lightning_address
        self.amount_msat = amount_msat
        self.comment = comment
        self.lnurlp_url = self._get_lnurlp_url()
        self.invoice: Optional[str] = None
        self.payment_status: Optional[bool] = None

    def _validate_lightning_address(self, address: str) -> None:
        """Validate the Lightning Address format."""
        pattern = r"^[\w\.=-]+@[\w\.-]+\.\w+$"
        if not re.match(pattern, address):
            raise ValueError("Invalid Lightning Address format. Expected: username@domain")

    def _validate_amount(self, amount: int) -> None:
        """Validate the amount is a positive integer."""
        if not isinstance(amount, int) or amount <= 0:
            raise ValueError("Amount must be a positive integer in millisatoshis")

    def _get_lnurlp_url(self) -> str:
        """Generate the LNURL-pay URL from the Lightning Address."""
        username, domain = self.lightning_address.split("@")
        return f"https://{domain}/.well-known/lnurlp/{username}"

    def _fetch_url(self, url: str) -> Dict[str, Any]:
        """Fetch URL with SSL verification and JSON parsing."""
        try:
            with urllib.request.urlopen(url) as response:
                return json.loads(response.read())
        except urllib.error.URLError as e:
            raise Exception(f"Failed to fetch URL: {e}")
        except json.JSONDecodeError as e:
            raise Exception(f"Invalid JSON response: {e}")

    def _fetch_lnurlp(self) -> Dict[str, Any]:
        """Fetch LNURL-pay metadata and callback URL."""
        return self._fetch_url(self.lnurlp_url)

    def _fetch_invoice(self, callback: str) -> str:
        """Fetch a BOLT11 invoice using the LNURL-pay callback."""
        params = {
            "amount": self.amount_msat,
            "comment": self.comment,
        }
        callback_url = f"{callback}?{urllib.parse.urlencode(params)}"
        data = self._fetch_url(callback_url)
        if "pr" not in data:
            raise Exception("Invalid invoice response: missing 'pr' field")
        return data["pr"]

    def _verify_payment(self, verify_url: str, max_attempts: int = 10, backoff_factor: int = 2) -> bool:
        """Poll the LUD-21 verify URL to confirm payment with exponential backoff."""
        attempt = 0
        delay = 1
        while attempt < max_attempts:
            try:
                data = self._fetch_url(verify_url)
                if data.get("paid"):
                    return True
                elif not data.get("success"):
                    return False
            except Exception as e:
                if attempt == max_attempts - 1:
                    raise Exception(f"Failed to verify payment after {max_attempts} attempts: {e}")
            attempt += 1
            time.sleep(delay)
            delay = min(delay * backoff_factor, 30)  # Cap delay at 30 seconds