package mail

import (
	"context"
	"errors"
	"fmt"

	"galaxy/backend/internal/config"

	gomail "github.com/wneessen/go-mail"
	"go.uber.org/zap"
)

// SMTPClient is the abstraction surface over `wneessen/go-mail` so
// tests can stub the wire layer without dialling. Production wires
// realSMTPClient.
type SMTPClient interface {
	DialAndSendWithContext(ctx context.Context, msg *gomail.Msg) error
}

// realSMTPClient adapts *gomail.Client to SMTPClient. The variadic
// nature of DialAndSendWithContext is hidden because the worker only
// ever sends one message per call.
type realSMTPClient struct {
	inner *gomail.Client
}

func (c *realSMTPClient) DialAndSendWithContext(ctx context.Context, msg *gomail.Msg) error {
	return c.inner.DialAndSendWithContext(ctx, msg)
}

// smtpSender implements SMTPSender on top of an SMTPClient. The
// `from` address is captured at construction time from
// `BACKEND_SMTP_FROM`.
type smtpSender struct {
	client SMTPClient
	from   string
	logger *zap.Logger
}

// NewSMTPSender constructs the production sender bound to the SMTP
// relay configured in cfg. The TLS-mode mapping is:
//
//   - "none"     → plain TCP, no TLS;
//   - "starttls" → STARTTLS required (TLSMandatory);
//   - "tls"      → implicit TLS at the configured port (WithSSL).
//
// PLAIN authentication is enabled when both Username and Password are
// non-empty.
func NewSMTPSender(cfg config.SMTPConfig, logger *zap.Logger) (SMTPSender, error) {
	if logger == nil {
		logger = zap.NewNop()
	}
	logger = logger.Named("mail.smtp")

	opts := []gomail.Option{gomail.WithPort(cfg.Port)}
	switch cfg.TLSMode {
	case "none":
		opts = append(opts, gomail.WithTLSPolicy(gomail.NoTLS))
	case "starttls":
		opts = append(opts, gomail.WithTLSPolicy(gomail.TLSMandatory))
	case "tls":
		opts = append(opts, gomail.WithSSL())
	default:
		return nil, fmt.Errorf("mail: unsupported SMTP TLS mode %q", cfg.TLSMode)
	}
	if cfg.Username != "" && cfg.Password != "" {
		opts = append(opts,
			gomail.WithSMTPAuth(gomail.SMTPAuthPlain),
			gomail.WithUsername(cfg.Username),
			gomail.WithPassword(cfg.Password),
		)
	}

	cli, err := gomail.NewClient(cfg.Host, opts...)
	if err != nil {
		return nil, fmt.Errorf("mail: build smtp client: %w", err)
	}
	return &smtpSender{
		client: &realSMTPClient{inner: cli},
		from:   cfg.From,
		logger: logger,
	}, nil
}

// Send renders the OutboundMessage as a *gomail.Msg and dispatches it
// through the SMTP client. Address validation is intentional: a
// malformed To here means the producer slipped past
// normaliseRecipient, which is a programming error and gets wrapped
// as Permanent so the worker dead-letters immediately.
func (s *smtpSender) Send(ctx context.Context, msg OutboundMessage) error {
	if len(msg.To) == 0 {
		return &SendError{Err: errors.New("mail: outbound message has no recipients"), Permanent: true}
	}
	m := gomail.NewMsg()
	if err := m.From(s.from); err != nil {
		return &SendError{Err: fmt.Errorf("set FROM: %w", err), Permanent: true}
	}
	for _, addr := range msg.To {
		if err := m.AddTo(addr); err != nil {
			return &SendError{Err: fmt.Errorf("add TO %q: %w", addr, err), Permanent: true}
		}
	}
	m.Subject(msg.Subject)
	contentType := gomail.ContentType(msg.ContentType)
	if msg.ContentType == "" {
		contentType = gomail.TypeTextPlain
	}
	m.SetBodyString(contentType, string(msg.Body))

	if err := s.client.DialAndSendWithContext(ctx, m); err != nil {
		permanent := classifySMTPError(err)
		return &SendError{Err: err, Permanent: permanent}
	}
	return nil
}

// classifySMTPError decides whether err is permanent. A *gomail.SendError
// reports its permanence through IsTemp; everything else (dial
// failures, context errors, generic I/O) is treated as transient so the
// worker retries until MaxAttempts.
func classifySMTPError(err error) bool {
	if err == nil {
		return false
	}
	var sendErr *gomail.SendError
	if errors.As(err, &sendErr) && sendErr != nil {
		return !sendErr.IsTemp()
	}
	return false
}