using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MyAudioMod;
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("MyRepoMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MyRepoMod")]
[assembly: AssemblyTitle("MyRepoMod")]
[assembly: AssemblyVersion("1.0.0.0")]
[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;
		}
	}
}
[HarmonyPatch(typeof(TumbleUI), "Update")]
public static class TumbleStartPatch
{
	private static bool wasActive;

	[HarmonyPostfix]
	public static void Postfix(TumbleUI __instance)
	{
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		if (!LevelGenerator.Instance.Generated)
		{
			return;
		}
		LoadingUI instance = LoadingUI.instance;
		if ((Object)(object)instance != (Object)null)
		{
			Type type = ((object)instance).GetType();
			FieldInfo fieldInfo = AccessTools.Field(type, "levelAnimationCompleted");
			if (fieldInfo != null && !(bool)(fieldInfo.GetValue(instance) ?? ((object)false)))
			{
				return;
			}
		}
		PlayerController instance2 = PlayerController.instance;
		if ((Object)(object)instance2 == (Object)null)
		{
			return;
		}
		Type type2 = ((object)instance2).GetType();
		FieldInfo fieldInfo2 = AccessTools.Field(type2, "InputDisableTimer");
		if (fieldInfo2 != null)
		{
			float num = (float)(fieldInfo2.GetValue(instance2) ?? ((object)0f));
			if (num > 0f)
			{
				return;
			}
		}
		PlayerAvatar playerAvatarScript = instance2.playerAvatarScript;
		if (!((Object)(object)playerAvatarScript == (Object)null))
		{
			Type type3 = ((object)playerAvatarScript).GetType();
			bool flag = (bool)(AccessTools.Field(type3, "isTumbling")?.GetValue(playerAvatarScript) ?? ((object)false));
			bool flag2 = (bool)(AccessTools.Field(type3, "isDisabled")?.GetValue(playerAvatarScript) ?? ((object)false));
			bool flag3 = flag && !flag2;
			if (flag3 && !wasActive && Time.timeSinceLevelLoad > 1f)
			{
				Plugin.Logger.LogInfo((object)"\ud83d\udd25 Tumble started — playing Hot.wav");
				Plugin.Instance?.PlayComingInHotAt(((Component)__instance).transform.position);
			}
			wasActive = flag3;
		}
	}
}
[HarmonyPatch(typeof(TumbleUI), "Update")]
public static class TumbleUI_Update_Patch
{
	private static bool previousCanExit;

	[HarmonyPostfix]
	public static void Postfix(TumbleUI __instance)
	{
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || (Object)(object)Plugin.Instance == (Object)null)
		{
			return;
		}
		FieldInfo fieldInfo = AccessTools.Field(typeof(TumbleUI), "canExit");
		FieldInfo fieldInfo2 = AccessTools.Field(typeof(TumbleUI), "canExitPrevious");
		if (fieldInfo == null || fieldInfo2 == null)
		{
			Plugin.Logger.LogError((object)"❌ Could not access canExit or canExitPrevious fields via reflection.");
			return;
		}
		bool flag = (bool)fieldInfo.GetValue(__instance);
		bool flag2 = (bool)fieldInfo2.GetValue(__instance);
		if (flag && !flag2)
		{
			Plugin.Logger.LogInfo((object)"\ud83d\udca5 Detected tumble exit transition — replacing sound with ComingInHot.wav");
			object? obj = AccessTools.Field(typeof(TumbleUI), "canExitSound")?.GetValue(__instance);
			Sound val = (Sound)((obj is Sound) ? obj : null);
			if ((Object)(object)val?.Source != (Object)null && val.Source.isPlaying)
			{
				val.Source.Stop();
				Plugin.Logger.LogInfo((object)"❌ Original tumble sound stopped.");
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine(PlaySoundDelayed(((Component)__instance).transform.position));
		}
	}

	private static IEnumerator PlaySoundDelayed(Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		yield return (object)new WaitForSeconds(0.1f);
		Plugin.Logger.LogInfo((object)$"\ud83d\udd0a Playing ComingInHot at {position}");
		Plugin.Instance.PlayComingInHotAt(position);
	}
}
namespace MyAudioMod
{
	[BepInPlugin("com.yourname.audioMod", "Audio Mod", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public class AutoDestroyAudio : MonoBehaviour
		{
			public float duration;

			private void Start()
			{
				Object.Destroy((Object)(object)((Component)this).gameObject, duration);
			}
		}

		private ManualLogSource _logger = null;

		private AudioClip? comingInHotClip;

		public static bool ReadyToPlayHot;

		public static ManualLogSource Logger => Instance._logger;

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			_logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"\ud83d\udd0a Audio Mod initializing...");
			Harmony.CreateAndPatchAll(typeof(Plugin), (string)null);
			Harmony.CreateAndPatchAll(typeof(TumbleStartPatch), (string)null);
			Harmony.CreateAndPatchAll(typeof(TumbleSoundReplacePatch), (string)null);
			((MonoBehaviour)this).StartCoroutine(MarkReadyToPlay());
			((MonoBehaviour)this).StartCoroutine(LoadEmbeddedClip("MyRepoMod.Hot.wav", delegate(AudioClip? clip)
			{
				comingInHotClip = clip;
			}));
		}

		private IEnumerator MarkReadyToPlay()
		{
			Logger.LogInfo((object)"\ud83d\udd53 Waiting 2 seconds before allowing Hot.wav playback...");
			yield return (object)new WaitForSeconds(2f);
			ReadyToPlayHot = true;
			Logger.LogInfo((object)"✅ ReadyToPlayHot is now TRUE");
		}

		private IEnumerator SetupInputHandler()
		{
			yield return (object)new WaitForSeconds(2f);
			GameObject go = new GameObject("AudioInputHandler");
			Object.DontDestroyOnLoad((Object)(object)go);
			go.AddComponent<AudioUpdate>().Plugin = this;
		}

		private IEnumerator LoadEmbeddedClip(string resourceName, Action<AudioClip?> callback)
		{
			Assembly assembly = Assembly.GetExecutingAssembly();
			using Stream stream = assembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				Logger.LogError((object)("❌ Embedded WAV not found: " + resourceName));
				yield break;
			}
			string tempPath = Path.Combine(Application.temporaryCachePath, Path.GetFileName(resourceName));
			using (FileStream file = File.Create(tempPath))
			{
				stream.CopyTo(file);
			}
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip("file://" + tempPath, (AudioType)20);
			yield return request.SendWebRequest();
			if ((int)request.result == 1)
			{
				AudioClip clip = DownloadHandlerAudioClip.GetContent(request);
				callback(clip);
				Logger.LogInfo((object)("✅ Loaded " + resourceName));
			}
			else
			{
				Logger.LogError((object)("❌ Failed to load " + resourceName + ": " + request.error));
			}
		}

		public void PlayComingInHot()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)comingInHotClip != (Object)null)
			{
				AudioSource val = new GameObject("LocalAudio").AddComponent<AudioSource>();
				val.clip = comingInHotClip;
				val.spatialBlend = 0f;
				val.volume = 1f;
				val.Play();
				Object.Destroy((Object)(object)((Component)val).gameObject, comingInHotClip.length);
			}
		}

		public void PlayComingInHotAt(Vector3 position)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)comingInHotClip == (Object)null)
			{
				Logger.LogError((object)"❌ Hot.wav is null.");
				return;
			}
			Logger.LogWarning((object)"\ud83d\udd25 Hot.wav triggered!");
			Logger.LogWarning((object)Environment.StackTrace);
			GameObject val = new GameObject("HotAudio");
			val.transform.position = position;
			AudioSource val2 = val.AddComponent<AudioSource>();
			val2.clip = comingInHotClip;
			val2.volume = 1f;
			val2.spatialBlend = 0f;
			val2.Play();
			val.AddComponent<AutoDestroyAudio>().duration = comingInHotClip.length + 0.5f;
		}

		private void EnsureAudioListenerExists()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if ((Object)(object)Object.FindObjectOfType<AudioListener>() == (Object)null)
			{
				Logger.LogWarning((object)"⚠\ufe0f No AudioListener found — creating fallback AudioListener.");
				GameObject val = new GameObject("FallbackAudioListener");
				val.AddComponent<AudioListener>();
				Object.DontDestroyOnLoad((Object)(object)val);
				Logger.LogInfo((object)"✅ Fallback AudioListener created.");
			}
			else
			{
				Logger.LogInfo((object)"\ud83c\udfa7 AudioListener found in scene.");
			}
		}
	}
	public class AudioUpdate : MonoBehaviour
	{
		public Plugin? Plugin;

		private void Update()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)116))
			{
				MyAudioMod.Plugin.Logger.LogInfo((object)"\ud83d\udd34 Manual test: playing Hot.wav in 2D");
				Plugin?.PlayComingInHotAt(Vector3.zero);
			}
		}
	}
	[HarmonyPatch(typeof(Sound), "Play")]
	public static class DebugSoundPlay
	{
		[HarmonyPrefix]
		public static void Prefix(Sound __instance)
		{
			if (__instance.Sounds != null && __instance.Sounds.Length != 0)
			{
				AudioClip obj = __instance.Sounds[0];
				string text = ((obj != null) ? ((Object)obj).name : null) ?? "null";
				Plugin.Logger.LogInfo((object)("\ud83d\udd0a Sound.Play called: " + text));
			}
		}
	}
	[HarmonyPatch(typeof(Sound), "Play")]
	public static class TumbleSoundInterceptPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Sound __instance, Vector3 position)
		{
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			StackTrace stackTrace = new StackTrace();
			for (int i = 0; i < stackTrace.FrameCount; i++)
			{
				MethodBase methodBase = stackTrace.GetFrame(i)?.GetMethod();
				if (!(methodBase?.DeclaringType?.Name == "TumbleUI") || !(methodBase.Name == "Update"))
				{
					continue;
				}
				Type declaringType = methodBase.DeclaringType;
				FieldInfo fieldInfo = AccessTools.Field(declaringType, "canExitSound");
				StackFrame[] frames = stackTrace.GetFrames();
				foreach (StackFrame stackFrame in frames)
				{
					if (!(stackFrame?.GetMethod()?.DeclaringType == declaringType))
					{
						continue;
					}
					object value = Traverse.Create(stackFrame.GetMethod().IsStatic ? null : stackFrame.GetMethod()?.ReflectedType).Field("this").GetValue();
					if (value != null)
					{
						object? value2 = fieldInfo.GetValue(value);
						Sound val = (Sound)((value2 is Sound) ? value2 : null);
						if (val == __instance)
						{
							Plugin.Logger.LogInfo((object)"\ud83c\udfaf Intercepted canExitSound from TumbleUI. Playing ComingInHot.wav instead.");
							Plugin.Instance?.PlayComingInHotAt(position);
							return false;
						}
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Sound), "Play")]
	public static class TumbleSoundReplacePatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Sound __instance, Vector3 position)
		{
			AudioClip value = Traverse.Create((object)__instance).Field("clip").GetValue<AudioClip>();
			if ((Object)(object)value != (Object)null && ((Object)value).name.Contains("player tumble can exit"))
			{
				Plugin.Logger.LogInfo((object)("\ud83d\ude45 Suppressing tumble exit sound: " + ((Object)value).name));
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class TumbleUI_Update_Patch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("TumbleUI");
			if (type == null)
			{
				Plugin.Logger.LogError((object)"❌ TumbleUI type not found!");
				return null;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "Update", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Logger.LogError((object)"❌ TumbleUI.Update not found!");
				return null;
			}
			Plugin.Logger.LogInfo((object)("✅ Patch target resolved: " + methodInfo.DeclaringType.FullName + "." + methodInfo.Name));
			return methodInfo;
		}

		private static bool Prefix(object __instance)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			Type type = __instance.GetType();
			FieldInfo fieldInfo = AccessTools.Field(type, "canExit");
			FieldInfo fieldInfo2 = AccessTools.Field(type, "canExitPrevious");
			if (fieldInfo == null || fieldInfo2 == null)
			{
				Plugin.Logger.LogWarning((object)"❌ TumbleUI fields not found.");
				return true;
			}
			bool flag = (bool)fieldInfo.GetValue(__instance);
			bool flag2 = (bool)fieldInfo2.GetValue(__instance);
			if (flag && !flag2)
			{
				Plugin.Logger.LogInfo((object)"\ud83d\udca5 Detected tumble exit — playing ComingInHot.wav");
				Plugin.Instance.PlayComingInHotAt(((Component)(MonoBehaviour)__instance).transform.position);
			}
			return true;
		}
	}
}
namespace MyRepoMod
{
	[HarmonyPatch(typeof(PlayerController))]
	internal static class ExamplePlayerControllerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void Update_Prefix(PlayerController __instance)
		{
			MyRepoMod.Logger.LogDebug((object)$"{__instance} Update Prefix");
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(PlayerController __instance)
		{
			MyRepoMod.Logger.LogDebug((object)$"{__instance} Update Postfix");
		}
	}
	[BepInPlugin("YourName.MyRepoMod", "MyRepoMod", "1.0")]
	public class MyRepoMod : BaseUnityPlugin
	{
		internal static MyRepoMod Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//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_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}