[Header, [ {ttl, 1}, {cancelid, CancelId}]] = Decoded,

    [Header, [ {ttl, 1}, {cancelId, CancelId}]] = Decoded,

    , {cancelid, CancelId}

    , {cancelId, CancelId}

-export([start_link/2, dial/2, channelList/1, join/2, part/2]).

-export([start_link/2, dial/2, peerList/1, channelList/1, join/2, part/2]).

%%    bytesTransmitted => [Sent, Received],

%%    bytesTransmitted => {Sent, Received},

peerList(Pid) ->
    gen_server:call(Pid, {peerList}).

    Handler = spawn_link(fun() -> event_loop(State) end),
    ListenProc = spawn_link(fun() -> listen_loop(Handler, Lis) end),

    Handler = spawn(fun() -> event_loop(State) end),
    io:format("[DEBUG] Event Loop: ~p~n", [Handler]),
    ListenProc = spawn(fun() -> listen_loop(Handler, Lis) end),
    io:format("[DEBUG] Socket listener: ~p~n", [ListenProc]),

    {noreply, State};
handle_call({peerList}, From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {peerList, From}, % reply via event loop

            io:format("[Peer] Connecting to ~p:~p~n", [Host, Port]),
            Handler = proplists:get_value(eventLoop, State),
            spawn_link(fun() -> decode_loop(Handler, Sock) end),

            io:format("[Peer] Dialed ~p:~p as ~p~n", [Host, Port, Sock]),

            EL ! {newPeer, Sock}

            EL ! {peerNew, Sock}

    ConnReader = spawn(fun() -> decode_loop(Handler, Sock) end),
    %% TODO: read docs of this linkage
    ok = gen_tcp:controlling_process(Sock, ConnReader),
    {ok, {RemoteIp, _}} = inet:peername(Sock),
    io:format("[Peer] Incoming Connection ~p (~p)~n", [RemoteIp, Sock]),

    {ok, {RemoteIp, Port}} = inet:peername(Sock),
    io:format("[Peer] Incoming Connection ~p:~p (~p)~n", [RemoteIp, Port, Sock]),

                 bytesTransmitted := [Sent, Received]

                 bytesTransmitted := {Sent, Received}

            FilterReqs = fun(ReqId) -> not maps:is_key(ReqId, PeersRequestIds) end,
            NewIn = lists:filter(FilterReqs, ActiveIn),
            NewOut = lists:filter(FilterReqs, ActiveOut),

            RmActives = fun(ReqId, _) -> not maps:is_key(ReqId, PeersRequestIds) end,
            NewIn = maps:filter(RmActives, ActiveIn),
            NewOut = maps:filter(RmActives, ActiveOut),

                                 ChanReqs = maps:take(ChanName, AccChans),

                                 {ChanReqs, NewChanAcc} = maps:take(ChanName, AccChans),

                                                                    io:format("[DEBUG Peer:~p] dropping ~p request ~p~n", [Peer, Direction, hex:binary_to_hexstr(ReqId)]),

                                                                    io:format("[DEBUG Peer:~p] dropping ~p request ~p~n", [Peer, Direction, hex:bin_to_hexstr(ReqId)]),

                                 NewChan = lists:filter(FilterReqsOfPeer, ChanReqs),
                                 NewChan

                                 NewReqs = lists:filter(FilterReqsOfPeer, ChanReqs),
                                 maps:put(ChanName, NewReqs, NewChanAcc)

            NewState = State#state{

            event_loop(State#state{

                        },
            event_loop(NewState);

                        });

            io:format("[DEBUG] Starting peerNew:~p~n", [Peer]),

                                 maps:update(Chan, ReqsForChan ++ [{sent, ReqId, Peer}]),

                                 maps:update(Chan, ReqsForChan ++ [{sent, ReqId, Peer}], AccChannels),

                                         map:put(ReqId, {Peer, Msg}, AccActiveOut)

                                         maps:put(ReqId, {Peer, Msg}, AccActiveOut)

                              bytesTransmitted => [PeerSent, 0]

                              bytesTransmitted => {PeerSent, 0}

            io:format("[DEBUG] Peer ~p added to event loop state~n", [Peer]),
            %Handler = proplists:get_value(eventLoop, State),
            Handler = self(),
            spawn(fun() -> decode_loop(Handler, Peer) end),

        {peerList, From} ->
            EachPeer = fun(PeerId, PeerMeta, Acc) ->
                               Acc ++ [{PeerId, PeerMeta}]
                       end,
            PeerList = maps:fold(EachPeer, [], Peers),
            gen_server:reply(From, PeerList),
            event_loop(State);

            io:format("[DEBUG] new message Type:~p - Body:~p~n", [MsgType, Body]),
            case maps:is_key(ReqId, ActiveOut) of

            IsActiveOut = maps:is_key(ReqId, ActiveOut),
            io:format("[DEBUG] new message Type:~p - IsActiveOut: ~p - Body:~p~n", [MsgType, IsActiveOut, Body]),
            case IsActiveOut of

                            [io:format("[TEMP] got post reply:~n~p~n", [posts:decode(P)]) || P <- Posts]

                            [io:format("[TEMP] got post reply:~n~p~n", [posts:decode(P)]) || P <- Posts],
                            event_loop(State)

                            erlang:error("TODO post req");

                            throw({todoPostReq});

                            erlang:error("TODO cancel req");

                            CancelId = proplists:get_value(cancelId, Body, <<>>),
                            case maps:take(CancelId, ActiveIn) of
                                error -> event_loop(State); % ignore
                                {_, NewActiveIn} ->
                                    UpdateChans = fun(_Chan, ChanReqs) ->
                                                          %% we might need to put the received atom in a variable. not sure if this pattern matching works like i think it does.
                                                          UpdatedReqs = lists:filter(fun({received, ChanReqId, _}) -> CancelId =/= ChanReqId  end, ChanReqs),
                                                          {true, UpdatedReqs}
                                                  end,
                                    event_loop(State#state{
                                                 peers = update_peer_received(Peers, Peer, MsgSize),
                                                 channels = maps:filtermap(UpdateChans, Chans),
                                                 activeIn = NewActiveIn
                                                })
                            end;

                            erlang:error("TODO channel time req");

                            RequestedChan = proplists:get_value(channel, Body),
                            case maps:take(RequestedChan, Chans) of
                                error -> event_loop(State); % ignore
                                {ChanReqs, TmpChans} ->
                                    %% TODO: send
                                    io:format("[TEMP] Received incoming chan time req for ~p from ~p~n", [RequestedChan, Peer]),
                                    NewChanReqs = ChanReqs ++ [{received, ReqId, Peer}],
                                    event_loop(State#state{
                                                 peers = update_peer_received(Peers, Peer, MsgSize),
                                                 channels = maps:put(RequestedChan, NewChanReqs, TmpChans),
                                                 activeIn = maps:put(ReqId, {Peer, Msg}, ActiveIn)
                                                })
                            end;

                                error -> ok; % ignore

                                error -> event_loop(State); % ignore

                            send_channel_list_response(Peer, ReqId, ChanList)

                            RxPeers = update_peer_received(Peers, Peer, MsgSize),
                            {ok, {_, _, ResponseSize}} = send_channel_list_response(Peer, ReqId, ChanList),
                            RTxPeers = update_peer_sent(RxPeers, Peer, ResponseSize),
                            event_loop(State#state{
                                         peers = RTxPeers
                                        });
                        Unhandled ->
                            io:format("[Warning] unhandled incoming message of type ~p that isn't state:activeOut - RequestId:~p~n", [Unhandled, ReqIdStr]),
                            event_loop(State)

            end,
            event_loop(State)
    end.

            end
    end,
    %% TODO: sup setup
    throw({eventLoopExited}).

    io:format("[DEBUG] sending ~p to peer ~p~n", [Binary, Peer]),

    %% io:format("[DEBUG] sending ~p to peer ~p~n", [Binary, Peer]),

            erlang:error("unexpected message size");

            throw("unexpected message size");

    [Tx, Rx] = maps:get(bytesTransmitted, PeerMeta),
    NewPeers = Peers#{Peer => maps:update(bytesTransmitted, [Tx+Size, Rx], PeerMeta)},

    {Tx, Rx} = maps:get(bytesTransmitted, PeerMeta),
    NewPeers = Peers#{Peer => maps:update(bytesTransmitted, {Tx+Size, Rx}, PeerMeta)},

    PeerMeta = maps:get(Peer, Peers),
    [Tx, Rx] = maps:get(bytesTransmitted, PeerMeta),
    Peers#{Peer => PeerMeta#{
                             bytesTransmitted => [Tx, Rx+Size],
                             lastSeenAt => os:system_time(1000)
                            }
          }.

    case maps:take(Peer, Peers) of
        error -> throw({peerNotActive, Peer});
        {PeerMeta, PeersSansPeer} ->
            {Tx, Rx} = maps:get(bytesTransmitted, PeerMeta),
            UpdatedMeta = PeerMeta#{bytesTransmitted => {Tx, Rx+Size}, lastSeenAt => os:system_time(1000)},
            maps:put(Peer, UpdatedMeta, PeersSansPeer)
    end.

    io_lib:format("~.2f ~s", [float(S), M]).

    lists:flatten(io_lib:format("~.1f~s", [float(S), M])).
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
human_bytesize_test() ->
    ?assertEqual("81.0mb", human_bytesize(84912712)),
    ?assertEqual("512.0b", human_bytesize(512)),
    ?assertEqual("1.0kb", human_bytesize(1024)).
-endif.