import logging
import smtplib
from email.message import EmailMessage
from typing import Dict, Optional
import anyio

from src.core.config import settings

logger = logging.getLogger(__name__)

class MailService:
    def __init__(self):
        self.account = settings.email_account
        self.password = settings.email_password
        self.smtp_server = settings.smtp_server
        self.smtp_port = settings.smtp_port

    def _get_smtp_config(self, group_config: Optional["GroupConfig"] = None):
        """Resolve SMTP settings from group config or fall back to global settings."""
        account = self.account
        password = self.password
        server = self.smtp_server
        port = self.smtp_port

        if group_config:
            if group_config.email_account:
                account = group_config.email_account
            if group_config.email_password_enc:
                from src.core.encryption import decrypt
                try:
                    password = decrypt(group_config.email_password_enc)
                except Exception:
                    logger.error(f"Failed to decrypt email password for group {group_config.group_email}")
            if group_config.smtp_server:
                server = group_config.smtp_server
            if group_config.smtp_port:
                port = group_config.smtp_port

        return account, password, server, port

    async def send_auto_mail(
        self,
        to_address: str,
        event_title: str = "Event",
        html_content: Optional[str] = None,
        inline_images: Optional[Dict[str, bytes]] = None,
        group_config: Optional["GroupConfig"] = None,
    ) -> bool:
        """Sends an automatic email with optional HTML/Charts via SMTP."""
        account, password, server, port = self._get_smtp_config(group_config)

        if not account or not password:
            logger.error(f"Email account or password not configured for {'global' if not group_config else group_config.group_email}.")
            return False

        if not to_address:
            logger.error("No recipient address defined for auto-mail.")
            return False

        msg = EmailMessage()
        msg["Subject"] = f"Automatischer Stats-Report: {event_title}"
        msg["From"] = account
        msg["To"] = to_address

        # Plain Text Fallback
        msg.set_content(
            f"Hallo,\n\nanbei die automatischen Statistiken für das anstehende Event '{event_title}'.\n\nViele Grüße\nDein automatischer Service"
        )

        # HTML Content
        if html_content:
            msg.add_alternative(html_content, subtype="html")
            if inline_images:
                # get_payload()[1] is the HTML part
                html_part = msg.get_payload()[1]
                for cid, img_bytes in inline_images.items():
                    html_part.add_related(
                        img_bytes, maintype="image", subtype="png", cid=f"<{cid}>"
                    )

        try:
            # Run the synchronous smtplib call in a thread pool
            await anyio.to_thread.run_sync(self._send_smtp, msg, server, port, account, password)
            logger.info(f"Auto-Mail successfully sent to: {to_address}")
            return True
        except Exception as e:
            logger.error(f"Error sending auto-mail via SMTP: {e}")
            return False

    def _send_smtp(self, msg: EmailMessage, server_host: str, server_port: int, account: str, password: str):
        """Synchronous SMTP sending logic."""
        with smtplib.SMTP_SSL(server_host, server_port) as server:
            server.login(account, password)
            server.send_message(msg)

mail_service = MailService()