discord_gleam

-module(discord_gleam@event_handler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/discord_gleam/event_handler.gleam").
-export([bot_from_mode/1, handle_event/5]).
-export_type([handler_message/1, internal_message/1, next/2, mode/2, 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 handler_message(TJI) :: {discord_packet, packet()} | {user, TJI}.

-type internal_message(TJJ) :: {internal_packet, binary()} |
    {internal_user, TJJ}.

-type next(TJK, TJL) :: {continue,
        TJK,
        gleam@option:option(gleam@erlang@process:selector(TJL))} |
    stop |
    {stop_abnormal, binary()}.

-type mode(TJM, TJN) :: {simple,
        discord_gleam@types@bot:bot(),
        list(fun((discord_gleam@types@bot:bot(), packet()) -> nil)),
        next(TJM, TJN),
        TJM} |
    {normal,
        discord_gleam@types@bot:bot(),
        fun((gleam@erlang@process:selector(TJN)) -> {TJM,
            gleam@erlang@process:selector(TJN)}),
        fun((discord_gleam@types@bot:bot(), TJM, handler_message(TJN)) -> next(TJM, TJN))}.

-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()} |
    {message_delete_bulk_packet,
        discord_gleam@ws@packets@message_delete_bulk:message_delete_bulk_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()} |
    {guild_member_add_packet,
        discord_gleam@ws@packets@guild_member_add:guild_member_add()} |
    {guild_member_update_packet,
        discord_gleam@ws@packets@guild_member_update:guild_member_update()} |
    {guild_member_remove_packet,
        discord_gleam@ws@packets@guild_member_remove:guild_member_remove()} |
    {guild_members_chunk_packet,
        discord_gleam@ws@packets@guild_members_chunk:guild_members_chunk_packet()} |
    {presence_update_packet,
        discord_gleam@ws@packets@presence_update:presence_update_packet()} |
    {unknown_packet, discord_gleam@ws@packets@generic:generic_packet()}.

-file("src/discord_gleam/event_handler.gleam", 76).
?DOC(" Get the bot from all possible modes\n").
-spec bot_from_mode(mode(any(), any())) -> discord_gleam@types@bot:bot().
bot_from_mode(Mode) ->
    case Mode of
        {simple, Bot, _, _, _} ->
            Bot;

        {normal, Bot@1, _, _} ->
            Bot@1
    end.

-file("src/discord_gleam/event_handler.gleam", 136).
?DOC(" For handling some events the library needs to handle, for functionality\n").
-spec internal_handler(
    discord_gleam@types@bot:bot(),
    packet(),
    booklet:booklet(gleam@dict:dict(binary(), binary()))
) -> nil.
internal_handler(Bot, Packet, State_ets) ->
    case Packet of
        {message_packet, Msg} ->
            booklet_ffi:update(
                erlang:element(2, erlang:element(5, Bot)),
                fun(Cache) ->
                    gleam@dict:insert(
                        Cache,
                        erlang:element(3, erlang:element(5, Msg)),
                        erlang:element(5, Msg)
                    )
                end
            ),
            nil;

        {message_update_packet, Msg@1} ->
            booklet_ffi:update(
                erlang:element(2, erlang:element(5, Bot)),
                fun(Cache@1) ->
                    gleam@dict:insert(
                        Cache@1,
                        erlang:element(3, erlang:element(5, Msg@1)),
                        erlang:element(5, Msg@1)
                    )
                end
            ),
            nil;

        {ready_packet, Ready} ->
            booklet_ffi:update(
                State_ets,
                fun(Cache@2) ->
                    Cache@3 = gleam@dict:insert(
                        Cache@2,
                        <<"session_id"/utf8>>,
                        erlang:element(5, erlang:element(5, Ready))
                    ),
                    gleam@dict:insert(
                        Cache@3,
                        <<"resume_gateway_url"/utf8>>,
                        erlang:element(6, erlang:element(5, Ready))
                    )
                end
            ),
            nil;

        _ ->
            nil
    end.

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

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

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

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

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

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

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

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

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

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

                {error, Err@8} ->
                    logging:log(
                        error,
                        <<"Failed to decode CHANNEL_UPDATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@8
                            ))/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@9} ->
                    {guild_ban_add_packet, Data@9};

                {error, Err@9} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_BAN_ADD packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@9
                            ))/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@10} ->
                    {guild_ban_remove_packet, Data@10};

                {error, Err@10} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_BAN_REMOVE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@10
                            ))/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@11} ->
                    {guild_role_create_packet, Data@11};

                {error, Err@11} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_ROLE_CREATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@11
                            ))/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@12} ->
                    {guild_role_update_packet, Data@12};

                {error, Err@12} ->
                    logging:log(
                        error,
                        <<"Failed to decode GUILD_ROLE_UPDATE packet: "/utf8,
                            (discord_gleam@internal@error:json_decode_error_to_string(
                                Err@12
                            ))/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@13} ->
                    {guild_role_delete_packet, Data@13};

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

        <<"GUILD_MEMBER_ADD"/utf8>> ->
            case discord_gleam@ws@packets@guild_member_add:string_to_data(Msg) of
                {ok, Data@14} ->
                    {guild_member_add_packet, Data@14};

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

        <<"GUILD_MEMBER_UPDATE"/utf8>> ->
            case discord_gleam@ws@packets@guild_member_update:string_to_data(
                Msg
            ) of
                {ok, Data@15} ->
                    {guild_member_update_packet, Data@15};

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

        <<"GUILD_MEMBER_REMOVE"/utf8>> ->
            case discord_gleam@ws@packets@guild_member_remove:string_to_data(
                Msg
            ) of
                {ok, Data@16} ->
                    {guild_member_remove_packet, Data@16};

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

        <<"GUILD_MEMBERS_CHUNK"/utf8>> ->
            case discord_gleam@ws@packets@guild_members_chunk:string_to_data(
                Msg
            ) of
                {ok, Data@17} ->
                    {guild_members_chunk_packet, Data@17};

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

        <<"PRESENCE_UPDATE"/utf8>> ->
            case discord_gleam@ws@packets@presence_update:string_to_data(Msg) of
                {ok, Data@18} ->
                    {presence_update_packet, Data@18};

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

        _ ->
            {unknown_packet, Generic_packet}
    end.

-file("src/discord_gleam/event_handler.gleam", 174).
?DOC(
    " Handle an event from the Discord API, using a current handler mode, state\n"
    " and internal message.\n"
).
-spec handle_event(
    discord_gleam@types@bot:bot(),
    TJV,
    internal_message(TJW),
    mode(TJV, TJW),
    booklet:booklet(gleam@dict:dict(binary(), binary()))
) -> next(TJV, TJW).
handle_event(Bot, User_state, Msg, Mode, State_ets) ->
    case Msg of
        {internal_packet, Packet} ->
            Packet@1 = decode_packet(Packet),
            internal_handler(Bot, Packet@1, State_ets),
            case Mode of
                {simple, Bot@1, Handlers, Next, _} ->
                    gleam@list:each(
                        Handlers,
                        fun(Handler) -> Handler(Bot@1, Packet@1) end
                    ),
                    Next;

                {normal, Bot@2, _, Handler@1} ->
                    Handler@1(Bot@2, User_state, {discord_packet, Packet@1})
            end;

        {internal_user, Msg@1} ->
            {Bot@4, Handler@3} = case Mode of
                {normal, Bot@3, _, Handler@2} -> {Bot@3, Handler@2};
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"discord_gleam/event_handler"/utf8>>,
                                function => <<"handle_event"/utf8>>,
                                line => 197,
                                value => _assert_fail,
                                start => 6154,
                                'end' => 6202,
                                pattern_start => 6165,
                                pattern_end => 6195})
            end,
            Handler@3(Bot@4, User_state, {user, Msg@1})
    end.