using System.Globalization;
using System.Text;

namespace WpywMail.Native;

/// <summary>一个解析出来的附件。</summary>
public sealed record ParsedAttachment(string FileName, string ContentType, byte[] Data, string ContentId, bool Inline);

/// <summary>解析结果。Text / Html 已经解码成可直接展示的字符串。</summary>
public sealed record ParsedMime(
    string From,
    string To,
    string Cc,
    string Subject,
    string MessageId,
    string InReplyTo,
    string References,
    DateTimeOffset? Date,
    string Text,
    string Html,
    IReadOnlyList<ParsedAttachment> Attachments);

/// <summary>待发送的附件。</summary>
public sealed record OutgoingAttachment(string FileName, string ContentType, byte[] Data, string ContentId = "", bool Inline = false);

/// <summary>组装一封待发送邮件的入参。</summary>
public sealed record ComposeRequest(
    string From,
    string? FromDisplay,
    string[] To,
    string[] Cc,
    string Subject,
    string Text,
    string? Html = null,
    IReadOnlyList<OutgoingAttachment>? Attachments = null,
    string? MessageId = null,
    string InReplyTo = "",
    string References = "");

/// <summary>
/// MIME 组装与解析。
///
/// 相比 v1 的关键修正：
///  1. 组装：Message-ID 的域来自配置（不再写死），正文与附件一律 base64，
///     非 ASCII 头一律 RFC 2047 编码并按 75 字符上限切分。
///  2. 解析：正确解码 RFC 2047 编码字、Content-Transfer-Encoding（base64/QP）、
///     charset（含 GBK/GB18030），并支持 multipart 与附件。
/// </summary>
public static class Mime
{
    private const string Crlf = "\r\n";

    // ---------------------------------------------------------------- 解析

    public static ParsedMime Parse(byte[] raw)
    {
        var (headers, body) = SplitMessage(raw);
        return ParseEntity(headers, body);
    }

    private static ParsedMime ParseEntity(List<KeyValuePair<string, string>> headers, byte[] body)
    {
        string Header(string name) => headers.FirstOrDefault(h => h.Key.Equals(name, StringComparison.OrdinalIgnoreCase)).Value ?? "";

        var from = AddressText(DecodeHeader(Header("From")));
        var to = AddressText(DecodeHeader(Header("To")));
        var cc = AddressText(DecodeHeader(Header("Cc")));
        var subject = DecodeHeader(Header("Subject"));
        if (string.IsNullOrWhiteSpace(subject)) subject = "(无主题)";

        var contentType = Header("Content-Type");
        var (mediaType, parameters) = ParseContentType(contentType);
        var transferEncoding = Header("Content-Transfer-Encoding").Trim().ToLowerInvariant();

        var text = new StringBuilder();
        var html = new StringBuilder();
        var attachments = new List<ParsedAttachment>();

        if (mediaType.StartsWith("multipart/", StringComparison.OrdinalIgnoreCase) &&
            parameters.TryGetValue("boundary", out var boundary) && !string.IsNullOrEmpty(boundary))
        {
            foreach (var part in SplitMultipart(body, boundary))
            {
                var (partHeaders, partBody) = SplitMessage(part);
                var nested = ParseEntity(partHeaders, partBody);
                // 嵌套的多部分（例如 mixed 里套 alternative）
                if (nested.Text.Length > 0) text.Append(nested.Text);
                if (nested.Html.Length > 0) html.Append(nested.Html);
                attachments.AddRange(nested.Attachments);
            }
        }
        else
        {
            var decoded = DecodeTransfer(body, transferEncoding);
            var charset = parameters.TryGetValue("charset", out var cs) ? cs : null;
            var content = DecodeCharset(decoded, charset);

            var isAttachment = parameters.TryGetValue("name", out var name) && !string.IsNullOrWhiteSpace(name);
            var disposition = Header("Content-Disposition");
            var (dispType, dispParams) = ParseContentType(disposition);
            if (dispType.Equals("attachment", StringComparison.OrdinalIgnoreCase) ||
                (dispType.Equals("inline", StringComparison.OrdinalIgnoreCase) && !mediaType.StartsWith("text/", StringComparison.OrdinalIgnoreCase)))
                isAttachment = true;

            if (isAttachment)
            {
                var fileName = DecodeParameter(dispParams.GetValueOrDefault("filename*"))
                               ?? DecodeHeader(dispParams.GetValueOrDefault("filename") ?? "")
                               ?? DecodeParameter(parameters.GetValueOrDefault("name*"))
                               ?? DecodeHeader(parameters.GetValueOrDefault("name") ?? "")
                               ?? "attachment.bin";
                if (string.IsNullOrWhiteSpace(fileName)) fileName = "attachment.bin";
                attachments.Add(new ParsedAttachment(
                    fileName,
                    mediaType,
                    decoded,
                    Header("Content-ID").Trim('<', '>'),
                    dispType.Equals("inline", StringComparison.OrdinalIgnoreCase)));
            }
            else if (mediaType.Equals("text/html", StringComparison.OrdinalIgnoreCase))
            {
                html.Append(content);
            }
            else
            {
                text.Append(content);
            }
        }

        return new ParsedMime(
            from, to, cc, subject,
            Header("Message-ID").Trim(),
            Header("In-Reply-To").Trim(),
            Header("References").Trim(),
            ParseDate(Header("Date")),
            text.ToString().TrimEnd(),
            html.ToString().TrimEnd(),
            attachments);
    }

    private static DateTimeOffset? ParseDate(string value)
    {
        if (string.IsNullOrWhiteSpace(value)) return null;
        if (DateTimeOffset.TryParse(value.Trim(), CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var parsed)) return parsed;
        // 常见变体：缺秒、单数字日等
        var cleaned = value.Replace("GMT", "+0000").Replace("UT", "+0000").Trim();
        if (DateTimeOffset.TryParse(cleaned, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out parsed)) return parsed;
        return null;
    }

    /// <summary>把原始字节切成「头（已展开）」与「正文」。</summary>
    internal static (List<KeyValuePair<string, string>> Headers, byte[] Body) SplitMessage(byte[] raw)
    {
        var separator = IndexOf(raw, Crlf + Crlf);
        var separatorLength = 4;
        if (separator < 0)
        {
            separator = IndexOf(raw, "\n\n");
            separatorLength = 2;
        }

        var headerBytes = separator >= 0 ? raw[..separator] : raw;
        var body = separator >= 0 ? raw[(separator + separatorLength)..] : [];
        var headerText = DecodeHeaderBlock(headerBytes);

        var headers = new List<KeyValuePair<string, string>>();
        string? currentName = null;
        var currentValue = new StringBuilder();
        void Flush()
        {
            if (currentName is not null) headers.Add(new KeyValuePair<string, string>(currentName, currentValue.ToString().Trim()));
            currentName = null;
            currentValue.Clear();
        }

        foreach (var line in headerText.Split('\n'))
        {
            if (line.Length == 0) continue;
            if ((line[0] == ' ' || line[0] == '\t') && currentName is not null)
            {
                currentValue.Append(' ').Append(line.Trim());
                continue;
            }
            Flush();
            var colon = line.IndexOf(':');
            if (colon <= 0) continue;
            currentName = line[..colon].Trim();
            currentValue.Append(line[(colon + 1)..].Trim());
        }
        Flush();
        return (headers, body);
    }

    /// <summary>
    /// 解码头部块。
    ///
    /// 头部按标准应当是 ASCII（非 ASCII 必须用 RFC 2047 编码字），但现实中不少客户端
    /// 直接把裸 UTF-8 写进头里（8bit 头）。这里优先按 UTF-8 严格解码，失败再回退
    /// Latin-1（保证字节不丢）；否则裸 UTF-8 的中文主题会变成 «æµè¯» 这种乱码。
    /// </summary>
    private static string DecodeHeaderBlock(byte[] bytes)
    {
        try
        {
            return new UTF8Encoding(false, throwOnInvalidBytes: true).GetString(bytes).Replace("\r\n", "\n").Replace('\r', '\n');
        }
        catch (DecoderFallbackException)
        {
            return Encoding.Latin1.GetString(bytes).Replace("\r\n", "\n").Replace('\r', '\n');
        }
    }

    /// <summary>按 boundary 切分 multipart 正文。返回每个子部分的原始字节。</summary>
    private static List<byte[]> SplitMultipart(byte[] body, string boundary)
    {
        var parts = new List<byte[]>();
        var delimiter = Encoding.ASCII.GetBytes("--" + boundary);
        var positions = new List<int>();
        for (var i = 0; i + delimiter.Length <= body.Length; i++)
        {
            if (body[i] != (byte)'-') continue;
            var match = true;
            for (var j = 0; j < delimiter.Length; j++)
            {
                if (body[i + j] != delimiter[j]) { match = false; break; }
            }
            if (match) { positions.Add(i); i += delimiter.Length - 1; }
        }
        if (positions.Count < 2) return parts;

        for (var index = 0; index < positions.Count - 1; index++)
        {
            var start = positions[index];
            // 跳过边界行自身
            var lineEnd = IndexOf(body, start, "\n");
            if (lineEnd < 0) continue;
            start = lineEnd + 1;
            var end = positions[index + 1];
            // 去掉结尾的 CRLF
            while (end > start && (body[end - 1] == (byte)'\n' || body[end - 1] == (byte)'\r')) end--;
            if (end > start) parts.Add(body[start..end]);
        }
        return parts;
    }

    /// <summary>解码 Content-Transfer-Encoding。</summary>
    private static byte[] DecodeTransfer(byte[] body, string encoding) => encoding switch
    {
        "base64" => TryBase64(body),
        "quoted-printable" => DecodeQuotedPrintable(body),
        _ => body, // 7bit / 8bit / binary / 空
    };

    private static byte[] TryBase64(byte[] body)
    {
        // 去掉所有空白字符后解码；容错处理不完整的 base64
        var buffer = new StringBuilder(body.Length);
        foreach (var b in body)
        {
            if (b is (byte)' ' or (byte)'\r' or (byte)'\n' or (byte)'\t') continue;
            if (b == (byte)'=') { buffer.Append('='); continue; }
            buffer.Append((char)b);
        }
        var text = buffer.ToString();
        var padding = text.Length % 4;
        if (padding == 1) text = text[..^1];
        else if (padding is 2 or 3) text += new string('=', 4 - padding);
        try { return Convert.FromBase64String(text); }
        catch (FormatException) { return []; }
    }

    private static byte[] DecodeQuotedPrintable(byte[] body)
    {
        using var output = new MemoryStream(body.Length);
        for (var i = 0; i < body.Length; i++)
        {
            var b = body[i];
            if (b != (byte)'=') { output.WriteByte(b); continue; }

            // 软换行 =CRLF / =LF
            if (i + 1 < body.Length && body[i + 1] == (byte)'\n') { i += 1; continue; }
            if (i + 2 < body.Length && body[i + 1] == (byte)'\r' && body[i + 2] == (byte)'\n') { i += 2; continue; }
            if (i + 2 < body.Length && IsHex(body[i + 1]) && IsHex(body[i + 2]))
            {
                output.WriteByte((byte)((HexValue(body[i + 1]) << 4) | HexValue(body[i + 2])));
                i += 2;
                continue;
            }
            output.WriteByte(b);
        }
        return output.ToArray();

        static bool IsHex(byte b) => (b >= '0' && b <= '9') || (b >= 'A' && b <= 'F') || (b >= 'a' && b <= 'f');
        static int HexValue(byte b) => b switch
        {
            >= (byte)'0' and <= (byte)'9' => b - '0',
            >= (byte)'A' and <= (byte)'F' => b - 'A' + 10,
            _ => b - 'a' + 10,
        };
    }

    // ---------------------------------------------------------------- 头编码

    /// <summary>解码 RFC 2047 编码字；相邻编码字之间的空白会被丢弃。</summary>
    public static string DecodeHeader(string value)
    {
        if (string.IsNullOrEmpty(value) || !value.Contains("=?")) return value ?? "";

        var result = new StringBuilder();
        var index = 0;
        var lastWasEncoded = false;
        while (index < value.Length)
        {
            var start = value.IndexOf("=?", index, StringComparison.Ordinal);
            if (start < 0) { result.Append(value, index, value.Length - index); break; }

            // 编码字之间的空格应被忽略
            var gap = value[index..start];
            if (!(lastWasEncoded && gap.Trim().Length == 0)) result.Append(gap);
            else if (lastWasEncoded) { /* 丢弃 */ }

            var firstQuestion = value.IndexOf('?', start + 2);
            var secondQuestion = firstQuestion < 0 ? -1 : value.IndexOf('?', firstQuestion + 1);
            var end = secondQuestion < 0 ? -1 : value.IndexOf("?=", secondQuestion + 1, StringComparison.Ordinal);
            if (firstQuestion < 0 || secondQuestion < 0 || end < 0)
            {
                result.Append(value, start, value.Length - start);
                break;
            }

            var charset = value[(start + 2)..firstQuestion];
            var encoding = value[(firstQuestion + 1)..secondQuestion];
            var payload = value[(secondQuestion + 1)..end];
            try
            {
                byte[] bytes;
                if (encoding.Equals("B", StringComparison.OrdinalIgnoreCase))
                    bytes = Convert.FromBase64String(payload);
                else if (encoding.Equals("Q", StringComparison.OrdinalIgnoreCase))
                    bytes = DecodeQ(payload);
                else { result.Append(value, start, end + 2 - start); index = end + 2; lastWasEncoded = false; continue; }

                result.Append(DecodeCharset(bytes, charset));
                lastWasEncoded = true;
            }
            catch
            {
                result.Append(value, start, end + 2 - start);
                lastWasEncoded = false;
            }
            index = end + 2;
        }
        return result.ToString();

        static byte[] DecodeQ(string payload)
        {
            using var output = new MemoryStream();
            for (var i = 0; i < payload.Length; i++)
            {
                var c = payload[i];
                if (c == '_') { output.WriteByte((byte)' '); continue; }
                if (c == '=' && i + 2 < payload.Length)
                {
                    try { output.WriteByte(Convert.ToByte(payload.Substring(i + 1, 2), 16)); i += 2; continue; }
                    catch { }
                }
                output.WriteByte((byte)c);
            }
            return output.ToArray();
        }
    }

    /// <summary>解码 RFC 2231 参数值（形如 UTF-8''%E4%B8%AD%文）。</summary>
    private static string? DecodeParameter(string? value)
    {
        if (string.IsNullOrWhiteSpace(value)) return null;
        var text = value.Trim();
        var separator = text.IndexOf("''", StringComparison.Ordinal);
        if (separator < 0) return null;
        var charset = text[..separator];
        var encoded = text[(separator + 2)..];
        try
        {
            using var buffer = new MemoryStream(encoded.Length);
            for (var i = 0; i < encoded.Length; i++)
            {
                if (encoded[i] == '%' && i + 2 < encoded.Length)
                {
                    buffer.WriteByte(Convert.ToByte(encoded.Substring(i + 1, 2), 16));
                    i += 2;
                }
                else buffer.WriteByte((byte)encoded[i]);
            }
            return DecodeCharset(buffer.ToArray(), charset);
        }
        catch { return null; }
    }

    /// <summary>对外暴露的 RFC 2047 编码入口（IMAP ENVELOPE 等需要把非 ASCII 头值变成 ASCII）。</summary>
    public static string EncodeHeaderValue(string value) =>
        EncodeHeader(value ?? "").Replace("\r\n", " ").Replace("\n", " ");

    /// <summary>需要时把文本编码成 RFC 2047 编码字（按 75 字符上限切分）。</summary>
    private static string EncodeHeader(string value)
    {
        if (string.IsNullOrEmpty(value)) return "";
        if (value.All(c => c is >= ' ' and <= '~')) return value;

        var bytes = Encoding.UTF8.GetBytes(value);
        var chunks = new List<string>();
        var offset = 0;
        while (offset < bytes.Length)
        {
            // 每个编码字最多 75 字符；"=?UTF-8?B?" + "?=" 占 12 个字符 → base64 最多 63
            var take = Math.Min(45, bytes.Length - offset);
            // 不要把多字节字符切开
            while (take > 1 && offset + take < bytes.Length && (bytes[offset + take] & 0xC0) == 0x80) take--;
            chunks.Add("=?UTF-8?B?" + Convert.ToBase64String(bytes, offset, take) + "?=");
            offset += take;
        }
        return chunks.Count == 1 ? chunks[0] : string.Join(Crlf + " ", chunks);
    }

    /// <summary>解析地址列表，抽出纯地址。</summary>
    public static string[] Addresses(string value)
    {
        if (string.IsNullOrWhiteSpace(value)) return [];
        var result = new List<string>();
        var depth = 0;
        var current = new StringBuilder();
        foreach (var c in value)
        {
            switch (c)
            {
                case '<': depth++; current.Append(c); break;
                case '>': depth = Math.Max(0, depth - 1); current.Append(c); break;
                case ',' or ';' when depth == 0: Add(); break;
                default: current.Append(c); break;
            }
        }
        Add();
        return result.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();

        void Add()
        {
            var item = current.ToString().Trim();
            current.Clear();
            if (item.Length == 0) return;
            var start = item.IndexOf('<');
            var end = item.IndexOf('>', start + 1);
            var address = start >= 0 && end > start ? item[(start + 1)..end].Trim() : item;
            if (address.Contains('@') && address.IndexOf('@') > 0 && address.IndexOf('@') < address.Length - 1) result.Add(address);
        }
    }

    private static string AddressText(string value) => value ?? "";

    internal static (string MediaType, Dictionary<string, string> Parameters) ParseContentType(string value)
    {
        var parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        if (string.IsNullOrWhiteSpace(value)) return ("text/plain", parameters);
        var segments = value.Split(';');
        var mediaType = segments[0].Trim().ToLowerInvariant();
        for (var i = 1; i < segments.Length; i++)
        {
            var part = segments[i].Trim();
            var equals = part.IndexOf('=');
            if (equals <= 0) continue;
            var name = part[..equals].Trim().ToLowerInvariant();
            var val = part[(equals + 1)..].Trim().Trim('"');
            parameters[name] = val;
        }
        return (mediaType, parameters);
    }

    /// <summary>按 charset 解码字节；未知字符集回退 UTF-8。</summary>
    public static string DecodeCharset(byte[] bytes, string? charset)
    {
        if (bytes.Length == 0) return "";
        var encoding = ResolveEncoding(charset);
        try { return encoding.GetString(bytes); }
        catch { return Encoding.UTF8.GetString(bytes); }
    }

    private static Encoding ResolveEncoding(string? charset)
    {
        if (string.IsNullOrWhiteSpace(charset)) return Encoding.UTF8;
        var name = charset.Trim().Trim('"').ToLowerInvariant();
        if (name is "utf8" or "utf-8" or "unicode-1-1-utf-8") return new UTF8Encoding(false);
        if (name is "us-ascii" or "ascii") return Encoding.ASCII;
        if (name is "latin1" or "iso-8859-1" or "iso8859-1" or "windows-1252") return Encoding.Latin1;
        try { return Encoding.GetEncoding(name); }
        catch
        {
            if (name is "gb2312" or "gbk" or "gb18030" or "csgb2312" or "x-gbk")
            {
                var provider = CodePagesShim.Provider;
                if (provider is not null)
                {
                    try
                    {
                        Encoding.RegisterProvider(provider);
                        var codePage = name == "gb18030" ? 54936 : 936;
                        return Encoding.GetEncoding(codePage);
                    }
                    catch { }
                }
            }
            AppLog.Warn($"[MIME] 不支持的字符集 {charset}，按 UTF-8 处理。");
            return Encoding.UTF8;
        }
    }

    // ---------------------------------------------------------------- 组装

    public static byte[] Build(ComposeRequest request, AppConfig config)
    {
        var messageId = string.IsNullOrWhiteSpace(request.MessageId)
            ? $"<{Guid.NewGuid():N}@{config.Domain}>"
            : (request.MessageId.StartsWith('<') ? request.MessageId : $"<{request.MessageId}>");

        var attachments = request.Attachments ?? [];
        var hasHtml = !string.IsNullOrWhiteSpace(request.Html);
        var textPartBytes = Encoding.UTF8.GetBytes(request.Text ?? "");
        var htmlPartBytes = hasHtml ? Encoding.UTF8.GetBytes(request.Html!) : [];

        var headers = new StringBuilder();
        headers.Append("Date: ").Append(FormatDate(DateTimeOffset.UtcNow)).Append(Crlf);
        headers.Append("From: ").Append(FormatAddress(request.From, request.FromDisplay)).Append(Crlf);
        headers.Append("To: ").Append(string.Join(", ", request.To.Select(a => FormatAddress(a, null)))).Append(Crlf);
        if (request.Cc.Length > 0) headers.Append("Cc: ").Append(string.Join(", ", request.Cc.Select(a => FormatAddress(a, null)))).Append(Crlf);
        headers.Append("Subject: ").Append(EncodeHeader(request.Subject ?? "")).Append(Crlf);
        headers.Append("Message-ID: ").Append(messageId).Append(Crlf);
        if (!string.IsNullOrWhiteSpace(request.InReplyTo)) headers.Append("In-Reply-To: ").Append(request.InReplyTo.Trim()).Append(Crlf);
        if (!string.IsNullOrWhiteSpace(request.References)) headers.Append("References: ").Append(request.References.Trim()).Append(Crlf);
        headers.Append("MIME-Version: 1.0").Append(Crlf);

        var body = new MemoryStream();
        if (attachments.Count > 0)
        {
            var mixedBoundary = "mix-" + Guid.NewGuid().ToString("N")[..16];
            headers.Append("Content-Type: multipart/mixed; boundary=\"").Append(mixedBoundary).Append('"').Append(Crlf);
            headers.Append(Crlf);

            WriteBoundary(body, mixedBoundary, false);
            body.Write(hasHtml ? BuildAlternativePart(textPartBytes, htmlPartBytes) : BuildTextPart(textPartBytes));

            foreach (var attachment in attachments)
            {
                WriteBoundary(body, mixedBoundary, false);
                var part = new StringBuilder();
                part.Append("Content-Type: ").Append(attachment.ContentType).Append("; ")
                    .Append(FileNameParameters(attachment.FileName, "name")).Append(Crlf);
                part.Append("Content-Transfer-Encoding: base64").Append(Crlf);
                part.Append("Content-Disposition: ").Append(attachment.Inline ? "inline" : "attachment").Append("; ")
                    .Append(FileNameParameters(attachment.FileName, "filename")).Append(Crlf);
                if (!string.IsNullOrWhiteSpace(attachment.ContentId))
                    part.Append("Content-ID: <").Append(attachment.ContentId.Trim('<', '>')).Append('>').Append(Crlf);
                part.Append(Crlf);
                part.Append(WrapBase64(attachment.Data));
                body.Write(Encoding.ASCII.GetBytes(part.ToString()));
            }
            WriteBoundary(body, mixedBoundary, true);
        }
        else if (hasHtml)
        {
            var boundary = "alt-" + Guid.NewGuid().ToString("N")[..16];
            headers.Append("Content-Type: multipart/alternative; boundary=\"").Append(boundary).Append('"').Append(Crlf);
            headers.Append(Crlf);
            body.Write(BuildAlternativeWithBoundary(textPartBytes, htmlPartBytes, boundary));
        }
        else
        {
            headers.Append("Content-Type: text/plain; charset=UTF-8").Append(Crlf);
            headers.Append("Content-Transfer-Encoding: base64").Append(Crlf);
            headers.Append(Crlf);
            body.Write(Encoding.ASCII.GetBytes(WrapBase64(textPartBytes)));
        }

        var output = new MemoryStream();
        output.Write(Encoding.ASCII.GetBytes(headers.ToString()));
        body.Position = 0;
        body.CopyTo(output);
        return output.ToArray();
    }

    private static byte[] BuildTextPart(byte[] textBytes)
    {
        var part = new StringBuilder();
        part.Append("Content-Type: text/plain; charset=UTF-8").Append(Crlf);
        part.Append("Content-Transfer-Encoding: base64").Append(Crlf);
        part.Append(Crlf);
        part.Append(WrapBase64(textBytes));
        return Encoding.ASCII.GetBytes(part.ToString());
    }

    /// <summary>作为 multipart/mixed 的子部分时，必须带上自己的 Content-Type 头。</summary>
    private static byte[] BuildAlternativePart(byte[] textBytes, byte[] htmlBytes)
    {
        var boundary = "alt-" + Guid.NewGuid().ToString("N")[..16];
        var output = new MemoryStream();
        output.Write(Encoding.ASCII.GetBytes("Content-Type: multipart/alternative; boundary=\"" + boundary + "\"" + Crlf + Crlf));
        output.Write(BuildAlternativeWithBoundary(textBytes, htmlBytes, boundary));
        return output.ToArray();
    }

    /// <summary>附件名参数：ASCII 回退 + RFC 2231 扩展写法，保证中文文件名不乱码。</summary>
    private static string FileNameParameters(string fileName, string parameterName)
    {
        var ascii = new string(fileName.Select(c => c is >= ' ' and <= '~' && c != '"' && c != '\\' ? c : '_').ToArray());
        if (ascii.Length == 0) ascii = "attachment";
        return $"{parameterName}=\"{ascii}\"; {parameterName}*=UTF-8''{Uri.EscapeDataString(fileName)}";
    }

    private static byte[] BuildAlternativeWithBoundary(byte[] textBytes, byte[] htmlBytes, string boundary)
    {
        var output = new MemoryStream();
        WriteBoundary(output, boundary, false);
        output.Write(BuildTextPart(textBytes));
        WriteBoundary(output, boundary, false);
        var html = new StringBuilder();
        html.Append("Content-Type: text/html; charset=UTF-8").Append(Crlf);
        html.Append("Content-Transfer-Encoding: base64").Append(Crlf);
        html.Append(Crlf);
        html.Append(WrapBase64(htmlBytes));
        output.Write(Encoding.ASCII.GetBytes(html.ToString()));
        WriteBoundary(output, boundary, true);
        return output.ToArray();
    }

    private static void WriteBoundary(Stream stream, string boundary, bool closing)
    {
        var line = "--" + boundary + (closing ? "--" : "") + Crlf;
        stream.Write(Encoding.ASCII.GetBytes(line));
    }

    private static string FormatAddress(string address, string? display)
    {
        address = address.Trim().Trim('<', '>');
        if (string.IsNullOrWhiteSpace(display)) return address;
        return $"{EncodeHeader(display)} <{address}>";
    }

    /// <summary>RFC 5322 日期（必须是 ±HHMM 形式的时区）。</summary>
    public static string FormatDate(DateTimeOffset value)
    {
        var offset = value.Offset;
        var sign = offset < TimeSpan.Zero ? "-" : "+";
        var absolute = offset.Duration();
        return value.ToString("ddd, dd MMM yyyy HH:mm:ss ", CultureInfo.InvariantCulture) +
               $"{sign}{absolute.Hours:D2}{absolute.Minutes:D2}";
    }

    private static string WrapBase64(byte[] bytes)
    {
        var encoded = Convert.ToBase64String(bytes);
        var builder = new StringBuilder(encoded.Length + encoded.Length / 76 * 2 + 2);
        for (var index = 0; index < encoded.Length; index += 76)
        {
            builder.Append(encoded, index, Math.Min(76, encoded.Length - index)).Append(Crlf);
        }
        return builder.ToString();
    }

    // ---------------------------------------------------------------- 工具

    private static int IndexOf(byte[] data, string text) => IndexOf(data, 0, text);

    private static int IndexOf(byte[] data, int start, string text)
    {
        var pattern = Encoding.ASCII.GetBytes(text);
        for (var i = start; i + pattern.Length <= data.Length; i++)
        {
            var match = true;
            for (var j = 0; j < pattern.Length; j++)
            {
                if (data[i + j] != pattern[j]) { match = false; break; }
            }
            if (match) return i;
        }
        return -1;
    }
}

/// <summary>
/// 可选注册 .NET 的代码页编码提供程序（用于 GBK/GB18030）。
/// 未引用 System.Text.Encoding.CodePages 包时静默降级为 UTF-8。
/// </summary>
internal static class CodePagesShim
{
    private static EncodingProvider? provider;
    private static bool resolved;

    public static EncodingProvider? Provider
    {
        get
        {
            if (!resolved)
            {
                resolved = true;
                try
                {
                    var type = Type.GetType("System.Text.CodePagesEncodingProvider, System.Text.Encoding.CodePages", throwOnError: false);
                    provider = type?.GetProperty("Instance", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static)?.GetValue(null) as EncodingProvider;
                    if (provider is not null) AppLog.Info("[MIME] 已启用代码页编码支持（GBK/GB18030 可正常解码）。");
                    else AppLog.Warn("[MIME] 未找到代码页编码支持；GBK/GB2312 编码的中文邮件可能解码异常。");
                }
                catch { provider = null; }
            }
            return provider;
        }
    }
}