package parsemail

import (
	"bytes"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"mime"
	"net/textproto"
	"regexp"
	"strings"
	"time"

	"git.pcux.cn/xuans/Smail/config"
	"git.pcux.cn/xuans/Smail/models"
	"git.pcux.cn/xuans/Smail/utils/context"
	"github.com/emersion/go-message"
	_ "github.com/emersion/go-message/charset"
	"github.com/emersion/go-message/mail"
	"github.com/microcosm-cc/bluemonday"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/cast"
	xhtml "golang.org/x/net/html"
	xhtmlatom "golang.org/x/net/html/atom"
)

type User struct {
	EmailAddress string `json:"EmailAddress"`
	Name         string `json:"Name"`
}

func (u User) Build() string {
	if u.Name != "" {
		return fmt.Sprintf("\"%s\" <%s>", mime.QEncoding.Encode("utf-8", u.Name), u.EmailAddress)
	}
	return fmt.Sprintf("<%s>", u.EmailAddress)
}

func (u User) GetDomainAccount() (string, string) {
	infos := strings.Split(u.EmailAddress, "@")
	if len(infos) >= 2 {
		return infos[0], infos[1]
	}

	return "", ""
}

type Attachment struct {
	Filename    string
	ContentType string
	Content     []byte
	ContentID   string
}

// EmailAuthentication 表示收信时的发件人身份认证结果。
type EmailAuthentication struct {
	SPFPassed  bool
	DKIMPassed bool
	Dangerous  bool
}

// NewEmailAuthentication 根据 SPF 和 DKIM 结果创建统一的邮件认证结论。
func NewEmailAuthentication(spfPassed, dkimPassed bool) *EmailAuthentication {
	return &EmailAuthentication{
		SPFPassed:  spfPassed,
		DKIMPassed: dkimPassed,
		Dangerous:  !spfPassed && !dkimPassed,
	}
}

// Email is the type used for email messages
type Email struct {
	InReplyTo        string
	ThreadReferences string
	EnvelopeFrom     string
	ReplyTo          []*User
	From             *User
	To               []*User
	Bcc              []*User
	Cc               []*User
	Subject          string
	Text             []byte // Plaintext message (optional)
	HTML             []byte // Html message (optional)
	Sender           *User  // override From as SMTP envelope sender (optional)
	Headers          textproto.MIMEHeader
	Attachments      []*Attachment
	ReadReceipt      []string
	Date             string
	Status           int // 0未发送，1已发送，2发送失败，3删除，5广告邮件
	MessageId        int64
	MsgID            string // RFC-compliant Message-ID, persisted in DB
	Size             int
	Authentication   *EmailAuthentication
}

func (e *Email) SenderFilterAddresses() []string {
	if e == nil {
		return nil
	}
	addresses := []string{e.EnvelopeFrom}
	if e.From != nil {
		addresses = append(addresses, e.From.EmailAddress)
	}
	if e.Sender != nil {
		addresses = append(addresses, e.Sender.EmailAddress)
	}
	return addresses
}

type StoredEmailFields struct {
	ReplyTo     string
	To          string
	Bcc         string
	Cc          string
	Sender      string
	Attachments string
}

func (e *Email) EncodeStoredFields() (StoredEmailFields, error) {
	if e == nil {
		return StoredEmailFields{}, errors.New("email is nil")
	}
	marshal := func(field string, value any) (string, error) {
		data, err := json.Marshal(value)
		if err != nil {
			return "", fmt.Errorf("encode %s: %w", field, err)
		}
		return string(data), nil
	}

	var fields StoredEmailFields
	var err error
	if fields.ReplyTo, err = marshal("reply-to", e.ReplyTo); err != nil {
		return StoredEmailFields{}, err
	}
	if fields.To, err = marshal("recipients", e.To); err != nil {
		return StoredEmailFields{}, err
	}
	if fields.Bcc, err = marshal("bcc", e.Bcc); err != nil {
		return StoredEmailFields{}, err
	}
	if fields.Cc, err = marshal("cc", e.Cc); err != nil {
		return StoredEmailFields{}, err
	}
	if fields.Sender, err = marshal("sender", e.Sender); err != nil {
		return StoredEmailFields{}, err
	}
	if fields.Attachments, err = marshal("attachments", e.Attachments); err != nil {
		return StoredEmailFields{}, err
	}
	return fields, nil
}

// GenerateMsgID creates an RFC-compliant Message-ID unique enough to avoid spam filters.
// It must be called once at email creation time and the result persisted to DB.
func GenerateMsgID(domain string) (string, error) {
	domain = strings.TrimSpace(domain)
	if domain == "" || len(domain) > 253 || strings.ContainsAny(domain, "\r\n\t <>@") {
		return "", errors.New("invalid message id domain")
	}
	randBytes := make([]byte, 16)
	if _, err := io.ReadFull(rand.Reader, randBytes); err != nil {
		return "", err
	}
	return fmt.Sprintf("%x.%d@%s", randBytes, time.Now().UnixNano(), domain), nil
}

// Xss filter policy
var (
	strictPolicy  *bluemonday.Policy
	relaxedPolicy *bluemonday.Policy
)

func init() {
	strictPolicy = bluemonday.StrictPolicy()

	relaxedPolicy = bluemonday.NewPolicy()

	relaxedPolicy.AllowElements("p", "br", "strong", "em", "u", "b", "i", "h1", "h2", "h3", "h4", "h5", "h6")
	relaxedPolicy.AllowElements("div", "span", "center")
	relaxedPolicy.AllowElements("ul", "ol", "li")
	relaxedPolicy.AllowElements("blockquote", "cite")

	relaxedPolicy.AllowElements("table", "tbody", "thead", "tr", "td", "th")
	relaxedPolicy.AllowAttrs("width", "height", "border", "cellpadding", "cellspacing").OnElements("table")
	relaxedPolicy.AllowAttrs("align", "valign", "colspan", "rowspan").OnElements("td", "th")
	relaxedPolicy.AllowAttrs("align").OnElements("tr")

	relaxedPolicy.AllowAttrs("class", "id").Globally()

	relaxedPolicy.AllowAttrs("bgcolor", "color", "background").Globally()
	relaxedPolicy.AllowAttrs("align").OnElements("p", "div", "h1", "h2", "h3", "h4", "h5", "h6")

	relaxedPolicy.AllowElements("img")
	relaxedPolicy.AllowAttrs("src", "alt", "width", "height", "align").OnElements("img")

	relaxedPolicy.AllowElements("a")
	relaxedPolicy.AllowAttrs("href").OnElements("a")
	relaxedPolicy.RequireNoReferrerOnLinks(true)
	relaxedPolicy.AddTargetBlankToFullyQualifiedLinks(true)
	relaxedPolicy.RequireNoFollowOnLinks(true)

	relaxedPolicy.AllowElements("font")
	relaxedPolicy.AllowAttrs("size", "color", "face").OnElements("font")

	relaxedPolicy.AllowURLSchemes("http", "https", "mailto", "cid")
	relaxedPolicy.AllowRelativeURLs(true)

	relaxedPolicy.SkipElementsContent("script", "object", "embed", "iframe", "frame", "frameset")
}

func SanitizeHTML(htmlContent string) string {
	if htmlContent == "" {
		return ""
	}

	sanitized := relaxedPolicy.Sanitize(htmlContent)
	sanitized = sanitizeHTMLFragment(sanitized)

	dataUrlRegex := regexp.MustCompile(`href\s*=\s*["']data:[^"']*["']`)
	sanitized = dataUrlRegex.ReplaceAllString(sanitized, `rel="nofollow"`)

	jsUrlRegex := regexp.MustCompile(`href\s*=\s*["']javascript:[^"']*["']`)
	sanitized = jsUrlRegex.ReplaceAllString(sanitized, `rel="nofollow"`)

	expressionRegex := regexp.MustCompile(`(?i)expression\s*\(.*?\)`)
	sanitized = expressionRegex.ReplaceAllString(sanitized, "")

	styleExpressionRegex := regexp.MustCompile(`(?i)style\s*=\s*["'][^"']*expression[^"']*["']`)
	sanitized = styleExpressionRegex.ReplaceAllString(sanitized, "")

	cssJsRegex := regexp.MustCompile(`(?i)javascript\s*:`)
	sanitized = cssJsRegex.ReplaceAllString(sanitized, "")

	return sanitized
}

func sanitizeHTMLFragment(content string) string {
	container := &xhtml.Node{Type: xhtml.ElementNode, Data: "div", DataAtom: xhtmlatom.Div}
	nodes, err := xhtml.ParseFragment(strings.NewReader(content), container)
	if err != nil {
		return ""
	}
	var builder strings.Builder
	for _, node := range nodes {
		if sanitizeHTMLNode(node) {
			if err := xhtml.Render(&builder, node); err != nil {
				return ""
			}
		}
	}
	return builder.String()
}

func sanitizeHTMLNode(node *xhtml.Node) bool {
	if node.Type == xhtml.ElementNode && node.Data == "style" {
		return false
	}
	if node.Type == xhtml.ElementNode {
		filtered := node.Attr[:0]
		for _, attr := range node.Attr {
			if strings.EqualFold(attr.Key, "style") {
				continue
			}
			if node.Data == "img" && strings.EqualFold(attr.Key, "src") {
				value := strings.TrimSpace(strings.ToLower(attr.Val))
				if strings.HasPrefix(value, "http:") || strings.HasPrefix(value, "https:") || strings.HasPrefix(value, "//") {
					continue
				}
			}
			filtered = append(filtered, attr)
		}
		node.Attr = filtered
	}
	for child := node.FirstChild; child != nil; {
		next := child.NextSibling
		if !sanitizeHTMLNode(child) {
			node.RemoveChild(child)
		}
		child = next
	}
	return true
}

// Sanitize Text
func SanitizeText(text string) string {
	return strictPolicy.Sanitize(text)
}

func users2String(users []*User) string {
	ret := ""
	for _, user := range users {
		if ret != "" {
			ret += ", "
		}
		ret += user.Build()
	}
	return ret
}

func (e *Email) BuildTo2String() string {
	return users2String(e.To)
}

func (e *Email) BuildCc2String() string {
	return users2String(e.Cc)
}

func (e *Email) BuildBcc2String() string {
	return users2String(e.Bcc)
}

func NewEmailFromModel(d models.Email) (*Email, error) {

	var to []*User
	if err := decodeModelField(d.To, &to, "recipients"); err != nil {
		return nil, err
	}

	var replyTo []*User
	if err := decodeModelField(d.ReplyTo, &replyTo, "reply-to"); err != nil {
		return nil, err
	}

	var sender *User
	if err := decodeModelField(d.Sender, &sender, "sender"); err != nil {
		return nil, err
	}

	var bcc []*User
	if err := decodeModelField(d.Bcc, &bcc, "bcc"); err != nil {
		return nil, err
	}

	var cc []*User
	if err := decodeModelField(d.Cc, &cc, "cc"); err != nil {
		return nil, err
	}

	var attachments []*Attachment
	if err := decodeModelField(d.Attachments, &attachments, "attachments"); err != nil {
		return nil, err
	}

	ret := &Email{
		MessageId:        cast.ToInt64(d.Id),
		InReplyTo:        NormalizeThreadHeader(d.InReplyTo),
		ThreadReferences: NormalizeThreadHeader(d.ThreadReferences),
		MsgID:            d.MsgID,
		From: &User{
			Name:         d.FromName,
			EmailAddress: d.FromAddress,
		},
		To:          to,
		Subject:     d.Subject,
		Text:        []byte(d.Text.String),
		HTML:        []byte(d.Html.String),
		Sender:      sender,
		ReplyTo:     replyTo,
		Bcc:         bcc,
		Cc:          cc,
		Attachments: attachments,
		Date:        d.SendDate.Format(time.RFC3339),
	}
	if d.Type == 0 {
		ret.Authentication = NewEmailAuthentication(d.SPFCheck == 1, d.DKIMCheck == 1)
	}
	return ret, nil
}

func decodeModelField(raw string, target any, field string) error {
	if strings.TrimSpace(raw) == "" {
		return nil
	}
	if err := json.Unmarshal([]byte(raw), target); err != nil {
		return fmt.Errorf("decode stored %s: %w", field, err)
	}
	return nil
}
func NewEmailFromReader(to []string, r io.Reader, size int) (*Email, error) {
	ret := &Email{}
	m, err := message.Read(r)
	if err != nil {
		log.Errorf("email解析错误！ Error %+v", err)
	}
	if err != nil {
		return nil, fmt.Errorf("parse message: %w", err)
	}

	ret.Size = size
	ret.InReplyTo = NormalizeThreadHeader(m.Header.Get("In-Reply-To"))
	ret.ThreadReferences = NormalizeThreadHeader(m.Header.Get("References"))
	// Preserve the original Message-ID from the sender so it is stored and reused consistently.
	if mid := m.Header.Get("Message-Id"); mid != "" {
		ret.MsgID = strings.TrimPrefix(strings.TrimSuffix(strings.TrimSpace(mid), ">"), "<")
	}
	ret.From = buildUser(m.Header.Get("From"))

	smtpTo := buildUsers(to)

	ret.To = buildUsers(m.Header.Values("To"))
	ret.Cc = buildUsers(m.Header.Values("Cc"))

	ret.Bcc = []*User{}

	for _, user := range smtpTo {
		in := false
		for _, u := range ret.To {
			if strings.EqualFold(u.EmailAddress, user.EmailAddress) {
				in = true
				break
			}
		}
		for _, u := range ret.Cc {
			if strings.EqualFold(u.EmailAddress, user.EmailAddress) {
				in = true
				break
			}
		}
		if !in {
			ret.Bcc = append(ret.Bcc, user)
		}

	}

	ret.ReplyTo = buildUsers(m.Header.Values("Reply-To"))
	ret.Sender = buildUser(m.Header.Get("Sender"))
	if ret.Sender == nil || strings.TrimSpace(ret.Sender.EmailAddress) == "" {
		ret.Sender = ret.From
	}

	subject, err := m.Header.Text("Subject")
	if err != nil {
		return nil, fmt.Errorf("decode message subject: %w", err)
	}
	ret.Subject = strictPolicy.Sanitize(subject)

	sendTime, err := time.Parse(time.RFC1123Z, m.Header.Get("Date"))
	if err != nil {
		sendTime = time.Now()
	}
	ret.Date = sendTime.Format(time.RFC3339)
	if err = m.Walk(func(path []int, entity *message.Entity, walkErr error) error {
		if walkErr != nil {
			return walkErr
		}
		if entity == nil {
			return fmt.Errorf("message part is missing")
		}
		return formatContent(entity, ret)
	}); err != nil {
		return nil, fmt.Errorf("read message content: %w", err)
	}

	if ret.From != nil {
		ret.From.Name = strictPolicy.Sanitize(ret.From.Name)
		ret.From.EmailAddress = strictPolicy.Sanitize(ret.From.EmailAddress)
	}

	return ret, nil
}

func formatContent(entity *message.Entity, ret *Email) error {
	if entity == nil {
		return fmt.Errorf("message part is missing")
	}
	contentType, p, err := entity.Header.ContentType()

	if err != nil {
		log.Errorf("email read error! %+v", err)
		return err
	}
	disp := strings.ToLower(entity.Header.Get("Content-Disposition"))
	isAttachment := strings.Contains(disp, "attachment")
	switch contentType {
	case "multipart/alternative":
	case "multipart/mixed":
	case "text/plain":
		body, err := io.ReadAll(entity.Body)
		if err != nil {
			return err
		}

		if isAttachment {
			fileName := getFileName(entity, p)

			ret.Attachments = append(ret.Attachments, &Attachment{
				Filename:    SanitizeText(fileName),
				ContentType: SanitizeText(strings.TrimSpace(contentType)),
				Content:     body,
				ContentID:   strings.TrimPrefix(strings.TrimSuffix(entity.Header.Get("Content-Id"), ">"), "<"),
			})

			return nil
		}

		ret.Text = []byte(strictPolicy.Sanitize(string(body)))
	case "text/html":
		body, err := io.ReadAll(entity.Body)
		if err != nil {
			return err
		}

		if isAttachment {
			fileName := getFileName(entity, p)

			ret.Attachments = append(ret.Attachments, &Attachment{
				Filename:    SanitizeText(fileName),
				ContentType: SanitizeText(strings.TrimSpace(contentType)),
				Content:     body,
				ContentID:   strings.TrimPrefix(strings.TrimSuffix(entity.Header.Get("Content-Id"), ">"), "<"),
			})

			return nil
		}

		ret.HTML = []byte(SanitizeHTML(string(body)))
	case "multipart/related":
	default:
		c, err := io.ReadAll(entity.Body)
		if err != nil {
			return err
		}
		fileName := getFileName(entity, p)

		ret.Attachments = append(ret.Attachments, &Attachment{
			Filename:    SanitizeText(fileName),
			ContentType: SanitizeText(strings.TrimSpace(contentType)),
			Content:     c,
			ContentID:   strings.TrimPrefix(strings.TrimSuffix(entity.Header.Get("Content-Id"), ">"), "<"),
		})
	}

	return nil
}
func getFileName(entity *message.Entity, p map[string]string) string {
	fileName := p["name"]

	if fileName != "" {
		return fileName
	}

	_, params, err := entity.Header.ContentDisposition()
	if err == nil && params["filename"] != "" {
		return params["filename"]
	}

	return "no_name_file"
}

func BuilderUser(str string) *User {
	return buildUser(str)
}

var emailAddressRe = regexp.MustCompile(`<(.*@.*)>`)

func buildUser(str string) *User {
	str = strings.TrimSpace(str)
	if str == "" {
		return &User{}
	}

	user := &User{}

	addr, err := mail.ParseAddress(str)
	if err == nil {
		user.EmailAddress = strings.TrimSpace(addr.Address)

		name := strings.TrimSpace(addr.Name)
		if name != "" {
			decoder := mime.WordDecoder{}
			if decoded, err := decoder.Decode(name); err == nil {
				name = decoded
			}
			user.Name = strictPolicy.Sanitize(name)
		}
		return user
	}

	matched := emailAddressRe.FindStringSubmatch(str)
	if len(matched) == 2 {
		user.EmailAddress = strings.TrimSpace(matched[1])
		namePart := strings.ReplaceAll(str, matched[0], "")
		namePart = strings.Trim(strings.TrimSpace(namePart), "\"")

		decoder := mime.WordDecoder{}
		if decoded, err := decoder.Decode(strings.ReplaceAll(namePart, "\"", "")); err == nil {
			user.Name = strictPolicy.Sanitize(strings.TrimSpace(decoded))
		} else {
			user.Name = strictPolicy.Sanitize(strings.TrimSpace(namePart))
		}
	} else {
		user.EmailAddress = strictPolicy.Sanitize(str)
	}

	return user
}

func buildUsers(strs []string) []*User {
	var ret []*User
	for _, line := range strs {
		if strings.TrimSpace(line) == "" {
			continue
		}
		addresses, err := mail.ParseAddressList(line)
		if err == nil {
			for _, address := range addresses {
				ret = append(ret, buildUser(address.String()))
			}
			continue
		}
		if user := buildUser(line); user != nil {
			ret = append(ret, user)
		}
	}
	return ret
}

func writeMessagePart(w io.WriteCloser, content []byte) error {
	n, writeErr := w.Write(content)
	closeErr := w.Close()
	if writeErr != nil {
		return errors.Join(writeErr, closeErr)
	}
	if n != len(content) {
		return errors.Join(io.ErrShortWrite, closeErr)
	}
	return closeErr
}

func closeMessageWriters(primary error, closers ...io.Closer) error {
	for _, closer := range closers {
		primary = errors.Join(primary, closer.Close())
	}
	return primary
}

func (e *Email) ForwardBuildBytes(ctx *context.Context, sender *models.User, forwardAddress string) ([]byte, error) {
	var b bytes.Buffer

	cfg := config.CurrentConfig()
	if e == nil || sender == nil || cfg == nil || len(cfg.Domains) == 0 {
		return nil, errors.New("invalid forwarding configuration")
	}
	forwardUser := buildUser(forwardAddress)
	if forwardUser == nil || forwardUser.EmailAddress == "" {
		return nil, errors.New("invalid forwarding address")
	}
	to := []*mail.Address{{Name: forwardUser.Name, Address: forwardUser.EmailAddress}}

	senderEmailAddress := fmt.Sprintf("%s@%s", sender.Account, cfg.Domains[0])
	senderAddress := []*mail.Address{{Name: sender.Name, Address: senderEmailAddress}}
	// Create our mail header
	var h mail.Header
	h.SetDate(time.Now())
	h.SetAddressList("From", senderAddress)
	h.SetAddressList("Sender", senderAddress)
	h.SetAddressList("To", to)
	if e.From != nil && e.From.EmailAddress != "" {
		h.SetAddressList("Reply-To", []*mail.Address{{Name: e.From.Name, Address: e.From.EmailAddress}})
		h.Set("X-Original-From", e.From.Build())
	}
	h.Set("X-Forwarded-By", senderEmailAddress)
	h.Set("X-Forwarded-To", forwardUser.EmailAddress)
	h.SetText("Subject", e.Subject)
	msgID, err := GenerateMsgID(cfg.Domain)
	if err != nil {
		return nil, fmt.Errorf("generate message id: %w", err)
	}
	h.SetMessageID(msgID)
	if e.MsgID != "" {
		h.Set("References", fmt.Sprintf("<%s>", e.MsgID))
		h.Set("In-Reply-To", fmt.Sprintf("<%s>", e.MsgID))
	}

	// Create a new mail writer
	mw, err := mail.CreateWriter(&b, h)
	if err != nil {
		return nil, fmt.Errorf("create mail writer: %w", err)
	}

	// Create a text part
	tw, err := mw.CreateInline()
	if err != nil {
		return nil, closeMessageWriters(fmt.Errorf("create inline writer: %w", err), mw)
	}
	var th mail.InlineHeader
	th.Set("Content-Type", "text/plain")
	w, err := tw.CreatePart(th)
	if err != nil {
		return nil, closeMessageWriters(fmt.Errorf("create text part: %w", err), tw, mw)
	}
	if err := writeMessagePart(w, e.Text); err != nil {
		return nil, closeMessageWriters(fmt.Errorf("write text part: %w", err), tw, mw)
	}

	var html mail.InlineHeader
	html.Set("Content-Type", "text/html")
	w, err = tw.CreatePart(html)
	if err != nil {
		return nil, closeMessageWriters(fmt.Errorf("create html part: %w", err), tw, mw)
	}
	if err := writeMessagePart(w, e.HTML); err != nil {
		return nil, closeMessageWriters(fmt.Errorf("write html part: %w", err), tw, mw)
	}

	if err := tw.Close(); err != nil {
		return nil, closeMessageWriters(fmt.Errorf("close inline writer: %w", err), mw)
	}

	// Create an attachment
	for _, attachment := range e.Attachments {
		if attachment == nil {
			return nil, closeMessageWriters(errors.New("nil attachment"), mw)
		}
		var ah mail.AttachmentHeader
		ah.Set("Content-Type", attachment.ContentType)
		if attachment.ContentID != "" {
			ah.Set("Content-ID", fmt.Sprintf("<%s>", attachment.ContentID))
		}
		ah.SetFilename(attachment.Filename)
		w, err = mw.CreateAttachment(ah)
		if err != nil {
			return nil, closeMessageWriters(fmt.Errorf("create attachment: %w", err), mw)
		}
		if err := writeMessagePart(w, attachment.Content); err != nil {
			return nil, closeMessageWriters(fmt.Errorf("write attachment: %w", err), mw)
		}
	}

	if err := mw.Close(); err != nil {
		return nil, fmt.Errorf("close mail writer: %w", err)
	}

	if instance == nil {
		return b.Bytes(), nil
	}

	// dkim 签名后返回
	return instance.Sign(b.String())
}

func (e *Email) BuildPart(ctx *context.Context, loc []int) []byte {
	if len(loc) == 0 {
		return nil
	}

	// 处理顶层 part (part 1 = alternative, part 2+ = attachments)
	if len(loc) == 1 {
		partIdx := loc[0]
		if partIdx == 1 {
			// Part 1 是 alternative，不能直接获取，需要获取子部分
			return nil
		}
		// Part 2, 3, ... 是附件
		attachIdx := partIdx - 2
		if attachIdx >= 0 && attachIdx < len(e.Attachments) {
			encoded := base64.StdEncoding.EncodeToString(e.Attachments[attachIdx].Content)
			encoded += "\r\n"
			return []byte(encoded)
		}
		return nil
	}

	// 处理 alternative 的子部分 (1.1, 1.2)
	if loc[0] == 1 && len(loc) >= 2 {
		subIdx := loc[1]

		// 根据 BODYSTRUCTURE 的构建顺序：先 text，后 html
		// 如果只有一个存在，那个就是 1.1
		hasText := len(e.Text) > 0
		hasHtml := len(e.HTML) > 0

		if hasText && hasHtml {
			// 两者都有: 1.1=text, 1.2=html
			if subIdx == 1 {
				encoded := base64.StdEncoding.EncodeToString(e.Text)
				encoded += "\r\n"
				return []byte(encoded)
			}
			if subIdx == 2 {
				encoded := base64.StdEncoding.EncodeToString(e.HTML)
				encoded += "\r\n"
				return []byte(encoded)
			}
		} else if hasText {
			// 只有 text: 1.1=text
			if subIdx == 1 {
				encoded := base64.StdEncoding.EncodeToString(e.Text)
				encoded += "\r\n"
				return []byte(encoded)
			}
		} else if hasHtml {
			// 只有 html: 1.1=html
			if subIdx == 1 {
				encoded := base64.StdEncoding.EncodeToString(e.HTML)
				encoded += "\r\n"
				return []byte(encoded)
			}
		}
	}

	return nil
}

func (e *Email) BuildBytes(ctx *context.Context, dkim bool) ([]byte, error) {
	var b bytes.Buffer

	if e == nil || e.From == nil || e.From.EmailAddress == "" {
		return nil, errors.New("invalid sender")
	}
	cfg := config.CurrentConfig()
	if e.MsgID == "" && (cfg == nil || cfg.Domain == "") {
		return nil, errors.New("message id domain is not configured")
	}
	from := []*mail.Address{{Name: e.From.Name, Address: e.From.EmailAddress}}
	to := []*mail.Address{}
	for _, user := range e.To {
		if user == nil || user.EmailAddress == "" {
			return nil, errors.New("invalid recipient")
		}
		to = append(to, &mail.Address{
			Name:    user.Name,
			Address: user.EmailAddress,
		})
	}

	// Create our mail header
	var h mail.Header
	if e.Date != "" {
		t, err := time.Parse(time.RFC3339, e.Date)
		if err != nil {
			// Keep compatibility with Date values stored before timezone offsets were preserved.
			t, err = time.ParseInLocation(time.DateTime, e.Date, time.Local)
		}
		if err != nil {
			log.WithContext(ctx).Errorf("Time Error ! Err:%+v", err)
			h.SetDate(time.Now())
		} else {
			h.SetDate(t)
		}
	} else {
		h.SetDate(time.Now())
	}
	if e.MsgID != "" {
		h.SetMessageID(e.MsgID)
	} else {
		h.SetMessageID(fmt.Sprintf("%d@%s", e.MessageId, cfg.Domain))
	}
	h.SetAddressList("From", from)
	h.SetMsgIDList("In-Reply-To", ThreadMessageIDs(e.InReplyTo))
	h.SetMsgIDList("References", ThreadMessageIDs(e.ThreadReferences))
	h.SetAddressList("Sender", from)
	h.SetAddressList("To", to)
	h.SetText("Subject", e.Subject)
	if len(e.ReplyTo) != 0 {
		replyTo := make([]*mail.Address, 0, len(e.ReplyTo))
		for _, user := range e.ReplyTo {
			if user == nil || user.EmailAddress == "" {
				return nil, errors.New("invalid reply-to recipient")
			}
			replyTo = append(replyTo, &mail.Address{Name: user.Name, Address: user.EmailAddress})
		}
		h.SetAddressList("Reply-To", replyTo)
	}
	if len(e.Cc) != 0 {
		cc := []*mail.Address{}
		for _, user := range e.Cc {
			if user == nil || user.EmailAddress == "" {
				return nil, errors.New("invalid cc recipient")
			}
			cc = append(cc, &mail.Address{
				Name:    user.Name,
				Address: user.EmailAddress,
			})
		}
		h.SetAddressList("Cc", cc)
	}

	// Create a new mail writer
	mw, err := mail.CreateWriter(&b, h)
	if err != nil {
		return nil, fmt.Errorf("create mail writer: %w", err)
	}

	// Create a text part
	tw, err := mw.CreateInline()
	if err != nil {
		return nil, closeMessageWriters(fmt.Errorf("create inline writer: %w", err), mw)
	}

	if len(e.Text) > 0 {
		var th mail.InlineHeader
		th.Header.Set("Content-Transfer-Encoding", "base64")
		th.SetContentType("text/plain", map[string]string{
			"charset": "UTF-8",
		})
		w, err := tw.CreatePart(th)
		if err != nil {
			return nil, closeMessageWriters(fmt.Errorf("create text part: %w", err), tw, mw)
		}
		if err := writeMessagePart(w, e.Text); err != nil {
			return nil, closeMessageWriters(fmt.Errorf("write text part: %w", err), tw, mw)
		}
	}

	var html mail.InlineHeader
	html.SetContentType("text/html", map[string]string{
		"charset": "UTF-8",
	})
	html.Header.Set("Content-Transfer-Encoding", "base64")
	w, err := tw.CreatePart(html)
	if err != nil {
		return nil, closeMessageWriters(fmt.Errorf("create html part: %w", err), tw, mw)
	}
	htmlContent := e.HTML
	if len(htmlContent) == 0 {
		htmlContent = e.Text
	}
	if err := writeMessagePart(w, htmlContent); err != nil {
		return nil, closeMessageWriters(fmt.Errorf("write html part: %w", err), tw, mw)
	}

	if err := tw.Close(); err != nil {
		return nil, closeMessageWriters(fmt.Errorf("close inline writer: %w", err), mw)
	}

	// Create an attachment
	for _, attachment := range e.Attachments {
		if attachment == nil {
			return nil, closeMessageWriters(errors.New("nil attachment"), mw)
		}
		var ah mail.AttachmentHeader
		ah.Set("Content-Type", attachment.ContentType)
		if attachment.ContentID != "" {
			ah.Set("Content-ID", fmt.Sprintf("<%s>", attachment.ContentID))
		}
		ah.SetFilename(attachment.Filename)
		w, err = mw.CreateAttachment(ah)
		if err != nil {
			return nil, closeMessageWriters(fmt.Errorf("create attachment: %w", err), mw)
		}
		if err := writeMessagePart(w, attachment.Content); err != nil {
			return nil, closeMessageWriters(fmt.Errorf("write attachment: %w", err), mw)
		}
	}

	if err := mw.Close(); err != nil {
		return nil, fmt.Errorf("close mail writer: %w", err)
	}

	if dkim {
		if instance == nil {
			return nil, errors.New("DKIM signer is not initialized")
		}
		// dkim 签名后返回
		return instance.Sign(b.String())
	}
	return b.Bytes(), nil
}