# ============================================================
# ADDITIVE: tiny in-process SMTP server for TESTS and API walk-throughs (never used in production).
# Understands EHLO, AUTH PLAIN / LOGIN, MAIL FROM, RCPT TO, DATA, RSET, NOOP, QUIT. No TLS.
# Every accepted message is stored in `server.messages`.
# ============================================================
import base64
import email
import socketserver
import threading
from email.header import decode_header, make_header


def _dh(v):
    return str(make_header(decode_header(v))) if v else ""


class _Handler(socketserver.StreamRequestHandler):
    def handle(self):
        srv = self.server.owner

        def w(s):
            self.wfile.write((s + "\r\n").encode())
            self.wfile.flush()

        def read_b64():
            return base64.b64decode(self.rfile.readline().decode().strip()).decode()

        w("220 fake-smtp ESMTP ready")
        user, authed, mail_from, rcpts = None, not srv.require_auth, None, []
        while True:
            raw = self.rfile.readline()
            if not raw:
                return
            cmd = raw.decode(errors="replace").rstrip("\r\n")
            up = cmd.upper()
            if up.startswith("EHLO"):
                w("250-fake-smtp")
                w("250-AUTH PLAIN LOGIN")
                w("250 8BITMIME")
            elif up.startswith("HELO"):
                w("250 fake-smtp")
            elif up.startswith("AUTH PLAIN"):
                parts = cmd.split(" ", 2)
                if len(parts) < 3:
                    w("334 ")
                    token = self.rfile.readline().decode().strip()
                else:
                    token = parts[2]
                try:
                    _, u, p = base64.b64decode(token).decode().split("\0")
                except Exception:
                    w("501 5.5.2 Cannot decode")
                    continue
                if srv.users.get(u) == p:
                    user, authed = u, True
                    w("235 2.7.0 Authentication successful")
                else:
                    srv.failed_logins.append(u)
                    w("535 5.7.8 Authentication credentials invalid")
            elif up.startswith("AUTH LOGIN"):
                parts = cmd.split(" ", 2)
                if len(parts) > 2:                                  # smtplib sends the user name inline
                    u = base64.b64decode(parts[2]).decode()
                else:
                    w("334 VXNlcm5hbWU6")
                    u = read_b64()
                w("334 UGFzc3dvcmQ6")
                p = read_b64()
                if srv.users.get(u) == p:
                    user, authed = u, True
                    w("235 2.7.0 Authentication successful")
                else:
                    srv.failed_logins.append(u)
                    w("535 5.7.8 Authentication credentials invalid")
            elif up.startswith("MAIL FROM"):
                if not authed:
                    w("530 5.7.0 Authentication required")
                    continue
                mail_from, rcpts = cmd.split(":", 1)[1].strip().split(" ")[0].strip("<>"), []
                w("250 2.1.0 OK")
            elif up.startswith("RCPT TO"):
                addr = cmd.split(":", 1)[1].strip().split(" ")[0].strip("<>")
                if addr.lower() in srv.reject_rcpt:
                    w("550 5.1.1 Mailbox unavailable")
                else:
                    rcpts.append(addr)
                    w("250 2.1.5 OK")
            elif up == "DATA":
                if not rcpts:
                    w("503 5.5.1 Need RCPT first")
                    continue
                w("354 End data with <CR><LF>.<CR><LF>")
                lines = []
                while True:
                    ln = self.rfile.readline().decode(errors="replace").rstrip("\r\n")
                    if ln == ".":
                        break
                    lines.append(ln[1:] if ln.startswith("..") else ln)
                msg = email.message_from_string("\r\n".join(lines))
                body = msg.get_payload(decode=True) if not msg.is_multipart() else None
                if msg.is_multipart():
                    body = next((p.get_payload(decode=True) for p in msg.walk() if p.get_content_type() == "text/plain"), b"")
                srv.messages.append({
                    "auth_user": user, "mail_from": mail_from, "rcpt_to": list(rcpts),
                    "from": _dh(msg["From"]), "to": _dh(msg["To"]), "cc": _dh(msg["Cc"]), "reply_to": _dh(msg["Reply-To"]),
                    "subject": _dh(msg["Subject"]), "headers": [k for k in msg.keys()],
                    "body": (body or b"").decode("utf-8", errors="replace"), "multipart": msg.is_multipart()})
                w("250 2.0.0 OK queued")
            elif up == "RSET":
                mail_from, rcpts = None, []
                w("250 OK")
            elif up == "NOOP":
                w("250 OK")
            elif up == "QUIT":
                w("221 Bye")
                return
            else:
                w("502 5.5.2 Command not recognized")


class _Server(socketserver.ThreadingTCPServer):
    allow_reuse_address = True
    daemon_threads = True


class FakeSMTPServer:
    def __init__(self, users=None, require_auth=True, reject_rcpt=()):
        self.users, self.require_auth = dict(users or {}), require_auth
        self.reject_rcpt = {r.lower() for r in reject_rcpt}
        self.messages, self.failed_logins = [], []
        self._srv = _Server(("127.0.0.1", 0), _Handler)
        self._srv.owner = self
        self.host, self.port = self._srv.server_address
        self._t = None

    def start(self):
        self._t = threading.Thread(target=self._srv.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)
        self._t.start()
        return self

    def stop(self):
        self._srv.shutdown()
        self._srv.server_close()

    def clear(self):
        self.messages.clear()
        self.failed_logins.clear()

    def __enter__(self):
        return self.start()

    def __exit__(self, *a):
        self.stop()
