%% Copyright (C) 2026 Fluxer Contributors
%%
%% This file is part of Fluxer.
%%
%% Fluxer is free software: you can redistribute it and/or modify
%% it under the terms of the GNU Affero General Public License as published by
%% the Free Software Foundation, either version 3 of the License, or
%% (at your option) any later version.
%%
%% Fluxer is distributed in the hope that it will be useful,
%% but WITHOUT ANY WARRANTY; without even the implied warranty of
%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
%% GNU Affero General Public License for more details.
%%
%% You should have received a copy of the GNU Affero General Public License
%% along with Fluxer. If not, see <https://www.gnu.org/licenses/>.

-module(session).
-behaviour(gen_server).

-export([start_link/1]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).

-type session_id() :: binary().
-type user_id() :: integer().
-type guild_id() :: integer().
-type channel_id() :: integer().
-type seq() :: non_neg_integer().
-type status() :: online | offline | idle | dnd.
-type guild_ref() :: {pid(), reference()} | undefined | cached_unavailable.
-type call_ref() :: {pid(), reference()}.

-type session_state() :: #{
    id := session_id(),
    user_id := user_id(),
    user_data := map(),
    custom_status := map() | null,
    version := non_neg_integer(),
    token_hash := binary(),
    auth_session_id_hash := binary(),
    buffer := [map()],
    seq := seq(),
    ack_seq := seq(),
    properties := map(),
    status := status(),
    afk := boolean(),
    mobile := boolean(),
    presence_pid := pid() | undefined,
    presence_mref := reference() | undefined,
    socket_pid := pid() | undefined,
    socket_mref := reference() | undefined,
    guilds := #{guild_id() => guild_ref()},
    calls := #{channel_id() => call_ref()},
    channels := #{channel_id() => map()},
    ready := map() | undefined,
    bot := boolean(),
    ignored_events := #{binary() => true},
    initial_guild_id := guild_id() | undefined,
    collected_guild_states := [map()],
    collected_sessions := [map()],
    collected_presences := [map()],
    relationships := #{user_id() => integer()},
    suppress_presence_updates := boolean(),
    pending_presences := [map()],
    guild_connect_inflight := #{guild_id() => non_neg_integer()},
    voice_queue := queue:queue(),
    voice_queue_timer := reference() | undefined,
    debounce_reactions := boolean(),
    reaction_buffer := [map()],
    reaction_buffer_timer := reference() | undefined
}.

-export_type([session_state/0, session_id/0, user_id/0, guild_id/0, channel_id/0, seq/0]).

-spec start_link(map()) -> {ok, pid()} | {error, term()}.
start_link(SessionData) ->
    gen_server:start_link(?MODULE, SessionData, []).

-spec init(map()) -> {ok, session_state()}.
init(SessionData) ->
    process_flag(trap_exit, true),
    Id = maps:get(id, SessionData),
    UserId = maps:get(user_id, SessionData),
    UserData = maps:get(user_data, SessionData),
    Version = maps:get(version, SessionData),
    TokenHash = maps:get(token_hash, SessionData),
    AuthSessionIdHash = maps:get(auth_session_id_hash, SessionData),
    Properties = maps:get(properties, SessionData),
    Status = maps:get(status, SessionData),
    Afk = maps:get(afk, SessionData, false),
    Mobile = maps:get(mobile, SessionData, false),
    SocketPid = maps:get(socket_pid, SessionData),
    GuildIds = maps:get(guilds, SessionData),
    Ready0 = maps:get(ready, SessionData),
    Bot = maps:get(bot, SessionData, false),
    InitialGuildId = maps:get(initial_guild_id, SessionData, undefined),
    Ready =
        case Bot of
            true -> ensure_bot_ready_map(Ready0);
            false -> Ready0
        end,
    IgnoredEvents = build_ignored_events_map(maps:get(ignored_events, SessionData, [])),
    DebounceReactions = maps:get(debounce_reactions, SessionData, false),
    Channels = load_private_channels(Ready),
    VoiceQueueState = session_voice:init_voice_queue(),
    State = #{
        id => Id,
        user_id => UserId,
        user_data => UserData,
        custom_status => maps:get(custom_status, SessionData, null),
        version => Version,
        token_hash => TokenHash,
        auth_session_id_hash => AuthSessionIdHash,
        buffer => [],
        seq => 0,
        ack_seq => 0,
        properties => Properties,
        status => Status,
        afk => Afk,
        mobile => Mobile,
        presence_pid => undefined,
        presence_mref => undefined,
        socket_pid => SocketPid,
        socket_mref => monitor(process, SocketPid),
        guilds => maps:from_list([{Gid, undefined} || Gid <- GuildIds]),
        calls => #{},
        channels => Channels,
        ready => Ready,
        bot => Bot,
        ignored_events => IgnoredEvents,
        initial_guild_id => InitialGuildId,
        collected_guild_states => [],
        collected_sessions => [],
        collected_presences => [],
        relationships => load_relationships(Ready),
        suppress_presence_updates => true,
        pending_presences => [],
        guild_connect_inflight => #{},
        debounce_reactions => DebounceReactions,
        reaction_buffer => [],
        reaction_buffer_timer => undefined
    },
    StateWithVoiceQueue = maps:merge(State, VoiceQueueState),
    self() ! {presence_connect, 0},
    case Bot of
        true -> self() ! bot_initial_ready;
        false -> ok
    end,
    lists:foreach(fun(Gid) -> self() ! {guild_connect, Gid, 0} end, GuildIds),
    erlang:send_after(3000, self(), premature_readiness),
    erlang:send_after(200, self(), enable_presence_updates),
    {ok, StateWithVoiceQueue}.

-spec handle_call(Request, From, State) -> Result when
    Request ::
        {token_verify, binary()}
        | {heartbeat_ack, seq()}
        | {resume, seq(), pid()}
        | {get_state}
        | {voice_state_update, map()}
        | term(),
    From :: gen_server:from(),
    State :: session_state(),
    Result :: {reply, term(), session_state()}.
handle_call({token_verify, Token}, _From, State) ->
    TokenHash = maps:get(token_hash, State),
    HashedInput = utils:hash_token(Token),
    IsValid = HashedInput =:= TokenHash,
    {reply, IsValid, State};
handle_call({heartbeat_ack, Seq}, _From, State) ->
    AckSeq = maps:get(ack_seq, State),
    Buffer = maps:get(buffer, State),
    if
        Seq < AckSeq ->
            {reply, false, State};
        true ->
            NewBuffer = [Event || Event <- Buffer, maps:get(seq, Event) > Seq],
            {reply, true, maps:merge(State, #{ack_seq => Seq, buffer => NewBuffer})}
    end;
handle_call({resume, Seq, SocketPid}, _From, State) ->
    CurrentSeq = maps:get(seq, State),
    Buffer = maps:get(buffer, State),
    PresencePid = maps:get(presence_pid, State, undefined),
    SessionId = maps:get(id, State),
    Status = maps:get(status, State),
    Afk = maps:get(afk, State),
    Mobile = maps:get(mobile, State),
    if
        Seq > CurrentSeq ->
            {reply, invalid_seq, State};
        true ->
            MissedEvents = [Event || Event <- Buffer, maps:get(seq, Event) > Seq],
            NewState = maps:merge(State, #{
                socket_pid => SocketPid,
                socket_mref => monitor(process, SocketPid)
            }),
            case PresencePid of
                undefined ->
                    ok;
                Pid when is_pid(Pid) ->
                    spawn(fun() ->
                        gen_server:call(
                            Pid,
                            {session_connect, #{
                                session_id => SessionId,
                                status => Status,
                                afk => Afk,
                                mobile => Mobile
                            }},
                            10000
                        )
                    end)
            end,
            {reply, {ok, MissedEvents}, NewState}
    end;
handle_call({get_state}, _From, State) ->
    SerializedState = serialize_state(State),
    {reply, SerializedState, State};
handle_call({voice_state_update, Data}, _From, State) ->
    session_voice:handle_voice_state_update(Data, State);
handle_call(_, _From, State) ->
    {reply, ok, State}.

-spec handle_cast(Request, State) -> Result when
    Request ::
        {presence_update, map()}
        | {dispatch, atom(), map()}
        | {initial_global_presences, [map()]}
        | {guild_join, guild_id()}
        | {guild_leave, guild_id()}
        | {guild_leave, guild_id(), forced_unavailable}
        | {terminate, [binary()]}
        | {terminate_force}
        | {call_monitor, channel_id(), pid()}
        | {call_unmonitor, channel_id()}
        | {call_force_disconnect, channel_id(), binary() | undefined}
        | term(),
    State :: session_state(),
    Result :: {noreply, session_state()} | {stop, normal, session_state()}.
handle_cast({presence_update, Update}, State) ->
    PresencePid = maps:get(presence_pid, State, undefined),
    SessionId = maps:get(id, State),
    Status = maps:get(status, State),
    Afk = maps:get(afk, State),
    Mobile = maps:get(mobile, State),
    NewStatus = maps:get(status, Update, Status),
    NewAfk = maps:get(afk, Update, Afk),
    NewMobile = maps:get(mobile, Update, Mobile),
    NewState = maps:merge(State, #{status => NewStatus, afk => NewAfk, mobile => NewMobile}),
    case PresencePid of
        undefined ->
            ok;
        Pid when is_pid(Pid) ->
            gen_server:cast(
                Pid,
                {presence_update, #{
                    session_id => SessionId, status => NewStatus, afk => NewAfk, mobile => NewMobile
                }}
            )
    end,
    {noreply, NewState};
handle_cast({dispatch, Event, Data}, State) ->
    session_dispatch:handle_dispatch(Event, Data, State);
handle_cast({initial_global_presences, Presences}, State) ->
    NewState = lists:foldl(
        fun(Presence, AccState) ->
            {noreply, UpdatedState} = session_dispatch:handle_dispatch(
                presence_update, Presence, AccState
            ),
            UpdatedState
        end,
        State,
        Presences
    ),
    {noreply, NewState};
handle_cast({guild_join, GuildId}, State) ->
    self() ! {guild_connect, GuildId, 0},
    {noreply, State};
handle_cast({guild_leave, GuildId, forced_unavailable}, State) ->
    Guilds = maps:get(guilds, State),
    case maps:get(GuildId, Guilds, undefined) of
        {Pid, Ref} when is_pid(Pid) ->
            demonitor(Ref, [flush]);
        _ ->
            ok
    end,
    NewGuilds = maps:put(GuildId, cached_unavailable, Guilds),
    {noreply, State1} = session_dispatch:handle_dispatch(
        guild_delete,
        #{<<"id">> => integer_to_binary(GuildId), <<"unavailable">> => true},
        State
    ),
    self() ! {guild_connect, GuildId, 0},
    {noreply, maps:put(guilds, NewGuilds, State1)};
handle_cast({guild_leave, GuildId}, State) ->
    Guilds = maps:get(guilds, State),
    case maps:get(GuildId, Guilds, undefined) of
        {Pid, Ref} when is_pid(Pid) ->
            demonitor(Ref, [flush]),
            NewGuilds = maps:put(GuildId, undefined, Guilds),
            session_dispatch:handle_dispatch(
                guild_delete, #{<<"id">> => integer_to_binary(GuildId)}, State
            ),
            {noreply, maps:put(guilds, NewGuilds, State)};
        _ ->
            {noreply, State}
    end;
handle_cast({terminate, SessionIdHashes}, State) ->
    AuthHash = maps:get(auth_session_id_hash, State),
    DecodedHashes = [base64url:decode(Hash) || Hash <- SessionIdHashes],
    case lists:member(AuthHash, DecodedHashes) of
        true -> {stop, normal, State};
        false -> {noreply, State}
    end;
handle_cast({terminate_force}, State) ->
    {stop, normal, State};
handle_cast({call_monitor, ChannelId, CallPid}, State) ->
    Calls = maps:get(calls, State, #{}),
    case maps:get(ChannelId, Calls, undefined) of
        undefined ->
            Ref = monitor(process, CallPid),
            NewCalls = maps:put(ChannelId, {CallPid, Ref}, Calls),
            {noreply, maps:put(calls, NewCalls, State)};
        {OldPid, OldRef} when OldPid =/= CallPid ->
            demonitor(OldRef, [flush]),
            Ref = monitor(process, CallPid),
            NewCalls = maps:put(ChannelId, {CallPid, Ref}, Calls),
            {noreply, maps:put(calls, NewCalls, State)};
        _ ->
            {noreply, State}
    end;
handle_cast({call_unmonitor, ChannelId}, State) ->
    Calls = maps:get(calls, State, #{}),
    case maps:get(ChannelId, Calls, undefined) of
        {_Pid, Ref} ->
            demonitor(Ref, [flush]),
            NewCalls = maps:remove(ChannelId, Calls),
            {noreply, maps:put(calls, NewCalls, State)};
        undefined ->
            {noreply, State}
    end;
handle_cast({call_force_disconnect, ChannelId, ConnectionId}, State) ->
    NewState = force_disconnect_dm_call(ChannelId, ConnectionId, State),
    {noreply, NewState};
handle_cast(_, State) ->
    {noreply, State}.

-spec handle_info(Info, State) -> Result when
    Info ::
        {presence_connect, non_neg_integer()}
        | {guild_connect, guild_id(), non_neg_integer()}
        | {guild_connect_result, guild_id(), non_neg_integer(), term()}
        | {guild_connect_timeout, guild_id(), non_neg_integer()}
        | {call_reconnect, channel_id(), non_neg_integer()}
        | enable_presence_updates
        | premature_readiness
        | bot_initial_ready
        | resume_timeout
        | flush_reaction_buffer
        | {process_voice_queue}
        | {'DOWN', reference(), process, pid(), term()}
        | term(),
    State :: session_state(),
    Result :: {noreply, session_state()} | {stop, normal, session_state()}.
handle_info({presence_connect, Attempt}, State) ->
    PresencePid = maps:get(presence_pid, State, undefined),
    case PresencePid of
        undefined -> session_connection:handle_presence_connect(Attempt, State);
        _ -> {noreply, State}
    end;
handle_info({guild_connect, GuildId, Attempt}, State) ->
    session_connection:handle_guild_connect(GuildId, Attempt, State);
handle_info({guild_connect_result, GuildId, Attempt, Result}, State) ->
    session_connection:handle_guild_connect_result(GuildId, Attempt, Result, State);
handle_info({guild_connect_timeout, GuildId, Attempt}, State) ->
    session_connection:handle_guild_connect_timeout(GuildId, Attempt, State);
handle_info({call_reconnect, ChannelId, Attempt}, State) ->
    session_connection:handle_call_reconnect(ChannelId, Attempt, State);
handle_info(enable_presence_updates, State) ->
    FlushedState = session_dispatch:flush_all_pending_presences(State),
    {noreply, maps:put(suppress_presence_updates, false, FlushedState)};
handle_info(premature_readiness, State) ->
    Ready = maps:get(ready, State),
    case Ready of
        undefined -> {noreply, State};
        _ -> session_ready:dispatch_ready_data(State)
    end;
handle_info(bot_initial_ready, State) ->
    Ready = maps:get(ready, State, undefined),
    case Ready of
        undefined -> {noreply, State};
        _ -> session_ready:dispatch_ready_data(State)
    end;
handle_info(resume_timeout, State) ->
    SocketPid = maps:get(socket_pid, State, undefined),
    case SocketPid of
        undefined -> {stop, normal, State};
        _ -> {noreply, State}
    end;
handle_info({process_voice_queue}, State) ->
    NewState = session_voice:process_voice_queue(State),
    VoiceQueue = maps:get(voice_queue, NewState, queue:new()),
    case queue:is_empty(VoiceQueue) of
        false ->
            Timer = erlang:send_after(100, self(), {process_voice_queue}),
            {noreply, maps:put(voice_queue_timer, Timer, NewState)};
        true ->
            {noreply, NewState}
    end;
handle_info(flush_reaction_buffer, State) ->
    NewState = session_dispatch:flush_reaction_buffer(State),
    {noreply, NewState};
handle_info({'DOWN', Ref, process, _Pid, Reason}, State) ->
    session_monitor:handle_process_down(Ref, Reason, State);
handle_info(_Info, State) ->
    {noreply, State}.

-spec terminate(term(), session_state()) -> ok.
terminate(_Reason, _State) ->
    ok.

-spec code_change(term(), session_state(), term()) -> {ok, session_state()}.
code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

-spec force_disconnect_dm_call(channel_id(), binary() | undefined, session_state()) -> session_state().
force_disconnect_dm_call(ChannelId, ConnectionId, State) ->
    UserId = maps:get(user_id, State),
    SessionId = maps:get(id, State),
    EffectiveConnectionId = resolve_dm_connection_id_for_channel(ChannelId, ConnectionId, UserId, State),
    gen_server:cast(self(), {call_unmonitor, ChannelId}),
    case EffectiveConnectionId of
        undefined ->
            State;
        _ ->
            Request = #{
                user_id => UserId,
                channel_id => null,
                session_id => SessionId,
                connection_id => EffectiveConnectionId,
                self_mute => false,
                self_deaf => false,
                self_video => false,
                self_stream => false,
                viewer_stream_keys => [],
                is_mobile => false,
                latitude => null,
                longitude => null
            },
            StateWithSessionPid = maps:put(session_pid, self(), State),
            case dm_voice:voice_state_update(Request, StateWithSessionPid) of
                {reply, #{success := true}, NewState} ->
                    maps:remove(session_pid, NewState);
                _ ->
                    {reply, #{success := true}, FallbackState} =
                        dm_voice:disconnect_voice_user(UserId, StateWithSessionPid),
                    maps:remove(session_pid, FallbackState)
            end
    end.

-spec resolve_dm_connection_id_for_channel(
    channel_id(), binary() | undefined, user_id(), session_state()
) -> binary() | undefined.
resolve_dm_connection_id_for_channel(_ChannelId, ConnectionId, _UserId, _State)
    when is_binary(ConnectionId) ->
    ConnectionId;
resolve_dm_connection_id_for_channel(ChannelId, _ConnectionId, UserId, State) ->
    VoiceStates = maps:get(dm_voice_states, State, #{}),
    UserIdBin = integer_to_binary(UserId),
    ChannelIdBin = integer_to_binary(ChannelId),
    maps:fold(
        fun
            (ConnId, VoiceState, undefined) ->
                case
                    {
                        maps:get(<<"user_id">>, VoiceState, undefined),
                        maps:get(<<"channel_id">>, VoiceState, undefined)
                    }
                of
                    {UserIdBin, ChannelIdBin} ->
                        ConnId;
                    _ ->
                        undefined
                end;
            (_ConnId, _VoiceState, ExistingConnId) ->
                ExistingConnId
        end,
        undefined,
        VoiceStates
    ).

-spec serialize_state(session_state()) -> map().
serialize_state(State) ->
    #{
        id => maps:get(id, State),
        session_id => maps:get(id, State),
        user_id => integer_to_binary(maps:get(user_id, State)),
        user_data => maps:get(user_data, State),
        version => maps:get(version, State),
        seq => maps:get(seq, State),
        ack_seq => maps:get(ack_seq, State),
        properties => maps:get(properties, State),
        status => maps:get(status, State),
        afk => maps:get(afk, State),
        mobile => maps:get(mobile, State),
        buffer => maps:get(buffer, State),
        ready => maps:get(ready, State),
        guilds => maps:get(guilds, State, #{}),
        collected_guild_states => maps:get(collected_guild_states, State),
        collected_sessions => maps:get(collected_sessions, State),
        collected_presences => maps:get(collected_presences, State, [])
    }.

-spec build_ignored_events_map([binary()]) -> #{binary() => true}.
build_ignored_events_map(Events) when is_list(Events) ->
    maps:from_list([{Event, true} || Event <- Events]);
build_ignored_events_map(_) ->
    #{}.

-spec load_private_channels(map() | undefined) -> #{channel_id() => map()}.
load_private_channels(Ready) when is_map(Ready) ->
    PrivateChannels = maps:get(<<"private_channels">>, Ready, []),
    maps:from_list([
        {type_conv:extract_id(Channel, <<"id">>), Channel}
     || Channel <- PrivateChannels
    ]);
load_private_channels(_) ->
    #{}.

-spec load_relationships(map() | undefined) -> #{user_id() => integer()}.
load_relationships(Ready) when is_map(Ready) ->
    Relationships = maps:get(<<"relationships">>, Ready, []),
    maps:from_list(
        [
            {type_conv:extract_id(Rel, <<"id">>), maps:get(<<"type">>, Rel, 0)}
         || Rel <- Relationships, type_conv:extract_id(Rel, <<"id">>) =/= undefined
        ]
    );
load_relationships(_) ->
    #{}.

-spec ensure_bot_ready_map(map() | undefined) -> map().
ensure_bot_ready_map(undefined) ->
    #{<<"guilds">> => []};
ensure_bot_ready_map(Ready) when is_map(Ready) ->
    maps:merge(Ready, #{<<"guilds">> => []});
ensure_bot_ready_map(_) ->
    #{<<"guilds">> => []}.

-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").

build_ignored_events_map_test() ->
    ?assertEqual(#{}, build_ignored_events_map([])),
    ?assertEqual(#{<<"TYPING_START">> => true}, build_ignored_events_map([<<"TYPING_START">>])),
    ?assertEqual(
        #{<<"TYPING_START">> => true, <<"PRESENCE_UPDATE">> => true},
        build_ignored_events_map([<<"TYPING_START">>, <<"PRESENCE_UPDATE">>])
    ),
    ?assertEqual(#{}, build_ignored_events_map(not_a_list)),
    ok.

load_private_channels_test() ->
    ?assertEqual(#{}, load_private_channels(undefined)),
    ?assertEqual(#{}, load_private_channels(#{})),
    Ready = #{
        <<"private_channels">> => [
            #{<<"id">> => <<"123">>, <<"type">> => 1},
            #{<<"id">> => <<"456">>, <<"type">> => 3}
        ]
    },
    Channels = load_private_channels(Ready),
    ?assertEqual(2, maps:size(Channels)),
    ?assert(maps:is_key(123, Channels)),
    ?assert(maps:is_key(456, Channels)),
    ok.

load_relationships_test() ->
    ?assertEqual(#{}, load_relationships(undefined)),
    ?assertEqual(#{}, load_relationships(#{})),
    Ready = #{
        <<"relationships">> => [
            #{<<"id">> => <<"100">>, <<"type">> => 1},
            #{<<"id">> => <<"200">>, <<"type">> => 3}
        ]
    },
    Rels = load_relationships(Ready),
    ?assertEqual(2, maps:size(Rels)),
    ?assertEqual(1, maps:get(100, Rels)),
    ?assertEqual(3, maps:get(200, Rels)),
    ok.

ensure_bot_ready_map_test() ->
    ?assertEqual(#{<<"guilds">> => []}, ensure_bot_ready_map(undefined)),
    ?assertEqual(
        #{<<"guilds">> => [], <<"user">> => #{}}, ensure_bot_ready_map(#{<<"user">> => #{}})
    ),
    ?assertEqual(#{<<"guilds">> => []}, ensure_bot_ready_map(not_a_map)),
    ok.

serialize_state_test() ->
    State = #{
        id => <<"session123">>,
        user_id => 12345,
        user_data => #{<<"username">> => <<"test">>},
        version => 9,
        seq => 10,
        ack_seq => 5,
        properties => #{},
        status => online,
        afk => false,
        mobile => false,
        buffer => [],
        ready => undefined,
        guilds => #{},
        collected_guild_states => [],
        collected_sessions => [],
        collected_presences => []
    },
    Serialized = serialize_state(State),
    ?assertEqual(<<"session123">>, maps:get(id, Serialized)),
    ?assertEqual(<<"12345">>, maps:get(user_id, Serialized)),
    ?assertEqual(10, maps:get(seq, Serialized)),
    ok.

handle_cast_forced_unavailable_guild_leave_schedules_retry_test() ->
    GuildId = 123,
    State0 = #{
        id => <<"session-force-unavailable">>,
        user_id => 1,
        user_data => #{},
        custom_status => null,
        version => 1,
        token_hash => <<>>,
        auth_session_id_hash => <<>>,
        buffer => [],
        seq => 0,
        ack_seq => 0,
        properties => #{},
        status => online,
        afk => false,
        mobile => false,
        presence_pid => undefined,
        presence_mref => undefined,
        socket_pid => undefined,
        socket_mref => undefined,
        guilds => #{GuildId => {self(), make_ref()}},
        calls => #{},
        channels => #{},
        ready => undefined,
        bot => false,
        ignored_events => #{},
        initial_guild_id => undefined,
        collected_guild_states => [],
        collected_sessions => [],
        collected_presences => [],
        relationships => #{},
        suppress_presence_updates => false,
        pending_presences => [],
        guild_connect_inflight => #{},
        voice_queue => queue:new(),
        voice_queue_timer => undefined,
        debounce_reactions => false,
        reaction_buffer => [],
        reaction_buffer_timer => undefined
    },
    {noreply, State1} = handle_cast({guild_leave, GuildId, forced_unavailable}, State0),
    Guilds = maps:get(guilds, State1),
    ?assertEqual(cached_unavailable, maps:get(GuildId, Guilds)),
    Buffer = maps:get(buffer, State1),
    ?assertEqual(1, length(Buffer)),
    [LastEvent] = Buffer,
    ?assertEqual(guild_delete, maps:get(event, LastEvent)),
    EventData = maps:get(data, LastEvent),
    ?assertEqual(true, maps:get(<<"unavailable">>, EventData)),
    receive
        {guild_connect, GuildId, 0} -> ok
    after 100 ->
        ?assert(false, forced_unavailable_retry_not_scheduled)
    end.

-endif.