using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using GTFO.API.Utilities;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("0.0.3")]
[assembly: AssemblyInformationalVersion("0.0.3")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("0.0.3.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;
		}
	}
}
internal class ManifestInfo
{
	internal const string TSName = "TrainingWheels";

	internal const string TSDescription = "A silly mod to put on some training wheels on prisoners.";

	internal const string TSVersion = "0.0.3";

	internal const string TSAuthor = "Angry-Maid";

	internal const string TSWebsite = "https://github.com/Angry-Maid/GTFO-TrainingWheels";
}
namespace TrainingWheels
{
	internal static class ModConf
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static LiveEditEventHandler <0>__OnFileChanged;
		}

		private static readonly ConfigEntry<int> _modMainStartingAmmo;

		private static readonly ConfigEntry<int> _modSpecialStartingAmmo;

		private static readonly ConfigEntry<int> _modToolStartingAmmo;

		private static readonly ConfigEntry<bool> _regenDisabled;

		private static readonly ConfigEntry<int> _startingHealth;

		private static readonly ConfigEntry<int> _startingInfection;

		private static readonly ConfigFile configFile;

		public static int ModMainStartingAmmo => _modMainStartingAmmo.Value;

		public static int ModSpecialStartingAmmo => _modSpecialStartingAmmo.Value;

		public static int ModToolStartingAmmo => _modToolStartingAmmo.Value;

		public static bool RegenDisabled => _regenDisabled.Value;

		public static int StartingHealth => _startingHealth.Value;

		public static int StartingInfection => _startingInfection.Value;

		static ModConf()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "TrainingWheels.cfg"), true);
			string text = "Ammo Percentages";
			_modMainStartingAmmo = configFile.Bind<int>(text, "Main Ammo Percentage", 15, "Percentage from the starting ammo of Main (0-65535)");
			_modSpecialStartingAmmo = configFile.Bind<int>(text, "Special Ammo Percentage", 15, "Percentage from the starting ammo of Special (0-65535)");
			_modToolStartingAmmo = configFile.Bind<int>(text, "Tool Ammo Percentage", 21, "Percentage from the starting ammo of Tool (0-65535)");
			string text2 = "Health";
			_regenDisabled = configFile.Bind<bool>(text2, "Regen Disabled", true, "Enables/Disables passive regeneration");
			_startingHealth = configFile.Bind<int>(text2, "Starting Health", 1, "Set starting health upon drop");
			_startingInfection = configFile.Bind<int>(text2, "Starting Infection", 100, "Set starting infection upon drop");
		}

		internal static void Init()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			LiveEditListener obj = LiveEdit.CreateListener(Paths.ConfigPath, "TrainingWheels.cfg", false);
			object obj2 = <>O.<0>__OnFileChanged;
			if (obj2 == null)
			{
				LiveEditEventHandler val = OnFileChanged;
				<>O.<0>__OnFileChanged = val;
				obj2 = (object)val;
			}
			obj.FileChanged += (LiveEditEventHandler)obj2;
		}

		private static void OnFileChanged(LiveEditEventArgs _)
		{
			configFile.Reload();
		}
	}
	[BepInPlugin("dev.Angry-Maid.gtfo.TrainingWheels", "TrainingWheels", "0.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string GUID = "dev.Angry-Maid.gtfo.TrainingWheels";

		public const string MOD_NAME = "TrainingWheels";

		public const string VERSION = "0.0.3";

		internal static ManualLogSource L;

		private static readonly Harmony _harmony = new Harmony("dev.Angry-Maid.gtfo.TrainingWheels");

		public override void Load()
		{
			L = ((BasePlugin)this).Log;
			ModConf.Init();
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			L.LogInfo((object)"Plugin loaded!");
		}
	}
}
namespace TrainingWheels.Patches
{
	[HarmonyPatch]
	internal static class AmmoStoragePatches
	{
		[HarmonyPatch(typeof(PlayerAmmoStorage), "AddLevelDefaultAmmoModifications")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_SetStorage(PlayerAmmoStorage __instance, PlayerAgent owner)
		{
			if (RundownManager.ActiveExpedition != null)
			{
				List<float> list = new List<float>
				{
					Math.Clamp((float)ModConf.ModMainStartingAmmo / 100f, 0f, 65535f),
					Math.Clamp((float)ModConf.ModSpecialStartingAmmo / 100f, 0f, 65535f),
					Math.Clamp((float)ModConf.ModToolStartingAmmo / 100f, 0f, 65535f)
				};
				Il2CppStructArray<uint> ammoModificationIDs = __instance.m_ammoModificationIDs;
				_ = RundownManager.ActiveExpedition.SpecialOverrideData;
				ModifierInstance val = default(ModifierInstance);
				if (!AgentModifierManager.TryGetModifierInstance((Agent)(object)owner, ref val))
				{
					AgentModifierManager.AddModifierValue((Agent)(object)owner, (AgentModifier)152, 0f, 0f);
					AgentModifierManager.TryGetModifierInstance((Agent)(object)owner, ref val);
				}
				float num = val.GetModifierValue((AgentModifier)152) + 1f;
				AgentModifierManager.ClearModifierChange(((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[0]);
				((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[0] = AgentModifierManager.AddModifierValue((Agent)(object)owner, (AgentModifier)152, num * list[0] - 1f, 0f);
				num = val.GetModifierValue((AgentModifier)153) + 1f;
				AgentModifierManager.ClearModifierChange(((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[1]);
				((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[1] = AgentModifierManager.AddModifierValue((Agent)(object)owner, (AgentModifier)153, num * list[1] - 1f, 0f);
				num = val.GetModifierValue((AgentModifier)154) + 1f;
				AgentModifierManager.ClearModifierChange(((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[2]);
				((Il2CppArrayBase<uint>)(object)ammoModificationIDs)[2] = AgentModifierManager.AddModifierValue((Agent)(object)owner, (AgentModifier)154, num * list[2] - 1f, 0f);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAgent))]
	internal class PlayerAgentRegenPatch
	{
		[HarmonyPatch("Setup")]
		[HarmonyPostfix]
		private static void Postfix_Setup(PlayerAgent __instance)
		{
			if (ModConf.RegenDisabled)
			{
				__instance.Damage.m_nextRegen = float.PositiveInfinity;
			}
		}
	}
	[HarmonyPatch(typeof(Dam_PlayerDamageBase))]
	internal static class PlayerRegenPatches
	{
		[HarmonyPatch("OnIncomingDamage")]
		[HarmonyPostfix]
		private static void Postfix_OnDamage(Dam_PlayerDamageBase __instance)
		{
			if (ModConf.RegenDisabled)
			{
				__instance.m_nextRegen = float.PositiveInfinity;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerSessionStatusManager))]
	internal class PlayerSessionStatus
	{
		[HarmonyPatch("GetDefaultSessionStatus")]
		[HarmonyPostfix]
		private static void Postfix_GetDefaultSessionStatus(ref pPlayerSessionStatus __result)
		{
			__result.resourceData.health = Math.Clamp((float)ModConf.StartingHealth / 100f, 0f, 1f);
			__result.resourceData.infection = Math.Clamp((float)ModConf.StartingInfection / 100f, 0f, 1f);
		}
	}
	[HarmonyPatch(typeof(RundownManager))]
	internal class SetActiveExpeditionPatches
	{
		[HarmonyPatch("SetActiveExpedition")]
		[HarmonyPostfix]
		private static void Postfix_SetActiveExpedition(pActiveExpedition expPackage, ExpeditionInTierData expTierData, bool forceUpdate)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			float num = Math.Clamp((float)ModConf.StartingHealth / 100f, 0f, 1f);
			float amount = Math.Clamp((float)ModConf.StartingInfection / 100f, 0f, 1f);
			pInfection val = new pInfection
			{
				amount = amount,
				mode = (pInfectionMode)0,
				effect = (pInfectionEffect)0
			};
			if (SNet.IsMaster)
			{
				Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
				while (enumerator.MoveNext())
				{
					PlayerAgent current = enumerator.Current;
					((Dam_SyncedDamageBase)current.Damage).SendSetHealth(num);
					current.Damage.m_receiveModifyInfectionPacket.Send(val, (SNet_ChannelType)2);
					current.Damage.ReceiveModifyInfection(val);
				}
			}
		}
	}
}