using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using HarmonyLib;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using R2API;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using RoR2.DirectionalSearch;
using RoR2.Projectile;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Chinchi")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Show all reroll targets in range for interactables and pickups.")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+8e280fe0e85b60337fc221c62696ca7053f3fc8c")]
[assembly: AssemblyProduct("BetterTinkerTracker")]
[assembly: AssemblyTitle("BetterTinkerTracker")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/schinchi/BetterTinkerTracker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[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 BetterTinkerTracker
{
	[BepInPlugin("Chinchi.BetterTinkerTracker", "BetterTinkerTracker", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BetterTinkerTracker : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__OverrideTinkerSearch;
		}

		public const string PluginGUID = "Chinchi.BetterTinkerTracker";

		public const string PluginAuthor = "Chinchi";

		public const string PluginName = "BetterTinkerTracker";

		public const string PluginVersion = "1.1.0";

		internal const string RiskOfOptionsGUID = "com.rune580.riskofoptions";

		private void Awake()
		{
			//IL_0046: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0088: 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)
			Log.Init(((BaseUnityPlugin)this).Logger);
			Configs.Init(((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Info.Location);
			object obj = <>O.<0>__OverrideTinkerSearch;
			if (obj == null)
			{
				Manipulator val = OverrideTinkerSearch;
				<>O.<0>__OverrideTinkerSearch = val;
				obj = (object)val;
			}
			DrifterTracker.SearchForTinkerTarget += (Manipulator)obj;
			AsyncOperationHandle<GameObject> val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/Drifter/DrifterBody.prefab");
			val2.Completed += delegate(AsyncOperationHandle<GameObject> handle)
			{
				handle.Result.AddComponent<DrifterTrackerBetter>();
			};
			CharacterBody.OnBuffFirstStackGained += new Manipulator(FixTinkerJitterBuff);
			val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/Drifter/TinkerWave.prefab");
			val2.Completed += delegate(AsyncOperationHandle<GameObject> handle)
			{
				ProjectileOverlapAttack val3 = default(ProjectileOverlapAttack);
				if (handle.Result.TryGetComponent<ProjectileOverlapAttack>(ref val3))
				{
					val3.impactEffect = null;
				}
			};
		}

		private static void OverrideTinkerSearch(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStfld<DrifterTracker>(x, "trackingTarget")
			}))
			{
				Log.PatchFail(il);
				return;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.Emit<DrifterTrackerBetter>(OpCodes.Call, "UpdateDrifterTracker");
		}

		private void FixTinkerJitterBuff(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0071: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			float num = default(float);
			if (!val.TryGotoNext(new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(CommonAssets), "jitterEffectPrefab"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num)
			}))
			{
				Log.PatchFail(il);
				return;
			}
			int index = val.Index;
			val.Index = index + 1;
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.PropertyGetter(typeof(CharacterBody), "modelLocator"));
			val.Emit(OpCodes.Callvirt, (MethodBase)AccessTools.PropertyGetter(typeof(ModelLocator), "modelTransform"));
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(Object), "Instantiate", new Type[2]
			{
				typeof(Object),
				typeof(Transform)
			}, (Type[])null));
		}
	}
	internal class Configs
	{
		internal static ConfigEntry<bool> ShowInvalidRerollIndicator { get; private set; }

		internal static ConfigEntry<bool> ShowValidPickupIndicator { get; private set; }

		internal static ConfigEntry<bool> ShowInvalidPickupIndicator { get; private set; }

		internal static ConfigEntry<bool> UseModifiedPickupIndicator { get; private set; }

		internal static void Init(ConfigFile config, string assemblyLocation)
		{
			ShowInvalidRerollIndicator = config.Bind<bool>("Reroll Indicator", "Enable Invalid Indicator", false, "Whether to show the indicator for any invalid interactables.");
			ShowValidPickupIndicator = config.Bind<bool>("Pickup Indicator", "Enable Valid Indicator", true, "Whether to show the indicator for any valid pickups on the ground.");
			ShowInvalidPickupIndicator = config.Bind<bool>("Pickup Indicator", "Enable Invalid Indicator", false, "Whether to show the indicator for any invalid pickups on the ground.");
			UseModifiedPickupIndicator = config.Bind<bool>("Pickup Indicator", "Flip Indicator", true, "Flip the indicator triangle upside down so it does not overlap with the Recycler reticle.");
			if (Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions"))
			{
				RiskOfOptionsInit(assemblyLocation);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void RiskOfOptionsInit(string assemblyLocation)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			FileInfo fileInfo = null;
			FileInfo[] files = new DirectoryInfo(Path.GetDirectoryName(assemblyLocation)).GetFiles("icon.png", SearchOption.TopDirectoryOnly);
			if (files != null && files.Length != 0)
			{
				fileInfo = files[0];
			}
			if (fileInfo != null)
			{
				string name = "BetterTinkerTrackerIcon";
				Texture2D val = new Texture2D(256, 256);
				((Object)val).name = name;
				if (ImageConversion.LoadImage(val, File.ReadAllBytes(fileInfo.FullName)))
				{
					Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
					((Object)obj).name = name;
					ModSettingsManager.SetModIcon(obj, "Chinchi.BetterTinkerTracker", "BetterTinkerTracker");
				}
			}
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShowInvalidRerollIndicator));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShowValidPickupIndicator));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ShowInvalidPickupIndicator));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(UseModifiedPickupIndicator));
		}
	}
	public class DrifterTrackerBetter : MonoBehaviour
	{
		private struct TinkerCandidateInfo
		{
			public GameObject gameObject;

			public Transform indicatorTransform;
		}

		private static readonly Dictionary<DrifterTracker, DrifterTrackerBetter> instancesMap = new Dictionary<DrifterTracker, DrifterTrackerBetter>();

		private static GameObject modifiedBreakTrackingPrefab;

		private static GameObject modifiedInvalidTrackingPrefab;

		private DrifterTracker drifterTracker;

		private readonly List<TinkerCandidateInfo> validRerolls = new List<TinkerCandidateInfo>();

		private readonly List<TinkerCandidateInfo> invalidRerolls = new List<TinkerCandidateInfo>();

		private readonly List<Indicator> validRerollIndicators = new List<Indicator>();

		private readonly List<Indicator> invalidRerollIndicators = new List<Indicator>();

		private readonly List<TinkerCandidateInfo> validPickups = new List<TinkerCandidateInfo>();

		private readonly List<TinkerCandidateInfo> invalidPickups = new List<TinkerCandidateInfo>();

		private readonly List<Indicator> validPickupIndicators = new List<Indicator>();

		private readonly List<Indicator> invalidPickupIndicators = new List<Indicator>();

		[SystemInitializer(new Type[] { })]
		public static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/Drifter/TinkerIndicatorBreak.prefab");
			val.Completed += delegate(AsyncOperationHandle<GameObject> handle)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				if ((int)handle.Status == 1)
				{
					modifiedBreakTrackingPrefab = PrefabAPI.InstantiateClone(handle.Result, "ModifiedTinkerIndicatorBreak", false);
					Transform val3 = modifiedBreakTrackingPrefab.transform.Find("Holder");
					if (Object.op_Implicit((Object)(object)val3))
					{
						val3.rotation = Quaternion.Euler(0f, 0f, 180f);
					}
					else
					{
						LogNotFound("Holder", handle.Result);
					}
					Transform val4 = modifiedBreakTrackingPrefab.transform.Find("TextMeshPro");
					if (Object.op_Implicit((Object)(object)val4))
					{
						val4.position = new Vector3(0f, -0.11f, 0f);
					}
					else
					{
						LogNotFound("TextMeshPro", handle.Result);
					}
				}
			};
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/Drifter/TinkerIndicatorBad.prefab");
			val.Completed += delegate(AsyncOperationHandle<GameObject> handle)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if ((int)handle.Status == 1)
				{
					modifiedInvalidTrackingPrefab = PrefabAPI.InstantiateClone(handle.Result, "ModifiedTinkerIndicatorBad", false);
					Transform val2 = modifiedInvalidTrackingPrefab.transform.Find("Holder");
					if (Object.op_Implicit((Object)(object)val2))
					{
						val2.rotation = Quaternion.Euler(0f, 0f, 180f);
					}
					else
					{
						LogNotFound("Holder", handle.Result);
					}
				}
			};
			static void LogNotFound(string childName, GameObject prefab)
			{
				Log.Warning($"'{childName}' object not found for prefab: {prefab}.");
			}
		}

		private void Awake()
		{
			drifterTracker = ((Component)this).GetComponent<DrifterTracker>();
		}

		private void OnEnable()
		{
			if (Object.op_Implicit((Object)(object)drifterTracker))
			{
				instancesMap[drifterTracker] = this;
			}
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)drifterTracker))
			{
				instancesMap.Remove(drifterTracker);
			}
		}

		public static void UpdateDrifterTracker(DrifterTracker drifterTracker)
		{
			if (Object.op_Implicit((Object)(object)drifterTracker) && instancesMap.TryGetValue(drifterTracker, out var value))
			{
				value.UpdateTinkerReticles();
			}
		}

		private void UpdateTinkerReticles()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)drifterTracker))
			{
				return;
			}
			drifterTracker.trackingTarget = null;
			validRerolls.Clear();
			invalidRerolls.Clear();
			TinkerableObjectAttributes val = default(TinkerableObjectAttributes);
			foreach (ExtendedCandidateInfo item2 in drifterTracker.tinkerSearch.extendedCandidateEnumberable)
			{
				if (Object.op_Implicit((Object)(object)item2.gameObject) && item2.gameObject.TryGetComponent<TinkerableObjectAttributes>(ref val))
				{
					if (val.IsTinkerable)
					{
						validRerolls.Add(new TinkerCandidateInfo
						{
							gameObject = ((Component)val).gameObject,
							indicatorTransform = (val.indicatorOffset ?? ((Component)val).transform)
						});
					}
					else if (Configs.ShowInvalidRerollIndicator.Value && (!Object.op_Implicit((Object)(object)val.shopBehavior) || (!val.shopBehavior.pickupIndexIsHidden && !val.shopBehavior.hasBeenPurchased)) && (!Object.op_Implicit((Object)(object)val.specialObjectAttributes) || val.specialObjectAttributes.isTargetable))
					{
						invalidRerolls.Add(new TinkerCandidateInfo
						{
							gameObject = ((Component)val).gameObject,
							indicatorTransform = (val.indicatorOffset ?? ((Component)val).transform)
						});
					}
				}
			}
			UpdateIndicators(validRerolls, validRerollIndicators, drifterTracker.rerollTrackingPrefab);
			UpdateIndicators(invalidRerolls, invalidRerollIndicators, drifterTracker.invalidTrackingPrefab);
			validPickups.Clear();
			invalidPickups.Clear();
			if (Configs.ShowValidPickupIndicator.Value || Configs.ShowInvalidPickupIndicator.Value)
			{
				foreach (GenericPickupController item3 in ((BaseDirectionalSearch<GenericPickupController, PickupSearchSelector, PickupSearchFilter>)(object)drifterTracker.pickupSearch).ReturnAllCandidates<List<GenericPickupController>>(InstanceTracker.GetInstancesList<GenericPickupController>()))
				{
					TinkerCandidateInfo tinkerCandidateInfo = default(TinkerCandidateInfo);
					tinkerCandidateInfo.gameObject = ((Component)item3).gameObject;
					tinkerCandidateInfo.indicatorTransform = ((Component)item3.pickupDisplay).transform;
					TinkerCandidateInfo item = tinkerCandidateInfo;
					DrifterTracker obj = drifterTracker;
					UniquePickup pickup = item3.pickup;
					if (obj.IsWhitelist(ref pickup))
					{
						if (Configs.ShowValidPickupIndicator.Value)
						{
							validPickups.Add(item);
						}
					}
					else if (Configs.ShowInvalidPickupIndicator.Value)
					{
						invalidPickups.Add(item);
					}
				}
			}
			GameObject indicatorPrefab = (Configs.UseModifiedPickupIndicator.Value ? modifiedBreakTrackingPrefab : drifterTracker.breakTrackingPrefab);
			UpdateIndicators(validPickups, validPickupIndicators, indicatorPrefab);
			GameObject indicatorPrefab2 = (Configs.UseModifiedPickupIndicator.Value ? modifiedInvalidTrackingPrefab : drifterTracker.invalidTrackingPrefab);
			UpdateIndicators(invalidPickups, invalidPickupIndicators, indicatorPrefab2);
		}

		private void UpdateIndicators(List<TinkerCandidateInfo> trackedObjects, List<Indicator> indicators, GameObject indicatorPrefab)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			int count = trackedObjects.Count;
			if (count > indicators.Count)
			{
				int num = count - indicators.Count;
				for (int i = 0; i < num; i++)
				{
					indicators.Add(new Indicator(((Component)this).gameObject, indicatorPrefab));
				}
			}
			for (int j = 0; j < count; j++)
			{
				Indicator val = indicators[j];
				val.targetTransform = trackedObjects[j].indicatorTransform;
				val.active = true;
				if ((Object)(object)val.visualizerPrefab != (Object)(object)indicatorPrefab)
				{
					val.visualizerPrefab = indicatorPrefab;
				}
			}
			for (int k = count; k < indicators.Count; k++)
			{
				indicators[k].active = false;
			}
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logger;

		internal static void Init(ManualLogSource logger)
		{
			_logger = logger;
		}

		internal static void Info(object data)
		{
			_logger.LogInfo(data);
		}

		internal static void Debug(object data)
		{
			_logger.LogDebug(data);
		}

		internal static void Message(object data)
		{
			_logger.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logger.LogWarning(data);
		}

		internal static void Error(object data)
		{
			_logger.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logger.LogFatal(data);
		}

		internal static void PatchFail(string message)
		{
			_logger.LogError((object)("Failed to patch " + message));
		}

		internal static void PatchFail(ILContext il)
		{
			PatchFail(((MemberReference)il.Method).Name);
		}
	}
}