-export([register_event_handler/3, unregister_event_handler/2]).

    reconnectTimer = undefined

    reconnectTimer = undefined,
    % Event handlers: #{HandlerPid => #{interval => Ms, timer_ref => Ref, pending => sets:set()}}
    eventHandlers = #{}

%% register for channel message event notifications
%% IntervalMs must be >= 100
register_event_handler(Pid, HandlerPid, IntervalMs) when IntervalMs >= 100 ->
    gen_server:call(Pid, {registerEventHandler, HandlerPid, IntervalMs}).

unregister_event_handler(Pid, HandlerPid) ->
    gen_server:call(Pid, {unregisterEventHandler, HandlerPid}).

    {reply, Result, State}.

    {reply, Result, State};
handle_call({registerEventHandler, HandlerPid, IntervalMs}, _From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {registerEventHandler, HandlerPid, IntervalMs, self()},
    receive
        {event_handler_registered, Result} ->
            {reply, Result, State}
    after 5000 ->
        {reply, {error, timeout}, State}
    end;
handle_call({unregisterEventHandler, HandlerPid}, _From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {unregisterEventHandler, HandlerPid, self()},
    receive
        {event_handler_unregistered, Result} ->
            {reply, Result, State}
    after 5000 ->
        {reply, {error, timeout}, State}
    end.

        {registerEventHandler, HandlerPid, IntervalMs, From} ->
            NewState = handle_register_event_handler(State, HandlerPid, IntervalMs),
            From ! {event_handler_registered, ok},
            event_loop(NewState);
        {unregisterEventHandler, HandlerPid, From} ->
            NewState = handle_unregister_event_handler(State, HandlerPid),
            From ! {event_handler_unregistered, ok},
            event_loop(NewState);
        {notificationTimer, HandlerPid} ->
            NewState = handle_notification_timer(State, HandlerPid),
            event_loop(NewState);

            %% Mark channel for notification (we wrote a message to it)
            StateWithNotif = mark_channels_for_notification(State, [Chan]),

            State#state{peers = SentPeers}

            StateWithNotif#state{peers = SentPeers}

                    S#state{peers = NewPeers};

                    %% Extract channels from saved posts and mark for notification
                    Channels = lists:filtermap(fun(P) ->
                        [_PostHeader, PostBody] = posts:decode(P),
                        case proplists:get_value(channel, PostBody, undefined) of
                            undefined -> false;
                            Chan -> {true, Chan}
                        end
                    end, NewPosts),
                    NewState = mark_channels_for_notification(S, Channels),
                    NewState#state{peers = NewPeers};

%% Get the address string for a peer from connected peers map
get_peer_address_string(ConnPid, Peers) ->
    case maps:get(ConnPid, Peers, undefined) of
        undefined -> undefined;
        PeerMeta ->
            case maps:get(address, PeerMeta, undefined) of
                undefined -> undefined;
                Addr -> Addr
            end
    end.

%% Event handler management functions
handle_register_event_handler(State = #state{eventHandlers = Handlers}, HandlerPid, IntervalMs) ->
    case maps:is_key(HandlerPid, Handlers) of
        true ->
            %% Already registered, update interval
            io:format("[Peer] Updating event handler ~p interval to ~pms~n", [HandlerPid, IntervalMs]),
            OldHandler = maps:get(HandlerPid, Handlers),
            %% Cancel old timer
            case maps:get(timer_ref, OldHandler, undefined) of
                undefined -> ok;
                OldTimerRef -> erlang:cancel_timer(OldTimerRef)
            end,
            %% Start new timer
            TimerRef = erlang:send_after(IntervalMs, self(), {notificationTimer, HandlerPid}),
            NewHandler = OldHandler#{interval => IntervalMs, timer_ref => TimerRef},
            State#state{eventHandlers = maps:put(HandlerPid, NewHandler, Handlers)};
        false ->
            %% New registration
            io:format("[Peer] Registered event handler ~p with interval ~pms~n", [HandlerPid, IntervalMs]),
            TimerRef = erlang:send_after(IntervalMs, self(), {notificationTimer, HandlerPid}),
            Handler = #{
                interval => IntervalMs,
                timer_ref => TimerRef,
                pending => sets:new()
            },
            State#state{eventHandlers = maps:put(HandlerPid, Handler, Handlers)}
    end.
handle_unregister_event_handler(State = #state{eventHandlers = Handlers}, HandlerPid) ->
    case maps:take(HandlerPid, Handlers) of
        error ->
            io:format("[Peer] Event handler ~p not found~n", [HandlerPid]),
            State;
        {Handler, NewHandlers} ->
            io:format("[Peer] Unregistered event handler ~p~n", [HandlerPid]),
            %% Cancel timer
            case maps:get(timer_ref, Handler, undefined) of
                undefined -> ok;
                TimerRef -> erlang:cancel_timer(TimerRef)
            end,
            State#state{eventHandlers = NewHandlers}
    end.
handle_notification_timer(State = #state{eventHandlers = Handlers}, HandlerPid) ->
    case maps:get(HandlerPid, Handlers, undefined) of
        undefined ->
            %% Handler was unregistered, ignore
            State;
        Handler ->
            Pending = maps:get(pending, Handler),
            Interval = maps:get(interval, Handler),
            %% Send notifications for all pending channels
            case sets:size(Pending) of
                0 ->
                    ok; % Nothing to notify
                _ ->
                    PendingList = sets:to_list(Pending),
                    lists:foreach(fun(Chan) ->
                        try
                            HandlerPid ! {channel_event, {new_messages, Chan}}
                        catch
                            _:_ ->
                                io:format("[Peer] Failed to send event to handler ~p~n", [HandlerPid])
                        end
                    end, PendingList),
                    io:format("[Peer] Notified handler ~p of ~p channels~n", [HandlerPid, length(PendingList)])
            end,
            %% Clear pending and restart timer
            TimerRef = erlang:send_after(Interval, self(), {notificationTimer, HandlerPid}),
            NewHandler = Handler#{pending => sets:new(), timer_ref => TimerRef},
            State#state{eventHandlers = maps:put(HandlerPid, NewHandler, Handlers)}
    end.
mark_channels_for_notification(State = #state{eventHandlers = Handlers}, Channels) ->
    case maps:size(Handlers) of
        0 ->
            State; % No handlers, nothing to do
        _ ->
            %% Add channels to pending set for all handlers
            NewHandlers = maps:map(fun(_Pid, Handler) ->
                Pending = maps:get(pending, Handler),
                NewPending = lists:foldl(fun sets:add_element/2, Pending, Channels),
                Handler#{pending => NewPending}
            end, Handlers),
            State#state{eventHandlers = NewHandlers}
    end.