-export([persistent_peer_add/2, persistent_peer_remove/2, persistent_peer_list/1]).

    peerChannelLists = #{}

    peerChannelLists = #{},
    % Timer reference for periodic reconnection attempts
    reconnectTimer = undefined

%% manage persistent peer connections
persistent_peer_add(Pid, Address) ->
    gen_server:call(Pid, {persistentPeerAdd, Address}).
persistent_peer_remove(Pid, Address) ->
    gen_server:call(Pid, {persistentPeerRemove, Address}).
persistent_peer_list(Pid) ->
    gen_server:call(Pid, {persistentPeerList}).

    %% Start periodic reconnection timer (check every 10 seconds)
    Handler ! {startReconnectTimer},

    {noreply, State}.

    {noreply, State};
handle_call({persistentPeerAdd, Address}, _From, State) ->
    Db = proplists:get_value(database, State),
    Result = db:peer_add(Db, Address),
    {reply, Result, State};

handle_call({persistentPeerRemove, Address}, _From, State) ->
    Db = proplists:get_value(database, State),
    Result = db:peer_delete(Db, Address),
    {reply, Result, State};
handle_call({persistentPeerList}, _From, State) ->
    Db = proplists:get_value(database, State),
    Result = db:peer_list(Db),
    {reply, Result, State}.

        {startReconnectTimer} ->
            %% Start periodic timer (10 seconds)
            TimerRef = erlang:send_after(10000, self(), {reconnectTimer}),
            event_loop(State#state{reconnectTimer = TimerRef});
        {reconnectTimer} ->
            %% Handle periodic reconnection attempts
            NewState = attempt_peer_reconnections(State),
            %% Reschedule timer
            TimerRef = erlang:send_after(10000, self(), {reconnectTimer}),
            event_loop(NewState#state{reconnectTimer = TimerRef});

            %% Update persistent peer database if this peer is in the list
            Db = State#state.db,
            case db:peer_get(Db, PeerAddr) of
                {ok, PeerInfo} ->
                    %% Peer is in persistent list - decrease score
                    CurrentScore = maps:get(score, PeerInfo, 0),
                    Now = os:system_time(millisecond),
                    db:peer_update(Db, PeerAddr, [
                        {score, max(0, CurrentScore - 5)},
                        {last_seen, Now}
                    ]),
                    io:format("[Peer] Updated persistent peer ~s: score -5~n", [PeerAddr]);
                not_found ->
                    ok % Not a persistent peer, no action needed
            end,

    %% Update persistent peer database if this peer is in the list
    Db = State#state.db,
    case db:peer_get(Db, PeerAddr) of
        {ok, PeerInfo} ->
            %% Peer is in persistent list - reset backoff and increase score
            CurrentScore = maps:get(score, PeerInfo, 0),
            Now = os:system_time(millisecond),
            db:peer_update(Db, PeerAddr, [
                {score, CurrentScore + 10},
                {last_seen, Now},
                {attempt_count, 0}
            ]),
            io:format("[Peer] Updated persistent peer ~s: score +10, reset backoff~n", [PeerAddr]);
        not_found ->
            ok % Not a persistent peer, no action needed
    end,

%% Persistent peer reconnection helpers
%% Calculate exponential backoff delay in milliseconds
%% Base delay is 5 seconds, max is 5 minutes
calculate_backoff_delay(AttemptCount) ->
    BaseDelayMs = 5000,  % 5 seconds
    MaxDelayMs = 300000, % 5 minutes
    %% Exponential backoff: base * 2^attempts, capped at max
    DelayMs = BaseDelayMs * math:pow(2, AttemptCount),
    min(trunc(DelayMs), MaxDelayMs).
%% Check if a peer should be reconnected based on last attempt and backoff
should_reconnect_peer(PeerInfo) ->
    Now = os:system_time(millisecond),
    LastAttempt = maps:get(last_attempt, PeerInfo, 0),
    AttemptCount = maps:get(attempt_count, PeerInfo, 0),
    BackoffDelay = calculate_backoff_delay(AttemptCount),
    %% Reconnect if enough time has passed since last attempt
    (Now - LastAttempt) >= BackoffDelay.
%% Get the address string for a peer from connected peers map
get_peer_address_string(ConnPid, Peers) ->
    case maps:get(ConnPid, Peers, undefined) of
        undefined -> undefined;
        PeerMeta ->
            case maps:get(address, PeerMeta, undefined) of
                undefined -> undefined;
                Addr -> Addr
            end
    end.
%% Check if peer address is already connected
is_peer_connected(Address, Peers) ->
    %% Check if any connected peer has this address
    lists:any(
        fun({_ConnPid, PeerMeta}) ->
            maps:get(address, PeerMeta, undefined) =:= Address
        end,
        maps:to_list(Peers)
    ).
%% Attempt to reconnect to persistent peers based on exponential backoff
attempt_peer_reconnections(State = #state{db = Db, transportPid = TransportPid, peers = Peers}) ->
    %% Get all persistent peers
    {ok, PersistentPeers} = db:peer_list(Db),
    %% Filter and attempt reconnections
    lists:foreach(
        fun(PeerInfo) ->
            Address = maps:get(address, PeerInfo),
            %% Only attempt if not already connected and backoff period has passed
            case is_peer_connected(Address, Peers) of
                true ->
                    ok; % Already connected, skip
                false ->
                    case should_reconnect_peer(PeerInfo) of
                        true ->
                            %% Attempt reconnection
                            io:format("[Peer] Attempting reconnection to ~s~n", [Address]),
                            try
                                %% Parse address and dial
                                [HostStr, PortStr] = string:split(Address, ":"),
                                {ok, Host} = inet:getaddr(HostStr, inet),
                                Port = list_to_integer(PortStr),
                                transport:dial(TransportPid, Host, Port),
                                %% Update last_attempt and increment attempt_count
                                Now = os:system_time(millisecond),
                                AttemptCount = maps:get(attempt_count, PeerInfo, 0),
                                db:peer_update(Db, Address, [
                                    {last_attempt, Now},
                                    {attempt_count, AttemptCount + 1}
                                ])
                            catch
                                _:Error ->
                                    io:format("[Peer] Failed to dial ~s: ~p~n", [Address, Error])
                            end;
                        false ->
                            ok % Backoff period not elapsed, skip
                    end
            end
        end,
        PersistentPeers
    ),
    State.

-export([peer_add/2, peer_update/3, peer_list/1, peer_delete/2, peer_get/2]).

%% manage persistent peers
peer_add(Db, Address) ->
    gen_server:call(Db, {peerAdd, Address}).
peer_update(Db, Address, Updates) ->
    gen_server:call(Db, {peerUpdate, Address, Updates}).
peer_list(Db) ->
    gen_server:call(Db, {peerList}).

peer_delete(Db, Address) ->
    gen_server:call(Db, {peerDelete, Address}).
peer_get(Db, Address) ->
    gen_server:call(Db, {peerGet, Address}).

    {reply, {ok, Chans}, State}.

    {reply, {ok, Chans}, State};
%%%%%%%%%%%
%% Peers %%
%%%%%%%%%%%
handle_call({peerAdd, Address}, _From, [{sql, Db}, _] = State) ->
    Now = os:system_time(millisecond),
    Row = [
        {address, Address},
        {score, 0},
        {attempt_count, 0},
        {created_at, Now}
    ],
    Res = case sqlite3:write(Db, peers, Row) of
        {rowid, RowId} -> {ok, RowId};
        {error, 19, _Msg} -> {error, already_exists}
    end,
    {reply, Res, State};
handle_call({peerUpdate, Address, Updates}, _From, [{sql, Db}, _] = State) ->
    %% Updates is a proplist like [{score, 10}, {last_seen, Timestamp}]
    Res = case sqlite3:update(Db, peers, {address, Address}, Updates) of
        ok -> ok;
        Error -> {error, Error}
    end,
    {reply, Res, State};
handle_call({peerList}, _From, [{sql, Db}, _] = State) ->
    [{columns, _Cols}, {rows, Rows}] = sqlite3:read_all(Db, peers),
    %% Expected columns: ["id", "address", "score", "last_seen", "last_attempt", "attempt_count", "created_at", "notes"]
    Peers = lists:map(
        fun({Id, Address, Score, LastSeen, LastAttempt, AttemptCount, CreatedAt, Notes}) ->
            #{
                id => Id,
                address => binary_to_list(Address),
                score => Score,
                last_seen => LastSeen,
                last_attempt => LastAttempt,
                attempt_count => AttemptCount,
                created_at => CreatedAt,
                notes => case Notes of
                    null -> undefined;
                    N -> binary_to_list(N)
                end
            }
        end,
        Rows
    ),
    {reply, {ok, Peers}, State};
handle_call({peerDelete, Address}, _From, [{sql, Db}, _] = State) ->
    ok = sqlite3:delete(Db, peers, {address, Address}),
    {reply, ok, State};
handle_call({peerGet, Address}, _From, [{sql, Db}, _] = State) ->
    Result = case sqlite3:read(Db, peers, {address, Address}) of
        [{columns, _Cols}, {rows, [{Id, Addr, Score, LastSeen, LastAttempt, AttemptCount, CreatedAt, Notes}]}] ->
            {ok, #{
                id => Id,
                address => binary_to_list(Addr),
                score => Score,
                last_seen => LastSeen,
                last_attempt => LastAttempt,
                attempt_count => AttemptCount,
                created_at => CreatedAt,
                notes => case Notes of
                    null -> undefined;
                    N -> binary_to_list(N)
                end
            }};
        _ ->
            not_found
    end,
    {reply, Result, State}.

        users => [ColId, {public_key, blob, [unique, not_null]}, {name, text, not_null}]

        users => [ColId, {public_key, blob, [unique, not_null]}, {name, text, not_null}],
        peers => [
            ColId,
            {address, text, [unique, not_null]},
            {score, integer, {default, 0}},
            {last_seen, integer},
            {last_attempt, integer},
            {attempt_count, integer, {default, 0}},
            {created_at, integer, not_null},
            {notes, text}
        ]

  nativeBuildInputs = with pkgs.buildPackages; [ erlang_27 rebar3 libsodium sqlite] ++ [erlang-language-platform erlfmt erlang-language-platform clang];

  nativeBuildInputs = with pkgs.buildPackages; [ erlang_27 rebar3 libsodium sqlite] ++ [erlang-language-platform erlfmt clang];