SrvOpts =
        [{mode, active},
         {echos, 5},
         % or whatever Pid you want to reply to
         {reply, self()}],

            92, 225, 220, 99, 50, 93, 96, 253, 250, 116, 196, 137, 103>>,

          92, 225, 220, 99, 50, 93, 96, 253, 250, 116, 196, 137, 103>>,

        <<112, 91, 141, 253, 183, 66, 217, 102, 211, 40, 13, 249, 238, 51, 77, 114, 163, 159, 32, 1,
            162, 219, 76, 106, 89, 164, 34, 71, 149, 2, 103, 59>>,

        <<112, 91, 141, 253, 183, 66, 217, 102, 211, 40, 13, 249, 238, 51, 77, 114, 163, 159, 32,
          1, 162, 219, 76, 106, 89, 164, 34, 71, 149, 2, 103, 59>>,

    Opts = [
        {noise, TestProtocol},
        {s, enoise_keypair:new(dh25519, ServerPrivKey, ServerPubKey)},
        {prologue, <<0, 8, 0, 0, 3>>}
    ],

    TcpOpts = [{active, true}, {reuseaddr, true}, binary],
    {ok, LSock} = gen_tcp:listen(7891, TcpOpts),

    {ok, LSock} = gen_tcp:listen(7891, [{reuseaddr, true}, binary, {active, false}]),

    {ok, TcpSock} = gen_tcp:accept(LSock, 10000),
    io:format("socket accepted~n"),
    receive
        {tcp, TcpSock, <<0, 8, 0, 0, 3>>} ->
            ok
    after 1000 ->
        error(timeout)
    end,

    spawn(fun() -> accept_loop(LSock, Opts) end),

    io:format("got preample~n"),

    timer:sleep(infinity).

    Opts =
        [{noise, TestProtocol},
         {s, enoise_keypair:new(dh25519, ServerPrivKey, ServerPubKey)},
         {prologue, <<0, 8, 0, 0, 3>>}],
    AcceptRes =
        try
            enoise:accept(TcpSock, Opts)
        catch
            _:R:S ->
                gen_tcp:close(TcpSock),
                {error, {R, S}}
        end,

accept_loop(LSock, Opts) ->
    case gen_tcp:accept(LSock, 5000) of
        {ok, TcpSock} ->
            io:format("Accepted connection from ...~n"),%, [peer_addr(TcpSock)]),
            spawn(fun() -> handle_connection(TcpSock, Opts) end),
            accept_loop(LSock, Opts);
        {error, timeout} ->
            accept_loop(LSock, Opts);
        {error, closed} ->
            io:format("Listener socket closed~n");
        {error, Reason} ->
            io:format("Accept failed: ~p~n", [Reason])

    %gen_tcp:close(LSock),
    %io:format("socket closed~n"),
    case AcceptRes of
        {ok, EConn, EHs} ->
            echo_srv_loop(EConn, EHs, SrvOpts);
        Err = {error, _} ->
            srv_reply(Err, SrvOpts)

handle_connection(TcpSock, Opts) ->
    io:format("socket accepted~n"),
    receive
        {tcp, TcpSock, <<0, 8, 0, 0, 3>>} -> ok
    after 5000 -> error(timeout)
    end,

echo_srv_loop(EConn, EHs, SrvOpts) ->
    io:format("got handshake!~n~p~n", [EHs]),

    io:format("got preample~n"),

    Echos = proplists:get_value(echos, SrvOpts, 3),
    Res = [begin
               Msg = receive
                   {noise, EConn, Data} ->
                       Data
               after 1000 ->
                   error(timeout)
               end,
               io:format("got message: ~p~n", [Msg]),
               ok = enoise:send(EConn, Msg)
           end
           || _ <- lists:seq(1, Echos)],
    io:format("Result:~p~n", [Res]),

    {ok, EConn, EHs} = enoise:accept(TcpSock, Opts),

    srv_reply(Res, SrvOpts),

    io:format("got handshake!~p~n", [EHs]),

    enoise:close(EConn),

    {EConn1, Msg} = enoise:recv(EConn),
    EConn2 = enoise:send(EConn1, Msg),

    Res.

    enoise:close(EConn2).

srv_reply(Reply, SrvOpts) ->
    case proplists:get_value(reply, SrvOpts, undefined) of
        undefined ->
            ok;
        Pid ->
            Pid ! {self(), server_result, Reply}
    end.

    TcpOpts = [
        {active, true},
        binary,
        {reuseaddr, true}
    ],

        [
            {active, once},
            binary,
            {reuseaddr, true}
        ],

        TcpOpts,

    gen_tcp:send(TcpSock, <<0, 8, 0, 0, 3>>),

    ok = gen_tcp:send(TcpSock, <<0, 8, 0, 0, 3>>),

        {rs, enoise_keypair:new(dh25519, ServerPubKey)},

        {rs, ServerPubKey},

    ok = enoise:send(EConn, <<"ok\n">>),

    LoopCount = 3,
    send_receive_loop(EConn, LoopCount),
    enoise:close(EConn).
send_receive_loop(_EConn, 0) ->
    io:format("Finished loop~n");
send_receive_loop(EConn, N) ->
    Message = <<"ok\n">>,
    ok = enoise:send(EConn, Message),
    io:format("Sent: ~p~n", [Message]),

        {noise, EConn, <<"ok\n">>} -> ok
    after 1000 -> error(timeout)

        {noise, EConn, Message} ->
            io:format("Received: ~p~n", [Message])
    after 3000 ->
        error({timeout, N})

    {ok, <<"ok\n">>} = enoise:recv(EConn, 3, 1000),
    enoise:close(EConn).

    timer:sleep(100), % Optional: avoid flooding
    send_receive_loop(EConn, N - 1).