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_emails(self, tenant_id: str, sender_emails: List[str]):
        """validate sender emails, including format validation and permission validation"""
        try:
            valid_senders = []
            invalid_senders = []
            
            authorized_senders = await self.email_sender_handler.get_email_senders(tenant_id)
            for sender_email in sender_emails:
                # format validation
                if not await self.email_validation_handler.is_valid_email(sender_email):
                    invalid_senders.append(sender_email)
                    continue
                
                # domain validation
                if not await self.email_validation_handler.is_valid_domain(sender_email):
                    invalid_senders.append(sender_email)
                    continue
                
                # sender permission validation
                # Allow support@freeleaps.com as default sender even if not in authorized_senders
                if sender_email not in authorized_senders and sender_email != "support@freeleaps.com":
                    invalid_senders.append(sender_email)
                    continue
                
                valid_senders.append(sender_email)
            
            await self.module_logger.log_info(
                "Sender email validation completed",
                properties={
                    "tenant_id": tenant_id,
                    "total_senders": len(sender_emails),
                    "valid_count": len(valid_senders),
                    "invalid_count": len(invalid_senders)
                }
            )
            
            return valid_senders, invalid_senders
            
        except Exception as e:
            await self.module_logger.log_error(
                "Sender email validation failed",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise