using System;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DoubleTrouble.Behaviors;
using DoubleTrouble.NetcodePatcher;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
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("Sehelitar")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Sehelitar @ https://sehelitar.tv")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3cad7d97011d8a4730c16d0223aafecbc6b36250")]
[assembly: AssemblyProduct("DoubleTrouble")]
[assembly: AssemblyTitle("DoubleTrouble")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 DoubleTrouble
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Locale
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("DoubleTrouble.Locale", typeof(Locale).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static string LandingInfoDiff => ResourceManager.GetString("LandingInfoDiff", resourceCulture);

		internal static string LandingInfoOverall => ResourceManager.GetString("LandingInfoOverall", resourceCulture);

		internal static string ResultLose => ResourceManager.GetString("ResultLose", resourceCulture);

		internal static string ResultWin => ResourceManager.GetString("ResultWin", resourceCulture);

		internal static string SpectateResultLose => ResourceManager.GetString("SpectateResultLose", resourceCulture);

		internal static string SpectateResultWin => ResourceManager.GetString("SpectateResultWin", resourceCulture);

		internal static string Title => ResourceManager.GetString("Title", resourceCulture);

		internal Locale()
		{
		}
	}
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Locale_fr
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("DoubleTrouble.Locale.fr", typeof(Locale_fr).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static string LandingInfoDiff => ResourceManager.GetString("LandingInfoDiff", resourceCulture);

		internal static string LandingInfoOverall => ResourceManager.GetString("LandingInfoOverall", resourceCulture);

		internal static string ResultLose => ResourceManager.GetString("ResultLose", resourceCulture);

		internal static string ResultWin => ResourceManager.GetString("ResultWin", resourceCulture);

		internal static string SpectateResultLose => ResourceManager.GetString("SpectateResultLose", resourceCulture);

		internal static string SpectateResultWin => ResourceManager.GetString("SpectateResultWin", resourceCulture);

		internal static string Title => ResourceManager.GetString("Title", resourceCulture);

		internal Locale_fr()
		{
		}
	}
	[BepInPlugin("DoubleTrouble", "DoubleTrouble", "1.0.0")]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		private static Harmony _globalHarmony;

		internal static ManualLogSource Log { get; private set; }

		internal static PluginConfigStruct GameConfig { get; private set; }

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin DoubleTrouble is loaded!");
			PatchNetwork();
			_globalHarmony = new Harmony("DoubleTrouble");
			_globalHarmony.PatchAll();
			PluginConfigStruct gameConfig = default(PluginConfigStruct);
			gameConfig.DoubleTroubleEnable = ((BaseUnityPlugin)this).Config.Bind<bool>("DoubleTrouble", "Enable", true, "Active l'évènement du \"quitte ou double\".");
			gameConfig.DoubleTroubleProbability = ((BaseUnityPlugin)this).Config.Bind<double>("DoubleTrouble", "Probability", 20.0, "Pourcentage de change qu'un évènement \"quitte ou double\" se lance (entre 0 et 100).");
			gameConfig.DoubleTroubleOverall = ((BaseUnityPlugin)this).Config.Bind<bool>("DoubleTrouble", "Overall", true, "Si activé, le quitte ou double se basera sur le nombre total de crédits au lieu de ce qui vient d'être vendu.");
			GameConfig = gameConfig;
		}

		private static void PatchNetwork()
		{
			try
			{
				Type[] types = Assembly.GetExecutingAssembly().GetTypes();
				foreach (Type type in types)
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in methods)
					{
						if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
						{
							Log.LogInfo((object)("Initialize network patch for " + type.FullName));
							methodInfo.Invoke(null, null);
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}
	internal struct PluginConfigStruct
	{
		public ConfigEntry<bool> DoubleTroubleEnable;

		public ConfigEntry<double> DoubleTroubleProbability;

		public ConfigEntry<bool> DoubleTroubleOverall;
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "DoubleTrouble";

		public const string PLUGIN_NAME = "DoubleTrouble";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace DoubleTrouble.Patches
{
	[HarmonyPatch(typeof(DepositItemsDesk))]
	public class DepositItemsDeskPatch
	{
		[HarmonyPatch("SellAndDisplayItemProfits")]
		[HarmonyPostfix]
		private static void SellAndDisplayItemProfits(int profit)
		{
			DoubleTroubleService instance = DoubleTroubleService.Instance;
			if (instance != null && instance.IsActive)
			{
				DoubleTroubleService.Instance.SoldAmount += profit;
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("StartGame")]
		[HarmonyPostfix]
		private static void StartOfRoundStartGame()
		{
			DoubleTroubleService.Instance?.BeginEvent();
		}

		[HarmonyPatch("ShipLeave")]
		[HarmonyPostfix]
		private static void StartOfRoundShipLeave()
		{
			DoubleTroubleService.Instance?.EndEvent();
		}

		[HarmonyPatch("ShipLeaveAutomatically")]
		[HarmonyPostfix]
		private static void StartOfRoundShipLeaveAutomatically()
		{
			DoubleTroubleService.Instance?.EndEvent();
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal class TerminalPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void TerminalAwake(ref Terminal __instance)
		{
			((Component)__instance).gameObject.AddComponent<DoubleTroubleService>();
		}
	}
}
namespace DoubleTrouble.Behaviors
{
	[RequireComponent(typeof(Terminal))]
	internal class DoubleTroubleService : NetworkBehaviour
	{
		public bool IsActive { get; private set; }

		public bool IsOverall { get; private set; } = true;


		public bool ProbabilityOverride { get; set; }

		public int SoldAmount { get; internal set; }

		public static DoubleTroubleService Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		internal void BeginEvent()
		{
			if (((NetworkBehaviour)this).IsServer && Plugin.GameConfig.DoubleTroubleEnable.Value && !RoundManager.Instance.currentLevel.planetHasTime && (ProbabilityOverride || ShouldLaunchEvent()))
			{
				IsActive = true;
				IsOverall = Plugin.GameConfig.DoubleTroubleOverall.Value;
				ProbabilityOverride = false;
				SoldAmount = 0;
				AnnounceEventClientRpc(IsOverall);
			}
		}

		private static bool ShouldLaunchEvent()
		{
			double value = Plugin.GameConfig.DoubleTroubleProbability.Value;
			return (double)Random.RandomRangeInt(0, 100) <= value;
		}

		internal void EndEvent()
		{
			if (!((NetworkBehaviour)this).IsServer || !IsActive)
			{
				return;
			}
			IsActive = false;
			bool flag = (double)Random.Range(0f, 1f) >= 0.5;
			Terminal component = ((Component)this).GetComponent<Terminal>();
			bool value = Plugin.GameConfig.DoubleTroubleOverall.Value;
			int groupCredits = component.groupCredits;
			if (value)
			{
				if (flag)
				{
					component.groupCredits *= 2;
				}
				else
				{
					component.groupCredits /= 2;
				}
			}
			else if (flag)
			{
				component.groupCredits += SoldAmount;
			}
			else
			{
				component.groupCredits -= Convert.ToInt32((float)SoldAmount / 2f);
			}
			AnnounceResultClientRpc(groupCredits, component.groupCredits);
		}

		[ClientRpc]
		private void AnnounceEventClientRpc(bool isOverall)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1055199686u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isOverall, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1055199686u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip(Locale.Title, isOverall ? Locale.LandingInfoOverall : Locale.LandingInfoDiff, false, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		private void AnnounceResultClientRpc(int amountBefore, int amountAfter)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2420471262u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, amountBefore);
				BytePacker.WriteValueBitPacked(val2, amountAfter);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2420471262u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				((Component)this).GetComponent<Terminal>().groupCredits = amountAfter;
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip(Locale.Title, (amountBefore > amountAfter) ? string.Format(Locale.ResultLose, amountAfter - amountBefore) : string.Format(Locale.ResultWin, amountAfter - amountBefore), false, false, "LC_Tip1");
				}
				HUDManager instance2 = HUDManager.Instance;
				if (instance2 != null)
				{
					instance2.DisplaySpectatorTip((amountBefore > amountAfter) ? string.Format(Locale.SpectateResultLose, amountAfter - amountBefore) : string.Format(Locale.SpectateResultWin, amountAfter - amountBefore));
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_DoubleTroubleService()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(1055199686u, new RpcReceiveHandler(__rpc_handler_1055199686));
			NetworkManager.__rpc_func_table.Add(2420471262u, new RpcReceiveHandler(__rpc_handler_2420471262));
		}

		private static void __rpc_handler_1055199686(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isOverall = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isOverall, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((DoubleTroubleService)(object)target).AnnounceEventClientRpc(isOverall);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2420471262(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int amountBefore = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amountBefore);
				int amountAfter = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amountAfter);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((DoubleTroubleService)(object)target).AnnounceResultClientRpc(amountBefore, amountAfter);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "DoubleTroubleService";
		}
	}
}
namespace DoubleTrouble.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}