-module(telega).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([set_webhook/1, is_webhook_path/2, is_secret_token_valid/2, reply/2, add_handler/2, decode_message/1, handle_update/2, new/4]).
-export_type([message_update/0, chat/0, config/0, bot/0, handler/0, message/0, context/0]).

-type message_update() :: {message_update, message()}.

-type chat() :: {chat, integer()}.

-opaque config() :: {config,
        binary(),
        binary(),
        binary(),
        binary(),
        gleam@option:option(binary())}.

-type bot() :: {bot, config(), list(handler())}.

-type handler() :: {handle_all, fun((context()) -> {ok, nil} | {error, nil})}.

-type message() :: {text_message, binary(), chat()}.

-type context() :: {context, message(), bot()}.

-spec set_webhook(bot()) -> {ok, boolean()} | {error, binary()}.
set_webhook(Bot) ->
    Webhook_url = <<<<(erlang:element(3, erlang:element(2, Bot)))/binary,
            "/"/utf8>>/binary,
        (erlang:element(4, erlang:element(2, Bot)))/binary>>,
    gleam@result:'try'(
        telega@api:set_webhook(
            erlang:element(2, erlang:element(2, Bot)),
            Webhook_url,
            erlang:element(5, erlang:element(2, Bot)),
            erlang:element(6, erlang:element(2, Bot))
        ),
        fun(Response) -> case erlang:element(2, Response) of
                200 ->
                    {ok, true};

                _ ->
                    {error, <<"Failed to set webhook"/utf8>>}
            end end
    ).

-spec is_webhook_path(bot(), binary()) -> boolean().
is_webhook_path(Bot, Path) ->
    erlang:element(4, erlang:element(2, Bot)) =:= Path.

-spec is_secret_token_valid(bot(), binary()) -> boolean().
is_secret_token_valid(Bot, Token) ->
    case erlang:element(6, erlang:element(2, Bot)) of
        {some, Secret} ->
            Secret =:= Token;

        none ->
            true
    end.

-spec reply(context(), binary()) -> {ok, nil} | {error, nil}.
reply(Ctx, Text) ->
    _pipe = telega@api:send_text(
        erlang:element(2, erlang:element(3, erlang:element(2, Ctx))),
        Text,
        erlang:element(2, erlang:element(2, erlang:element(3, Ctx))),
        erlang:element(5, erlang:element(2, erlang:element(3, Ctx)))
    ),
    _pipe@1 = gleam@result:map(_pipe, fun(_) -> nil end),
    gleam@result:nil_error(_pipe@1).

-spec add_handler(bot(), handler()) -> bot().
add_handler(Bot, Handler) ->
    erlang:setelement(3, Bot, [Handler | erlang:element(3, Bot)]).

-spec new_context(bot(), message()) -> context().
new_context(Bot, Message) ->
    {context, Message, Bot}.

-spec build_message_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
        message_update()} |
    {error, list(gleam@dynamic:decode_error())}).
build_message_decoder() ->
    gleam@dynamic:decode1(
        fun(Field@0) -> {message_update, Field@0} end,
        gleam@dynamic:field(
            <<"message"/utf8>>,
            gleam@dynamic:decode2(
                fun(Field@0, Field@1) -> {text_message, Field@0, Field@1} end,
                gleam@dynamic:field(<<"text"/utf8>>, fun gleam@dynamic:string/1),
                gleam@dynamic:field(
                    <<"chat"/utf8>>,
                    gleam@dynamic:decode1(
                        fun(Field@0) -> {chat, Field@0} end,
                        gleam@dynamic:field(
                            <<"id"/utf8>>,
                            fun gleam@dynamic:int/1
                        )
                    )
                )
            )
        )
    ).

-spec decode_message(gleam@dynamic:dynamic_()) -> {ok, message()} |
    {error, list(gleam@dynamic:decode_error())}.
decode_message(Json) ->
    Decode = build_message_decoder(),
    gleam@result:'try'(
        Decode(Json),
        fun(Message_update) -> {ok, erlang:element(2, Message_update)} end
    ).

-spec do_handle_update(bot(), message(), list(handler())) -> nil.
do_handle_update(Bot, Message, Handlers) ->
    case Handlers of
        [Handler | Rest] ->
            case (erlang:element(2, Handler))(new_context(Bot, Message)) of
                {ok, _} ->
                    do_handle_update(Bot, Message, Rest);

                {error, _} ->
                    logging:log(error, <<"Failed to handle message"/utf8>>),
                    nil
            end;

        _ ->
            nil
    end.

-spec handle_update(bot(), message()) -> nil.
handle_update(Bot, Message) ->
    do_handle_update(Bot, Message, erlang:element(3, Bot)).

-spec new(binary(), binary(), binary(), gleam@option:option(binary())) -> bot().
new(Token, Server_url, Webhook_path, Secret_token) ->
    {bot,
        {config,
            Token,
            Server_url,
            Webhook_path,
            <<"https://api.telegram.org/bot"/utf8>>,
            Secret_token},
        []}.