using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UltraAchievementsRevamped.Core.Achievements;
using UnityEngine;
using UnityEngine.AddressableAssets;

[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("UltraAchievementsRevamped.Mod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Content mod for Ultrakill which contains UltraAchievements")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+9feab18fa052fdeb2a12a79832b0577f650570d9")]
[assembly: AssemblyProduct("UltraAchievementsRevamped.Mod")]
[assembly: AssemblyTitle("UltraAchievementsRevamped.Mod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 UltraAchievementsRevamped.Mod
{
	internal static class Assets
	{
		public static string AssetPath => Path.Combine(ModFolder, "Assets");

		private static string ModFolder => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		private static string CatalogPath => Path.Combine(AssetPath, "catalog_mod.json");

		internal static void LoadAssets()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			Addressables.LoadContentCatalogAsync(CatalogPath, true, (string)null).WaitForCompletion();
			List<AchievementInfo> achievementInfos = new List<AchievementInfo>();
			Addressables.LoadAssetsAsync<AchievementInfo>((object)"UltraAchievementsMod", (Action<AchievementInfo>)delegate(AchievementInfo asset)
			{
				Debug.Log((object)("Loaded Achievement: " + asset.Id));
				achievementInfos.Add(asset);
			}).WaitForCompletion();
			AchievementManager.RegisterAchievementInfos((IEnumerable<AchievementInfo>)achievementInfos);
		}
	}
	[BepInPlugin("protract.ultrakill.ultra_achievements_revamped", "UltraAchievementsRevamped.Mod", "2.0.1")]
	[BepInDependency("protract.ultrakill.ultra_achievements_core", "2.0.0")]
	internal class Plugin : BaseUnityPlugin
	{
		private static class PluginInfo
		{
			public const string Name = "UltraAchievementsRevamped.Mod";

			public const string Guid = "protract.ultrakill.ultra_achievements_revamped";

			public const string Version = "2.0.1";
		}

		internal static ManualLogSource Logger;

		private void Awake()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"UltraAchievementsRevamped.Mod 2.0.1 has loaded!");
			new Harmony("protract.ultrakill.ultra_achievements_core").PatchAll();
			Assets.LoadAssets();
		}
	}
}
namespace UltraAchievementsRevamped.Mod.Achievements
{
	[HarmonyPatch]
	internal class BoardLegally
	{
		[HarmonyPatch(typeof(FerrymanFake), "BlowCoin")]
		[HarmonyPostfix]
		private static void FerrymanCoinCheck()
		{
			AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.boardLegally");
		}
	}
	[HarmonyPatch]
	internal class CultOfJakito
	{
		[HarmonyPatch(typeof(HudMessage), "PlayMessage")]
		[HarmonyPostfix]
		private static void WorldDestructionCheckPatch(HudMessage __instance)
		{
			if (__instance.message.Contains("THANK YOU. NOW I SHALL LAY WASTE TO THIS WORLD."))
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.cultOfJakito");
			}
		}
	}
	[HarmonyPatch]
	internal class DeathSimulator
	{
		[HarmonyPatch(typeof(NewMovement), "Respawn")]
		[HarmonyPrefix]
		private static void DeathPatch()
		{
			AchievementManager.AddProgressToAchievement("ultraAchievementsRevamped.deathSimulator", 1);
		}
	}
	[HarmonyPatch]
	internal class DiscoParty
	{
		[HarmonyPatch(typeof(ItemPlaceZone), "CheckItem")]
		[HarmonyPostfix]
		private static void SoapPlacedPatch(ItemPlaceZone __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			StatsManager instance = MonoSingleton<StatsManager>.Instance;
			if (instance == null || instance.levelNumber != 18 || (int)__instance.acceptedItemType != 6)
			{
				return;
			}
			ItemIdentifier componentInChildren = ((Component)__instance).gameObject.GetComponentInChildren<ItemIdentifier>();
			if ((Object)(object)componentInChildren == (Object)null || (int)componentInChildren.itemType != 6)
			{
				return;
			}
			GameObject[] activateOnSuccess = __instance.activateOnSuccess;
			for (int i = 0; i < activateOnSuccess.Length; i++)
			{
				if (((Object)activateOnSuccess[i]).name.Contains("Rainbow"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.discoParty");
				}
			}
		}
	}
	[HarmonyPatch]
	internal class DoubleIt
	{
		private static int _dualWieldCounter;

		[HarmonyPatch(typeof(DualWield), "Start")]
		[HarmonyPostfix]
		private static void DualWieldGainPatch()
		{
			_dualWieldCounter++;
			if (_dualWieldCounter >= 3)
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.doubleIt");
			}
		}

		[HarmonyPatch(typeof(DualWield), "EndPowerUp")]
		[HarmonyPostfix]
		private static void DualWieldEndPatch()
		{
			_dualWieldCounter--;
		}
	}
	[HarmonyPatch]
	internal class IfIWasRich
	{
		[HarmonyPatch(typeof(MoneyText), "DivideMoney")]
		[HarmonyPrefix]
		private static void MoneyCheck(int dosh)
		{
			if (dosh > 1000000000)
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.ifIWasRich");
			}
		}
	}
	[HarmonyPatch]
	internal class KillAFish : MonoBehaviour
	{
		[HarmonyPatch(typeof(Breakable), "Break", new Type[] { typeof(float) })]
		[HarmonyPostfix]
		private static void FishDeathPatch(Breakable __instance)
		{
			FishGhost val = default(FishGhost);
			if (((Component)__instance).gameObject.TryGetComponent<FishGhost>(ref val))
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.killAFish");
			}
		}
	}
	[HarmonyPatch]
	internal class KillingMachine
	{
		[HarmonyPatch(typeof(FinalRank), "LevelChange")]
		[HarmonyPrefix]
		private static void RankTimeCheckPrefix(FinalRank __instance)
		{
			string[] array = __instance.time.text.Split(':');
			if (array.Length >= 2 && int.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2))
			{
				float num = (float)(result * 60) + result2;
				if (__instance.totalRank.text.Contains(">P<") && num <= 60f)
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.killingMachine");
				}
			}
		}
	}
	[HarmonyPatch]
	internal class MemoryWiped
	{
		[HarmonyPatch(typeof(SaveSlotMenu), "ConfirmWipe")]
		[HarmonyPostfix]
		private static void DeleteSavePatch()
		{
			AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.memoryWiped");
		}
	}
	[HarmonyPatch]
	internal class PipeClip
	{
		[HarmonyPatch(typeof(HudMessage), "PlayMessage")]
		[HarmonyPostfix]
		private static void PipeClipCheckPatch(HudMessage __instance)
		{
			if (__instance.message.Contains("PIPE CLIP"))
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.pipeClip");
			}
		}
	}
	[HarmonyPatch]
	internal class SandboxAddiction : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <SandboxTimeCheck>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private WaitForSeconds <wait>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SandboxTimeCheck>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<wait>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					<wait>5__2 = new WaitForSeconds(60f);
				}
				SteamController instance = SteamController.Instance;
				if (((instance != null) ? instance.GetSandboxStats().hoursSpend : 0f) > 5f)
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sandboxAddiction");
					return false;
				}
				<>2__current = <wait>5__2;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch(typeof(ShopZone), "Start")]
		[HarmonyPostfix]
		private static void TerminalSpawnPatch(ShopZone __instance)
		{
			if (!(((Object)__instance).name != "Sandbox Shop"))
			{
				((Component)__instance).gameObject.AddComponent<SandboxAddiction>();
			}
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(SandboxTimeCheck());
		}

		[IteratorStateMachine(typeof(<SandboxTimeCheck>d__2))]
		private static IEnumerator SandboxTimeCheck()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SandboxTimeCheck>d__2(0);
		}
	}
	[HarmonyPatch]
	internal class SequenceBreak
	{
		[HarmonyPatch(typeof(StatsManager), "GetFinalRank")]
		[HarmonyPostfix]
		private static void WeaponsCheckPatch()
		{
			int? num = MonoSingleton<StatsManager>.Instance?.levelNumber;
			if (!num.HasValue)
			{
				return;
			}
			switch (num.GetValueOrDefault())
			{
			case 1:
				if (!HasWeapon("Revolver"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sequenceBreak");
				}
				break;
			case 3:
				if (!HasWeapon("Shotgun"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sequenceBreak");
				}
				break;
			case 6:
				if (!HasWeapon("Nailgun"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sequenceBreak");
				}
				break;
			case 11:
				if (!HasWeapon("Railcannon"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sequenceBreak");
				}
				break;
			case 22:
				if (!HasWeapon("Rocket Launcher"))
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.sequenceBreak");
				}
				break;
			}
		}

		private static bool HasWeapon(string name)
		{
			return (MonoSingleton<GunControl>.Instance?.allWeapons ?? new List<GameObject>()).Any((GameObject weapon) => ((Object)weapon).name.Contains(name));
		}
	}
	[HarmonyPatch]
	internal class SoftDamage
	{
		private static bool _timerStarted;

		private static float _timePassed;

		[HarmonyPatch(typeof(NewMovement), "Update")]
		[HarmonyPostfix]
		public static void Postfix(NewMovement __instance)
		{
			if (_timerStarted)
			{
				_timePassed += Time.deltaTime;
				if (_timePassed < 6f && __instance.hp >= 99)
				{
					AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.softDamage");
				}
				else if (_timePassed > 6f)
				{
					_timerStarted = false;
				}
			}
			else if (__instance.antiHp >= 98f)
			{
				_timerStarted = true;
			}
		}
	}
	[HarmonyPatch]
	internal class V2IntroKill
	{
		[HarmonyPatch(typeof(V2), "Die")]
		[HarmonyPrefix]
		private static void V2DeathPatch(V2 __instance)
		{
			if (__instance.inIntro)
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.v2IntroKill");
			}
		}
	}
	[HarmonyPatch]
	internal class YouAreAMonster
	{
		[HarmonyPatch(typeof(Breakable), "Break", new Type[] { typeof(float) })]
		[HarmonyPostfix]
		private static void SandcastleCheck(Breakable __instance)
		{
			if (((Object)__instance).name.Contains("Sand Castle"))
			{
				AchievementManager.MarkAchievementComplete("ultraAchievementsRevamped.youAreAMonster");
			}
		}
	}
}