from typing import List, Dict, Tuple
from common.log.module_logger import ModuleLogger
from common.exception.exceptions import InvalidDataError
from backend.infra.email.email_validation_handler import EmailValidationHandler
from backend.infra.email_sender_handler import EmailSenderHandler


class EmailValidationService:
    def __init__(self):
        self.email_validation_handler = EmailValidationHandler()
        self.email_sender_handler = EmailSenderHandler()
        self.module_logger = ModuleLogger(sender_id="EmailValidationService")

    async def validate_emails(self, emails: List[str]):
        """validate email list, return valid and invalid emails"""
        try:
            valid_emails = []
            invalid_emails = []
            
            for email in emails:
                if await self.email_validation_handler.is_valid_email(email):
                    valid_emails.append(email)
                else:
                    invalid_emails.append(email)
                    await self.module_logger.log_warning(
                        f"Invalid email detected: {email}",
                        properties={"email": email}
                    )
            
            await self.module_logger.log_info(
                "Email validation completed",
                properties={
                    "total_emails": len(emails),
                    "valid_count": len(valid_emails),
                    "invalid_count": len(invalid_emails)
                }
            )
            
            return valid_emails, invalid_emails
            
        except Exception as e:
            await self.module_logger.log_error(
                "Email validation failed",
                properties={"error": str(e)}
            )
            raise

    async def validate_sender_email(self, tenant_id: str, sender_email: str):
        """validate sender email, including format validation and permission validation"""
        try:
            authorized_sender = await self.email_sender_handler.get_email_sender(tenant_id)
            # format validation
            if not await self.email_validation_handler.is_valid_email(sender_email):
                return None
                
            # sender permission validation
            # Allow support@freeleaps.com as default sender even if not in authorized_senders
            if sender_email not in ["support@freeleaps.com", authorized_sender]:
                return None
            
            await self.module_logger.log_info(
                "Sender email validation completed",
                properties={
                    "tenant_id": tenant_id,
                    "sender_email": sender_email,
                    "authorized_sender": authorized_sender,
                    "is_valid": True
                }
            )
            
            return sender_email
            
        except Exception as e:
            await self.module_logger.log_error(
                "Sender email validation failed",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise