"""
SMS Provider using sms.ir API.
"""
import logging
import re

import requests
from django.conf import settings

from . import BaseNotificationProvider, ProviderResponse
from ..models import NotificationChannel

logger = logging.getLogger('notification.sms')


class SMSProvider(BaseNotificationProvider):
    """
    SMS notification provider using sms.ir API.
    """
    
    channel = NotificationChannel.SMS
    BASE_URL = "https://api.sms.ir/v1"
    
    def __init__(self):
        self.api_key = getattr(settings, 'SMS_IR_API_KEY', None)
        self.line_number = getattr(settings, 'SMS_IR_LINE_NUMBER', None)
        
        if not self.api_key:
            logger.warning("SMS_IR_API_KEY not configured")
        if not self.line_number:
            logger.warning("SMS_IR_LINE_NUMBER not configured")
    
    def send(
        self,
        recipient: str,
        content: str,
        subject: str | None = None,
        **kwargs
    ) -> ProviderResponse:
        """
        Send SMS via sms.ir API.
        
        Args:
            recipient: Phone number (Iranian format: 09XXXXXXXXX)
            content: SMS text content
            subject: Not used for SMS
            
        Returns:
            ProviderResponse with send status
        """
        if not self.api_key or not self.line_number:
            return ProviderResponse(
                success=False,
                error="SMS provider not configured"
            )
        
        if not self.validate_recipient(recipient):
            return ProviderResponse(
                success=False,
                error=f"Invalid phone number format: {recipient}"
            )
        
        # Normalize phone number
        phone = self._normalize_phone(recipient)
        
        try:
            headers = {
                "Content-Type": "application/json",
                "Accept": "text/plain",
                "x-api-key": self.api_key,
            }
            
            payload = {
                "lineNumber": self.line_number,
                "messageText": content,
                "mobiles": [phone],
            }
            
            response = requests.post(
                f"{self.BASE_URL}/send/bulk",
                json=payload,
                headers=headers,
                timeout=30
            )
            
            response_data = response.json() if response.content else {}
            
            if response.status_code == 200 and response_data.get("status") == 1:
                return ProviderResponse(
                    success=True,
                    message_id=str(response_data.get("data", {}).get("messageId")),
                    raw_response=response_data
                )
            else:
                error_msg = response_data.get("message", "Unknown error")
                logger.error(f"SMS send failed: {error_msg}")
                return ProviderResponse(
                    success=False,
                    error=error_msg,
                    raw_response=response_data
                )
                
        except requests.RequestException as e:
            logger.exception(f"SMS request failed: {e}")
            return ProviderResponse(
                success=False,
                error=str(e)
            )
    
    def validate_recipient(self, recipient: str) -> bool:
        """
        Validate Iranian phone number format.
        
        Valid formats:
        - 09XXXXXXXXX (11 digits starting with 09)
        - +989XXXXXXXXX (12 digits starting with +98)
        - 989XXXXXXXXX (12 digits starting with 98)
        """
        if not recipient:
            return False
        
        # Remove spaces and dashes
        phone = re.sub(r'[\s\-]', '', recipient)
        
        # Iranian mobile patterns
        patterns = [
            r'^09\d{9}$',       # 09XXXXXXXXX
            r'^\+989\d{9}$',    # +989XXXXXXXXX
            r'^989\d{9}$',      # 989XXXXXXXXX
        ]
        
        return any(re.match(pattern, phone) for pattern in patterns)
    
    def _normalize_phone(self, phone: str) -> str:
        """
        Normalize phone number to format 98XXXXXXXXXX.
        """
        phone = re.sub(r'[\s\-\+]', '', phone)
        
        if phone.startswith('09'):
            return '98' + phone[1:]
        elif phone.startswith('9') and len(phone) == 10:
            return '98' + phone
        elif phone.startswith('98'):
            return phone
        
        return phone