zeptomail

-module(zeptomail).
-compile(no_auto_import).

-export([email_request/2, decode_email_response/1]).
-export_type([email/0, addressee/0, body/0, api_data/0, api_datum/0, api_error/0, api_error_detail/0]).

-type email() :: {email,
                  addressee(),
                  list(addressee()),
                  list(addressee()),
                  list(addressee()),
                  list(addressee()),
                  body(),
                  binary()}.

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

-type body() :: {text_body, binary()} | {html_body, binary()}.

-type api_data() :: {api_data, binary(), binary(), binary(), list(api_datum())}.

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

-type api_error() :: {api_error, binary(), binary(), list(api_error_detail())} |
    {unexpected_response, gleam@json:decode_error()}.

-type api_error_detail() :: {api_error_detail,
                             binary(),
                             binary(),
                             gleam@option:option(binary()),
                             gleam@option:option(binary())}.

-spec email_request(email(), binary()) -> gleam@http@request:request(binary()).
email_request(Email, Api_token) ->
    Body = begin
        _pipe = Email,
        _pipe@1 = encode_email(_pipe),
        gleam@json:to_string(_pipe@1)
    end,
    _pipe@2 = gleam@http@request:new(),
    _pipe@3 = gleam@http@request:set_method(_pipe@2, post),
    _pipe@4 = gleam@http@request:set_host(_pipe@3, <<"api.zeptomail.com"/utf8>>),
    _pipe@5 = gleam@http@request:set_path(_pipe@4, <<"/v1.1/email"/utf8>>),
    _pipe@6 = gleam@http@request:set_body(_pipe@5, Body),
    gleam@http@request:prepend_header(
        _pipe@6,
        <<"authorization"/utf8>>,
        Api_token
    ).

-spec decode_email_response(gleam@http@response:response(binary())) -> {ok,
                                                                        api_data()} |
    {error, api_error()}.
decode_email_response(Response) ->
    case (erlang:element(2, Response)
    >= 200)
    andalso (erlang:element(2, Response)
    < 300) of
        true ->
            _pipe = gleam@json:decode(
                erlang:element(4, Response),
                api_data_decoder()
            ),
            gleam@result:map_error(
                _pipe,
                fun(A) -> {unexpected_response, A} end
            );

        false ->
            _pipe@1 = gleam@json:decode(
                erlang:element(4, Response),
                api_error_decoder()
            ),
            _pipe@2 = gleam@result:map_error(
                _pipe@1,
                fun(A) -> {unexpected_response, A} end
            ),
            gleam@result:then(_pipe@2, fun(A) -> {error, A} end)
    end.

-spec encode_email(email()) -> gleam@json:json().
encode_email(Email) ->
    Bodykind = case erlang:element(7, Email) of
        {text_body, _@1} ->
            <<"textbody"/utf8>>;

        {html_body, _@2} ->
            <<"htmlbody"/utf8>>
    end,
    Addressee_array = fun(Addressees) ->
        gleam@json:array(
            Addressees,
            fun(A) ->
                gleam@json:object(
                    [{<<"email_address"/utf8>>, encode_addressee(A)}]
                )
            end
        )
    end,
    gleam@json:object(
        [{<<"from"/utf8>>, encode_addressee(erlang:element(2, Email))},
         {<<"to"/utf8>>, Addressee_array(erlang:element(3, Email))},
         {<<"cc"/utf8>>, Addressee_array(erlang:element(4, Email))},
         {<<"bcc"/utf8>>, Addressee_array(erlang:element(5, Email))},
         {<<"reply_to"/utf8>>,
          gleam@json:array(erlang:element(6, Email), fun encode_addressee/1)},
         {<<"subject"/utf8>>, gleam@json:string(erlang:element(8, Email))},
         {Bodykind,
          gleam@json:string(erlang:element(2, erlang:element(7, Email)))}]
    ).

-spec encode_addressee(addressee()) -> gleam@json:json().
encode_addressee(Addressee) ->
    gleam@json:object(
        [{<<"name"/utf8>>, gleam@json:string(erlang:element(2, Addressee))},
         {<<"address"/utf8>>, gleam@json:string(erlang:element(3, Addressee))}]
    ).

-spec api_data_decoder() -> fun((gleam@dynamic:dynamic()) -> {ok, api_data()} |
    {error, list(gleam@dynamic:decode_error())}).
api_data_decoder() ->
    gleam@dynamic:decode4(
        fun(A, B, C, D) -> {api_data, A, B, C, D} end,
        gleam@dynamic:field(<<"object"/utf8>>, fun gleam@dynamic:string/1),
        gleam@dynamic:field(<<"request_id"/utf8>>, fun gleam@dynamic:string/1),
        gleam@dynamic:field(<<"message"/utf8>>, fun gleam@dynamic:string/1),
        gleam@dynamic:field(
            <<"data"/utf8>>,
            gleam@dynamic:list(api_datum_decoder())
        )
    ).

-spec api_datum_decoder() -> fun((gleam@dynamic:dynamic()) -> {ok, api_datum()} |
    {error, list(gleam@dynamic:decode_error())}).
api_datum_decoder() ->
    gleam@dynamic:decode2(
        fun(A, B) -> {api_datum, A, B} end,
        gleam@dynamic:field(<<"code"/utf8>>, fun gleam@dynamic:string/1),
        gleam@dynamic:field(<<"message"/utf8>>, fun gleam@dynamic:string/1)
    ).

-spec api_error_decoder() -> fun((gleam@dynamic:dynamic()) -> {ok, api_error()} |
    {error, list(gleam@dynamic:decode_error())}).
api_error_decoder() ->
    gleam@dynamic:field(
        <<"error"/utf8>>,
        gleam@dynamic:decode3(
            fun(A, B, C) -> {api_error, A, B, C} end,
            gleam@dynamic:field(<<"code"/utf8>>, fun gleam@dynamic:string/1),
            gleam@dynamic:field(<<"message"/utf8>>, fun gleam@dynamic:string/1),
            gleam@dynamic:field(
                <<"details"/utf8>>,
                gleam@dynamic:list(api_error_detail_encoder())
            )
        )
    ).

-spec api_error_detail_encoder() -> fun((gleam@dynamic:dynamic()) -> {ok,
                                                                      api_error_detail()} |
    {error, list(gleam@dynamic:decode_error())}).
api_error_detail_encoder() ->
    Optional_string = fun(Field) ->
        gleam@dynamic:any(
            [gleam@dynamic:field(
                 Field,
                 gleam@dynamic:optional(fun gleam@dynamic:string/1)
             ),
             fun(_) -> {ok, none} end]
        )
    end,
    gleam@dynamic:decode4(
        fun(A, B, C, D) -> {api_error_detail, A, B, C, D} end,
        gleam@dynamic:field(<<"code"/utf8>>, fun gleam@dynamic:string/1),
        gleam@dynamic:field(<<"message"/utf8>>, fun gleam@dynamic:string/1),
        Optional_string(<<"target"/utf8>>),
        Optional_string(<<"target_value"/utf8>>)
    ).