-module(sendr_lettermint).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sendr_lettermint.gleam").
-export([config/1, set_route/2, request/2, response/1]).
-export_type([lettermint_error/0, lettermint_config/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(
    " sendr_lettermint — Lettermint email backend for sendr.\n"
    "\n"
    " Builds HTTP `Request` values for the Lettermint send API and parses\n"
    " `Response` values returned by it.\n"
).

-type lettermint_error() :: {invalid_uri, binary()} |
    {invalid_response, integer(), gleam@json:decode_error()} |
    {api_error, integer(), gleam@option:option(binary()), binary()}.

-opaque lettermint_config() :: {lettermint_config, binary(), binary()}.

-file("src/sendr_lettermint.gleam", 45).
?DOC(" Create a new `LettermintConfig` with the given API token.\n").
-spec config(binary()) -> lettermint_config().
config(Token) ->
    {lettermint_config, Token, <<""/utf8>>}.

-file("src/sendr_lettermint.gleam", 52).
?DOC(
    " Set the route for this config.\n"
    "\n"
    " Routes control deliverability settings in your Lettermint account.\n"
).
-spec set_route(lettermint_config(), binary()) -> lettermint_config().
set_route(Config, Route) ->
    {lettermint_config, erlang:element(2, Config), Route}.

-file("src/sendr_lettermint.gleam", 296).
-spec add(list({binary(), gleam@json:json()}), binary(), gleam@json:json()) -> list({binary(),
    gleam@json:json()}).
add(Entries, Key, Value) ->
    lists:append(Entries, [{Key, Value}]).

-file("src/sendr_lettermint.gleam", 304).
-spec add_if_some(
    list({binary(), gleam@json:json()}),
    binary(),
    gleam@option:option(gleam@json:json())
) -> list({binary(), gleam@json:json()}).
add_if_some(Entries, Key, Value) ->
    case Value of
        {some, Value@1} ->
            add(Entries, Key, Value@1);

        none ->
            Entries
    end.

-file("src/sendr_lettermint.gleam", 271).
-spec attachment_to_json(sendr@message@attachment:attachment()) -> gleam@json:json().
attachment_to_json(Attachment) ->
    Filename@1 = case erlang:element(3, Attachment) of
        <<""/utf8>> ->
            erlang:element(4, Attachment);

        Filename ->
            Filename
    end,
    Content = gleam_stdlib:base64_encode(erlang:element(5, Attachment), true),
    Content_type = case erlang:element(2, Attachment) of
        <<""/utf8>> ->
            <<"application/octet-stream"/utf8>>;

        Ct ->
            Ct
    end,
    gleam@json:object(
        begin
            _pipe = [{<<"filename"/utf8>>, gleam@json:string(Filename@1)},
                {<<"content"/utf8>>, gleam@json:string(Content)},
                {<<"content_type"/utf8>>, gleam@json:string(Content_type)}],
            add_if_some(_pipe, <<"content_id"/utf8>>, case Attachment of
                    {inlined_attachment, _, _, _, _, Cid} when Cid =/= <<""/utf8>> ->
                        {some, gleam@json:string(Cid)};

                    _ ->
                        none
                end)
        end
    ).

-file("src/sendr_lettermint.gleam", 264).
-spec mailbox_to_json(sendr@message@mailbox:mailbox()) -> gleam@json:json().
mailbox_to_json(Mailbox) ->
    case Mailbox of
        {mailbox, <<""/utf8>>, Address} ->
            gleam@json:string(Address);

        {mailbox, Name, Address@1} ->
            gleam@json:string(
                <<<<<<Name/binary, " <"/utf8>>/binary, Address@1/binary>>/binary,
                    ">"/utf8>>
            )
    end.

-file("src/sendr_lettermint.gleam", 232).
-spec build_body(sendr@message:message(), lettermint_config()) -> gleam@json:json().
build_body(Message, Config) ->
    _pipe = [],
    _pipe@1 = add_if_some(
        _pipe,
        <<"route"/utf8>>,
        case erlang:element(3, Config) of
            <<""/utf8>> ->
                none;

            Route ->
                {some, gleam@json:string(Route)}
        end
    ),
    _pipe@2 = add_if_some(
        _pipe@1,
        <<"from"/utf8>>,
        gleam@option:map(erlang:element(2, Message), fun mailbox_to_json/1)
    ),
    _pipe@3 = add_if_some(
        _pipe@2,
        <<"reply_to"/utf8>>,
        gleam@option:map(
            erlang:element(3, Message),
            fun(Mailboxes) ->
                gleam@json:array(Mailboxes, fun mailbox_to_json/1)
            end
        )
    ),
    _pipe@4 = add_if_some(
        _pipe@3,
        <<"to"/utf8>>,
        gleam@option:map(
            erlang:element(4, Message),
            fun(_capture) ->
                gleam@json:array(_capture, fun mailbox_to_json/1)
            end
        )
    ),
    _pipe@5 = add_if_some(
        _pipe@4,
        <<"cc"/utf8>>,
        gleam@option:map(
            erlang:element(5, Message),
            fun(_capture@1) ->
                gleam@json:array(_capture@1, fun mailbox_to_json/1)
            end
        )
    ),
    _pipe@6 = add_if_some(
        _pipe@5,
        <<"bcc"/utf8>>,
        gleam@option:map(
            erlang:element(6, Message),
            fun(_capture@2) ->
                gleam@json:array(_capture@2, fun mailbox_to_json/1)
            end
        )
    ),
    _pipe@7 = add_if_some(
        _pipe@6,
        <<"subject"/utf8>>,
        gleam@option:map(erlang:element(7, Message), fun gleam@json:string/1)
    ),
    _pipe@8 = add_if_some(
        _pipe@7,
        <<"text"/utf8>>,
        gleam@option:map(
            erlang:element(2, erlang:element(9, Message)),
            fun gleam@json:string/1
        )
    ),
    _pipe@9 = add_if_some(
        _pipe@8,
        <<"html"/utf8>>,
        gleam@option:map(
            erlang:element(3, erlang:element(9, Message)),
            fun gleam@json:string/1
        )
    ),
    _pipe@10 = add(
        _pipe@9,
        <<"attachments"/utf8>>,
        gleam@json:array(erlang:element(8, Message), fun attachment_to_json/1)
    ),
    gleam@json:object(_pipe@10).

-file("src/sendr_lettermint.gleam", 219).
-spec validate_body(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_body(Message) ->
    Text_length = begin
        _pipe = erlang:element(2, erlang:element(9, Message)),
        gleam@option:map(_pipe, fun string:length/1)
    end,
    Html_length = begin
        _pipe@1 = erlang:element(3, erlang:element(9, Message)),
        gleam@option:map(_pipe@1, fun string:length/1)
    end,
    case {Text_length, Html_length} of
        {none, none} ->
            {error, {invalid_body, no_body}};

        {{some, 0}, {some, 0}} ->
            {error, {invalid_body, no_body}};

        {{some, Length}, _} when Length < 3 ->
            {error, {invalid_body, {text_to_short, 3, Length}}};

        {_, {some, Length@1}} when Length@1 < 3 ->
            {error, {invalid_body, {html_to_short, 3, Length@1}}};

        {_, _} ->
            {ok, nil}
    end.

-file("src/sendr_lettermint.gleam", 205).
-spec validate_attachments(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_attachments(Message) ->
    gleam@list:try_each(
        erlang:element(8, Message),
        fun(Attachment) ->
            case {erlang:element(3, Attachment), erlang:element(4, Attachment)} of
                {<<""/utf8>>, <<""/utf8>>} ->
                    {error,
                        {invalid_attachment,
                            required_filename_missing,
                            Attachment}};

                {_, _} ->
                    case Attachment of
                        {inlined_attachment, _, _, _, _, <<""/utf8>>} ->
                            {error,
                                {invalid_attachment,
                                    required_content_id_missing,
                                    Attachment}};

                        _ ->
                            {ok, nil}
                    end
            end
        end
    ).

-file("src/sendr_lettermint.gleam", 194).
-spec validate_subject(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_subject(Message) ->
    Subject_length = begin
        _pipe = erlang:element(7, Message),
        gleam@option:map(_pipe, fun string:length/1)
    end,
    case Subject_length of
        none ->
            {error, {required_field_missing, subject}};

        {some, 0} ->
            {error, {required_field_missing, subject}};

        {some, Length} when Length > 998 ->
            {error, {field_exceeds_maximum_length, subject, 998, Length}};

        _ ->
            {ok, nil}
    end.

-file("src/sendr_lettermint.gleam", 184).
-spec validate_mailbox(sendr@message@mailbox:mailbox(), sendr:field()) -> {ok,
        nil} |
    {error, sendr:sendr_error(any())}.
validate_mailbox(Mailbox, Field) ->
    case gleam@string:split_once(erlang:element(3, Mailbox), <<"@"/utf8>>) of
        {ok, {Local, Domain}} when (Local =/= <<""/utf8>>) andalso (Domain =/= <<""/utf8>>) ->
            {ok, nil};

        _ ->
            {error, {invalid_mailbox, Field, Mailbox}}
    end.

-file("src/sendr_lettermint.gleam", 155).
-spec validate_recipients(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_recipients(Message) ->
    Recipients = begin
        _pipe = [erlang:element(4, Message),
            erlang:element(5, Message),
            erlang:element(6, Message)],
        _pipe@1 = gleam@option:values(_pipe),
        lists:append(_pipe@1)
    end,
    Validate = fun(Mailboxes, Field) -> _pipe@2 = Mailboxes,
        _pipe@3 = gleam@option:unwrap(_pipe@2, []),
        gleam@list:try_each(
            _pipe@3,
            fun(_capture) -> validate_mailbox(_capture, Field) end
        ) end,
    case Recipients of
        [] ->
            {error, no_recipients};

        _ ->
            _pipe@4 = Validate(erlang:element(6, Message), bcc),
            _pipe@5 = gleam@result:'or'(
                _pipe@4,
                Validate(erlang:element(5, Message), cc)
            ),
            gleam@result:'or'(
                _pipe@5,
                begin
                    _pipe@6 = Validate(erlang:element(4, Message), to),
                    gleam@result:'try'(
                        _pipe@6,
                        fun(_) ->
                            case gleam@option:unwrap(
                                erlang:element(4, Message),
                                []
                            ) of
                                [] ->
                                    {error, {required_field_missing, to}};

                                _ ->
                                    {ok, nil}
                            end
                        end
                    )
                end
            )
    end.

-file("src/sendr_lettermint.gleam", 146).
-spec validate_reply_to(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_reply_to(Message) ->
    case erlang:element(3, Message) of
        none ->
            {ok, nil};

        {some, []} ->
            {ok, nil};

        {some, Mailboxes} ->
            _pipe = gleam@list:try_each(
                Mailboxes,
                fun(_capture) -> validate_mailbox(_capture, reply_to) end
            ),
            gleam@result:replace(_pipe, nil)
    end.

-file("src/sendr_lettermint.gleam", 139).
-spec validate_from(sendr@message:message()) -> {ok, nil} |
    {error, sendr:sendr_error(any())}.
validate_from(Message) ->
    case erlang:element(2, Message) of
        none ->
            {error, {required_field_missing, from}};

        {some, Mailbox} ->
            validate_mailbox(Mailbox, from)
    end.

-file("src/sendr_lettermint.gleam", 63).
?DOC(
    " Build an HTTP `Request` for the Lettermint send API from a sendr `Message`.\n"
    "\n"
    " Validates the message (from, reply-to, recipients, subject, attachments)\n"
    " and returns `Error(SendrError(LettermintError))` on validation failure.\n"
).
-spec request(sendr@message:message(), lettermint_config()) -> {ok,
        gleam@http@request:request(binary())} |
    {error, sendr:sendr_error(lettermint_error())}.
request(Message, Config) ->
    gleam@result:'try'(
        validate_from(Message),
        fun(_) ->
            gleam@result:'try'(
                validate_reply_to(Message),
                fun(_) ->
                    gleam@result:'try'(
                        validate_recipients(Message),
                        fun(_) ->
                            gleam@result:'try'(
                                validate_subject(Message),
                                fun(_) ->
                                    gleam@result:'try'(
                                        validate_attachments(Message),
                                        fun(_) ->
                                            gleam@result:'try'(
                                                validate_body(Message),
                                                fun(_) ->
                                                    Body = build_body(
                                                        Message,
                                                        Config
                                                    ),
                                                    _pipe = <<"https://api.lettermint.co/v1/send"/utf8>>,
                                                    _pipe@1 = gleam_stdlib:uri_parse(
                                                        _pipe
                                                    ),
                                                    _pipe@2 = gleam@result:'try'(
                                                        _pipe@1,
                                                        fun gleam@http@request:from_uri/1
                                                    ),
                                                    _pipe@3 = gleam@result:replace_error(
                                                        _pipe@2,
                                                        {invalid_uri,
                                                            <<"https://api.lettermint.co/v1/send"/utf8>>}
                                                    ),
                                                    _pipe@8 = gleam@result:map(
                                                        _pipe@3,
                                                        fun(Req) ->
                                                            _pipe@4 = Req,
                                                            _pipe@5 = gleam@http@request:set_method(
                                                                _pipe@4,
                                                                post
                                                            ),
                                                            _pipe@6 = gleam@http@request:set_header(
                                                                _pipe@5,
                                                                <<"content-type"/utf8>>,
                                                                <<"application/json"/utf8>>
                                                            ),
                                                            _pipe@7 = gleam@http@request:set_header(
                                                                _pipe@6,
                                                                <<"x-lettermint-token"/utf8>>,
                                                                erlang:element(
                                                                    2,
                                                                    Config
                                                                )
                                                            ),
                                                            gleam@http@request:set_body(
                                                                _pipe@7,
                                                                gleam@json:to_string(
                                                                    Body
                                                                )
                                                            )
                                                        end
                                                    ),
                                                    gleam@result:map_error(
                                                        _pipe@8,
                                                        fun(Field@0) -> {backend_error, Field@0} end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/sendr_lettermint.gleam", 95).
?DOC(
    " Parse a `Response` from the Lettermint send API.\n"
    "\n"
    " On HTTP 202 the response body is decoded and the `message_id` value\n"
    " is returned. On HTTP 422 the `detail` array is decoded into\n"
    " `ApiErrorDetail` entries. All other statuses are treated as generic\n"
    " API errors.\n"
).
-spec response(gleam@http@response:response(binary())) -> {ok, binary()} |
    {error, sendr:sendr_error(lettermint_error())}.
response(Response) ->
    case erlang:element(2, Response) of
        202 = Status ->
            Success_decoder = begin
                gleam@dynamic@decode:field(
                    <<"message_id"/utf8>>,
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    fun(Id) -> gleam@dynamic@decode:success(Id) end
                )
            end,
            _pipe = gleam@json:parse(
                erlang:element(4, Response),
                Success_decoder
            ),
            gleam@result:map_error(
                _pipe,
                fun(Error) ->
                    {backend_error, {invalid_response, Status, Error}}
                end
            );

        422 = Status@1 ->
            Error_decoder = begin
                gleam@dynamic@decode:field(
                    <<"error"/utf8>>,
                    begin
                        gleam@dynamic@decode:field(
                            <<"code"/utf8>>,
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            fun(Code) ->
                                gleam@dynamic@decode:field(
                                    <<"message"/utf8>>,
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1},
                                    fun(Message) ->
                                        gleam@dynamic@decode:success(
                                            {api_error,
                                                Status@1,
                                                {some, Code},
                                                Message}
                                        )
                                    end
                                )
                            end
                        )
                    end,
                    fun(Error@1) -> gleam@dynamic@decode:success(Error@1) end
                )
            end,
            case gleam@json:parse(erlang:element(4, Response), Error_decoder) of
                {ok, Api_error} ->
                    {error, {backend_error, Api_error}};

                {error, Error@2} ->
                    {error,
                        {backend_error, {invalid_response, Status@1, Error@2}}}
            end;

        Status@2 ->
            Error_decoder@1 = begin
                gleam@dynamic@decode:field(
                    <<"message"/utf8>>,
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    fun(Message@1) ->
                        gleam@dynamic@decode:success(
                            {api_error, Status@2, none, Message@1}
                        )
                    end
                )
            end,
            case gleam@json:parse(erlang:element(4, Response), Error_decoder@1) of
                {ok, Api_error@1} ->
                    {error, {backend_error, Api_error@1}};

                {error, Error@3} ->
                    {error,
                        {backend_error, {invalid_response, Status@2, Error@3}}}
            end
    end.