%% 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]).

start_link(SessionData) ->
    gen_server:start_link(?MODULE, SessionData, []).

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, [])),

    Channels = load_private_channels(Ready),
    logger:debug("[session] Loaded ~p private channels into session state for user ~p", [
        maps:size(Channels),
        UserId
    ]),

    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 => #{}
    },

    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, 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) ->
                    gen_server:call(
                        Pid,
                        {session_connect, #{
                            session_id => SessionId,
                            status => Status,
                            afk => Afk,
                            mobile => Mobile
                        }},
                        10000
                    )
            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}.

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}, State) ->
    Guilds = maps:get(guilds, State),
    case maps:get(GuildId, Guilds, undefined) of
        {Pid, Ref} when is_pid(Pid) ->
            demonitor(Ref),
            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_connect, ChannelIdBin}, State) ->
    case validation:validate_snowflake(<<"channel_id">>, ChannelIdBin) of
        {ok, ChannelId} ->
            case gen_server:call(call_manager, {lookup, ChannelId}, 5000) of
                {ok, CallPid} ->
                    case gen_server:call(CallPid, {get_state}, 5000) of
                        {ok, CallData} ->
                            session_dispatch:handle_dispatch(call_create, CallData, State);
                        _ ->
                            {noreply, State}
                    end;
                not_found ->
                    {noreply, State}
            end;
        {error, _, Reason} ->
            logger:warning("[session] Invalid channel_id for call_connect: ~p", [Reason]),
            {noreply, State}
    end;
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(_, State) ->
    {noreply, 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({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({'DOWN', Ref, process, _Pid, Reason}, State) ->
    session_monitor:handle_process_down(Ref, Reason, State);
handle_info(_Info, State) ->
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

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

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, [])
    }.

build_ignored_events_map(Events) when is_list(Events) ->
    maps:from_list([{Event, true} || Event <- Events]);
build_ignored_events_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(_) ->
    #{}.

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(_) ->
    #{}.

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