% SPDX-FileCopyrightText: 2023 Henry Bubert
%
% SPDX-License-Identifier: LGPL-2.1-or-later
-module(cable_peer_suite).
-include_lib("eunit/include/eunit.hrl").
open_close_test() ->
    A = make_test_args(),
    {ok, P} = peer:start_link(A),
    ok = peer:stop(P).
empty_state_test() ->
    A = make_test_args(),
    {ok, P} = peer:start_link(A),
    {ok, Chans} = peer:channelList(P),
    ?assertEqual([], Chans),
    ok = peer:stop(P).
join_and_leave_test() ->
    A = make_test_args(),
    {ok, P} = peer:start_link(A),
    {ok, []} = peer:channelList(P),
    peer:join(P, "default"),
    {ok, ["default"]} = peer:channelList(P),
    ok = peer:leave(P, "default"),
    {ok, []} = peer:channelList(P),
    ok = peer:stop(P).
make_test_args() ->
    S = string:chomp(os:cmd("mktemp --tmpdir -d caberl-peer-XXXXX")),
    ?debugFmt("~nUsing Storage: ~p~n", [S]),
    [ {listener, ["localhost", 0]}
    , {storage, S}].

    TestDb = string:chomp(os:cmd("mktemp --tmpdir  -d " ++ Name ++ "-XXXXX")),
    ?debugFmt("Using DB Path: ~p~n", [TestDb]),

    TestDb = string:chomp(os:cmd("mktemp --tmpdir  -d caberl-" ++ Name ++ "-XXXXX")),
    ?debugFmt("~nUsing DB Path: ~p~n", [TestDb]),

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

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

%% start/stop server
start_link(Args) ->
    LisAddr = proplists:get_value(listener, Args, ["0.0.0.0", 3113]),
    StoragePath = proplists:get_value(storage, Args, default_caberl_location()),
    gen_server:start_link(peer, [{listener, LisAddr}, {storage, StoragePath}], []).

stop(Pid) ->
    gen_server:cast(Pid, stop).

    gen_server:cast(Pid, {channelJoin, Chan}).

    gen_server:cast(Pid, {channelsJoin, Chan}).

part(Pid, Chan) when is_list(Chan) ->
    gen_server:cast(Pid, {channelPart, Chan}).

leave(Pid, Chan) when is_list(Chan) ->
    gen_server:cast(Pid, {channelsLeave, Chan}).

    gen_server:call(Pid, {channelList}).

    gen_server:call(Pid, {channelsList}).

start_link(Host, Port) ->
    Args = [ {listener, [Host, Port]}
           , {storage, default_caberl_location()}],
    gen_server:start_link({local, cabalPeer}, peer, Args, []).

    {ok, [{listenProc, ListenProc}, {eventLoop, Handler}]}.

    {ok, [{listenProc, ListenProc}, {eventLoop, Handler}, {database, Db}]}.

handle_call({channelList}, From, State) ->

handle_call({channelsList}, From, State) ->

    EL ! {channelList, From}, % reply via event loop

    EL ! {channelsList, From}, % reply via event loop

handle_cast({channelJoin, Chan}, State) ->

handle_cast({channelsJoin, Chan}, State) ->

    EL ! {channelJoin, Chan},

    EL ! {channelsJoin, Chan},

handle_cast({channelPart, Chan}, State) ->

handle_cast({channelsLeave, Chan}, State) ->

    EL ! {channelPart, Chan},

    EL ! {channelsLeave, Chan},

handle_cast(stop, State) ->
    io:format("[Peer] shutting down~n", []),
    LisProc = proplists:get_value(listenProc, State),
    unlink(LisProc),
    EventLoopProc = proplists:get_value(eventLoop, State),
    EventLoopProc ! {stop},
    unlink(EventLoopProc),
    Db = proplists:get_value(database, State),
    ok = db:close(Db),
    {stop, normal, State};

terminate(TermReason, _State) ->
    io:format("terminating peer: ~p~n", [TermReason]),
    %% LisProc = proplists:get_value(listenProc, State),
    %% unlink(LisProc),
    %% EventLoopProc = proplists:get_value(eventLoop, State),
    %% unlink(EventLoopProc),

terminate(Reason, _State) ->

    {ok, Sock} = gen_tcp:accept(Lis, infinity),
    {ok, {RemoteIp, Port}} = inet:peername(Sock),
    io:format("[Peer] Incoming Connection ~p:~p (~p)~n", [RemoteIp, Port, Sock]),
    Handler ! {peerNew, Sock},
    listen_loop(Handler, Lis).

    case gen_tcp:accept(Lis, infinity) of
        {error, closed} ->
            %% io:format("[Peer] Incoming listener closed"),
            ok;
        {ok, Sock} ->
            {ok, {RemoteIp, Port}} = inet:peername(Sock),
            io:format("[Peer] Incoming Connection ~p:~p (~p)~n", [RemoteIp, Port, Sock]),
            Handler ! {peerNew, Sock},
            listen_loop(Handler, Lis)
    end.

        {stop} -> ok;

        {channelJoin, Chan} ->

        {channelsJoin, Chan} ->

                    {ok, _} = db:channelsJoin(Db, Chan),

                    ok = db:channelsJoin(Db, Chan),

        {channelPart, Chan} ->

        {channelsLeave, Chan} ->

        {channelList, From} ->
            gen_server:reply(From, maps:keys(Chans)),

        {channelsList, From} ->
            gen_server:reply(From, {ok, maps:keys(Chans)}),

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

    end.

    {ok, Db} = sqlite3:open(cabalDb, [{file, Path}]),

    {ok, Db} = sqlite3:open(list_to_atom(Path), [{file, Path}]),

    gen_server:start_link({local, cabalDatabase}, ?MODULE, [{dbPath, DbPath}], []).

    gen_server:start_link(?MODULE, [{dbPath, DbPath}], []).

    ok = sqlite3:delete(Db, channels, [{name, Name}]),

    ok = sqlite3:delete(Db, channels, {name, Name}),