#{mode := client, host := Host, port := Port, keys := KeyFile, server_pk := ServerPKStr} ->

        #{mode := client,
          host := Host,
          port := Port,
          keys := KeyFile,
          server_pk := ServerPKStr} ->

        #{mode := server, port := Port, keys := KeyFile} ->

        #{mode := server,
          port := Port,
          keys := KeyFile} ->

    PKHex = hex:bin_to_hexstrn(Public),

    PKHex = hex:bin_to_hexstr(Public),

    Content = io_lib:format(
        "%% Generated Noise keypairs~n"
        "~n"
        "{my_keys, #{~n"
        "    priv => \"~s\",~n"
        "    pub => \"~s\"~n"
        "}}.~n",
       [SKHex, PKHex]
    ),

    Content =
        io_lib:format("%% Generated Noise keypairs~n~n{my_keys, #{~n    priv => \"~s\",~n "
                      "   pub => \"~s\"~n}}.~n",
                      [SKHex, PKHex]),

            io:format("Connected to ~s:~p~n", [Host, Port]),
            ok = gen_tcp:send(TcpSock, <<0, 8, 0, 0, 3>>),
            Opts = [
                {noise, TestProtocol},
                {s, enoise_keypair:new(dh25519, ClientSK, ClientPK)},
                {rs, ServerPK},
                {prologue, <<0, 8, 0, 0, 3>>}
            ],

            Opts =
                [{noise, TestProtocol},
                 {s, enoise_keypair:new(dh25519, ClientSK, ClientPK)},
                 {rs, ServerPK},
                 {prologue, <<0, 8, 0, 0, 3>>}],

                    spawn(fun() -> chat_receiver(EConn) end),
                    chat_client(EConn),
                    enoise:close(EConn);

                    init_loop(EConn);

chat_client(EConn) ->
    io:format("Connected. Type messages (Ctrl+C to quit):~n"),
    chat_send_loop(EConn).

init_loop(EConn) ->
    Self = self(),
    Input = spawn(fun() -> input_loop(Self) end),
    io:setopts([{echo, false}]),
    chat_loop(EConn, Input).

chat_send_loop(Econn) ->
    case io:get_line("> ") of
        eof ->
            io:format("Exiting...~n");
        Line ->
            ok = enoise:send(Econn, Line),
            chat_send_loop(Econn)

input_loop(Server) ->
    case io:get_line("") of
        eof -> exit(normal);
        {error, _} -> exit(error);
        Line -> Server ! {input_line, Line}, input_loop(Server)

chat_receiver(EConn) ->

chat_loop(EConn, Input) ->

        {noise, EConn, Msg} ->
            io:format("~s", [Msg]),
            chat_receiver(EConn);
        {'EXIT', _, _} ->
            io:format("Conn exited~n"),
            ok

        {noise, EConn2, Msg} ->
            io:format("💬 ~s~n", [string:chomp(Msg)]),
            chat_loop(EConn2, Input);
        {input_line, InputLine} ->
            case string:chomp(InputLine) of
                "quit" -> enoise:close(EConn);
                Clean -> enoise:send(EConn, Clean ++ "\n")
            end,
            chat_loop(EConn, Input);
        {io_request, From, ReplyAs, {get_line, _, _}} ->
            io:reply(From, ReplyAs, {data, ""}), % Ignore, we drive input
            chat_loop(EConn, Input);
        {io_request, From, ReplyAs, {put_chars, _, Str}} ->
            io:put_chars(Str),
            io:reply(From, ReplyAs, ok),
            chat_loop(EConn, Input);
        {'EXIT', Input, _} ->
            io:format("Input process died~n"),
            enoise:close(EConn)

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

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

    case gen_tcp:accept(ListenSock, 10000) of

    case gen_tcp:accept(ListenSock, -1) of

            io:format("Client connected~n"),
            Opts = [
                {noise, Proto},
                {s, enoise_keypair:new(dh25519, ServerSK, ServerPK)},
                {prologue, <<0, 8, 0, 0, 3>>}
            ],
            Pid = spawn(fun() ->
                case enoise:accept(TcpSock, Opts) of
                    {ok, EConn, _Hs} ->
                        io:format("Handshake successful~n"),
                        chat_server(EConn),
                        enoise:close(EConn);
                    {error, Reason} ->
                        io:format("Accept failed: ~p~n", [Reason])
                end
            end),
            % Keep listening
            gen_tcp:controlling_process(TcpSock, Pid),

            Opts =
                [{noise, Proto},
                 {s, enoise_keypair:new(dh25519, ServerSK, ServerPK)},
                 {prologue, <<0, 8, 0, 0, 3>>}],
            %Pid = spawn(fun() ->
                           case enoise:accept(TcpSock, Opts) of
                               {ok, EConn, _Hs} ->
                                   io:format("Handshake successful~n"),
                                   init_loop(EConn);
                               {error, Reason} -> io:format("Accept failed: ~p~n", [Reason])
                           end
            %            end),
            %gen_tcp:controlling_process(TcpSock, Pid),
                ,

chat_server(EConn) ->
    io:format("Chat started with client~n"),
    spawn(fun() -> server_receiver(EConn) end),
    server_send_loop(EConn).

server_send_loop(EConn) ->
    case io:get_line("server> ") of
        eof ->
            io:format("Server closing connection~n");
        Line ->
            ok = enoise:send(EConn, Line),
            server_send_loop(EConn)
    end.
server_receiver(EConn) ->
    receive
        {noise, EConn, Msg} ->
            io:format("client: ~s", [Msg]),
            server_receiver(EConn);
        {'EXIT', _, _} ->
            ok
    end.

parse_args([], Acc) -> Acc;

parse_args([], Acc) ->
    Acc;

    io:format("  rebar3 run -- -mode client -host localhost -port 7891 -keys keys.txt -sever-pk hexstring~n").

    io:format("  rebar3 run -- -mode client -host localhost -port 7891 -keys "
              "keys.txt -sever-pk hexstring~n").