-export([start_link/1]).

-export([start_link/1, get_transport_pid/1]).

%% Retrieve the transport worker PID from the supervisor
get_transport_pid(SupPid) ->
    Children = supervisor:which_children(SupPid),
    case lists:keyfind(cabal_transport, 1, Children) of
        {cabal_transport, Pid, _, _} when is_pid(Pid) -> {ok, Pid};
        _ -> {error, not_found}
    end.

            %% Phase 2: Get TransportPid and start peer_server

            %% Phase 2: Get TransportSupPid and start peer_server

            TransportPid = get_child_pid(TransportSupPid, cabal_transport),

            %% Start peer_server with transport_pid

            %% Start peer_server with transport_sup

                            {transport_pid, TransportPid},

                            {transport_sup, TransportSupPid},

                            {transport_pid, TransportPid},

                            {transport_sup, TransportSupPid},

    % Transport Supervisor PID (needed for recovery)
    transport_sup,

    TransportPid = proplists:get_value(transport_pid, Args),

    TransportSup = proplists:get_value(transport_sup, Args),
    {ok, TransportPid} = cabal_transport_sup:get_transport_pid(TransportSup),
    erlang:monitor(process, TransportPid),

        transport_sup = TransportSup,

handle_info({'DOWN', _Ref, process, Pid, _Reason}, State) when Pid =:= State#state.transport_pid ->
    io:format("[PeerEvents] Transport process died. Attempting recovery...~n"),
    %% Transport died, query supervisor for new PID
    TransportSup = State#state.transport_sup,
    %% Wait a moment for supervisor to restart it
    timer:sleep(200),
    case cabal_transport_sup:get_transport_pid(TransportSup) of
        {ok, NewTPid} ->
            io:format("[PeerEvents] Reacquired transport PID: ~p~n", [NewTPid]),
            erlang:monitor(process, NewTPid),
            {noreply, State#state{transport_pid = NewTPid}};
        {error, _} ->
            {stop, transport_died_permanently, State}
    end;

    % PID of the transport supervisor (for recovery)
    transportSup,

    TPid = proplists:get_value(transport_pid, Args),

    TransportSup = proplists:get_value(transport_sup, Args),
    {ok, TPid} = cabal_transport_sup:get_transport_pid(TransportSup),
    erlang:monitor(process, TPid),

        transportSup = TransportSup,

        _ when Pid =:= State#state.transportPid ->
            io:format("[Peer] Transport process died: ~p. Attempting recovery...~n", [Reason]),
            %% Transport died, query supervisor for new PID
            TransportSup = State#state.transportSup,
            %% Wait a moment for supervisor to restart it
            timer:sleep(200),
            case cabal_transport_sup:get_transport_pid(TransportSup) of
                {ok, NewTPid} ->
                    io:format("[Peer] Reacquired transport PID: ~p~n", [NewTPid]),
                    erlang:monitor(process, NewTPid),
                    ok = cabal_transport:register_handler(NewTPid, self()),
                    {noreply, State#state{transportPid = NewTPid}};
                {error, _} ->
                    io:format("[Peer] Failed to reacquire transport PID! Stopping.~n"),
                    {stop, transport_died_permanently, State}
            end;

        "lastModified": 1765425892,
        "narHash": "sha256-jlQpSkg2sK6IJVzTQBDyRxQZgKADC2HKMRfGCSgNMHo=",

        "lastModified": 1766025857,
        "narHash": "sha256-Lav5jJazCW4mdg1iHcROpuXqmM94BWJvabLFWaJVJp0=",

        "rev": "5d6bdbddb4695a62f0d00a3620b37a15275a5093",

        "rev": "def3da69945bbe338c373fddad5a1bb49cf199ce",