using System;
using System.Linq;
using BepInEx;
using BepInEx.Logging;
using UnityEngine;
using NetworkingLibrary.Services;
using NetworkingLibrary.Modules;
using NetworkingLibrary;
using Steamworks;

namespace PEAKTest
{
    [BepInDependency("off_grid.NetworkingLibrary")]
    [BepInPlugin(MyPluginInfo.PLUGIN_GUID, MyPluginInfo.PLUGIN_NAME, MyPluginInfo.PLUGIN_VERSION)]
    public class Plugin : BaseUnityPlugin
    {
        readonly static uint MOD_ID = ModId.FromGuid(MyPluginInfo.PLUGIN_GUID); // Use this when you do not want to compute bytes.
        const string LOBBY_KEY_PACK_COUNT = "peak_test.pack_count";
        const string PLAYER_KEY_STATUS = "peak_test.player_status";

        static ManualLogSource Log => Instance.Logger;
        public static Plugin Instance { get; private set; } = null!;

        IDisposable? registrationToken;
        internal static INetworkingService Service = Net.Service!;

        void Awake()
        {
            Instance = this;
            Log.LogInfo($"{MyPluginInfo.PLUGIN_NAME} Awake");

            // Register keys
            Service.RegisterLobbyDataKey(LOBBY_KEY_PACK_COUNT);
            Service.RegisterPlayerDataKey(PLAYER_KEY_STATUS);

            // Register RPC handlers by reflecting this instance's [CustomRPC] methods.
            registrationToken = Service.RegisterNetworkObject(this, MOD_ID);

            // Subscribe to a few events, none of these are required.
            Service.LobbyEntered += OnLobbyEntered;
            Service.LobbyCreated += () => Log.LogInfo("LobbyCreated event");
            Service.PlayerEntered += id => Log.LogInfo($"PlayerEntered: {id}");
            Service.PlayerLeft += id => Log.LogInfo($"PlayerLeft: {id}");
            Service.LobbyDataChanged += keys => Log.LogInfo("LobbyDataChanged: " + string.Join(",", keys));
            Service.PlayerDataChanged += (steam, keys) => Log.LogInfo($"PlayerDataChanged: {steam} -> {string.Join(',', keys)}");

            // If already in a lobby at load time, run quick checks
            if (Service.InLobby) OnLobbyEntered();
        }

        void OnDestroy()
        {
            Service.LobbyEntered -= OnLobbyEntered;
            Service.LobbyCreated -= () => { }; //

            registrationToken?.Dispose();
            Log.LogInfo($"{MyPluginInfo.PLUGIN_NAME} destroyed");
        }

        // Called when we enter a lobby (host or client).
        void OnLobbyEntered()
        {
            Log.LogInfo($"OnLobbyEntered: InLobby={Service.InLobby}, HostSteamId64={Service.HostSteamId64}");

            // Host will announce a small package list via RPC to all clients.
            // Non-host clients will request the package list from host (RPCToHost).
            if (Service.IsHost)
            {
                Log.LogInfo("We are host. Announcing packages to clients.");

                // pretend-loaded packages, fill with your actual data.
                string[] loaded = new[] { "pivo1", "pivo2" };

                // set a lobby value
                Service.SetLobbyData(LOBBY_KEY_PACK_COUNT, loaded.Length);

                // set player data (host status)
                Service.SetPlayerData(PLAYER_KEY_STATUS, "host_ready");

                // send package list as a single joined string
                string payload = string.Join("|", loaded);
                Service.RPC(MOD_ID, nameof(HandlePackagesRpc), ReliableType.Reliable, payload);

                Log.LogInfo($"Host RPC broadcast sent with {loaded.Length} packages.");
            }
            else
            {
                Log.LogInfo("We are client. Requesting package list from host.");
                // ask host to send packages to everyone (host will handle RequestPackagesRpc)
                Service.RPCToHost(MOD_ID, nameof(RequestPackagesRpc), ReliableType.Reliable);
            }
        }

        // Host broadcasts packages with this RPC. Clients receive here.
        // Signature shows a single string parameter.
        [CustomRPC]
        void HandlePackagesRpc(string joined)
        {
            try
            {
                var list = string.IsNullOrEmpty(joined) ? Array.Empty<string>() : joined.Split('|');
                Log.LogInfo($"HandlePackagesRpc: received {list.Length} packages: {string.Join(", ", list)}");

                // Set player key to indicate we received packages, not required.
                var svc = Net.Service;
                svc?.SetPlayerData(PLAYER_KEY_STATUS, "packages_received");
            }
            catch (Exception ex)
            {
                Log.LogError($"HandlePackagesRpc exception: {ex}");
            }
        }

        // Clients call this (RPCToHost) to request the host's package list.
        // Host will respond by performing an RPC broadcast (see OnLobbyEntered path).
        [CustomRPC]
        void RequestPackagesRpc()
        {
            try
            {
                // Only the host should act on this. We do a host check.
                if (!Service.IsHost)
                {
                    Log.LogInfo("RequestPackagesRpc called on non-host.");
                    return;
                }

                Log.LogInfo("Host handling RequestPackagesRpc; responding with package list.");
                // Example data
                var loaded = new[] { "pivo1", "pivo2" };
                string payload = string.Join("|", loaded);
                Service.RPC(MOD_ID, nameof(HandlePackagesRpc), ReliableType.Reliable, payload);
            }
            catch (Exception ex)
            {
                Log.LogError($"RequestPackagesRpc exception: {ex}");
            }
        }
    }
}

Host sets one string key. Clients read it on change.

Host: broadcast package list

// host only
void BroadcastLoadedPackages(INetworkingService svc, IEnumerable<string> packages)
{
    const string KEY = "PEAK_PACKAGES_V1";
    svc.RegisterLobbyDataKey(KEY); // safe to call on all peers

    // serialize: escape '|' then join and compress+base64 option
    string joined = string.Join("|", packages.Select(p => p.Replace("|","||")));
    string payload = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(joined));
    svc.SetLobbyData(KEY, payload); // host-only action
}

Client: receive update

void SubscribeToPackageUpdates(INetworkingService svc)
{
    const string KEY = "PEAK_PACKAGES_V1";
    svc.RegisterLobbyDataKey(KEY); // register the key used by host
    svc.LobbyDataChanged += keys =>
    {
        if (!keys.Contains(KEY)) return;
        var payload = svc.GetLobbyData<string>(KEY);
        if (string.IsNullOrEmpty(payload)) return;
        var joined = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(payload));
        var packages = joined.Length == 0 ? Array.Empty<string>() :
                       joined.Split('|').Select(s => s.Replace("||","|")).ToArray();
        // now packages[] contains the host list
    };
}

Notes:

• Lobby metadata is small and best for modest lists (tens of items).
• If payload grows large, compress it (gzip) before base64.

Use RPC when you need immediate notification or structured params.

Register and broadcast

const uint MOD = 0xDEADBEEF;

// on plugin init
IDisposable token = svc.RegisterNetworkObject(this, MOD);

// broadcast
svc.RPC(MOD, "NotifyPackages", ReliableType.Reliable,  "GAME_PACKAGES_READY");

In same class: RPC handler

[CustomRPC]
void NotifyPackages(string tag)
{
    // runs on all peers (including host by loopback)
    Logger.LogInfo($"NotifyPackages received: {tag}");
}

Notes:

• [LEGACY] Must call PollReceive() each frame for Steam adapter.
• RegisterNetworkObject discovers methods tagged [CustomRPC].

svc.RPCTarget(MOD, "PrivateMessage", targetSteamId64, ReliableType.Reliable, "hello");

Handler:

[CustomRPC]
void PrivateMessage(string text) { Debug.Log(text); }

svc.IncomingValidator = (msg, fromSteam64) =>
{
    // drop messages with a specific method name
    if (msg.MethodName == "DropMe") return false;
    return true;
};

// Use this for unit tests or local dev when Steam not available.
INetworkingService svc = new OfflineNetworkingService();
svc.Initialize();
// Offline shim delivers messages immediately. PollReceive() is a no-op.

> Use uint MOD = ModId.FromGuid("<your-mod-guid>"); it produces a stable 32-bit id from your mod GUID so you do not hand-pick hex values.

var svc = Net.Service;
ulong local = svc.GetLocalSteam64();
ulong[] members = svc.GetLobbyMemberSteamIds(); // empty when not in a lobby

If you use Photon and need actor -> steam mappings, then you can use svc.GetLobbyMemberSteamIds().