-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() :: {ready_packet, discord_gleam@ws@packets@ready:ready_packet()} |
    {interaction_create_packet,
        discord_gleam@ws@packets@interaction_create:interaction_create_packet()} |
    {message_delete_packet,
        discord_gleam@ws@packets@message_delete:message_delete_packet()} |
    {message_packet, discord_gleam@ws@packets@message:message_packet()} |
    {message_update_packet,
        discord_gleam@ws@packets@message_update:message_update_packet()} |
    {channel_create_packet,
        discord_gleam@ws@packets@channel_create:channel_create_packet()} |
    {channel_delete_packet,
        discord_gleam@ws@packets@channel_delete:channel_delete_packet()} |
    {channel_update_packet,
        discord_gleam@ws@packets@channel_update:channel_update_packet()} |
    {guild_ban_add_packet,
        discord_gleam@ws@packets@guild_ban_add:guild_ban_add_packet()} |
    {guild_ban_remove_packet,
        discord_gleam@ws@packets@guild_ban_remove:guild_ban_remove_packet()} |
    {guild_role_create_packet,
        discord_gleam@ws@packets@guild_role_create:guild_role_create_packet()} |
    {guild_role_update_packet,
        discord_gleam@ws@packets@guild_role_update:guild_role_update_packet()} |
    {guild_role_delete_packet,
        discord_gleam@ws@packets@guild_role_delete:guild_role_delete_packet()} |
    {unknown_packet, discord_gleam@ws@packets@generic:generic_packet()}.

-file("src/discord_gleam/event_handler.gleam", 64).
?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", 125).
-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
        <<"READY"/utf8>> ->
            case discord_gleam@ws@packets@ready:string_to_data(Msg) of
                {ok, Data} ->
                    {ready_packet, Data};

                {error, Err} ->
                    logging:log(
                        error,
                        <<"Failed to decode READY packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"MESSAGE_CREATE"/utf8>> ->
            case discord_gleam@ws@packets@message:string_to_data(Msg) of
                {ok, Data@1} ->
                    {message_packet, Data@1};

                {error, Err@1} ->
                    logging:log(
                        error,
                        <<"Failed to decode MESSAGE_CREATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@1
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"MESSAGE_UPDATE"/utf8>> ->
            case discord_gleam@ws@packets@message_update:string_to_data(Msg) of
                {ok, Data@2} ->
                    {message_update_packet, Data@2};

                {error, Err@2} ->
                    logging:log(
                        error,
                        <<"Failed to decode MESSAGE_UPDATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@2
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"MESSAGE_DELETE"/utf8>> ->
            case discord_gleam@ws@packets@message_delete:string_to_data(Msg) of
                {ok, Data@3} ->
                    {message_delete_packet, Data@3};

                {error, Err@3} ->
                    logging:log(
                        error,
                        <<"Failed to decode MESSAGE_DELETE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@3
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"INTERACTION_CREATE"/utf8>> ->
            case discord_gleam@ws@packets@interaction_create:string_to_data(Msg) of
                {ok, Data@4} ->
                    {interaction_create_packet, Data@4};

                {error, Err@4} ->
                    logging:log(
                        error,
                        <<"Failed to decode INTERACTION_CREATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@4
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"CHANNEL_CREATE"/utf8>> ->
            case discord_gleam@ws@packets@channel_create:string_to_data(Msg) of
                {ok, Data@5} ->
                    {channel_create_packet, Data@5};

                {error, Err@5} ->
                    logging:log(
                        error,
                        <<"Failed to decode CHANNEL_CREATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@5
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"CHANNEL_DELETE"/utf8>> ->
            case discord_gleam@ws@packets@channel_delete:string_to_data(Msg) of
                {ok, Data@6} ->
                    {channel_delete_packet, Data@6};

                {error, Err@6} ->
                    logging:log(
                        error,
                        <<"Failed to decode CHANNEL_DELETE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@6
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"CHANNEL_UPDATE"/utf8>> ->
            case discord_gleam@ws@packets@channel_update:string_to_data(Msg) of
                {ok, Data@7} ->
                    {channel_update_packet, Data@7};

                {error, Err@7} ->
                    logging:log(
                        error,
                        <<"Failed to decode CHANNEL_UPDATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@7
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"GUILD_BAN_ADD"/utf8>> ->
            case discord_gleam@ws@packets@guild_ban_add:string_to_data(Msg) of
                {ok, Data@8} ->
                    {guild_ban_add_packet, Data@8};

                {error, Err@8} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_BAN_ADD packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@8
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"GUILD_BAN_REMOVE"/utf8>> ->
            case discord_gleam@ws@packets@guild_ban_remove:string_to_data(Msg) of
                {ok, Data@9} ->
                    {guild_ban_remove_packet, Data@9};

                {error, Err@9} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_BAN_REMOVE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@9
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"GUILD_ROLE_CREATE"/utf8>> ->
            case discord_gleam@ws@packets@guild_role_create:string_to_data(Msg) of
                {ok, Data@10} ->
                    {guild_role_create_packet, Data@10};

                {error, Err@10} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_ROLE_CREATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@10
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"GUILD_ROLE_UPDATE"/utf8>> ->
            case discord_gleam@ws@packets@guild_role_update:string_to_data(Msg) of
                {ok, Data@11} ->
                    {guild_role_update_packet, Data@11};

                {error, Err@11} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_ROLE_UPDATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@11
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        <<"GUILD_ROLE_DELETE"/utf8>> ->
            case discord_gleam@ws@packets@guild_role_delete:string_to_data(Msg) of
                {ok, Data@12} ->
                    {guild_role_delete_packet, Data@12};

                {error, Err@12} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_ROLE_DELETE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@12
                            ))/binary>>
                    ),
                    {unknown_packet, Generic_packet}
            end;

        _ ->
            {unknown_packet, Generic_packet}
    end.

-file("src/discord_gleam/event_handler.gleam", 113).
?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).