timer:sleep(500),

    %% Wait for connection to be fully established
    wait_for_peer(Bob, AliceAddr, 10),

    timer:sleep(500),

    timer:sleep(1000),
    %% Bob should have received Alice's channel list
    {ok, AliceChannels} = peer:peer_channel_list(Bob, AliceAddr),
    ?assertEqual(3, length(AliceChannels)),
    ?assert(lists:member("general", AliceChannels)),
    ?assert(lists:member("random", AliceChannels)),
    ?assert(lists:member("dev", AliceChannels)),

    timer:sleep(500),

    timer:sleep(1000),

    %% The responses will be logged to console
    %% (not stored anywhere yet - just testing the protocol works)

    %% Alice should have received Bob's channel list
    {ok, BobChannels} = peer:peer_channel_list(Alice, BobAddr),
    ?assertEqual(1, length(BobChannels)),
    ?assert(lists:member("announcements", BobChannels)),

%% Wait for a peer to appear in the peer list (connection established)
wait_for_peer(_Pid, _PeerAddr, 0) ->
    timeout;
wait_for_peer(Pid, PeerAddr, Retries) ->
    PeerList = peer:peer_list(Pid),
    case lists:keyfind(PeerAddr, 1, PeerList) of
        false ->
            timer:sleep(100),
            wait_for_peer(Pid, PeerAddr, Retries - 1);
        _Found ->
            ok
    end.

terminate(_Reason, #state{listener_pid = ListenerPid}) ->

terminate(_Reason, #state{listener_pid = ListenerPid, conn_to_peer = Connections}) ->
    %% Note: Don't use io:format here - group leader may be dead during test cleanup
    %% Close all active connections
    maps:foreach(
        fun(ConnPid, _Peer) ->
            catch enoise_cable:close(ConnPid)
        end,
        Connections
    ),
    %% Close the listener

-export([request_channel_list/2]).

-export([request_channel_list/2, peer_channel_list/2]).

    activeIn = #{}

    activeIn = #{},
    % Map of received channel lists from peers: #{PeerAddr => [Channels]}
    peerChannelLists = #{}

peer_channel_list(Pid, Peer) ->
    gen_server:call(Pid, {peerChannelList, Peer}).

    {noreply, State};
handle_call({peerChannelList, Peer}, From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {peerChannelList, Peer, From},

    io:format("[Peer] shutting down~n", []),

    %% Note: Avoid io:format during shutdown - group leader may be dead in tests
    %% Stop transport with timeout to avoid hanging

    transport:stop(TPid),

    case catch gen_server:call(TPid, stop, 1000) of
        ok ->
            ok;
        {'EXIT', {timeout, _}} ->
            exit(TPid, kill);
        _Other ->
            ok
    end,
    %% Stop event loop

    %% Close database

        {peerChannelList, Peer, From} ->
            NewState = handle_system_messages(peerChannelList, {Peer, From}, State),
            event_loop(NewState);

    gen_server:reply(From, Result),
    State;
handle_system_messages(peerChannelList, {Peer, From}, State = #state{peerChannelLists = Lists}) ->
    Result = case maps:get(Peer, Lists, undefined) of
        undefined -> {ok, []};
        Channels -> {ok, Channels}
    end,

    {ok, {ReqId, _Msg, Size}} = send_channel_list_request(State, Peer, 0, 100),
    io:format("[Peer] Sent channel list request (~p) to ~p~n", [hex:bin_to_hexstr(ReqId), Peer]),
    NewActiveOut = maps:put(ReqId, {Peer, channel_list_request}, ActiveOut),
    NewPeers = update_peer_sent(Peers, Peer, Size),
    State#state{activeOut = NewActiveOut, peers = NewPeers};

    case send_channel_list_request(State, Peer, 0, 100) of
        {ok, {ReqId, _Msg, Size}} ->
            io:format("[Peer] Sent channel list request (~p) to ~p~n", [hex:bin_to_hexstr(ReqId), Peer]),
            NewActiveOut = maps:put(ReqId, {Peer, channel_list_request}, ActiveOut),
            NewPeers = update_peer_sent(Peers, Peer, Size),
            State#state{activeOut = NewActiveOut, peers = NewPeers};
        {error, Reason} ->
            io:format("[Peer] Failed to send channel list request to ~p: ~p~n", [Peer, Reason]),
            State
    end;

                    %% TODO: Could store these in a separate table or emit an event
                    %% For now, just log them
                    S#state{peers = NewPeers}

                    %% Store the received channel list
                    PeerChannelLists = S#state.peerChannelLists,
                    NewPeerChannelLists = maps:put(Peer, Channels, PeerChannelLists),
                    S#state{peers = NewPeers, peerChannelLists = NewPeerChannelLists}