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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Coruscnium")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Warframe-style enemy highlight, outline, and target tint with configurable colors and intensity")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0.0")]
[assembly: AssemblyProduct("EnemyHighlights")]
[assembly: AssemblyTitle("EnemyHighlights")]
[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 EnemyHighlights
{
	[BepInPlugin("enemyhighlights.mycopunk", "EnemyHighlights", "1.0.0.0")]
	[BepInProcess("Mycopunk.exe")]
	[MycoMod(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private static class HighlightOverlay
		{
			private static readonly HashSet<EnemyPart> _parts = new HashSet<EnemyPart>();

			private static readonly List<EnemyPart> _iter = new List<EnemyPart>();

			private static Material _overlayMat;

			private static RenderParams _renderParams;

			private static readonly int _LineRotation = Shader.PropertyToID("_LineRotation");

			internal static void Register(EnemyPart part)
			{
				if (part != null)
				{
					_parts.Add(part);
				}
			}

			internal static void Render()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				if (_highlightStrength <= 0f || _parts.Count == 0 || !EnsureMaterial())
				{
					return;
				}
				Color val = _highlightColor * (1f + 0.6f * _highlightStrength);
				val.a = Mathf.Lerp(0.15f, 1f, _highlightStrength);
				_overlayMat.SetColor(Global._BaseColor, val);
				_iter.Clear();
				_iter.AddRange(_parts);
				for (int i = 0; i < _iter.Count; i++)
				{
					EnemyPart val2 = _iter[i];
					if (val2 == null || !Object.op_Implicit((Object)(object)val2))
					{
						_parts.Remove(val2);
					}
					else
					{
						if (!((Behaviour)val2).isActiveAndEnabled)
						{
							continue;
						}
						EnemyBrain brain = val2.Brain;
						if (brain == null || brain.DigProgress > 0f)
						{
							continue;
						}
						List<TargetMesh> meshes = val2.Meshes;
						if (meshes == null)
						{
							continue;
						}
						for (int j = 0; j < meshes.Count; j++)
						{
							TargetMesh val3 = meshes[j];
							if (val3 == null || val3.mesh == null)
							{
								continue;
							}
							Mesh sharedMesh = val3.mesh.sharedMesh;
							if (sharedMesh != null)
							{
								Matrix4x4 localToWorldMatrix = ((Component)val3.mesh).transform.localToWorldMatrix;
								int subMeshCount = sharedMesh.subMeshCount;
								for (int k = 0; k < subMeshCount; k++)
								{
									Graphics.RenderMesh(ref _renderParams, sharedMesh, k, localToWorldMatrix, (Matrix4x4?)null);
								}
							}
						}
					}
				}
			}

			private static bool EnsureMaterial()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Expected O, but got Unknown
				if (_overlayMat != null)
				{
					return true;
				}
				Shader val = Shader.Find("Universal Render Pipeline/Unlit");
				if (val != null)
				{
					_overlayMat = new Material(val);
					_overlayMat.SetFloat("_Surface", 1f);
					_overlayMat.SetOverrideTag("RenderType", "Transparent");
					_overlayMat.SetInt("_SrcBlend", 5);
					_overlayMat.SetInt("_DstBlend", 10);
					_overlayMat.SetInt("_ZWrite", 0);
					_overlayMat.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
					_overlayMat.renderQueue = 3000;
					Logger.LogInfo((object)"[highlight] overlay using URP/Unlit (depth-tested)");
				}
				else
				{
					Highlighter val2 = default(Highlighter);
					if (!Highlighter.TryGetInstance(ref val2))
					{
						return false;
					}
					Material highlightMaterial = val2.HighlightMaterial;
					if (highlightMaterial == null)
					{
						return false;
					}
					_overlayMat = new Material(highlightMaterial);
					_overlayMat.SetFloat(_LineRotation, 1f);
					if (!_overlayMat.HasProperty("_ZTest"))
					{
						Logger.LogError((object)("[highlight] URP/Unlit stripped from build and Highlighter shader '" + ((Object)highlightMaterial.shader).name + "' has no _ZTest property — overlay would draw through walls, DISABLING highlight"));
						_overlayMat = null;
						return false;
					}
					_overlayMat.SetInt("_ZTest", 4);
					Logger.LogInfo((object)("[highlight] overlay cloned from Highlighter ('" + ((Object)highlightMaterial.shader).name + "'), _ZTest forced to LessEqual"));
				}
				RenderParams renderParams = default(RenderParams);
				((RenderParams)(ref renderParams))..ctor(_overlayMat);
				((RenderParams)(ref renderParams)).layer = 0;
				((RenderParams)(ref renderParams)).renderingLayerMask = 1u;
				_renderParams = renderParams;
				return true;
			}
		}

		private static class EnemyPartPatches
		{
			[HarmonyPatch(typeof(EnemyPart), "Initialize")]
			[HarmonyPostfix]
			private static void Initialize_Postfix(EnemyPart __instance)
			{
				HighlightOverlay.Register(__instance);
			}

			[HarmonyPatch(typeof(EnemyPart), "SetupRenderersOnAttach")]
			[HarmonyPostfix]
			private static void SetupRenderersOnAttach_Postfix(EnemyPart __instance)
			{
				HighlightOverlay.Register(__instance);
			}
		}

		private static class HighlighterPatches
		{
			private static readonly FieldInfo GradientField = AccessTools.Field(typeof(Highlighter), "highlightHealthColor");

			private static readonly FieldInfo OpacityField = AccessTools.Field(typeof(Highlighter), "highlightOpacity");

			private static Gradient _vanillaGradient;

			private static Range<float> _vanillaOpacity;

			private static bool _captured;

			[HarmonyPatch(typeof(Highlighter), "Setup")]
			[HarmonyPostfix]
			private static void Setup_Postfix(Highlighter __instance)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				_vanillaGradient = (Gradient)GradientField.GetValue(__instance);
				_vanillaOpacity = (Range<float>)OpacityField.GetValue(__instance);
				_captured = true;
				ApplyTargetingOverride();
			}

			internal static void ApplyTargetingOverride()
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				Highlighter obj = default(Highlighter);
				if (_captured && Highlighter.TryGetInstance(ref obj))
				{
					if (_targetingStrength <= 0f)
					{
						GradientField.SetValue(obj, _vanillaGradient);
						OpacityField.SetValue(obj, _vanillaOpacity);
						return;
					}
					Gradient val = new Gradient();
					val.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
					{
						new GradientColorKey(_targetingColor, 0f),
						new GradientColorKey(_targetingColor, 1f)
					};
					val.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
					{
						new GradientAlphaKey(1f, 0f),
						new GradientAlphaKey(1f, 1f)
					};
					Gradient value = val;
					GradientField.SetValue(obj, value);
					OpacityField.SetValue(obj, new Range<float>(_targetingStrength, _targetingStrength));
				}
			}
		}

		public const string PluginGUID = "enemyhighlights.mycopunk";

		public const string PluginName = "EnemyHighlights";

		public const string PluginVersion = "1.0.0.0";

		internal static ManualLogSource Logger;

		private static ConfigEntry<string> _highlightColorCfg;

		private static ConfigEntry<int> _highlightIntensityCfg;

		private static ConfigEntry<string> _targetingColorCfg;

		private static ConfigEntry<int> _targetingIntensityCfg;

		private static Color _highlightColor = Color.red;

		private static float _highlightStrength;

		private static Color _targetingColor = Color.red;

		private static float _targetingStrength;

		private static FileSystemWatcher _configWatcher;

		private static volatile bool _pendingConfigReload;

		private void Awake()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			_highlightColorCfg = ((BaseUnityPlugin)this).Config.Bind<string>("Highlight", "HighlightColor", "FF2A00", "Hex color (RRGGBB) for the whole-enemy overlay.");
			_highlightIntensityCfg = ((BaseUnityPlugin)this).Config.Bind<int>("Highlight", "HighlightIntensity", 30, new ConfigDescription("0 disables (vanilla). 100 = solid, super-bright color coat.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			_targetingColorCfg = ((BaseUnityPlugin)this).Config.Bind<string>("Targeting", "TargetingColor", "FF2A00", "Hex color (RRGGBB) for the pointed-at part overlay.");
			_targetingIntensityCfg = ((BaseUnityPlugin)this).Config.Bind<int>("Targeting", "TargetingIntensity", 0, new ConfigDescription("0 disables (vanilla health-gradient overlay). 100 = fully opaque overlay.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
			((BaseUnityPlugin)this).Config.Save();
			try
			{
				_configWatcher = new FileSystemWatcher(Paths.ConfigPath, "enemyhighlights.mycopunk.cfg")
				{
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
					EnableRaisingEvents = true
				};
				_configWatcher.Changed += OnConfigFileChanged;
				_configWatcher.Created += OnConfigFileChanged;
				_configWatcher.Renamed += OnConfigFileChanged;
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Could not start config file watcher: " + ex.Message));
			}
			RefreshCachedValues();
			Harmony val = new Harmony("enemyhighlights.mycopunk");
			val.PatchAll(typeof(EnemyPartPatches));
			val.PatchAll(typeof(HighlighterPatches));
			Logger.LogInfo((object)"EnemyHighlights 1.0.0.0 loaded.");
		}

		private static void OnSettingChanged(object sender, SettingChangedEventArgs args)
		{
			RefreshCachedValues();
			HighlighterPatches.ApplyTargetingOverride();
		}

		private static void OnConfigFileChanged(object sender, FileSystemEventArgs e)
		{
			_pendingConfigReload = true;
		}

		private void Update()
		{
			if (_pendingConfigReload)
			{
				_pendingConfigReload = false;
				((BaseUnityPlugin)this).Config.Reload();
			}
		}

		private void LateUpdate()
		{
			HighlightOverlay.Render();
		}

		private void OnDestroy()
		{
			if (_configWatcher != null)
			{
				_configWatcher.EnableRaisingEvents = false;
				_configWatcher.Changed -= OnConfigFileChanged;
				_configWatcher.Created -= OnConfigFileChanged;
				_configWatcher.Renamed -= OnConfigFileChanged;
				_configWatcher.Dispose();
				_configWatcher = null;
			}
		}

		private static void RefreshCachedValues()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			_highlightColor = ParseHex(_highlightColorCfg.Value, Color.red);
			_highlightStrength = (float)Mathf.Clamp(_highlightIntensityCfg.Value, 0, 100) / 100f;
			_targetingColor = ParseHex(_targetingColorCfg.Value, Color.red);
			_targetingStrength = (float)Mathf.Clamp(_targetingIntensityCfg.Value, 0, 100) / 100f;
		}

		private static Color ParseHex(string hex, Color fallback)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0040: 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)
			if (string.IsNullOrWhiteSpace(hex))
			{
				return fallback;
			}
			string text = hex.Trim();
			if (!text.StartsWith("#"))
			{
				text = "#" + text;
			}
			Color val = default(Color);
			return ColorUtility.TryParseHtmlString(text, ref val) ? val : fallback;
		}
	}
}