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;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using LGBTQHitscan.Utils;
using Microsoft.CodeAnalysis;
using ThornClient.Core;
using ThornClient.Core.ConfigurableElements;
using ThornClient.Managers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("LGBTQHitscan")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LGBTQ Hitscan")]
[assembly: AssemblyTitle("LGBTQHitscan")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace LGBTQHitscan
{
	public enum FlagChoice
	{
		Random,
		Transgender,
		Pansexual,
		Nonbinary,
		Lesbian,
		Gay,
		Bisexual,
		Asexual,
		Agender
	}
	public class HitscanConfig : Module
	{
		private static Sprite icon;

		public override Sprite Icon => ((Object)(object)icon != (Object)null) ? icon : (icon = BundleLoader.LoadIcon("LGBTQHitscan.icon.png"));

		public HitscanConfig()
			: base("com.achelia.lgbtqhitscan", "LGBTQ Hitscan", "Pride flag hitscan beams", (ModuleCategory)1, (KeyCode)0, (KeyCode)0, false, true)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			((Configurable)this).IsEnabled = true;
			Plugin.FlagField = ((Configurable)this).CreateSetting<FlagChoice>("flag", "Beam Flag", "", FlagChoice.Random, (SettingGroup)null);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<FlagChoice, string> flagLabel in Plugin.FlagLabels)
			{
				dictionary[flagLabel.Key.ToString()] = flagLabel.Value;
			}
			((Setting)Plugin.FlagField).Hints = new InterfaceHints
			{
				EnumSubstitutions = dictionary,
				EnumPreferButtonGroup = true
			};
		}
	}
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.achelia.lgbtqhitscan";

		public const string PLUGIN_NAME = "LGBTQ Hitscan";

		public const string PLUGIN_VERSION = "1.0.0";
	}
	[BepInPlugin("com.achelia.lgbtqhitscan", "LGBTQ Hitscan", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(RevolverBeam), "Start")]
		private class RevolverBeamPatch
		{
			private static void Postfix(RevolverBeam __instance)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: 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_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_00dd: 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_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				string text = PickFlagKey();
				if (text == null)
				{
					return;
				}
				LineRenderer component = ((Component)__instance).GetComponent<LineRenderer>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				Gradient val = new Gradient();
				val.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
				{
					new GradientColorKey(Color.white, 0f),
					new GradientColorKey(Color.white, 1f)
				};
				val.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
				{
					new GradientAlphaKey(1f, 0f),
					new GradientAlphaKey(1f, 1f)
				};
				component.colorGradient = val;
				Material val2 = new Material(((Renderer)component).material);
				val2.mainTexture = (Texture)(object)CachedTextures[text];
				((Renderer)component).material = val2;
				Color color = AverageColors[text];
				Sprite muzzleFlashSprite = MuzzleFlashSprite;
				SpriteRenderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<SpriteRenderer>(true);
				SpriteRenderer[] array = componentsInChildren;
				foreach (SpriteRenderer val3 in array)
				{
					if (((Object)val3).name.ToLower().Contains("muzzle"))
					{
						val3.color = color;
						if ((Object)(object)muzzleFlashSprite != (Object)null)
						{
							val3.sprite = muzzleFlashSprite;
						}
					}
				}
				Light component2 = ((Component)__instance).GetComponent<Light>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.color = color;
				}
			}
		}

		public static readonly Dictionary<string, Texture2D> CachedTextures = new Dictionary<string, Texture2D>();

		public static readonly Dictionary<string, Color> AverageColors = new Dictionary<string, Color>();

		public static readonly List<string> FlagPool = new List<string>();

		public static readonly Dictionary<FlagChoice, string> FlagKeys = new Dictionary<FlagChoice, string>
		{
			{
				FlagChoice.Transgender,
				"tran"
			},
			{
				FlagChoice.Pansexual,
				"pan"
			},
			{
				FlagChoice.Nonbinary,
				"non"
			},
			{
				FlagChoice.Lesbian,
				"les"
			},
			{
				FlagChoice.Gay,
				"gay"
			},
			{
				FlagChoice.Bisexual,
				"bi"
			},
			{
				FlagChoice.Asexual,
				"ase"
			},
			{
				FlagChoice.Agender,
				"age"
			}
		};

		public static readonly Dictionary<FlagChoice, string> FlagLabels = new Dictionary<FlagChoice, string>
		{
			{
				FlagChoice.Random,
				"Random"
			},
			{
				FlagChoice.Transgender,
				"Transgender"
			},
			{
				FlagChoice.Pansexual,
				"Pansexual"
			},
			{
				FlagChoice.Nonbinary,
				"Nonbinary"
			},
			{
				FlagChoice.Lesbian,
				"Lesbian"
			},
			{
				FlagChoice.Gay,
				"Gay"
			},
			{
				FlagChoice.Bisexual,
				"Bisexual"
			},
			{
				FlagChoice.Asexual,
				"Asexual"
			},
			{
				FlagChoice.Agender,
				"Agender"
			}
		};

		private static readonly string[] FlagFiles = new string[9] { "tran.png", "pan.png", "non.png", "les.png", "gay.png", "bi.png", "ase.png", "age.png", "muzzleflashwhite1.png" };

		private const string AssetPath = "Assets/Custom/improudofyou/";

		private const string MuzzleFlashKey = "flash";

		internal static ManualLogSource Log;

		public static HitscanConfig ConfigModule;

		public static Setting<FlagChoice> FlagField;

		private static Sprite muzzleFlashSprite;

		private static Harmony harmony;

		private static Sprite MuzzleFlashSprite
		{
			get
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)muzzleFlashSprite != (Object)null)
				{
					return muzzleFlashSprite;
				}
				if (!CachedTextures.TryGetValue("flash", out Texture2D value))
				{
					return null;
				}
				return muzzleFlashSprite = Sprite.Create(value, new Rect(0f, 0f, (float)((Texture)value).width, (float)((Texture)value).height), new Vector2(0.5f, 0.5f), 100f);
			}
		}

		private static bool Enabled => ConfigModule == null || ((Configurable)ConfigModule).IsEnabled;

		private static string PickFlagKey()
		{
			if (!Enabled)
			{
				return null;
			}
			FlagChoice flagChoice = ((FlagField != null) ? FlagField.Value : FlagChoice.Random);
			if (flagChoice != FlagChoice.Random && FlagKeys.TryGetValue(flagChoice, out string value) && CachedTextures.ContainsKey(value))
			{
				return value;
			}
			if (FlagPool.Count == 0)
			{
				return null;
			}
			return FlagPool[Random.Range(0, FlagPool.Count)];
		}

		private void Awake()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			BundleLoader.Initialize();
			string[] flagFiles = FlagFiles;
			foreach (string file in flagFiles)
			{
				LoadTexture(file);
			}
			Log.LogInfo((object)("Loaded " + FlagPool.Count + " of " + (FlagFiles.Length - 1) + " flag textures."));
			ConfigModule = new HitscanConfig();
			RegisterConfig();
			ConfigManager.LoadConfig((Configurable)(object)ConfigModule);
			harmony = new Harmony("com.achelia.lgbtqhitscan");
			harmony.PatchAll();
			Log.LogInfo((object)"LGBTQ Hitscan 1.0.0 loaded.");
		}

		private static void RegisterConfig()
		{
			if (ConfigModule == null || ModuleManager.Items == null)
			{
				return;
			}
			ModuleManager.Items.RemoveAll((Module module) => module != null && ((Configurable)module).GUID == "com.achelia.lgbtqhitscan" && (object)module != ConfigModule);
			foreach (Module item in ModuleManager.Items)
			{
				if ((object)item == ConfigModule)
				{
					return;
				}
			}
			ModuleManager.Items.Add((Module)(object)ConfigModule);
		}

		private static void LoadTexture(string file)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)BundleLoader.Bundle == (Object)null)
			{
				return;
			}
			Texture2D val = BundleLoader.Bundle.LoadAsset<Texture2D>("Assets/Custom/improudofyou/" + file);
			if ((Object)(object)val == (Object)null)
			{
				Log.LogWarning((object)("Asset bundle does not contain " + file + "."));
				return;
			}
			string text = Path.GetFileNameWithoutExtension(file);
			if (text == "muzzleflashwhite1")
			{
				text = "flash";
			}
			CachedTextures[text] = val;
			AverageColors[text] = CalculateAverageColor(val);
			if (text != "flash" && !FlagPool.Contains(text))
			{
				FlagPool.Add(text);
			}
		}

		private static Color CalculateAverageColor(Texture2D texture)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			Color[] pixels = texture.GetPixels();
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			for (int i = 0; i < pixels.Length; i++)
			{
				num += pixels[i].r;
				num2 += pixels[i].g;
				num3 += pixels[i].b;
				num4 += pixels[i].a;
			}
			float num5 = pixels.Length;
			return new Color(num / num5, num2 / num5, num3 / num5, num4 / num5);
		}
	}
}
namespace LGBTQHitscan.Utils
{
	public static class BundleLoader
	{
		private const string BundleResourceName = "LGBTQHitscan.bundle";

		public static AssetBundle? Bundle;

		public static void Initialize()
		{
			if ((Object)(object)Bundle != (Object)null)
			{
				return;
			}
			Assembly assembly = typeof(BundleLoader).Assembly;
			using Stream stream = assembly.GetManifestResourceStream("LGBTQHitscan.bundle");
			if (stream == null)
			{
				Plugin.Log.LogError((object)"Embedded asset bundle 'LGBTQHitscan.bundle' was not found in the assembly.");
				return;
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			Bundle = AssetBundle.LoadFromMemory(memoryStream.ToArray());
			if ((Object)(object)Bundle == (Object)null)
			{
				Plugin.Log.LogError((object)"Failed to load the asset bundle from memory.");
			}
			else
			{
				Plugin.Log.LogInfo((object)"Asset bundle loaded.");
			}
		}

		public static Sprite? LoadIcon(string resourcePath)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				using Stream stream = typeof(BundleLoader).Assembly.GetManifestResourceStream(resourcePath);
				if (stream == null)
				{
					Plugin.Log.LogWarning((object)("Embedded icon '" + resourcePath + "' was not found in the assembly."));
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					Plugin.Log.LogWarning((object)("Embedded icon '" + resourcePath + "' could not be decoded."));
					return null;
				}
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			catch
			{
				return null;
			}
		}
	}
}