using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Serializing;
using FishNet.Transporting;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NoSharedMoney")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NoSharedMoney")]
[assembly: AssemblyTitle("NoSharedMoney")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NoSharedMoney
{
	public static class ClientMoney
	{
		public static int Money { get; private set; }

		public static void Apply(int money)
		{
			int num = money - Money;
			Money = money;
			Refl.SetStaticMoney(money);
			Refl.RaiseOnItemSold();
			PlayerUI.SetMoney(money, (num < 0) ? (-num) : num, num > 0);
		}

		public static void Reset()
		{
			Money = 0;
			Refl.SetStaticMoney(0);
		}
	}
	public struct MoneySyncBroadcast : IBroadcast
	{
		public int Money;
	}
	public struct ModHandshakeBroadcast : IBroadcast
	{
		public int Version;
	}
	public static class Net
	{
		public const int ProtocolVersion = 1;

		private static bool _serializersRegistered;

		private static bool _serverRegistered;

		private static bool _clientRegistered;

		public static void RegisterSerializers()
		{
			if (!_serializersRegistered)
			{
				_serializersRegistered = true;
				GenericWriter<MoneySyncBroadcast>.SetWrite((Action<Writer, MoneySyncBroadcast>)delegate(Writer w, MoneySyncBroadcast v)
				{
					w.WriteInt32(v.Money);
				});
				GenericReader<MoneySyncBroadcast>.SetRead((Func<Reader, MoneySyncBroadcast>)((Reader r) => new MoneySyncBroadcast
				{
					Money = r.ReadInt32()
				}));
				GenericWriter<ModHandshakeBroadcast>.SetWrite((Action<Writer, ModHandshakeBroadcast>)delegate(Writer w, ModHandshakeBroadcast v)
				{
					w.WriteInt32(v.Version);
				});
				GenericReader<ModHandshakeBroadcast>.SetRead((Func<Reader, ModHandshakeBroadcast>)((Reader r) => new ModHandshakeBroadcast
				{
					Version = r.ReadInt32()
				}));
			}
		}

		public static void TryRegisterHandlers()
		{
			if (!((Object)(object)InstanceFinder.NetworkManager == (Object)null))
			{
				RegisterSerializers();
				if (!_serverRegistered && (Object)(object)InstanceFinder.ServerManager != (Object)null)
				{
					_serverRegistered = true;
					InstanceFinder.ServerManager.RegisterBroadcast<ModHandshakeBroadcast>((Action<NetworkConnection, ModHandshakeBroadcast, Channel>)OnHandshakeFromClient, true);
					Plugin.Log.LogDebug((object)"Registered server broadcast handler.");
				}
				if (!_clientRegistered && (Object)(object)InstanceFinder.ClientManager != (Object)null)
				{
					_clientRegistered = true;
					InstanceFinder.ClientManager.RegisterBroadcast<MoneySyncBroadcast>((Action<MoneySyncBroadcast, Channel>)OnMoneyFromServer);
					Plugin.Log.LogDebug((object)"Registered client broadcast handler.");
				}
			}
		}

		private static void OnHandshakeFromClient(NetworkConnection conn, ModHandshakeBroadcast msg, Channel channel)
		{
			Wallets.MarkModded(conn, msg.Version);
		}

		private static void OnMoneyFromServer(MoneySyncBroadcast msg, Channel channel)
		{
			ClientMoney.Apply(msg.Money);
		}

		public static void SendHandshake()
		{
			if (!InstanceFinder.IsClientStarted || (Object)(object)InstanceFinder.ClientManager == (Object)null)
			{
				return;
			}
			try
			{
				InstanceFinder.ClientManager.Broadcast<ModHandshakeBroadcast>(new ModHandshakeBroadcast
				{
					Version = 1
				}, (Channel)0);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to send handshake: " + ex));
			}
		}

		public static void SendMoney(NetworkConnection conn, int money)
		{
			if (!InstanceFinder.IsServerStarted || (Object)(object)InstanceFinder.ServerManager == (Object)null || conn == (NetworkConnection)null || !conn.IsActive)
			{
				return;
			}
			try
			{
				InstanceFinder.ServerManager.Broadcast<MoneySyncBroadcast>(conn, new MoneySyncBroadcast
				{
					Money = money
				}, true, (Channel)0);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to send money to client " + conn.ClientId + ": " + ex));
			}
		}
	}
	public static class PurchaseContext
	{
		public static Player Buyer;

		private static int _depth;

		public static bool Active
		{
			get
			{
				if (_depth > 0)
				{
					return (Object)(object)Buyer != (Object)null;
				}
				return false;
			}
		}

		public static void Enter(Player buyer)
		{
			_depth++;
			if ((Object)(object)buyer != (Object)null)
			{
				Buyer = buyer;
			}
		}

		public static void Exit()
		{
			_depth--;
			if (_depth <= 0)
			{
				_depth = 0;
				Buyer = null;
			}
		}
	}
	public static class Patches
	{
		private static readonly string[] SpendMethods = new string[8] { "BuyItem", "BuyBait", "BuyAttachment", "BuyBulletUpgrade", "BuySharpnessUpgrade", "BuyBoatMotor", "BuyBoatRadar", "UnlockPocket" };

		public static void ApplyAll(Harmony harmony)
		{
			PatchMoneyManager(harmony);
			PatchSaveManager(harmony);
			PatchSpendSites(harmony);
		}

		private static void PatchMoneyManager(Harmony harmony)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			Type typeFromHandle = typeof(MoneyManager);
			Type typeFromHandle2 = typeof(Patches);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "AddMoney", (Type[])null, (Type[])null), new HarmonyMethod(typeFromHandle2, "AddMoneyPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "RemoveMoney", (Type[])null, (Type[])null), new HarmonyMethod(typeFromHandle2, "RemoveMoneyPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "SellItem", (Type[])null, (Type[])null), new HarmonyMethod(typeFromHandle2, "SellItemPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "CanAfford", (Type[])null, (Type[])null), new HarmonyMethod(typeFromHandle2, "CanAffordPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "OnChangeMoney", (Type[])null, (Type[])null), new HarmonyMethod(typeFromHandle2, "SkipPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "OnStartServer", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeFromHandle2, "OnStartServerPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "OnStartClient", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeFromHandle2, "OnStartClientPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeFromHandle, "OnStopClient", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeFromHandle2, "OnStopClientPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void PatchSaveManager(Harmony harmony)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0049: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(SaveManager), "SaveServer", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "SaveServerPrefix", (Type[])null), new HarmonyMethod(typeof(Patches), "SaveServerPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void PatchSpendSites(Harmony harmony)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			HarmonyMethod val = new HarmonyMethod(typeof(Patches), "SpendPrefix", (Type[])null);
			HarmonyMethod val2 = new HarmonyMethod(typeof(Patches), "SpendFinalizer", (Type[])null);
			MethodInfo[] methods = typeof(Server).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			List<string> list = new List<string>();
			string[] spendMethods = SpendMethods;
			foreach (string text in spendMethods)
			{
				string text2 = "RpcLogic___" + text + "___";
				bool flag = false;
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo in array)
				{
					if (methodInfo.Name.StartsWith(text2, StringComparison.Ordinal))
					{
						harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null);
						list.Add(text);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					Plugin.Log.LogError((object)("Could not find Server." + text2 + "* - purchases through '" + text + "' will be charged to the wrong wallet."));
				}
			}
			Plugin.Log.LogInfo((object)string.Format("Hooked {0}/{1} purchase paths: {2}", list.Count, SpendMethods.Length, string.Join(", ", list.ToArray())));
		}

		private static bool SkipPrefix()
		{
			return false;
		}

		private static bool AddMoneyPrefix(int amount, Player player)
		{
			if (!InstanceFinder.IsServerStarted)
			{
				return false;
			}
			Wallets.Add(player, amount);
			Refl.PlayMoneySounds(increase: true, player);
			return false;
		}

		private static bool RemoveMoneyPrefix(int amount, Player player)
		{
			if (!InstanceFinder.IsServerStarted)
			{
				return false;
			}
			Wallets.Remove(player, amount);
			Refl.PlayMoneySounds(increase: false, player);
			return false;
		}

		private static bool SellItemPrefix(Item item)
		{
			if (!InstanceFinder.IsServerStarted || (Object)(object)item == (Object)null)
			{
				return false;
			}
			Player val = item.LastHolder;
			if ((Object)(object)val == (Object)null)
			{
				if (!Plugin.UnclaimedSalesGoToHost.Value)
				{
					Plugin.Log.LogInfo((object)$"Sold '{item.GetName()}' for {item.TotalWorth} but nobody had held it; income discarded.");
					return false;
				}
				val = Player.LocalPlayer;
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Plugin.Log.LogInfo((object)$"Sold '{item.GetName()}' for {item.TotalWorth} but nobody had held it; credited the host.");
			}
			Wallets.Add(val, item.TotalWorth);
			Refl.PlayMoneySounds(increase: true, val);
			return false;
		}

		private static bool CanAffordPrefix(int cost, ref bool __result)
		{
			if (InstanceFinder.IsServerStarted && PurchaseContext.Active)
			{
				__result = cost <= Wallets.Get(PurchaseContext.Buyer);
				return false;
			}
			return true;
		}

		private static void SpendPrefix(object[] __args)
		{
			PurchaseContext.Enter(ResolveBuyer(__args));
		}

		private static void SpendFinalizer()
		{
			PurchaseContext.Exit();
		}

		private static Player ResolveBuyer(object[] args)
		{
			if (args == null)
			{
				return null;
			}
			object[] array = args;
			foreach (object obj in array)
			{
				Player val = (Player)((obj is Player) ? obj : null);
				if (val != null)
				{
					return val;
				}
			}
			array = args;
			foreach (object obj2 in array)
			{
				Item val2 = (Item)((obj2 is Item) ? obj2 : null);
				if (val2 != null && (Object)(object)val2 != (Object)null)
				{
					Player val3 = val2.Holder;
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = val2.SyncedHolder;
					}
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = val2.LastHolder;
					}
					if ((Object)(object)val3 != (Object)null)
					{
						return val3;
					}
				}
			}
			Plugin.Log.LogWarning((object)"Could not work out who is buying; the purchase will be refused.");
			return null;
		}

		private static void SaveServerPrefix(out int __state)
		{
			__state = Refl.GetStaticMoney();
			if (InstanceFinder.IsServerStarted)
			{
				Refl.SetStaticMoney(Wallets.Total());
			}
		}

		private static void SaveServerPostfix(int __state)
		{
			Refl.SetStaticMoney(__state);
			if (InstanceFinder.IsServerStarted)
			{
				Wallets.Save();
			}
		}

		private static void OnStartServerPostfix()
		{
			Wallets.LoadForServer();
		}

		private static void OnStartClientPostfix()
		{
			ClientMoney.Reset();
			Net.SendHandshake();
		}

		private static void OnStopClientPostfix()
		{
			ClientMoney.Reset();
			if (!InstanceFinder.IsServerStarted)
			{
				Wallets.Save();
				Wallets.OnServerStopped();
			}
		}
	}
	[BepInPlugin("dazed.howtofish.nosharedmoney", "NoSharedMoney", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "dazed.howtofish.nosharedmoney";

		public const string Name = "NoSharedMoney";

		public const string Version = "1.0.0";

		public static ManualLogSource Log;

		public static ConfigEntry<int> StartingMoney;

		public static ConfigEntry<bool> WarnInChat;

		public static ConfigEntry<bool> UnclaimedSalesGoToHost;

		private Harmony _harmony;

		private float _nextReconcile;

		private void Awake()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			StartingMoney = ((BaseUnityPlugin)this).Config.Bind<int>("General", "StartingMoney", 0, "How much money a player who has never played this save starts with.");
			WarnInChat = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "WarnInChat", true, "Host only: announce in chat when a connected player is missing the mod.");
			UnclaimedSalesGoToHost = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UnclaimedSalesGoToHost", true, "If something is sold that no player ever held, credit the host instead of discarding the money.");
			if (!Refl.Resolve())
			{
				Log.LogError((object)"Aborting: the game's money internals do not look the way this mod expects.");
				return;
			}
			Net.RegisterSerializers();
			_harmony = new Harmony("dazed.howtofish.nosharedmoney");
			Patches.ApplyAll(_harmony);
			Server.OnServerStopped += OnServerStopped;
			Log.LogInfo((object)"NoSharedMoney 1.0.0 loaded. Money is now per-player; every player needs this mod installed.");
		}

		private void OnDestroy()
		{
			Server.OnServerStopped -= OnServerStopped;
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private static void OnServerStopped()
		{
			Wallets.Save();
			Wallets.OnServerStopped();
		}

		private void Update()
		{
			Net.TryRegisterHandlers();
			if (!(Time.unscaledTime < _nextReconcile))
			{
				_nextReconcile = Time.unscaledTime + 0.25f;
				if (InstanceFinder.IsServerStarted)
				{
					Wallets.Reconcile();
				}
			}
		}
	}
	public static class Refl
	{
		private static FieldInfo _moneyBackingField;

		private static FieldInfo _onItemSoldField;

		private static MethodInfo _moneySound;

		private static MethodInfo _observerMoneySound;

		public static bool Resolve()
		{
			bool flag = true;
			_moneyBackingField = AccessTools.Field(typeof(MoneyManager), "<Money>k__BackingField");
			flag &= Require(_moneyBackingField, "MoneyManager.<Money>k__BackingField");
			_onItemSoldField = AccessTools.Field(typeof(MoneyManager), "OnItemSold");
			flag &= Require(_onItemSoldField, "MoneyManager.OnItemSold");
			_moneySound = AccessTools.Method(typeof(MoneyManager), "MoneySound", new Type[2]
			{
				typeof(bool),
				typeof(Player)
			}, (Type[])null);
			flag &= Require(_moneySound, "MoneyManager.MoneySound");
			_observerMoneySound = AccessTools.Method(typeof(MoneyManager), "ObserverMoneySound", new Type[2]
			{
				typeof(bool),
				typeof(Player)
			}, (Type[])null);
			return flag & Require(_observerMoneySound, "MoneyManager.ObserverMoneySound");
		}

		private static bool Require(MemberInfo member, string name)
		{
			if (member != null)
			{
				return true;
			}
			Plugin.Log.LogError((object)("Could not find " + name + ". The game has probably updated; NoSharedMoney will not work correctly."));
			return false;
		}

		public static void SetStaticMoney(int value)
		{
			_moneyBackingField?.SetValue(null, value);
		}

		public static int GetStaticMoney()
		{
			if (_moneyBackingField == null)
			{
				return 0;
			}
			return (int)_moneyBackingField.GetValue(null);
		}

		public static void RaiseOnItemSold()
		{
			(_onItemSoldField?.GetValue(null) as Action)?.Invoke();
		}

		public static void PlayMoneySounds(bool increase, Player player)
		{
			MoneyManager instance = MoneyManager.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)player == (Object)null)
			{
				return;
			}
			object[] parameters = new object[2] { increase, player };
			try
			{
				_observerMoneySound?.Invoke(instance, parameters);
				_moneySound?.Invoke(instance, parameters);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Money sound failed: " + ex.Message));
			}
		}
	}
	public static class Wallets
	{
		private const ulong SyntheticKeyBase = 18446462598732840960uL;

		private static readonly Dictionary<ulong, int> _wallets = new Dictionary<ulong, int>();

		private static readonly Dictionary<ulong, int> _lastSent = new Dictionary<ulong, int>();

		private static readonly HashSet<int> _moddedClientIds = new HashSet<int>();

		private static readonly Dictionary<int, float> _firstSeen = new Dictionary<int, float>();

		private static readonly HashSet<int> _warnedClientIds = new HashSet<int>();

		private static string _saveName;

		private static int _unassignedPot;

		private static bool _loaded;

		public static bool IsModded(NetworkConnection conn)
		{
			if (conn != (NetworkConnection)null)
			{
				return _moddedClientIds.Contains(conn.ClientId);
			}
			return false;
		}

		public static void LoadForServer()
		{
			_wallets.Clear();
			_lastSent.Clear();
			_moddedClientIds.Clear();
			_firstSeen.Clear();
			_warnedClientIds.Clear();
			_unassignedPot = 0;
			_loaded = true;
			_saveName = ((SaveManager.CurServerSave != null) ? SaveManager.CurServerSave.Name : null);
			WalletFile walletFile = WalletStore.Load(_saveName);
			if (walletFile != null)
			{
				foreach (WalletEntry wallet in walletFile.Wallets)
				{
					if (ulong.TryParse(wallet.SteamID, out var result) && result != 0L)
					{
						_wallets[result] = Mathf.Max(0, wallet.Money);
					}
				}
				Plugin.Log.LogInfo((object)$"Loaded {_wallets.Count} individual wallet(s) totalling {Total()} for save '{_saveName}'.");
			}
			else
			{
				MigrateSharedPot();
				Save();
			}
		}

		private static void MigrateSharedPot()
		{
			int num = ((SaveManager.CurServerSave != null) ? SaveManager.CurServerSave.Money : 0);
			if (num <= 0)
			{
				Plugin.Log.LogInfo((object)"No shared balance to migrate; everyone starts from the configured amount.");
				return;
			}
			List<ulong> list = new List<ulong>();
			if (SaveManager.CurServerSave != null && SaveManager.CurServerSave.Players != null)
			{
				foreach (SavedPlayer player in SaveManager.CurServerSave.Players)
				{
					if (player != null && player.SteamID != 0L && !list.Contains(player.SteamID))
					{
						list.Add(player.SteamID);
					}
				}
			}
			if (list.Count == 0)
			{
				_unassignedPot = num;
				Plugin.Log.LogInfo((object)$"Migrating shared balance of {num}: no player records in the save, so it goes to the first player who joins.");
				return;
			}
			int num2 = num / list.Count;
			int num3 = num - num2 * list.Count;
			for (int i = 0; i < list.Count; i++)
			{
				_wallets[list[i]] = num2 + ((i == 0) ? num3 : 0);
			}
			Plugin.Log.LogInfo((object)$"Migrated shared balance of {num} evenly across {list.Count} saved player(s) ({num2} each, remainder {num3} to the first).");
		}

		public static void OnServerStopped()
		{
			_loaded = false;
			_wallets.Clear();
			_lastSent.Clear();
			_moddedClientIds.Clear();
			_firstSeen.Clear();
			_warnedClientIds.Clear();
			_saveName = null;
			_unassignedPot = 0;
		}

		private static ulong KeyFor(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0uL;
			}
			ulong steamID = player.SteamID;
			if (steamID != 0L)
			{
				return steamID;
			}
			NetworkConnection owner = ((NetworkBehaviour)player).Owner;
			if (owner != (NetworkConnection)null && owner.ClientId >= 0)
			{
				return (ulong)(-281474976710656L | (uint)owner.ClientId);
			}
			return 0uL;
		}

		private static bool IsSynthetic(ulong key)
		{
			return (key & 0xFFFF000000000000uL) == 18446462598732840960uL;
		}

		public static int Get(Player player)
		{
			ulong num = KeyFor(player);
			if (num == 0L)
			{
				return 0;
			}
			return EnsureWallet(num);
		}

		private static int EnsureWallet(ulong key)
		{
			if (_wallets.TryGetValue(key, out var value))
			{
				return value;
			}
			int num = Plugin.StartingMoney.Value;
			if (_unassignedPot > 0)
			{
				num += _unassignedPot;
				Plugin.Log.LogInfo((object)$"Handed the migrated shared balance of {_unassignedPot} to the first joining player.");
				_unassignedPot = 0;
			}
			num = Mathf.Max(0, num);
			_wallets[key] = num;
			return num;
		}

		public static void Add(Player player, int amount)
		{
			Set(player, Get(player) + Mathf.Abs(amount));
		}

		public static void Remove(Player player, int amount)
		{
			Set(player, Get(player) - Mathf.Abs(amount));
		}

		public static void Set(Player player, int value)
		{
			ulong num = KeyFor(player);
			if (num == 0L)
			{
				Plugin.Log.LogWarning((object)"Tried to change the wallet of a player with no identity; ignoring.");
				return;
			}
			EnsureWallet(num);
			_wallets[num] = Mathf.Clamp(value, 0, int.MaxValue);
			Push(player);
		}

		public static int Total()
		{
			int num = 0;
			foreach (int value in _wallets.Values)
			{
				num += value;
			}
			return num;
		}

		public static void Push(Player player)
		{
			ulong num = KeyFor(player);
			if (num == 0L || !_wallets.TryGetValue(num, out var value) || (_lastSent.TryGetValue(num, out var value2) && value2 == value))
			{
				return;
			}
			_lastSent[num] = value;
			if ((Object)(object)Player.LocalPlayer == (Object)(object)player)
			{
				ClientMoney.Apply(value);
				return;
			}
			NetworkConnection owner = ((NetworkBehaviour)player).Owner;
			if (!(owner == (NetworkConnection)null) && IsModded(owner))
			{
				Net.SendMoney(owner, value);
			}
		}

		public static void MarkModded(NetworkConnection conn, int version)
		{
			if (conn == (NetworkConnection)null)
			{
				return;
			}
			if (version != 1)
			{
				Plugin.Log.LogWarning((object)$"Client {conn.ClientId} runs NoSharedMoney protocol {version}, this server is {1}. Wallet sync may misbehave; use matching mod versions.");
			}
			if (_moddedClientIds.Add(conn.ClientId))
			{
				Plugin.Log.LogInfo((object)$"Client {conn.ClientId} has NoSharedMoney installed.");
			}
			foreach (Player player in PlayerManager.Players)
			{
				if ((Object)(object)player != (Object)null && ((NetworkBehaviour)player).Owner == conn)
				{
					_lastSent.Remove(KeyFor(player));
					Push(player);
					break;
				}
			}
		}

		public static void Reconcile()
		{
			if (!_loaded || !InstanceFinder.IsServerStarted)
			{
				return;
			}
			List<Player> players = PlayerManager.Players;
			if (players == null)
			{
				return;
			}
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if ((Object)(object)val == (Object)null || ((NetworkBehaviour)val).IsDeinitializing)
				{
					continue;
				}
				ulong num = KeyFor(val);
				if (num == 0L)
				{
					continue;
				}
				EnsureWallet(num);
				Push(val);
				NetworkConnection owner = ((NetworkBehaviour)val).Owner;
				if (owner == (NetworkConnection)null || (Object)(object)val == (Object)(object)Player.LocalPlayer)
				{
					continue;
				}
				if (!_firstSeen.ContainsKey(owner.ClientId))
				{
					_firstSeen[owner.ClientId] = Time.time;
				}
				if (!IsModded(owner) && Time.time - _firstSeen[owner.ClientId] > 10f && _warnedClientIds.Add(owner.ClientId))
				{
					string text = "'" + val.SteamName + "' does not have NoSharedMoney installed. Their money display will be wrong and they will not be able to buy anything.";
					Plugin.Log.LogWarning((object)text);
					if (Plugin.WarnInChat.Value)
					{
						ChatManager.ChatMessage("<i>[NoSharedMoney] " + text + "</i>");
					}
				}
			}
		}

		public static void Save()
		{
			if (!_loaded || string.IsNullOrEmpty(_saveName))
			{
				return;
			}
			WalletFile walletFile = new WalletFile();
			foreach (KeyValuePair<ulong, int> wallet in _wallets)
			{
				if (!IsSynthetic(wallet.Key))
				{
					walletFile.Wallets.Add(new WalletEntry
					{
						SteamID = wallet.Key.ToString(),
						Money = wallet.Value
					});
				}
			}
			WalletStore.Save(_saveName, walletFile);
			Plugin.Log.LogInfo((object)$"Saved {walletFile.Wallets.Count} wallet(s) totalling {Total()} for save '{_saveName}'.");
		}
	}
	[Serializable]
	public class WalletEntry
	{
		public string SteamID;

		public int Money;
	}
	[Serializable]
	public class WalletFile
	{
		public List<WalletEntry> Wallets = new List<WalletEntry>();
	}
	public static class WalletStore
	{
		private static string Folder => Path.Combine(Application.persistentDataPath, "NoSharedMoney");

		private static string PathFor(string saveName)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				saveName = saveName.Replace(oldChar, '_');
			}
			return Path.Combine(Folder, saveName + ".json");
		}

		public static WalletFile Load(string saveName)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				return null;
			}
			try
			{
				string path = PathFor(saveName);
				if (!File.Exists(path))
				{
					return null;
				}
				WalletFile walletFile = JsonConvert.DeserializeObject<WalletFile>(File.ReadAllText(path));
				if (walletFile == null)
				{
					return null;
				}
				if (walletFile.Wallets == null)
				{
					walletFile.Wallets = new List<WalletEntry>();
				}
				return walletFile;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to read wallets: " + ex));
				return null;
			}
		}

		public static void Save(string saveName, WalletFile file)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(Folder);
				string text = JsonConvert.SerializeObject((object)file, (Formatting)1);
				if (string.IsNullOrEmpty(text) || text == "{}")
				{
					Plugin.Log.LogError((object)"Wallet serialization produced nothing; refusing to overwrite the file.");
				}
				else
				{
					File.WriteAllText(PathFor(saveName), text);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to write wallets: " + ex));
			}
		}
	}
}