"""Reusable outbound SMTP transport for the local Amazon clone.

No network delivery is configured by default.  Supplying SMTP environment
variables switches registration, password-recovery, and order-confirmation
outboxes from ``LOCAL_ONLY`` to an asynchronous SMTP delivery attempt.
"""

from __future__ import annotations

import ipaddress
import os
import re
import smtplib
import ssl
from dataclasses import dataclass
from email.message import EmailMessage
from email.utils import getaddresses, parseaddr
from typing import Mapping
from urllib.parse import urlsplit


class SMTPConfigurationError(ValueError):
    pass


@dataclass(frozen=True, repr=False)
class SMTPConfig:
    host: str
    port: int
    security: str
    sender: str
    username: str | None = None
    password: str | None = None
    timeout_seconds: float = 10.0
    mailbox_namespace: str | None = None
    mailbox_capability: str | None = None

    def __repr__(self) -> str:
        return (
            "SMTPConfig("
            f"host={self.host!r}, port={self.port!r}, security={self.security!r}, "
            f"sender={self.sender!r}, username={'<configured>' if self.username else None}, "
            "password=<redacted>, "
            f"timeout_seconds={self.timeout_seconds!r}, "
            f"mailbox_namespace={self.mailbox_namespace!r}, "
            "mailbox_capability=<redacted>)"
        )


_SMTP_ENV_KEYS = (
    "AMAZON_CLONE_SMTP_HOST",
    "AMAZON_CLONE_SMTP_PORT",
    "AMAZON_CLONE_SMTP_TLS",
    "AMAZON_CLONE_SMTP_USERNAME",
    "AMAZON_CLONE_SMTP_PASSWORD",
    "AMAZON_CLONE_SMTP_FROM",
    "AMAZON_CLONE_SMTP_TIMEOUT_SECONDS",
    "AMAZON_CLONE_MAILBOX_NAMESPACE",
    "AMAZON_CLONE_MAILBOX_CAPABILITY",
)
_REQUIRE_SMTP_ENV_KEY = "AMAZON_CLONE_REQUIRE_SMTP"


def _clean_header(value: str, field: str, *, max_bytes: int = 512) -> str:
    cleaned = value.strip()
    if (
        not cleaned
        or len(cleaned.encode("utf-8")) > max_bytes
        or any(ord(character) < 32 or ord(character) == 127 for character in cleaned)
    ):
        raise SMTPConfigurationError(f"{field} must be a non-empty single-line value")
    return cleaned


def _clean_body(value: str) -> str:
    if not isinstance(value, str) or len(value.encode("utf-8")) > 64 * 1024:
        raise SMTPConfigurationError("message body must not exceed 64 KiB")
    if any(
        (ord(character) < 32 or ord(character) == 127)
        and character not in {"\t", "\n", "\r"}
        for character in value
    ):
        raise SMTPConfigurationError("message body contains a forbidden control character")
    return value


def _mailbox(value: str, field: str, *, allow_display_name: bool) -> str:
    cleaned = _clean_header(value, field)
    parsed_addresses = getaddresses([cleaned])
    if len(parsed_addresses) != 1:
        raise SMTPConfigurationError(f"{field} must contain one valid email address")
    display_name, address = parseaddr(cleaned)
    if (
        parsed_addresses[0] != (display_name, address)
        or not address
        or address.count("@") != 1
        or any(character.isspace() for character in address)
    ):
        raise SMTPConfigurationError(f"{field} must contain one valid email address")
    if not allow_display_name and (display_name or address != cleaned):
        raise SMTPConfigurationError(f"{field} must be a bare email address")
    return cleaned


def load_smtp_config(
    environ: Mapping[str, str] | None = None,
) -> SMTPConfig | None:
    """Load strict SMTP configuration, or return ``None`` for LOCAL_ONLY mode."""

    source = os.environ if environ is None else environ
    require_value = source.get(_REQUIRE_SMTP_ENV_KEY, "0").strip().lower()
    require_aliases = {
        "": False,
        "0": False,
        "false": False,
        "no": False,
        "1": True,
        "true": True,
        "yes": True,
    }
    if require_value not in require_aliases:
        raise SMTPConfigurationError(
            "AMAZON_CLONE_REQUIRE_SMTP must be 1 or 0"
        )
    require_smtp = require_aliases[require_value]
    host_value = source.get("AMAZON_CLONE_SMTP_HOST", "").strip()
    any_smtp_value = any(source.get(key, "").strip() for key in _SMTP_ENV_KEYS)
    if not host_value:
        if require_smtp:
            raise SMTPConfigurationError(
                "AMAZON_CLONE_REQUIRE_SMTP=1 requires a complete SMTP configuration"
            )
        if any_smtp_value:
            raise SMTPConfigurationError(
                "AMAZON_CLONE_SMTP_HOST is required when any SMTP setting is present"
            )
        return None

    host = _clean_header(host_value, "SMTP host")
    tls_value = source.get("AMAZON_CLONE_SMTP_TLS", "starttls").strip().lower()
    security_aliases = {
        "1": "starttls",
        "true": "starttls",
        "yes": "starttls",
        "starttls": "starttls",
        "ssl": "ssl",
        "implicit": "ssl",
        "0": "plain",
        "false": "plain",
        "no": "plain",
        "none": "plain",
        "plain": "plain",
    }
    security = security_aliases.get(tls_value)
    if security is None:
        raise SMTPConfigurationError(
            "AMAZON_CLONE_SMTP_TLS must be starttls, ssl, or none"
        )

    default_port = 465 if security == "ssl" else 587
    try:
        port = int(source.get("AMAZON_CLONE_SMTP_PORT", str(default_port)))
    except ValueError as exc:
        raise SMTPConfigurationError("SMTP port must be an integer") from exc
    if not 1 <= port <= 65535:
        raise SMTPConfigurationError("SMTP port must be between 1 and 65535")

    username = source.get("AMAZON_CLONE_SMTP_USERNAME", "").strip() or None
    password = source.get("AMAZON_CLONE_SMTP_PASSWORD", "") or None
    if (username is None) != (password is None):
        raise SMTPConfigurationError(
            "SMTP username and password must be configured together"
        )
    if username is not None:
        username = _clean_header(username, "SMTP username")
    if security == "plain":
        try:
            parsed_host = ipaddress.ip_address(host.strip("[]"))
            host_is_loopback = parsed_host.is_loopback
        except ValueError:
            host_is_loopback = host.casefold() in {
                "localhost",
                "mailbox-internal",
            }
        if not host_is_loopback:
            raise SMTPConfigurationError(
                "unencrypted SMTP is permitted only for a loopback mail server"
            )
        if username is not None:
            raise SMTPConfigurationError(
                "unencrypted SMTP cannot be configured with authentication"
            )

    sender = _mailbox(
        source.get("AMAZON_CLONE_SMTP_FROM", ""),
        "AMAZON_CLONE_SMTP_FROM",
        allow_display_name=True,
    )
    try:
        timeout_seconds = float(
            source.get("AMAZON_CLONE_SMTP_TIMEOUT_SECONDS", "10")
        )
    except ValueError as exc:
        raise SMTPConfigurationError("SMTP timeout must be numeric") from exc
    if not 1 <= timeout_seconds <= 60:
        raise SMTPConfigurationError("SMTP timeout must be between 1 and 60 seconds")

    mailbox_namespace = source.get("AMAZON_CLONE_MAILBOX_NAMESPACE", "").strip() or None
    mailbox_capability = source.get("AMAZON_CLONE_MAILBOX_CAPABILITY", "") or None
    if (mailbox_namespace is None) != (mailbox_capability is None):
        raise SMTPConfigurationError(
            "mailbox namespace and capability must be configured together"
        )
    if mailbox_namespace is not None and (
        len(mailbox_namespace) > 128
        or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", mailbox_namespace) is None
    ):
        raise SMTPConfigurationError("mailbox namespace is malformed")
    if mailbox_capability is not None and len(mailbox_capability) < 32:
        raise SMTPConfigurationError("mailbox capability is malformed")

    return SMTPConfig(
        host=host,
        port=port,
        security=security,
        sender=sender,
        username=username,
        password=password,
        timeout_seconds=timeout_seconds,
        mailbox_namespace=mailbox_namespace,
        mailbox_capability=mailbox_capability,
    )


def smtp_public_summary(config: SMTPConfig | None) -> dict[str, object]:
    if config is None:
        return {"mode": "LOCAL_ONLY"}
    return {
        "mode": "SMTP",
        "host": config.host,
        "port": config.port,
        "security": config.security,
        "authentication": bool(config.username),
        "sender": config.sender,
    }


def load_local_inbox_url(
    config: SMTPConfig | None,
    environ: Mapping[str, str] | None = None,
) -> str | None:
    """Return a validated loopback inbox URL for the local capture profile."""

    source = os.environ if environ is None else environ
    raw = source.get("AMAZON_CLONE_LOCAL_INBOX_URL", "").strip()
    if not raw:
        return None
    if config is None:
        raise SMTPConfigurationError(
            "AMAZON_CLONE_LOCAL_INBOX_URL requires SMTP configuration"
        )
    try:
        config_host = ipaddress.ip_address(config.host.strip("[]"))
    except ValueError as exc:
        raise SMTPConfigurationError(
            "AMAZON_CLONE_LOCAL_INBOX_URL is allowed only with loopback SMTP"
        ) from exc
    if not config_host.is_loopback:
        raise SMTPConfigurationError(
            "AMAZON_CLONE_LOCAL_INBOX_URL is allowed only with loopback SMTP"
        )
    parsed = urlsplit(raw)
    try:
        port = parsed.port
    except ValueError as exc:
        raise SMTPConfigurationError("local inbox URL has an invalid port") from exc
    if (
        parsed.scheme != "http"
        or parsed.hostname not in {"127.0.0.1", "::1"}
        or port is None
        or parsed.username is not None
        or parsed.password is not None
        or parsed.path not in {"", "/"}
        or parsed.query
        or parsed.fragment
    ):
        raise SMTPConfigurationError(
            "AMAZON_CLONE_LOCAL_INBOX_URL must be a loopback HTTP origin"
        )
    host = f"[{parsed.hostname}]" if parsed.hostname == "::1" else parsed.hostname
    return f"http://{host}:{port}/"


def send_smtp_message(
    config: SMTPConfig,
    *,
    recipient: str,
    subject: str,
    body: str,
) -> None:
    """Send one plain-text message without logging credentials or message content."""

    safe_recipient = _mailbox(recipient, "recipient", allow_display_name=False)
    safe_subject = _clean_header(subject, "subject")
    safe_body = _clean_body(body)
    message = EmailMessage()
    message["From"] = config.sender
    message["To"] = safe_recipient
    message["Subject"] = safe_subject
    if config.mailbox_namespace is not None:
        assert config.mailbox_capability is not None
        message["X-WebsiteBench-Namespace"] = config.mailbox_namespace
        message["X-WebsiteBench-Capability"] = config.mailbox_capability
    message.set_content(safe_body)

    context = ssl.create_default_context()
    if config.security == "ssl":
        client: smtplib.SMTP = smtplib.SMTP_SSL(
            config.host,
            config.port,
            timeout=config.timeout_seconds,
            context=context,
        )
    else:
        client = smtplib.SMTP(
            config.host, config.port, timeout=config.timeout_seconds
        )
    with client:
        client.ehlo()
        if config.security == "starttls":
            client.starttls(context=context)
            client.ehlo()
        if config.username is not None:
            assert config.password is not None
            client.login(config.username, config.password)
        client.send_message(message)


def smtp_error_summary(error: BaseException) -> str:
    """Return an admin-safe failure category without exception text or secrets."""

    name = type(error).__name__
    if isinstance(error, smtplib.SMTPResponseException):
        return f"{name}:smtp-{int(error.smtp_code)}"
    return name[:96] or "SMTPDeliveryError"


__all__ = [
    "SMTPConfig",
    "SMTPConfigurationError",
    "load_local_inbox_url",
    "load_smtp_config",
    "send_smtp_message",
    "smtp_error_summary",
    "smtp_public_summary",
]