using System;
using System.Collections;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Logging;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Object;
using FishNet.Transporting;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace FairShare;

public struct FairShareBroadcast : IBroadcast
{
	public byte ItemID;

	public byte SkinIndex;
}
[BepInPlugin("orbnation.howtofish.fairshare", "FairShare", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "orbnation.howtofish.fairshare";

	public const string PluginName = "FairShare";

	public const string PluginVersion = "1.0.0";

	internal static ManualLogSource Log;

	private bool _clientHandlerRegistered;

	private bool _serverHandlerRegistered;

	private void Awake()
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Harmony val = new Harmony("orbnation.howtofish.fairshare");
		val.PatchAll();
		((MonoBehaviour)this).StartCoroutine(WatchForNetworkManager());
		Log.LogInfo((object)string.Format("{0} v{1} loaded.", "FairShare", "1.0.0"));
	}

	private IEnumerator WatchForNetworkManager()
	{
		while (true)
		{
			NetworkManager nm = InstanceFinder.NetworkManager;
			if ((Object)(object)nm != (Object)null)
			{
				if (!_clientHandlerRegistered)
				{
					nm.ClientManager.OnClientConnectionState += OnClientConnectionState;
					_clientHandlerRegistered = true;
				}
				if (!_serverHandlerRegistered)
				{
					nm.ServerManager.OnServerConnectionState += OnServerConnectionState;
					_serverHandlerRegistered = true;
				}
			}
			yield return (object)new WaitForSeconds(1f);
		}
	}

	private void OnClientConnectionState(ClientConnectionStateArgs args)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		if ((int)args.ConnectionState == 8)
		{
			InstanceFinder.ClientManager.RegisterBroadcast<FairShareBroadcast>((Action<FairShareBroadcast, Channel>)OnSkinShareReceived);
		}
	}

	private void OnServerConnectionState(ServerConnectionStateArgs args)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		if ((int)args.ConnectionState == 8)
		{
			InstanceFinder.ServerManager.RegisterBroadcast<FairShareBroadcast>((Action<NetworkConnection, FairShareBroadcast, Channel>)OnServerReceivedShare, true);
		}
	}

	private void OnServerReceivedShare(NetworkConnection sender, FairShareBroadcast msg, Channel channel)
	{
		Log.LogInfo((object)$"Relaying skin share from {sender.ClientId}: item {msg.ItemID}, skin {msg.SkinIndex}");
		InstanceFinder.ServerManager.Broadcast<FairShareBroadcast>(msg, true, (Channel)0);
	}

	private void OnSkinShareReceived(FairShareBroadcast msg, Channel channel)
	{
		Log.LogInfo((object)$"Unlocking shared skin: item {msg.ItemID}, skin {msg.SkinIndex}");
		SaveManager.UnlockSkin(msg.ItemID, msg.SkinIndex);
	}
}
[HarmonyPatch(typeof(SlotMachine), "OnRollFinished")]
public static class SlotMachine_OnRollFinished_Patch
{
	[HarmonyPostfix]
	public static void Postfix(Player ____playerWhoRolled, byte ____itemIndex, byte ____skinIndex)
	{
		if (!((Object)(object)____playerWhoRolled == (Object)null) && !(((NetworkBehaviour)____playerWhoRolled).Owner == (NetworkConnection)null) && ((NetworkBehaviour)____playerWhoRolled).Owner.IsLocalClient)
		{
			FairShareBroadcast fairShareBroadcast = new FairShareBroadcast
			{
				ItemID = ____itemIndex,
				SkinIndex = ____skinIndex
			};
			Plugin.Log.LogInfo((object)$"Sharing rolled skin with lobby: item {fairShareBroadcast.ItemID}, skin {fairShareBroadcast.SkinIndex}");
			InstanceFinder.ClientManager.Broadcast<FairShareBroadcast>(fairShareBroadcast, (Channel)0);
		}
	}
}