-module(discord_gleam@event_handler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([handle_event/4]).
-export_type([packet/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 packet() :: {message_packet,
        discord_gleam@ws@packets@message:message_packet()} |
    {message_update_packet,
        discord_gleam@ws@packets@message_update:message_update_packet()} |
    {ready_packet, discord_gleam@ws@packets@ready:ready_packet()} |
    {message_delete_packet,
        discord_gleam@ws@packets@message_delete:message_delete_packet()} |
    {interaction_create,
        discord_gleam@ws@packets@interaction_create:interaction_create()} |
    {unknown_packet, discord_gleam@ws@packets@generic:generic_packet()}.

-file("src/discord_gleam/event_handler.gleam", 34).
?DOC(" For handling some events the library needs to handle, for functionality\n").
-spec internal_handler(
    discord_gleam@types@bot:bot(),
    packet(),
    bravo@uset:u_set({binary(), binary()})
) -> nil.
internal_handler(Bot, Packet, State_uset) ->
    case Packet of
        {message_packet, Msg} ->
            case erlang:element(2, erlang:element(5, Bot)) of
                {some, Cache} ->
                    bravo@uset:insert(
                        Cache,
                        [{erlang:element(3, erlang:element(5, Msg)),
                                erlang:element(5, Msg)}]
                    ),
                    nil;

                none ->
                    nil
            end,
            nil;

        {message_update_packet, Msg@1} ->
            case erlang:element(2, erlang:element(5, Bot)) of
                {some, Cache@1} ->
                    bravo@uset:insert(
                        Cache@1,
                        [{erlang:element(3, erlang:element(5, Msg@1)),
                                erlang:element(5, Msg@1)}]
                    ),
                    nil;

                none ->
                    nil
            end;

        {ready_packet, Ready} ->
            bravo@uset:insert(
                State_uset,
                [{<<"session_id"/utf8>>,
                        erlang:element(4, erlang:element(5, Ready))}]
            ),
            bravo@uset:insert(
                State_uset,
                [{<<"resume_gateway_url"/utf8>>,
                        erlang:element(5, erlang:element(5, Ready))}]
            ),
            nil;

        _ ->
            nil
    end.

-file("src/discord_gleam/event_handler.gleam", 95).
-spec decode_packet(binary()) -> packet().
decode_packet(Msg) ->
    Generic_packet = discord_gleam@ws@packets@generic:string_to_data(Msg),
    case erlang:element(2, Generic_packet) of
        <<"MESSAGE_CREATE"/utf8>> ->
            _pipe = discord_gleam@ws@packets@message:string_to_data(Msg),
            _pipe@1 = gleam@result:map(
                _pipe,
                fun(Field@0) -> {message_packet, Field@0} end
            ),
            gleam@result:unwrap(_pipe@1, {unknown_packet, Generic_packet});

        <<"MESSAGE_UPDATE"/utf8>> ->
            _pipe@2 = discord_gleam@ws@packets@message_update:string_to_data(
                Msg
            ),
            _pipe@3 = gleam@result:map(
                _pipe@2,
                fun(Field@0) -> {message_update_packet, Field@0} end
            ),
            gleam@result:unwrap(_pipe@3, {unknown_packet, Generic_packet});

        <<"READY"/utf8>> ->
            _pipe@4 = discord_gleam@ws@packets@ready:string_to_data(Msg),
            _pipe@5 = gleam@result:map(
                _pipe@4,
                fun(Field@0) -> {ready_packet, Field@0} end
            ),
            gleam@result:unwrap(_pipe@5, {unknown_packet, Generic_packet});

        <<"MESSAGE_DELETE"/utf8>> ->
            _pipe@6 = discord_gleam@ws@packets@message_delete:string_to_data(
                Msg
            ),
            _pipe@7 = gleam@result:map(
                _pipe@6,
                fun(Field@0) -> {message_delete_packet, Field@0} end
            ),
            gleam@result:unwrap(_pipe@7, {unknown_packet, Generic_packet});

        <<"INTERACTION_CREATE"/utf8>> ->
            _pipe@8 = discord_gleam@ws@packets@interaction_create:string_to_data(
                Msg
            ),
            _pipe@9 = gleam@result:map(
                _pipe@8,
                fun(Field@0) -> {interaction_create, Field@0} end
            ),
            gleam@result:unwrap(_pipe@9, {unknown_packet, Generic_packet});

        _ ->
            {unknown_packet, Generic_packet}
    end.

-file("src/discord_gleam/event_handler.gleam", 83).
?DOC(" Handle an event from the Discord API, using a set of event handlers.\n").
-spec handle_event(
    discord_gleam@types@bot:bot(),
    binary(),
    list(fun((discord_gleam@types@bot:bot(), packet()) -> nil)),
    bravo@uset:u_set({binary(), binary()})
) -> nil.
handle_event(Bot, Msg, Handlers, State_uset) ->
    Packet = decode_packet(Msg),
    internal_handler(Bot, Packet, State_uset),
    gleam@list:each(Handlers, fun(Handler) -> Handler(Bot, Packet) end).