using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using GlobalEnums;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Silksong.DataManager;
using Silksong.ModMenu.Elements;
using Silksong.ModMenu.Models;
using Silksong.ModMenu.Plugin;
using Silksong.ModMenu.Screens;
using UnityEngine;
using UnityEngine.SceneManagement;

[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("HueShifter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+c56cebd489a1455ad1f68a97e65d40e0c652a0d1")]
[assembly: AssemblyProduct("HueShifter")]
[assembly: AssemblyTitle("HueShifter")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dpinela/HueShifter")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace HueShifter
{
	[HarmonyPatch(typeof(SceneColorManager), "UpdateScriptParameters")]
	internal static class HeroLightHandler
	{
		private static void Postfix()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (HueShifterPlugin.Instance.GS.ModEnabled && (Object)(object)HeroController.instance != (Object)null)
			{
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				Color.RGBToHSV(HeroController.instance.heroLight.BaseColor, ref num, ref num2, ref num3);
				HeroController.instance.heroLight.BaseColor = Color.HSVToRGB(Mathf.Repeat(num + HueShifterPlugin.Instance.GetPhase(), 1f), num2, num3);
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("io.github.dpinela.hueshifter", "HueShifter", "1.0.2")]
	public class HueShifterPlugin : BaseUnityPlugin, IModMenuCustomMenu, IModMenuInterface, IProfileDataMod<HueShifterSettings>, IProfileDataMod
	{
		[HarmonyPatch(typeof(GameManager), "OnNextLevelReady")]
		private static class NextLevelPatch
		{
			[CompilerGenerated]
			private sealed class <<Postfix>g__DelayedShaderSet|0_0>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <<Postfix>g__DelayedShaderSet|0_0>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = null;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Instance.SetAllTheShaders();
						return false;
					}
				}

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

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

			private static void Postfix(GameManager __instance)
			{
				if (Instance.GS.ModEnabled)
				{
					((MonoBehaviour)__instance).StartCoroutine(DelayedShaderSet());
				}
				[IteratorStateMachine(typeof(<<Postfix>g__DelayedShaderSet|0_0>d))]
				static IEnumerator DelayedShaderSet()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<Postfix>g__DelayedShaderSet|0_0>d(0);
				}
			}
		}

		public static HueShifterPlugin Instance;

		[CompilerGenerated]
		private HueShifterSettings? <ProfileData>k__BackingField = new HueShifterSettings();

		public Shader RainbowDefault;

		public Shader RainbowScreenBlend;

		public Shader RainbowLit;

		public Shader RainbowParticleAdd;

		public Shader RainbowParticleAddSoft;

		public Shader RainbowGrassDefault;

		public Shader RainbowGrassLit;

		public readonly Dictionary<string, float> Palette = new Dictionary<string, float>();

		internal readonly MaterialPropertyBlock materialPropertyBlock = new MaterialPropertyBlock();

		private readonly Dictionary<Material, Material> materialSwaps = new Dictionary<Material, Material>();

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

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

		private const string MenuName = "HueShifter";

		public const string Id = "io.github.dpinela.hueshifter";

		public HueShifterSettings? ProfileData
		{
			[CompilerGenerated]
			get
			{
				return <ProfileData>k__BackingField;
			}
			set
			{
				<ProfileData>k__BackingField = ((value != null) ? value : new HueShifterSettings());
			}
		}

		internal HueShifterSettings GS => ProfileData;

		public bool ToggleButtonInsideMenu => true;

		public static string Name => "HueShifter";

		public static string Version => "1.0.2";

		public void LoadAssets()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			RuntimePlatform platform = Application.platform;
			string text;
			if ((int)platform != 1)
			{
				if ((int)platform != 2)
				{
					if ((int)platform != 13)
					{
						throw new PlatformNotSupportedException("What platform are you even on??");
					}
					text = "linux";
				}
				else
				{
					text = "windows";
				}
			}
			else
			{
				text = "osx";
			}
			string text2 = text;
			AssetBundle val = AssetBundle.LoadFromStream(typeof(HueShifterPlugin).Assembly.GetManifestResourceStream("HueShifter.Resources.AssetBundles.hueshiftshaders-" + text2));
			RainbowDefault = val.LoadAsset<Shader>("assets/shader/rainbowdefault.shader");
			RainbowScreenBlend = val.LoadAsset<Shader>("assets/shader/rainbowscreenblend.shader");
			RainbowLit = val.LoadAsset<Shader>("assets/shader/rainbowlit.shader");
			RainbowParticleAdd = val.LoadAsset<Shader>("assets/shader/rainbowparticleadd.shader");
			RainbowParticleAddSoft = val.LoadAsset<Shader>("assets/shader/rainbowparticleaddsoft.shader");
			RainbowGrassDefault = val.LoadAsset<Shader>("assets/shader/rainbowgrassdefault.shader");
			RainbowGrassLit = val.LoadAsset<Shader>("assets/shader/rainbowgrasslit.shader");
		}

		public void Start()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			if (RainbowDefault == null)
			{
				LoadAssets();
			}
			new Harmony("io.github.dpinela.hueshifter").PatchAll();
		}

		public float GetPhase()
		{
			string key;
			switch (GS.RandomPhase)
			{
			case RandomPhaseSetting.RandomPerMapArea:
				key = ((object)(MapZone)(ref GameManager.instance.sm.mapZone)).ToString();
				break;
			case RandomPhaseSetting.RandomPerRoom:
				key = GameManager.instance.sceneName;
				break;
			default:
				return GS.Phase / 360f;
			}
			if (!Palette.ContainsKey(key))
			{
				Palette[key] = (GS.AllowVanillaPhase ? Random.Range(0f, 1f) : Random.Range(0.05f, 0.95f));
			}
			return Palette[key];
		}

		private void SetAllTheShaders()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			Vector4 frequencyVector = default(Vector4);
			((Vector4)(ref frequencyVector))..ctor(GS.XFrequency / 40f, GS.YFrequency / 40f, GS.ZFrequency / 200f, GS.TimeFrequency / 10f);
			float phase = GetPhase();
			Renderer[] componentsInChildren;
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (GameManager.GetBaseSceneName(((Scene)(ref sceneAt)).name) != GameManager.instance.sceneName)
				{
					continue;
				}
				GameObject[] rootGameObjects = ((Scene)(ref sceneAt)).GetRootGameObjects();
				for (int j = 0; j < rootGameObjects.Length; j++)
				{
					componentsInChildren = rootGameObjects[j].GetComponentsInChildren<Renderer>(true);
					foreach (Renderer renderer in componentsInChildren)
					{
						if (ShouldShift(renderer))
						{
							SetShader(renderer, phase, frequencyVector);
						}
					}
				}
			}
			componentsInChildren = ((Component)GameCameras.instance.sceneParticles).GetComponentsInChildren<Renderer>(false);
			foreach (Renderer val in componentsInChildren)
			{
				if (val.enabled)
				{
					SetShader(val, phase, frequencyVector);
				}
			}
			materialSwaps.Clear();
		}

		public static bool ShouldShift(Renderer renderer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)renderer).gameObject;
			SpriteRenderer val = (SpriteRenderer)(object)((renderer is SpriteRenderer) ? renderer : null);
			if (val != null)
			{
				Color color = val.color;
				if (((Color)(ref color)).maxColorComponent == 0f)
				{
					return false;
				}
			}
			return ((Object)gameObject).name != "Item Sprite";
		}

		public void SetShader(Renderer renderer, float phase, Vector4 frequencyVector)
		{
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Material[] sharedMaterials = renderer.sharedMaterials;
			for (int i = 0; i < sharedMaterials.Length; i++)
			{
				Material val = sharedMaterials[i];
				if (val == null)
				{
					continue;
				}
				bool flag2;
				switch (((Object)val.shader).name)
				{
				case "Custom/RainbowParticleAdd":
				case "Custom/RainbowScreenBlend":
				case "Custom/RainbowLit":
				case "Custom/RainbowDefault":
				case "Custom/RainbowParticleAddSoft":
				case "Custom/RainbowGrassDefault":
				case "Custom/RainbowGrassLit":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				if (flag2)
				{
					flag = true;
					continue;
				}
				if (!materialSwaps.ContainsKey(val))
				{
					Shader val2 = (Shader)(((Object)val.shader).name switch
					{
						"Sprites/Lit" => GS.RespectLighting ? RainbowLit : RainbowDefault, 
						"Sprites/Default" => RainbowDefault, 
						"Sprites/Cherry-Default" => RainbowDefault, 
						"UI/BlendModes/Screen" => RainbowScreenBlend, 
						"Sprites/Screen" => RainbowScreenBlend, 
						"Legacy Shaders/Particles/Additive" => RainbowParticleAdd, 
						"Legacy Shaders/Particles/Additive (Soft)" => RainbowParticleAddSoft, 
						"Hollow Knight/Grass-Default" => RainbowGrassDefault, 
						"Hollow Knight/Grass-Diffuse" => GS.RespectLighting ? RainbowGrassLit : RainbowGrassDefault, 
						_ => null, 
					});
					if (val2 == null)
					{
						continue;
					}
					Material val3 = Object.Instantiate<Material>(val);
					val3.shader = val2;
					materialSwaps[val] = val3;
				}
				flag = true;
				sharedMaterials[i] = materialSwaps[val];
			}
			if (flag)
			{
				renderer.sharedMaterials = sharedMaterials;
				renderer.GetPropertyBlock(materialPropertyBlock);
				materialPropertyBlock.SetFloat(PhaseProperty, phase);
				materialPropertyBlock.SetVector(FrequencyProperty, frequencyVector);
				renderer.SetPropertyBlock(materialPropertyBlock);
			}
		}

		public string ModMenuName()
		{
			return "HueShifter";
		}

		public AbstractMenuScreen BuildCustomMenu()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			PaginatedMenuScreen val = new PaginatedMenuScreen(LocalizedText.op_Implicit("HueShifter"));
			VerticalGroup val2 = new VerticalGroup();
			Action refreshMenu = delegate
			{
			};
			val2.Add((IMenuEntity)(object)Toggle("Mod Enabled", () => GS.ModEnabled, delegate(bool v)
			{
				GS.ModEnabled = v;
			}, ref refreshMenu));
			ListChoiceModel<RandomPhaseSetting> model = ChoiceModels.ForEnum<RandomPhaseSetting>();
			((AbstractValueModel<RandomPhaseSetting>)(object)model).OnValueChanged += delegate(RandomPhaseSetting ps)
			{
				GS.RandomPhase = ps;
			};
			refreshMenu = (Action)Delegate.Combine(refreshMenu, (Action)delegate
			{
				((AbstractValueModel<RandomPhaseSetting>)(object)model).SetValue(GS.RandomPhase);
			});
			val2.Add((IMenuEntity)(object)new ChoiceElement<RandomPhaseSetting>(LocalizedText.op_Implicit("Randomize Hues"), (IChoiceModel<RandomPhaseSetting>)(object)model));
			val2.Add((IMenuEntity)(object)Slider("Hue Shift Angle", 0f, 360f, 37, () => GS.Phase, delegate(float v)
			{
				GS.Phase = v;
			}, ref refreshMenu));
			val2.Add((IMenuEntity)(object)Toggle("Allow Vanilla Colours", () => GS.AllowVanillaPhase, delegate(bool v)
			{
				GS.AllowVanillaPhase = v;
			}, ref refreshMenu));
			val2.Add((IMenuEntity)(object)Toggle("Respect Lighting", () => GS.RespectLighting, delegate(bool v)
			{
				GS.RespectLighting = v;
			}, ref refreshMenu));
			val2.Add((IMenuEntity)(object)Button("Re-roll Palette", delegate
			{
				Palette.Clear();
				SetAllTheShaders();
			}));
			val.AddPage((INavigableMenuEntity)(object)val2);
			VerticalGroup val3 = new VerticalGroup();
			val3.Add((IMenuEntity)(object)Slider("Rainbow Y", -100f, 100f, 21, () => GS.YFrequency, delegate(float v)
			{
				GS.YFrequency = v;
			}, ref refreshMenu));
			val3.Add((IMenuEntity)(object)Slider("Rainbow Z", -100f, 100f, 21, () => GS.ZFrequency, delegate(float v)
			{
				GS.ZFrequency = v;
			}, ref refreshMenu));
			val3.Add((IMenuEntity)(object)Slider("Rainbow X", -100f, 100f, 21, () => GS.XFrequency, delegate(float v)
			{
				GS.XFrequency = v;
			}, ref refreshMenu));
			val3.Add((IMenuEntity)(object)Slider("Animation Speed", -100f, 100f, 21, () => GS.TimeFrequency, delegate(float v)
			{
				GS.TimeFrequency = v;
			}, ref refreshMenu));
			val3.Add((IMenuEntity)(object)Button("Apply to Current Room", SetAllTheShaders));
			val3.Add((IMenuEntity)(object)Button("Reset to Defaults", delegate
			{
				ProfileData = new HueShifterSettings();
				refreshMenu();
				SetAllTheShaders();
			}));
			val.AddPage((INavigableMenuEntity)(object)val3);
			refreshMenu();
			return (AbstractMenuScreen)val;
		}

		private static ChoiceElement<bool> Toggle(string label, Func<bool> getter, Action<bool> setter, ref Action refresh)
		{
			Func<bool> getter2 = getter;
			ListChoiceModel<bool> model = ChoiceModels.ForBool("Off", "On");
			((AbstractValueModel<bool>)(object)model).OnValueChanged += setter;
			refresh = (Action)Delegate.Combine(refresh, (Action)delegate
			{
				((AbstractValueModel<bool>)(object)model).SetValue(getter2());
			});
			return new ChoiceElement<bool>(LocalizedText.op_Implicit(label), (IChoiceModel<bool>)(object)model);
		}

		private static SliderElement<float> Slider(string label, float min, float max, int numSteps, Func<float> getter, Action<float> setter, ref Action refresh)
		{
			Func<float> getter2 = getter;
			LinearFloatSliderModel model = SliderModels.ForFloats(min, max, numSteps);
			((AbstractValueModel<float>)(object)model).OnValueChanged += setter;
			refresh = (Action)Delegate.Combine(refresh, (Action)delegate
			{
				((AbstractValueModel<float>)(object)model).SetValue(getter2());
			});
			return new SliderElement<float>(LocalizedText.op_Implicit(label), (SliderModel<float>)(object)model);
		}

		private static TextButton Button(string label, Action effect)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//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_0023: Expected O, but got Unknown
			TextButton val = new TextButton(LocalizedText.op_Implicit(label));
			val.OnSubmit = (Action)Delegate.Combine(val.OnSubmit, effect);
			return val;
		}
	}
	public enum RandomPhaseSetting
	{
		Fixed,
		RandomPerMapArea,
		RandomPerRoom
	}
	public class HueShifterSettings
	{
		public bool ModEnabled = true;

		public float Phase;

		public RandomPhaseSetting RandomPhase = RandomPhaseSetting.RandomPerMapArea;

		public bool RespectLighting = true;

		public float XFrequency;

		public float YFrequency;

		public float ZFrequency;

		public float TimeFrequency;

		public bool AllowVanillaPhase;
	}
}