using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using RainbowGuard;
using RumbleModdingAPI.RMAPI;
using UIFramework;
using UIFramework.UiExtensions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(global::RainbowGuard.RainbowGuard), "RainbowGuard", "3.1.1", "ninjaguardian", "https://thunderstore.io/c/rumble/p/ninjaguardian/RainbowGuard")]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 0, 160, 230)]
[assembly: MelonAuthorColor(255, 0, 160, 230)]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: VerifyLoaderVersion("0.7.2", true)]
[assembly: MelonOptionalDependencies(new string[] { "UIFramework" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ninjaguardian")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 ninjaguardian")]
[assembly: AssemblyDescription("Changes the color of the guard effect")]
[assembly: AssemblyFileVersion("3.1.1.0")]
[assembly: AssemblyInformationalVersion("3.1.1")]
[assembly: AssemblyProduct("RainbowGuard")]
[assembly: AssemblyTitle("RainbowGuard")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ninjaguardian/RainbowGuard")]
[assembly: AssemblyVersion("3.1.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
}
namespace RainbowGuard
{
	public static class BuildInfo
	{
		public const string ModName = "RainbowGuard";

		public const string ModVersion = "3.1.1";

		public const string MLVersion = "0.7.2";

		public const string Author = "ninjaguardian";

		public const string DownloadLink = "https://thunderstore.io/c/rumble/p/ninjaguardian/RainbowGuard";

		public const string ConfigFile = "config.cfg";
	}
	[Obsolete("RainbowGuard has been replaced by RainbowEffects")]
	public class RainbowGuard : MelonMod
	{
		private const float Phase120 = (float)Math.PI * 2f / 3f;

		private const float Phase240 = 4.1887903f;

		private static readonly string ConfigDir = Path.Combine(MelonEnvironment.UserDataDirectory, "RainbowGuard");

		private static readonly string Config = Path.Combine(ConfigDir, "config.cfg");

		private Effect? _mainEffect;

		private Effect? _particles;

		public override void OnLateInitializeMelon()
		{
			AssetBundle obj = AssetBundles.LoadAssetBundleFromStream((MelonMod)(object)this, "RainbowGuard.rainbowGuard");
			Shader val = obj.LoadAsset<Shader>("guard.shader");
			Shader val2 = obj.LoadAsset<Shader>("guard2.shader");
			obj.Unload(false);
			((Object)val).hideFlags = (HideFlags)61;
			((Object)val2).hideFlags = (HideFlags)61;
			foreach (Material item in Resources.FindObjectsOfTypeAll<Material>())
			{
				if (!((Object)(object)item == (Object)null))
				{
					if (((Object)item).name == "Hidden/VFX/Guardstone VFX/System/Output Particle Shader Graph Quad - Unlit")
					{
						item.shader = val;
					}
					else if (((Object)item).name == "Hidden/VFX/Guardstone VFX/System (1)/Output Particle Unlit Quad")
					{
						item.shader = val2;
					}
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public override void OnUpdate()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			if (_mainEffect.Mode.Value == ColorMode.Rainbow)
			{
				float num = Time.time * _mainEffect.Speed.Value + _mainEffect.Offset.Value;
				_mainEffect.SetShader(new Vector4(Mathf.Sin(num) * 0.5f + 0.5f, Mathf.Sin(num + (float)Math.PI * 2f / 3f) * 0.5f + 0.5f, Mathf.Sin(num + 4.1887903f) * 0.5f + 0.5f, 0f));
			}
			if (_particles.Mode.Value == ColorMode.Rainbow)
			{
				float num2 = Time.time * _particles.Speed.Value + _particles.Offset.Value;
				_particles.SetShader(new Vector4(Mathf.Sin(num2) * 0.5f + 0.5f, Mathf.Sin(num2 + (float)Math.PI * 2f / 3f) * 0.5f + 0.5f, Mathf.Sin(num2 + 4.1887903f) * 0.5f + 0.5f, 0f));
			}
		}

		public override void OnInitializeMelon()
		{
			MelonLogger.Error("RainbowGuard has been replaced by RainbowEffects at https://thunderstore.io/c/rumble/p/ninjaguardian/RainbowEffects/");
			bool num = (Effect.UIPresent = MelonTypeBase<MelonMod>.RegisteredMelons.Any((MelonMod m) => ((MelonBase)m).Info.Name == "UIFramework"));
			if (!Directory.Exists(ConfigDir))
			{
				Directory.CreateDirectory(ConfigDir);
			}
			_mainEffect = new Effect("Main Effect", "rainbowGuard");
			_particles = new Effect("Particles", "rainbowGuard2");
			if (num)
			{
				RegisterUI();
			}
		}

		public override void OnEarlyInitializeMelon()
		{
			MelonLogger.Error("RainbowGuard has been replaced by RainbowEffects at https://thunderstore.io/c/rumble/p/ninjaguardian/RainbowEffects/");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void RegisterUI()
		{
			UI.RegisterMelon((MelonBase)(object)this, (MelonPreferences_Category[])(object)new MelonPreferences_Category[2] { _mainEffect.Category, _particles.Category });
		}

		internal static MelonPreferences_Category CreateCategory(string categoryID, string categoryName)
		{
			MelonPreferences_Category obj = MelonPreferences.CreateCategory("RainbowGuard_" + categoryID, categoryName);
			obj.SetFilePath(Config);
			return obj;
		}

		internal static MelonPreferences_Entry<T> CreateEntry<T>(MelonPreferences_Category category, string entryID, T defaultValue, string entryName, string description, ValueValidator? validator = null)
		{
			return category.CreateEntry<T>(category.Identifier + "_" + entryID, defaultValue, entryName, description, false, false, validator, (string)null);
		}
	}
	internal enum ColorMode
	{
		Rainbow,
		Static
	}
	internal class Effect
	{
		public static bool UIPresent;

		private readonly int _shaderID;

		internal readonly MelonPreferences_Category Category;

		internal readonly MelonPreferences_Entry<float> Speed;

		internal readonly MelonPreferences_Entry<float> Offset;

		internal readonly MelonPreferences_Entry<Vector3> Color;

		internal readonly MelonPreferences_Entry<ColorMode> Mode;

		internal Effect(string name, string property)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			_shaderID = Shader.PropertyToID(property);
			string text = name.ToLower();
			Category = RainbowGuard.CreateCategory(name.Replace(" ", null), name);
			Speed = RainbowGuard.CreateEntry(Category, "Speed", 1f, "Speed", "Speed of the rainbow");
			Offset = RainbowGuard.CreateEntry(Category, "Offset", 0f, "Offset", "Offset of the rainbow");
			Color = RainbowGuard.CreateEntry<Vector3>(Category, "Color", new Vector3(1f, 0.20507877f, 0f), "Color", "The color of the " + text, (ValueValidator?)(object)new VectorRange(0f, 1f));
			((MelonEventBase<LemonAction<Vector3, Vector3>>)(object)Color.OnEntryValueChanged).Subscribe((LemonAction<Vector3, Vector3>)delegate(Vector3 _, Vector3 newColor)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				SetShader(Vector4.op_Implicit(newColor));
			}, 0, false);
			Mode = RainbowGuard.CreateEntry(Category, "Mode", ColorMode.Rainbow, "Mode", "The color mode of the " + text, UIPresent ? Ui() : null);
			((MelonEventBase<LemonAction<ColorMode, ColorMode>>)(object)Mode.OnEntryValueChanged).Subscribe((LemonAction<ColorMode, ColorMode>)delegate(ColorMode _, ColorMode newMode)
			{
				//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)
				if (newMode == ColorMode.Static)
				{
					SetShader(Vector4.op_Implicit(Color.Value));
				}
			}, 0, false);
			ModeToggled(Mode.Value);
			if (Mode.Value == ColorMode.Static)
			{
				SetShader(Vector4.op_Implicit(Color.Value));
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private ValueValidator Ui()
		{
			//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_0018: Expected O, but got Unknown
			return (ValueValidator)new UserEditNotifier
			{
				OnUserEdit = ModeToggled
			};
		}

		internal void SetShader(Vector4 v)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Shader.SetGlobalVector(_shaderID, v);
		}

		private void ModeToggled(object newValue)
		{
			if (newValue is ColorMode colorMode)
			{
				switch (colorMode)
				{
				case ColorMode.Rainbow:
					((MelonPreferences_Entry)Speed).IsHidden = false;
					((MelonPreferences_Entry)Offset).IsHidden = false;
					((MelonPreferences_Entry)Color).IsHidden = true;
					return;
				case ColorMode.Static:
					((MelonPreferences_Entry)Speed).IsHidden = true;
					((MelonPreferences_Entry)Offset).IsHidden = true;
					((MelonPreferences_Entry)Color).IsHidden = false;
					return;
				}
			}
			throw new ArgumentOutOfRangeException("newValue", newValue, "Value not present in enum ColorMode");
		}
	}
	internal class VectorRange : ValueValidator
	{
		private readonly float _minValue;

		private readonly float _maxValue;

		public VectorRange(float minValue, float maxValue)
		{
			if (maxValue < minValue)
			{
				throw new ArgumentException($"Min value ({minValue}) must be less than or equal to max value ({maxValue})!");
			}
			_minValue = minValue;
			_maxValue = maxValue;
		}

		public override bool IsValid(object value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00af: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!(value is Vector4 val))
			{
				if (!(value is Vector3 val2))
				{
					if (value is Vector2 val3)
					{
						return IsValid(val3.x) && IsValid(val3.y);
					}
					throw new ArgumentException($"Unsupported type: {value.GetType()}");
				}
				return IsValid(val2.x) && IsValid(val2.y) && IsValid(val2.z);
			}
			return IsValid(val.x) && IsValid(val.y) && IsValid(val.z) && IsValid(val.w);
		}

		private bool IsValid(float value)
		{
			if (value >= _minValue)
			{
				return value <= _maxValue;
			}
			return false;
		}

		private float EnsureValid(float value)
		{
			if (!(value < _minValue))
			{
				if (!(value > _maxValue))
				{
					return value;
				}
				return _maxValue;
			}
			return _minValue;
		}

		public override object EnsureValid(object value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if (!(value is Vector4 val))
			{
				if (!(value is Vector3 val2))
				{
					if (value is Vector2 val3)
					{
						val3.x = EnsureValid(val3.x);
						val3.y = EnsureValid(val3.y);
						return val3;
					}
					throw new ArgumentException($"Unsupported type: {value.GetType()}");
				}
				val2.x = EnsureValid(val2.x);
				val2.y = EnsureValid(val2.y);
				val2.z = EnsureValid(val2.z);
				return val2;
			}
			val.x = EnsureValid(val.x);
			val.y = EnsureValid(val.y);
			val.z = EnsureValid(val.z);
			val.w = EnsureValid(val.w);
			return val;
		}
	}
}