using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Skong")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("ShawPlugin")]
[assembly: AssemblyTitle("Skong")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Skong
{
	[BepInPlugin("com.notsora.hornetremembered", "Old Hornet voicelines", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static class Global
		{
			public static bool hasPlayed;
		}

		public static class SoundContext
		{
			public static bool InSkill;

			public static bool CanPlay;
		}

		[HarmonyPatch(typeof(HeroController), "ThrowTool")]
		private class Patch_ThrowTool
		{
			private static void Prefix(HeroController __instance)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Invalid comparison between Unknown and I4
				float num = Random.Range(0f, 1f);
				if (num <= voiceLineChance.Value)
				{
					SoundContext.CanPlay = true;
					FieldInfo fieldInfo = AccessTools.Field(typeof(HeroController), "willThrowTool");
					ToolItem val = (ToolItem)fieldInfo.GetValue(__instance);
					if ((Object)(object)val != (Object)null && (int)val.Type == 3)
					{
						SoundContext.InSkill = true;
					}
				}
			}

			private static void Postfix(HeroController __instance)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Invalid comparison between Unknown and I4
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Invalid comparison between Unknown and I4
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				SoundContext.InSkill = false;
				FieldInfo fieldInfo = AccessTools.Field(typeof(HeroController), "willThrowTool");
				ToolItem val = (ToolItem)fieldInfo.GetValue(__instance);
				GameManager instance = GameManager.instance;
				AudioSource val2 = ((Component)instance).gameObject.GetComponent<AudioSource>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)instance).gameObject.AddComponent<AudioSource>();
					val2.playOnAwake = false;
				}
				if (!SoundContext.CanPlay)
				{
					return;
				}
				SoundContext.CanPlay = false;
				if ((Object)(object)val != (Object)null && (int)val.Type == 3 && val.Usage.FsmEventName == "PARRY")
				{
					List<string> list = new List<string> { "laugh1", "laugh2" };
					string text = list[Random.Range(0, list.Count)];
					if (clips.TryGetValue(text, out var value))
					{
						val2.PlayOneShot(value, voiceLineVolume.Value);
					}
					else
					{
						Logger.LogWarning((object)("Clip " + text + " not loaded yet!"));
					}
				}
				else
				{
					if (!((Object)(object)val != (Object)null) || (int)val.Type != 3 || val.Usage.FsmEventName == "PARRY")
					{
						return;
					}
					List<string> list2 = new List<string>();
					if (canAdino.Value)
					{
						list2.Add("adino");
					}
					if (canShaw.Value)
					{
						list2.Add("shaw");
					}
					if (canHegale.Value)
					{
						list2.Add("hegale");
					}
					if (canHaaa.Value)
					{
						list2.Add("haaaa");
					}
					string text2 = list2[Random.Range(0, list2.Count())];
					if (!val2.isPlaying)
					{
						if (clips.TryGetValue(text2, out var value2))
						{
							val2.PlayOneShot(value2, voiceLineVolume.Value);
						}
						else
						{
							Logger.LogWarning((object)("Clip " + text2 + " not loaded yet!"));
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(AudioSource), "PlayOneShot", new Type[]
		{
			typeof(AudioClip),
			typeof(float)
		})]
		private class Patch_AudioSourcePlayOneShot
		{
			private static bool Prefix(AudioSource __instance, AudioClip clip)
			{
				if (SoundContext.CanPlay && SoundContext.InSkill && (((Object)clip).name.StartsWith("a") || ((Object)clip).name.Contains("Hornet_attack_large")))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(HeroController), "Die")]
		private class Patch_Die
		{
			private static void Postfix(HeroController __instance)
			{
				AudioSource val = ((Component)__instance).gameObject.GetComponent<AudioSource>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)__instance).gameObject.AddComponent<AudioSource>();
				}
				if (Random.Range(0f, 1f) <= gitGudChance.Value && clips.TryGetValue("gitgud", out var value))
				{
					val.PlayOneShot(value, voiceLineVolume.Value + 0.4f);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <LoadAudio>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string filename;

			public string key;

			public Plugin <>4__this;

			private string <pluginFolder>5__1;

			private string <resourcePath>5__2;

			private UnityWebRequest <www>5__3;

			private AudioClip <clip>5__4;

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

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

			[DebuggerHidden]
			public <LoadAudio>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<pluginFolder>5__1 = null;
				<resourcePath>5__2 = null;
				<www>5__3 = null;
				<clip>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<pluginFolder>5__1 = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
						<resourcePath>5__2 = Path.Combine(<pluginFolder>5__1, filename);
						if (!File.Exists(<resourcePath>5__2))
						{
							Logger.LogWarning((object)(filename + " not found in plugins folder!"));
							return false;
						}
						<www>5__3 = UnityWebRequestMultimedia.GetAudioClip("file:///" + <resourcePath>5__2, (AudioType)20);
						<>1__state = -3;
						<>2__current = <www>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<www>5__3.result == 1)
						{
							<clip>5__4 = DownloadHandlerAudioClip.GetContent(<www>5__3);
							clips[key] = <clip>5__4;
							Logger.LogInfo((object)("Loaded sound: " + filename + " as " + key));
							<clip>5__4 = null;
						}
						else
						{
							Logger.LogError((object)("Failed to load " + filename + ": " + <www>5__3.error));
						}
						<>m__Finally1();
						<www>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__3 != null)
				{
					((IDisposable)<www>5__3).Dispose();
				}
			}

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

		public static Plugin Instance;

		internal static ManualLogSource Logger;

		public static AudioClip shawClip;

		public static Dictionary<string, AudioClip> clips = new Dictionary<string, AudioClip>();

		public static ConfigEntry<float> voiceLineVolume;

		public static ConfigEntry<float> gitGudChance;

		public static ConfigEntry<float> voiceLineChance;

		public static ConfigEntry<bool> canShaw;

		public static ConfigEntry<bool> canHaaa;

		public static ConfigEntry<bool> canHegale;

		public static ConfigEntry<bool> canAdino;

		private void Awake()
		{
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin Skong is loaded!");
			voiceLineVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Volume", "VoiceLineVolume", 0.4f, "Volume for hornet voice lines (0.0 = mute, 1.0 = loud, >1.0 very loud");
			voiceLineChance = ((BaseUnityPlugin)this).Config.Bind<float>("Chance", "VoiceLineChance", 1f, "Chance that hornet will do one of her voice lines from Hollow Knight (0.0 = 0%, 1.0 = 100%)");
			gitGudChance = ((BaseUnityPlugin)this).Config.Bind<float>("Chance", "OnDeathSoundChance", 0.1f, "Chance that hornet will tell you to get good after dying (0.0 = 0%, 1.0 = 100%)");
			canAdino = ((BaseUnityPlugin)this).Config.Bind<bool>("Variance", "AdinoChance", true, "Flag that allows the 'Adino' voice line to play");
			canShaw = ((BaseUnityPlugin)this).Config.Bind<bool>("Variance", "ShawChance", true, "Flag that allows the 'Shaw' voice line to play");
			canHaaa = ((BaseUnityPlugin)this).Config.Bind<bool>("Variance", "HaaaChance", true, "Flag that allows the 'Haaa' voice line to play");
			canHegale = ((BaseUnityPlugin)this).Config.Bind<bool>("Variance", "HegaleChance", true, "Flag that allows the 'Hegale' voice line to play");
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_gitgud.wav", "gitgud"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_shaw.wav", "shaw"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_adino.wav", "adino"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_haaaa.wav", "haaaa"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_hegale.wav", "hegale"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_laugh1.wav", "laugh1"));
			((MonoBehaviour)this).StartCoroutine(LoadAudio("hornet_laugh2.wav", "laugh2"));
			Harmony val = new Harmony("com.notsora.hornetremembered");
			val.PatchAll();
		}

		[IteratorStateMachine(typeof(<LoadAudio>d__13))]
		private IEnumerator LoadAudio(string filename, string key)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudio>d__13(0)
			{
				<>4__this = this,
				filename = filename,
				key = key
			};
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Skong";

		public const string PLUGIN_NAME = "ShawPlugin";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}