-module(plunk@transactional).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/plunk/transactional.gleam").
-export([send/2, decode/1, send_transactional_email_decoder/0]).
-export_type([to/0, transactional_email/0, contact/0, email/0, send_transactional_email_response/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.

-type to() :: {address, binary()} | {addresses, list(binary())}.

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

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

-type email() :: {email, contact(), binary()}.

-type send_transactional_email_response() :: {send_transactional_email_response,
        boolean(),
        list(email()),
        gleam@option:option(binary())}.

-file("src/plunk/transactional.gleam", 102).
?DOC(
    "\n"
    " Send a transactional email\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import gleam/option.{None}\n"
    " import gleam/hackney\n"
    " import plunk\n"
    " import plunk/transactional.{Address, TransactionalEmail}\n"
    "\n"
    " fn main() {\n"
    "   let instance = plunk.new(key: \"YOUR_API_KEY\")\n"
    "\n"
    "   let req =\n"
    "     instance\n"
    "     |> transactional.send(\n"
    "       mail: TransactionalEmail(\n"
    "         to: Address(\"someone@example.com\"),\n"
    "         subject: \"Hello\",\n"
    "         body: \"<h1>Hello, World!</h1>\",\n"
    "         name: None,\n"
    "         from: None,\n"
    "       )\n"
    "     )\n"
    "   let assert Ok(resp) = hackney.send(req)\n"
    "   let assert Ok(data) = transactional.decode(resp)\n"
    "   // do whatever you want with the data\n"
    " }\n"
    " ```\n"
).
-spec send(plunk@instance:instance(), transactional_email()) -> gleam@http@request:request(binary()).
send(Instance, Mail) ->
    Body = begin
        _pipe = [{<<"to"/utf8>>, case erlang:element(2, Mail) of
                    {address, Addr} ->
                        gleam@json:string(Addr);

                    {addresses, Addrs} ->
                        gleam@json:array(Addrs, fun gleam@json:string/1)
                end}, {<<"subject"/utf8>>,
                gleam@json:string(erlang:element(3, Mail))}, {<<"body"/utf8>>,
                gleam@json:string(erlang:element(4, Mail))}],
        _pipe@1 = plunk@internal@utils:omit_if_none(
            _pipe,
            <<"name"/utf8>>,
            erlang:element(5, Mail),
            fun gleam@json:string/1
        ),
        _pipe@2 = plunk@internal@utils:omit_if_none(
            _pipe@1,
            <<"from"/utf8>>,
            erlang:element(6, Mail),
            fun gleam@json:string/1
        ),
        _pipe@3 = gleam@json:object(_pipe@2),
        gleam@json:to_string(_pipe@3)
    end,
    _pipe@4 = Instance,
    plunk@internal@bridge:make_request(_pipe@4, <<"/send"/utf8>>, post, Body).

-file("src/plunk/transactional.gleam", 49).
-spec email_decoder() -> gleam@dynamic@decode:decoder(email()).
email_decoder() ->
    gleam@dynamic@decode:field(
        <<"contact"/utf8>>,
        contact_decoder(),
        fun(Contact) ->
            gleam@dynamic@decode:field(
                <<"email"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Email) ->
                    gleam@dynamic@decode:success({email, Contact, Email})
                end
            )
        end
    ).

-file("src/plunk/transactional.gleam", 125).
?DOC(" Decode the raw response into a `SendTransactionalEmailResponse` type wrapped in a `Result` type that can be pattern matched on.\n").
-spec decode(gleam@http@response:response(binary())) -> {ok,
        send_transactional_email_response()} |
    {error, plunk@types:plunk_error()}.
decode(Res) ->
    _pipe = Res,
    plunk@internal@bridge:decode(_pipe, fun send_transactional_email_decoder/0).

-file("src/plunk/transactional.gleam", 55).
-spec send_transactional_email_decoder() -> gleam@dynamic@decode:decoder(send_transactional_email_response()).
send_transactional_email_decoder() ->
    gleam@dynamic@decode:field(
        <<"success"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_bool/1},
        fun(Success) ->
            gleam@dynamic@decode:field(
                <<"emails"/utf8>>,
                gleam@dynamic@decode:list(email_decoder()),
                fun(Emails) ->
                    gleam@dynamic@decode:optional_field(
                        <<"timestamp"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Timestamp) ->
                            gleam@dynamic@decode:success(
                                {send_transactional_email_response,
                                    Success,
                                    Emails,
                                    Timestamp}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/plunk/transactional.gleam", 43).
-spec contact_decoder() -> gleam@dynamic@decode:decoder(contact()).
contact_decoder() ->
    gleam@dynamic@decode:field(
        <<"id"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Id) ->
            gleam@dynamic@decode:field(
                <<"email"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Email) ->
                    gleam@dynamic@decode:success({contact, Id, Email})
                end
            )
        end
    ).