-module(lumenmail@message).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lumenmail/message.gleam").
-export([new/0, from/2, from_email/2, from_name_email/3, reply_to/2, to/2, to_email/2, to_name_email/3, to_many/2, cc/2, cc_email/2, cc_many/2, bcc/2, bcc_email/2, bcc_many/2, subject/2, text_body/2, html_body/2, body/3, attachment/4, inline_attachment/5, header/3, priority/2, message_id/2, in_reply_to/2, add_reference/2, all_recipients/1, format_address/1, format_address_list/1, content_type_to_string/1, generate_boundary/0, build/1]).
-export_type([content_type/0, encoding/0, attachment/0, header/0, priority/0, message/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Email message builder module.\n"
    " Provides a fluent API for constructing RFC 5322 compliant email messages.\n"
).

-type content_type() :: text_plain |
    text_html |
    multipart_alternative |
    multipart_mixed |
    multipart_related |
    application_octet_stream |
    {custom, binary()}.

-type encoding() :: seven_bit | eight_bit | quoted_printable | base64.

-type attachment() :: {attachment,
        binary(),
        content_type(),
        bitstring(),
        boolean(),
        gleam@option:option(binary())}.

-type header() :: {header, binary(), binary()}.

-type priority() :: high | normal | low.

-type message() :: {message,
        gleam@option:option(lumenmail@types:address()),
        gleam@option:option(lumenmail@types:address()),
        list(lumenmail@types:address()),
        list(lumenmail@types:address()),
        list(lumenmail@types:address()),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        list(attachment()),
        list(header()),
        priority(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        list(binary())}.

-file("src/lumenmail/message.gleam", 74).
?DOC(" Creates a new empty message builder.\n").
-spec new() -> message().
new() ->
    {message,
        none,
        none,
        [],
        [],
        [],
        none,
        none,
        none,
        [],
        [],
        normal,
        none,
        none,
        []}.

-file("src/lumenmail/message.gleam", 94).
?DOC(" Sets the sender address.\n").
-spec from(message(), lumenmail@types:address()) -> message().
from(Message, Address) ->
    {message,
        {some, Address},
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 99).
?DOC(" Sets the sender using just an email string.\n").
-spec from_email(message(), binary()) -> message().
from_email(Message, Email) ->
    {message,
        {some, lumenmail@types:address(Email)},
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 104).
?DOC(" Sets the sender with name and email.\n").
-spec from_name_email(message(), binary(), binary()) -> message().
from_name_email(Message, Name, Email) ->
    {message,
        {some, lumenmail@types:address_with_name(Name, Email)},
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 113).
?DOC(" Sets the reply-to address.\n").
-spec reply_to(message(), lumenmail@types:address()) -> message().
reply_to(Message, Address) ->
    {message,
        erlang:element(2, Message),
        {some, Address},
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 118).
?DOC(" Adds a recipient to the To field.\n").
-spec to(message(), lumenmail@types:address()) -> message().
to(Message, Address) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        lists:append(erlang:element(4, Message), [Address]),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 123).
?DOC(" Adds a recipient to To using just an email string.\n").
-spec to_email(message(), binary()) -> message().
to_email(Message, Email) ->
    to(Message, lumenmail@types:address(Email)).

-file("src/lumenmail/message.gleam", 128).
?DOC(" Adds a recipient with name and email to To field.\n").
-spec to_name_email(message(), binary(), binary()) -> message().
to_name_email(Message, Name, Email) ->
    to(Message, lumenmail@types:address_with_name(Name, Email)).

-file("src/lumenmail/message.gleam", 133).
?DOC(" Sets multiple To recipients at once.\n").
-spec to_many(message(), list(lumenmail@types:address())) -> message().
to_many(Message, Addresses) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        lists:append(erlang:element(4, Message), Addresses),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 138).
?DOC(" Adds a recipient to the CC field.\n").
-spec cc(message(), lumenmail@types:address()) -> message().
cc(Message, Address) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        lists:append(erlang:element(5, Message), [Address]),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 143).
?DOC(" Adds a recipient to CC using just an email string.\n").
-spec cc_email(message(), binary()) -> message().
cc_email(Message, Email) ->
    cc(Message, lumenmail@types:address(Email)).

-file("src/lumenmail/message.gleam", 148).
?DOC(" Sets multiple CC recipients at once.\n").
-spec cc_many(message(), list(lumenmail@types:address())) -> message().
cc_many(Message, Addresses) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        lists:append(erlang:element(5, Message), Addresses),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 153).
?DOC(" Adds a recipient to the BCC field.\n").
-spec bcc(message(), lumenmail@types:address()) -> message().
bcc(Message, Address) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        lists:append(erlang:element(6, Message), [Address]),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 158).
?DOC(" Adds a recipient to BCC using just an email string.\n").
-spec bcc_email(message(), binary()) -> message().
bcc_email(Message, Email) ->
    bcc(Message, lumenmail@types:address(Email)).

-file("src/lumenmail/message.gleam", 163).
?DOC(" Sets multiple BCC recipients at once.\n").
-spec bcc_many(message(), list(lumenmail@types:address())) -> message().
bcc_many(Message, Addresses) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        lists:append(erlang:element(6, Message), Addresses),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 168).
?DOC(" Sets the email subject.\n").
-spec subject(message(), binary()) -> message().
subject(Message, Subject) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        {some, Subject},
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 173).
?DOC(" Sets the plain text body.\n").
-spec text_body(message(), binary()) -> message().
text_body(Message, Body) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        {some, Body},
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 178).
?DOC(" Sets the HTML body.\n").
-spec html_body(message(), binary()) -> message().
html_body(Message, Body) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        {some, Body},
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 183).
?DOC(" Sets both text and HTML body (multipart/alternative).\n").
-spec body(message(), binary(), binary()) -> message().
body(Message, Text, Html) ->
    _pipe = Message,
    _pipe@1 = text_body(_pipe, Text),
    html_body(_pipe@1, Html).

-file("src/lumenmail/message.gleam", 190).
?DOC(" Adds an attachment.\n").
-spec attachment(message(), binary(), content_type(), bitstring()) -> message().
attachment(Message, Filename, Content_type, Data) ->
    Att = {attachment, Filename, Content_type, Data, false, none},
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        lists:append(erlang:element(10, Message), [Att]),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 208).
?DOC(" Adds an inline attachment (e.g., for images in HTML).\n").
-spec inline_attachment(
    message(),
    binary(),
    content_type(),
    bitstring(),
    binary()
) -> message().
inline_attachment(Message, Filename, Content_type, Data, Content_id) ->
    Att = {attachment, Filename, Content_type, Data, true, {some, Content_id}},
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        lists:append(erlang:element(10, Message), [Att]),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 227).
?DOC(" Adds a custom header.\n").
-spec header(message(), binary(), binary()) -> message().
header(Message, Name, Value) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        lists:append(erlang:element(11, Message), [{header, Name, Value}]),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 235).
?DOC(" Sets the message priority.\n").
-spec priority(message(), priority()) -> message().
priority(Message, Priority) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        Priority,
        erlang:element(13, Message),
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 240).
?DOC(" Sets the Message-ID header.\n").
-spec message_id(message(), binary()) -> message().
message_id(Message, Id) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        {some, Id},
        erlang:element(14, Message),
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 245).
?DOC(" Sets the In-Reply-To header (for threading).\n").
-spec in_reply_to(message(), binary()) -> message().
in_reply_to(Message, Id) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        {some, Id},
        erlang:element(15, Message)}.

-file("src/lumenmail/message.gleam", 250).
?DOC(" Adds a reference message ID (for threading).\n").
-spec add_reference(message(), binary()) -> message().
add_reference(Message, Id) ->
    {message,
        erlang:element(2, Message),
        erlang:element(3, Message),
        erlang:element(4, Message),
        erlang:element(5, Message),
        erlang:element(6, Message),
        erlang:element(7, Message),
        erlang:element(8, Message),
        erlang:element(9, Message),
        erlang:element(10, Message),
        erlang:element(11, Message),
        erlang:element(12, Message),
        erlang:element(13, Message),
        erlang:element(14, Message),
        lists:append(erlang:element(15, Message), [Id])}.

-file("src/lumenmail/message.gleam", 255).
?DOC(" Gets all recipients (to + cc + bcc).\n").
-spec all_recipients(message()) -> list(lumenmail@types:address()).
all_recipients(Message) ->
    lists:append(
        [erlang:element(4, Message),
            erlang:element(5, Message),
            erlang:element(6, Message)]
    ).

-file("src/lumenmail/message.gleam", 260).
?DOC(" Formats an address for use in email headers.\n").
-spec format_address(lumenmail@types:address()) -> binary().
format_address(Address) ->
    case erlang:element(2, Address) of
        {some, Name} ->
            <<<<<<<<"\""/utf8, Name/binary>>/binary, "\" <"/utf8>>/binary,
                    (erlang:element(3, Address))/binary>>/binary,
                ">"/utf8>>;

        none ->
            erlang:element(3, Address)
    end.

-file("src/lumenmail/message.gleam", 268).
?DOC(" Formats a list of addresses for use in email headers.\n").
-spec format_address_list(list(lumenmail@types:address())) -> binary().
format_address_list(Addresses) ->
    _pipe = Addresses,
    _pipe@1 = gleam@list:map(_pipe, fun format_address/1),
    gleam@string:join(_pipe@1, <<", "/utf8>>).

-file("src/lumenmail/message.gleam", 275).
?DOC(" Converts content type to MIME string.\n").
-spec content_type_to_string(content_type()) -> binary().
content_type_to_string(Ct) ->
    case Ct of
        text_plain ->
            <<"text/plain"/utf8>>;

        text_html ->
            <<"text/html"/utf8>>;

        multipart_alternative ->
            <<"multipart/alternative"/utf8>>;

        multipart_mixed ->
            <<"multipart/mixed"/utf8>>;

        multipart_related ->
            <<"multipart/related"/utf8>>;

        application_octet_stream ->
            <<"application/octet-stream"/utf8>>;

        {custom, Mime} ->
            Mime
    end.

-file("src/lumenmail/message.gleam", 288).
?DOC(" Generates a random boundary string for multipart messages.\n").
-spec generate_boundary() -> binary().
generate_boundary() ->
    <<<<"----=_Part_"/utf8, "gleam_lumenmail_boundary_"/utf8>>/binary,
        "0123456789"/utf8>>.

-file("src/lumenmail/message.gleam", 306).
-spec build_message_string(message(), lumenmail@types:address()) -> binary().
build_message_string(Message, From_addr) ->
    Builder = gleam@string_tree:new(),
    Boundary = generate_boundary(),
    Builder@1 = begin
        _pipe = Builder,
        gleam@string_tree:append(
            _pipe,
            <<<<"From: "/utf8, (format_address(From_addr))/binary>>/binary,
                "\r\n"/utf8>>
        )
    end,
    Builder@2 = case erlang:element(4, Message) of
        [] ->
            Builder@1;

        Addrs ->
            _pipe@1 = Builder@1,
            gleam@string_tree:append(
                _pipe@1,
                <<<<"To: "/utf8, (format_address_list(Addrs))/binary>>/binary,
                    "\r\n"/utf8>>
            )
    end,
    Builder@3 = case erlang:element(5, Message) of
        [] ->
            Builder@2;

        Addrs@1 ->
            _pipe@2 = Builder@2,
            gleam@string_tree:append(
                _pipe@2,
                <<<<"Cc: "/utf8, (format_address_list(Addrs@1))/binary>>/binary,
                    "\r\n"/utf8>>
            )
    end,
    Builder@4 = case erlang:element(3, Message) of
        none ->
            Builder@3;

        {some, Addr} ->
            _pipe@3 = Builder@3,
            gleam@string_tree:append(
                _pipe@3,
                <<<<"Reply-To: "/utf8, (format_address(Addr))/binary>>/binary,
                    "\r\n"/utf8>>
            )
    end,
    Builder@5 = case erlang:element(7, Message) of
        none ->
            Builder@4;

        {some, Subj} ->
            _pipe@4 = Builder@4,
            gleam@string_tree:append(
                _pipe@4,
                <<<<"Subject: "/utf8, Subj/binary>>/binary, "\r\n"/utf8>>
            )
    end,
    Builder@6 = case erlang:element(13, Message) of
        none ->
            Builder@5;

        {some, Id} ->
            _pipe@5 = Builder@5,
            gleam@string_tree:append(
                _pipe@5,
                <<<<"Message-ID: <"/utf8, Id/binary>>/binary, ">\r\n"/utf8>>
            )
    end,
    Builder@7 = case erlang:element(14, Message) of
        none ->
            Builder@6;

        {some, Id@1} ->
            _pipe@6 = Builder@6,
            gleam@string_tree:append(
                _pipe@6,
                <<<<"In-Reply-To: <"/utf8, Id@1/binary>>/binary, ">\r\n"/utf8>>
            )
    end,
    Builder@8 = case erlang:element(15, Message) of
        [] ->
            Builder@7;

        Refs ->
            Refs_str = begin
                _pipe@7 = Refs,
                _pipe@8 = gleam@list:map(
                    _pipe@7,
                    fun(R) -> <<<<"<"/utf8, R/binary>>/binary, ">"/utf8>> end
                ),
                gleam@string:join(_pipe@8, <<" "/utf8>>)
            end,
            _pipe@9 = Builder@7,
            gleam@string_tree:append(
                _pipe@9,
                <<<<"References: "/utf8, Refs_str/binary>>/binary, "\r\n"/utf8>>
            )
    end,
    Builder@9 = case erlang:element(12, Message) of
        high ->
            _pipe@10 = Builder@8,
            _pipe@11 = gleam@string_tree:append(
                _pipe@10,
                <<"X-Priority: 1\r\n"/utf8>>
            ),
            gleam@string_tree:append(_pipe@11, <<"Importance: high\r\n"/utf8>>);

        normal ->
            Builder@8;

        low ->
            _pipe@12 = Builder@8,
            _pipe@13 = gleam@string_tree:append(
                _pipe@12,
                <<"X-Priority: 5\r\n"/utf8>>
            ),
            gleam@string_tree:append(_pipe@13, <<"Importance: low\r\n"/utf8>>)
    end,
    Builder@10 = gleam@list:fold(
        erlang:element(11, Message),
        Builder@9,
        fun(B, H) -> _pipe@14 = B,
            gleam@string_tree:append(
                _pipe@14,
                <<<<<<(erlang:element(2, H))/binary, ": "/utf8>>/binary,
                        (erlang:element(3, H))/binary>>/binary,
                    "\r\n"/utf8>>
            ) end
    ),
    Builder@11 = begin
        _pipe@15 = Builder@10,
        gleam@string_tree:append(_pipe@15, <<"MIME-Version: 1.0\r\n"/utf8>>)
    end,
    Builder@13 = case {erlang:element(8, Message),
        erlang:element(9, Message),
        gleam@list:is_empty(erlang:element(10, Message))} of
        {{some, Text}, none, true} ->
            _pipe@16 = Builder@11,
            _pipe@17 = gleam@string_tree:append(
                _pipe@16,
                <<"Content-Type: text/plain; charset=utf-8\r\n\r\n"/utf8>>
            ),
            gleam@string_tree:append(_pipe@17, Text);

        {none, {some, Html}, true} ->
            _pipe@18 = Builder@11,
            _pipe@19 = gleam@string_tree:append(
                _pipe@18,
                <<"Content-Type: text/html; charset=utf-8\r\n\r\n"/utf8>>
            ),
            gleam@string_tree:append(_pipe@19, Html);

        {{some, Text@1}, {some, Html@1}, true} ->
            _pipe@20 = Builder@11,
            _pipe@21 = gleam@string_tree:append(
                _pipe@20,
                <<<<"Content-Type: multipart/alternative; boundary=\""/utf8,
                        Boundary/binary>>/binary,
                    "\"\r\n\r\n"/utf8>>
            ),
            _pipe@22 = gleam@string_tree:append(
                _pipe@21,
                <<<<"--"/utf8, Boundary/binary>>/binary, "\r\n"/utf8>>
            ),
            _pipe@23 = gleam@string_tree:append(
                _pipe@22,
                <<"Content-Type: text/plain; charset=utf-8\r\n\r\n"/utf8>>
            ),
            _pipe@24 = gleam@string_tree:append(
                _pipe@23,
                <<Text@1/binary, "\r\n\r\n"/utf8>>
            ),
            _pipe@25 = gleam@string_tree:append(
                _pipe@24,
                <<<<"--"/utf8, Boundary/binary>>/binary, "\r\n"/utf8>>
            ),
            _pipe@26 = gleam@string_tree:append(
                _pipe@25,
                <<"Content-Type: text/html; charset=utf-8\r\n\r\n"/utf8>>
            ),
            _pipe@27 = gleam@string_tree:append(
                _pipe@26,
                <<Html@1/binary, "\r\n\r\n"/utf8>>
            ),
            gleam@string_tree:append(
                _pipe@27,
                <<<<"--"/utf8, Boundary/binary>>/binary, "--\r\n"/utf8>>
            );

        {Text_opt, Html_opt, false} ->
            Mixed_boundary = <<Boundary/binary, "_mixed"/utf8>>,
            Alt_boundary = <<Boundary/binary, "_alt"/utf8>>,
            B@1 = begin
                _pipe@28 = Builder@11,
                gleam@string_tree:append(
                    _pipe@28,
                    <<<<"Content-Type: multipart/mixed; boundary=\""/utf8,
                            Mixed_boundary/binary>>/binary,
                        "\"\r\n\r\n"/utf8>>
                )
            end,
            B@2 = case {Text_opt, Html_opt} of
                {{some, Text@2}, {some, Html@2}} ->
                    _pipe@29 = B@1,
                    _pipe@30 = gleam@string_tree:append(
                        _pipe@29,
                        <<<<"--"/utf8, Mixed_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@31 = gleam@string_tree:append(
                        _pipe@30,
                        <<<<"Content-Type: multipart/alternative; boundary=\""/utf8,
                                Alt_boundary/binary>>/binary,
                            "\"\r\n\r\n"/utf8>>
                    ),
                    _pipe@32 = gleam@string_tree:append(
                        _pipe@31,
                        <<<<"--"/utf8, Alt_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@33 = gleam@string_tree:append(
                        _pipe@32,
                        <<"Content-Type: text/plain; charset=utf-8\r\n\r\n"/utf8>>
                    ),
                    _pipe@34 = gleam@string_tree:append(
                        _pipe@33,
                        <<Text@2/binary, "\r\n\r\n"/utf8>>
                    ),
                    _pipe@35 = gleam@string_tree:append(
                        _pipe@34,
                        <<<<"--"/utf8, Alt_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@36 = gleam@string_tree:append(
                        _pipe@35,
                        <<"Content-Type: text/html; charset=utf-8\r\n\r\n"/utf8>>
                    ),
                    _pipe@37 = gleam@string_tree:append(
                        _pipe@36,
                        <<Html@2/binary, "\r\n\r\n"/utf8>>
                    ),
                    gleam@string_tree:append(
                        _pipe@37,
                        <<<<"--"/utf8, Alt_boundary/binary>>/binary,
                            "--\r\n"/utf8>>
                    );

                {{some, Text@3}, none} ->
                    _pipe@38 = B@1,
                    _pipe@39 = gleam@string_tree:append(
                        _pipe@38,
                        <<<<"--"/utf8, Mixed_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@40 = gleam@string_tree:append(
                        _pipe@39,
                        <<"Content-Type: text/plain; charset=utf-8\r\n\r\n"/utf8>>
                    ),
                    gleam@string_tree:append(
                        _pipe@40,
                        <<Text@3/binary, "\r\n\r\n"/utf8>>
                    );

                {none, {some, Html@3}} ->
                    _pipe@41 = B@1,
                    _pipe@42 = gleam@string_tree:append(
                        _pipe@41,
                        <<<<"--"/utf8, Mixed_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@43 = gleam@string_tree:append(
                        _pipe@42,
                        <<"Content-Type: text/html; charset=utf-8\r\n\r\n"/utf8>>
                    ),
                    gleam@string_tree:append(
                        _pipe@43,
                        <<Html@3/binary, "\r\n\r\n"/utf8>>
                    );

                {none, none} ->
                    B@1
            end,
            B@3 = gleam@list:fold(
                erlang:element(10, Message),
                B@2,
                fun(Builder@12, Att) ->
                    Disposition = case erlang:element(5, Att) of
                        true ->
                            <<"inline"/utf8>>;

                        false ->
                            <<"attachment"/utf8>>
                    end,
                    Ct = content_type_to_string(erlang:element(3, Att)),
                    _pipe@44 = Builder@12,
                    _pipe@45 = gleam@string_tree:append(
                        _pipe@44,
                        <<<<"--"/utf8, Mixed_boundary/binary>>/binary,
                            "\r\n"/utf8>>
                    ),
                    _pipe@46 = gleam@string_tree:append(
                        _pipe@45,
                        <<<<<<<<"Content-Type: "/utf8, Ct/binary>>/binary,
                                    "; name=\""/utf8>>/binary,
                                (erlang:element(2, Att))/binary>>/binary,
                            "\"\r\n"/utf8>>
                    ),
                    _pipe@47 = gleam@string_tree:append(
                        _pipe@46,
                        <<"Content-Transfer-Encoding: base64\r\n"/utf8>>
                    ),
                    _pipe@48 = gleam@string_tree:append(
                        _pipe@47,
                        <<<<<<<<"Content-Disposition: "/utf8,
                                        Disposition/binary>>/binary,
                                    "; filename=\""/utf8>>/binary,
                                (erlang:element(2, Att))/binary>>/binary,
                            "\"\r\n"/utf8>>
                    ),
                    _pipe@49 = gleam@string_tree:append(
                        _pipe@48,
                        case erlang:element(6, Att) of
                            {some, Cid} ->
                                <<<<"Content-ID: <"/utf8, Cid/binary>>/binary,
                                    ">\r\n"/utf8>>;

                            none ->
                                <<""/utf8>>
                        end
                    ),
                    _pipe@50 = gleam@string_tree:append(
                        _pipe@49,
                        <<"\r\n"/utf8>>
                    ),
                    gleam@string_tree:append(
                        _pipe@50,
                        <<(gleam_stdlib:base64_encode(
                                erlang:element(4, Att),
                                true
                            ))/binary,
                            "\r\n\r\n"/utf8>>
                    )
                end
            ),
            _pipe@51 = B@3,
            gleam@string_tree:append(
                _pipe@51,
                <<<<"--"/utf8, Mixed_boundary/binary>>/binary, "--\r\n"/utf8>>
            );

        {none, none, true} ->
            _pipe@52 = Builder@11,
            gleam@string_tree:append(
                _pipe@52,
                <<"Content-Type: text/plain; charset=utf-8\r\n\r\n"/utf8>>
            )
    end,
    Result = unicode:characters_to_binary(Builder@13),
    case gleam_stdlib:string_ends_with(Result, <<"\r\n"/utf8>>) of
        true ->
            Result;

        false ->
            <<Result/binary, "\r\n"/utf8>>
    end.

-file("src/lumenmail/message.gleam", 294).
?DOC(" Builds the raw email message as a string.\n").
-spec build(message()) -> {ok, binary()} | {error, binary()}.
build(Message) ->
    case erlang:element(2, Message) of
        none ->
            {error, <<"From address is required"/utf8>>};

        {some, From_addr} ->
            case erlang:element(4, Message) of
                [] ->
                    {error, <<"At least one recipient is required"/utf8>>};

                _ ->
                    {ok, build_message_string(Message, From_addr)}
            end
    end.