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 System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ScaryCompany.audio;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Audio;
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("ScaryCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f69faac1182112586c370f50803b57bbbcbf16a9")]
[assembly: AssemblyProduct("ScaryCompany")]
[assembly: AssemblyTitle("ScaryCompany")]
[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;
		}
	}
}
namespace ScaryCompany
{
	[BepInPlugin("ScaryCompany", "ScaryCompany", "1.0.0")]
	public class ScaryCompany : BaseUnityPlugin
	{
		public static string ModDirectory;

		public static ScaryCompany Instance { get; private set; }

		public static ManualLogSource Logger { get; set; }

		private static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			ModDirectory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Patch();
			Logger.LogInfo((object)"ScaryCompany loaded successfully.");
		}

		private static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("ScaryCompany");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ScaryCompany";

		public const string PLUGIN_NAME = "ScaryCompany";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ScaryCompany.Patches
{
	[HarmonyPatch(typeof(BoomboxItem))]
	public class BoomboxPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void OverwriteBoomboxMusic(BoomboxItem __instance)
		{
			__instance.musicAudios = (AudioClip[])(object)new AudioClip[1] { AudioManager.Instance.GetClip(AudioList.Music0) };
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	public class EntrancePatch
	{
		[HarmonyPatch("TeleportPlayer")]
		[HarmonyPostfix]
		private static void TriggerSoundOnEntry(EntranceTeleport __instance)
		{
			if (__instance.isEntranceToBuilding)
			{
				ScaryCompany.Logger.LogInfo((object)"Player Entered Building.");
				AudioManager.Instance.LoopRandomClip(AudioCategory.Ambience);
			}
			else
			{
				ScaryCompany.Logger.LogInfo((object)"Player Exited Building.");
				AudioManager.Instance.StopAll(AudioCategory.Ambience);
			}
		}
	}
	[HarmonyPatch(typeof(FlashlightItem))]
	public class FlashlightPatch
	{
		private const float FlickerChance = 0.05f;

		private const float FlickerMaxPitchOffset = 0.1f;

		private const float FlickerMinTime = 0.3f;

		private const float FlickerMaxTime = 1.3f;

		private const float FlickerRoutineMinTime = 0.05f;

		private const float FlickerRoutineMaxTime = 0.15f;

		private static readonly HashSet<FlashlightItem> ActiveFlickers = new HashSet<FlashlightItem>();

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Flicker(FlashlightItem __instance)
		{
			if (((GrabbableObject)__instance).isBeingUsed && !ActiveFlickers.Contains(__instance))
			{
				float num = 0.05f * Time.deltaTime;
				if (!(Random.value >= num))
				{
					float duration = Random.Range(0.3f, 1.3f);
					((MonoBehaviour)__instance).StartCoroutine(FlickerRoutine(__instance, duration));
				}
			}
		}

		private static IEnumerator FlickerRoutine(FlashlightItem flashlight, float duration)
		{
			ActiveFlickers.Add(flashlight);
			AudioManager.Instance.PlayClipRandomPitch(AudioList.Flicker0, 0.1f);
			float waitTime;
			for (float elapsed = 0f; elapsed < duration; elapsed += waitTime)
			{
				((Behaviour)flashlight.flashlightBulb).enabled = !((Behaviour)flashlight.flashlightBulb).enabled;
				float pitchOffset = Random.Range(-0.1f, 0.1f);
				AudioManager.Instance.PlayClipRandomPitch(AudioList.Flicker0, pitchOffset);
				waitTime = Random.Range(0.05f, 0.15f);
				yield return (object)new WaitForSeconds(waitTime);
			}
			((Behaviour)flashlight.flashlightBulb).enabled = true;
			ActiveFlickers.Remove(flashlight);
		}
	}
	[HarmonyPatch(typeof(FlowermanAI))]
	public class FlowermanPatch
	{
		[HarmonyPatch(typeof(FlowermanAI), "Update")]
		[HarmonyPostfix]
		public static void OnStalk(FlowermanAI __instance)
		{
			if (!((Object)(object)AudioManager.Instance == (Object)null) && AudioManager.Instance.IsInitialized)
			{
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				if (((EnemyAI)__instance).currentBehaviourStateIndex == 0 && (Object)(object)((EnemyAI)__instance).targetPlayer == (Object)(object)localPlayerController)
				{
					AudioManager.Instance.FadeIn(AudioList.FlowermanStalk, 1f, 1f, loop: true);
				}
				else
				{
					AudioManager.Instance.FadeOut(AudioList.FlowermanStalk, 3f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(JesterAI))]
	public class JesterPopPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void EnterChase(JesterAI __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				if (((EnemyAI)__instance).currentBehaviourStateIndex == 2)
				{
					AudioManager.Instance.PlayClip(AudioList.JesterPop);
					AudioManager.Instance.LoopClip(AudioList.JesterChase);
				}
				else
				{
					AudioManager.Instance.StopClip(AudioList.JesterChase);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerPatch
	{
		private const float SoundIntervalSeconds = 20f;

		private const float SoundChance = 0.05f;

		private const float MinDistance = 5f;

		private const float MaxDistance = 20f;

		private const float MaxPitchOffset = 0.2f;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void PlayRandomSounds(PlayerControllerB __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//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_00a4: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.isInsideFactory)
			{
				float num = Time.deltaTime * 0.05f;
				if (!(Random.value >= num))
				{
					ScaryCompany.Logger.LogInfo((object)"Playing random ambience sound");
					float num2 = Random.Range(5f, 20f);
					Vector2 val = new Vector2(Random.value * 2f - 1f, Random.value * 2f - 1f);
					Vector2 val2 = ((Vector2)(ref val)).normalized * num2;
					Vector3 targetPosition = ((Component)__instance).transform.position + new Vector3(val2.x, 0f, val2.y);
					AudioManager.Instance.PlayClipPositioned(AudioCategory.Random, targetPosition, 1.2f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	public class RoundManagerPatch
	{
		private const float DoorIntervalSeconds = 180f;

		private const float DoorChance = 1f / 180f;

		private const float FlickerIntervalSeconds = 20f;

		private const float FlickerChance = 0.05f;

		private const float FlickerMaxPitchOffset = 0.1f;

		private const float FlickerMinTime = 0.7f;

		private const float FlickerMaxTime = 4.5f;

		private const float FlickerRoutineMinTime = 0.05f;

		private const float FlickerRoutineMaxTime = 0.15f;

		private static Coroutine? _activeFlicker;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void DoorSlam(RoundManager __instance)
		{
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServer || !RoundManager.Instance.dungeonCompletedGenerating)
			{
				return;
			}
			float num = 1f / 180f * Time.deltaTime;
			if (Random.value > num)
			{
				return;
			}
			List<PlayerControllerB> players = StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB player) => Object.op_Implicit((Object)(object)player) && player != null && player.isPlayerControlled && !player.isPlayerDead).ToList();
			if (players.Count == 0)
			{
				return;
			}
			ScaryCompany.Logger.LogInfo((object)"Door slam triggered!");
			DoorLock[] array = Object.FindObjectsOfType<DoorLock>();
			ScaryCompany.Logger.LogInfo((object)("Found " + array.Length + " doors"));
			array = array.Where((DoorLock door) => door.isDoorOpened).ToArray();
			if (array.Length == 0)
			{
				ScaryCompany.Logger.LogInfo((object)"No open doors found!");
				return;
			}
			List<float> list = array.Select((DoorLock door) => players.Select(delegate(PlayerControllerB player)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = ((Component)player).transform.position - ((Component)door).transform.position;
				return ((Vector3)(ref val2)).magnitude;
			}).Prepend(float.MaxValue).Min()).ToList();
			int num2 = list.IndexOf(list.Min());
			DoorLock closestDoor = array[num2];
			PlayerControllerB val = players.OrderBy(delegate(PlayerControllerB player)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = ((Component)player).transform.position - ((Component)closestDoor).transform.position;
				return ((Vector3)(ref val2)).sqrMagnitude;
			}).First();
			closestDoor.isDoorOpened = false;
			closestDoor.OpenOrCloseDoor(val);
			AudioManager.Instance.PlayClipPositioned(AudioCategory.DoorSlam, ((Component)closestDoor).transform.position);
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void LightFlicker(RoundManager __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer && _activeFlicker == null)
			{
				float num = 0.05f * Time.deltaTime;
				if (!(Random.value >= num))
				{
					ScaryCompany.Logger.LogInfo((object)"Light flicker triggered!");
					float duration = Random.Range(0.7f, 4.5f);
					_activeFlicker = ((MonoBehaviour)__instance).StartCoroutine(FlickerRoutine(__instance, duration));
				}
			}
		}

		private static IEnumerator FlickerRoutine(RoundManager instance, float duration)
		{
			List<Light> poweredLights = instance.allPoweredLights;
			if (poweredLights == null || poweredLights.Count == 0)
			{
				ScaryCompany.Logger.LogInfo((object)"No lights found!");
				_activeFlicker = null;
				yield break;
			}
			List<float> intensities = poweredLights.Select((Light l) => l.intensity).ToList();
			float waitTime;
			for (float elapsed = 0f; elapsed < duration; elapsed += waitTime)
			{
				for (int i = 0; i < poweredLights.Count; i++)
				{
					Light light = poweredLights[i];
					if (Object.op_Implicit((Object)(object)light))
					{
						light.intensity = ((light.intensity > 0f) ? 0f : intensities[i]);
					}
				}
				if (GameNetworkManager.Instance.localPlayerController.isInsideFactory)
				{
					AudioList clip = AudioManager.GetRandomClip(AudioCategory.LightFlicker);
					AudioManager.Instance.PlayClipRandomPitch(clip, 0.1f);
				}
				waitTime = Random.Range(0.05f, 0.15f);
				yield return (object)new WaitForSeconds(waitTime);
			}
			for (int i2 = 0; i2 < poweredLights.Count; i2++)
			{
				if (Object.op_Implicit((Object)(object)poweredLights[i2]))
				{
					poweredLights[i2].intensity = intensities[i2];
				}
			}
			_activeFlicker = null;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void SpawnAudioManager()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)AudioManager.Instance != (Object)null))
			{
				GameObject val = new GameObject("AudioManager");
				val.AddComponent<AudioManager>();
				Object.DontDestroyOnLoad((Object)(object)val);
			}
		}
	}
	[HarmonyPatch(typeof(WalkieTalkie))]
	public class WalkieTalkiePatch
	{
		private const float GhostIntervalSeconds = 120f;

		private const float GhostChance = 1f / 120f;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void OnGhostNoise(WalkieTalkie __instance)
		{
			if (((GrabbableObject)__instance).isBeingUsed && !(((GrabbableObject)__instance).insertedBattery.charge <= 0f) && !((Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				float num = 1f / 120f * Time.deltaTime;
				if (!(Random.value > num))
				{
					AudioManager.Instance.PlayClip(AudioList.WalkieNoise);
					AudioManager.Instance.PlayClip(AudioList.WalkieGhost);
				}
			}
		}

		[HarmonyPatch("SwitchWalkieTalkieOn")]
		[HarmonyPostfix]
		public static void OnItemActivate(WalkieTalkie __instance)
		{
			if (!((GrabbableObject)__instance).isBeingUsed)
			{
				AudioManager.Instance.StopClip(AudioList.WalkieNoise);
				AudioManager.Instance.StopClip(AudioList.WalkieGhost);
			}
		}
	}
}
namespace ScaryCompany.audio
{
	public enum AudioCategory
	{
		Ambience,
		Entity,
		Miscellaneous,
		Random,
		Music,
		DoorSlam,
		LightFlicker
	}
	public class AudioList
	{
		private static int _currentIndex;

		public static readonly AudioList Ambience0 = new AudioList("ambience0.mp3", AudioCategory.Ambience, 0.3f, spatial: false);

		public static readonly AudioList Ambience1 = new AudioList("ambience1.mp3", AudioCategory.Ambience, 0.3f, spatial: false);

		public static readonly AudioList JesterChase = new AudioList("jester.mp3", AudioCategory.Entity);

		public static readonly AudioList JesterPop = new AudioList("jester_pop.mp3", AudioCategory.Entity);

		public static readonly AudioList FlowermanStalk = new AudioList("flowerman_stalk.ogg", AudioCategory.Entity, 0.1f, spatial: false);

		public static readonly AudioList FlowermanAnger = new AudioList("flowerman_anger.wav", AudioCategory.Entity);

		public static readonly AudioList Flicker0 = new AudioList("light_flicker0.mp3", AudioCategory.LightFlicker, 1f, spatial: false);

		public static readonly AudioList Flicker1 = new AudioList("light_flicker1.mp3", AudioCategory.LightFlicker, 1f, spatial: false);

		public static readonly AudioList WalkieNoise = new AudioList("radio_noise.wav", AudioCategory.Miscellaneous, 0.3f, spatial: false);

		public static readonly AudioList WalkieGhost = new AudioList("walkie_ghost.wav", AudioCategory.Miscellaneous, 0.1f, spatial: false);

		public static readonly AudioList DoorSlam0 = new AudioList("door_slam0.mp3", AudioCategory.DoorSlam);

		public static readonly AudioList DoorSlam1 = new AudioList("door_slam1.mp3", AudioCategory.DoorSlam);

		public static readonly AudioList Random0 = new AudioList("random0.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Random1 = new AudioList("random1.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Random2 = new AudioList("random2.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Random3 = new AudioList("random3.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Random4 = new AudioList("random4.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Random5 = new AudioList("random5.wav", AudioCategory.Random, 0.3f);

		public static readonly AudioList Music0 = new AudioList("music0.mp3", AudioCategory.Music);

		public string Filename { get; }

		public AudioCategory Category { get; }

		public int Index { get; }

		public float Volume { get; }

		public bool Spatial { get; }

		public static AudioList[] Values => new AudioList[19]
		{
			Ambience0, Ambience1, JesterChase, JesterPop, FlowermanStalk, FlowermanAnger, Flicker0, Flicker1, WalkieNoise, WalkieGhost,
			DoorSlam0, DoorSlam1, Random0, Random1, Random2, Random3, Random4, Random5, Music0
		};

		private AudioList(string filename, AudioCategory category, float volume = 1f, bool spatial = true)
		{
			Filename = filename;
			Category = category;
			Volume = volume;
			Spatial = spatial;
			Index = _currentIndex;
			_currentIndex++;
		}

		public override string ToString()
		{
			return Filename;
		}
	}
	[RequireComponent(typeof(AudioManager))]
	public class AudioManager : MonoBehaviour
	{
		private const float MinSoundDistance = 0.1f;

		private const float MaxSoundDistance = 50f;

		private const float DefaultPitch = 1f;

		public static AudioManager Instance;

		private readonly Dictionary<int, Coroutine> _activeFades = new Dictionary<int, Coroutine>();

		private AudioSource[] _audioSources = null;

		private GameObject[] _objects = null;

		public bool IsInitialized { get; private set; }

		private async void Awake()
		{
			Instance = this;
			ScaryCompany.Logger.LogInfo((object)"AudioManager: Awake starting...");
			try
			{
				AudioList[] audioData = AudioList.Values;
				_objects = (GameObject[])(object)new GameObject[audioData.Length];
				_audioSources = (AudioSource[])(object)new AudioSource[audioData.Length];
				ScaryCompany.Logger.LogInfo((object)$"AudioManager: Array initialized with size {audioData.Length}");
				for (int i = 0; i < audioData.Length; i++)
				{
					AudioList info = audioData[i];
					string path = Path.Combine(ScaryCompany.ModDirectory, info.Filename);
					ScaryCompany.Logger.LogInfo((object)("AudioManager: Awaiting load for " + info.Filename + "..."));
					AudioClip clip = await SoundLoader.LoadAudio(path);
					if ((Object)(object)clip != (Object)null)
					{
						GameObject newObject = new GameObject(info.Filename);
						_objects[i] = newObject;
						AudioSource newSource = newObject.AddComponent<AudioSource>();
						if ((Object)(object)newSource == (Object)null)
						{
							ScaryCompany.Logger.LogError((object)"AudioManager: Unity failed to AddComponent<AudioSource>!");
							continue;
						}
						newSource.clip = clip;
						newSource.playOnAwake = false;
						newSource.volume = info.Volume;
						newSource.spatialize = false;
						newSource.spatialBlend = (info.Spatial ? 1f : 0f);
						newSource.spread = (info.Spatial ? 0f : 360f);
						newSource.rolloffMode = (AudioRolloffMode)1;
						newSource.minDistance = 0.1f;
						newSource.maxDistance = 50f;
						AudioMixerGroup mixerGroup = (info.Spatial ? SoundManager.Instance.diageticMixer.outputAudioMixerGroup : SoundManager.Instance.ambienceAudioNonDiagetic.outputAudioMixerGroup);
						newSource.outputAudioMixerGroup = mixerGroup;
						_audioSources[i] = newSource;
						ScaryCompany.Logger.LogInfo((object)$"AudioManager: Slot {i} finalized for {info.Filename}");
					}
					else
					{
						ScaryCompany.Logger.LogWarning((object)$"AudioManager: Failed to get clip for {info.Filename}, skipping slot {i}");
					}
				}
				IsInitialized = true;
				ScaryCompany.Logger.LogInfo((object)"AudioManager: Initialization complete.");
			}
			catch (Exception ex)
			{
				Exception e = ex;
				ScaryCompany.Logger.LogError((object)$"AudioManager: Fatal error in Awake loop: {e}");
			}
		}

		private void PlayClip(AudioList clip, float pitch, bool loop, Vector3? position = null)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (_audioSources == null)
			{
				throw new NullReferenceException("_audioSources");
			}
			if (_audioSources[clip.Index].isPlaying)
			{
				return;
			}
			pitch = Mathf.Clamp(pitch, 0f, 2f);
			AudioSource val = _audioSources[clip.Index];
			val.pitch = pitch;
			val.loop = loop;
			if (position.HasValue)
			{
				if (!clip.Spatial)
				{
					ScaryCompany.Logger.LogWarning((object)"AudioManager: Playing a positioned, non-spatial sound!");
				}
				((Component)val).gameObject.transform.position = position.Value;
			}
			ScaryCompany.Logger.LogInfo((object)("Playing clip: " + clip.Filename + " at pitch: " + pitch + " loop: " + loop));
			val.Play();
		}

		public void PlayClip(AudioList clip, float pitch)
		{
			PlayClip(clip, pitch, loop: false);
		}

		public void PlayClipRandomPitch(AudioList clip, float maxPitchOffset)
		{
			float num = 1f - Random.Range(0f - maxPitchOffset, maxPitchOffset);
			num = Mathf.Clamp(num, 0f, 2f);
			PlayClip(clip, num, loop: false);
		}

		public void PlayClip(AudioList clip)
		{
			PlayClip(clip, 1f, loop: false);
		}

		public void LoopClip(AudioList clip, float pitch)
		{
			PlayClip(clip, pitch, loop: true);
		}

		public void LoopClip(AudioList clip)
		{
			PlayClip(clip, 1f, loop: true);
		}

		public void LoopRandomClip(AudioCategory category, float pitch)
		{
			AudioList[] array = AudioList.Values.Where((AudioList entry) => entry.Category == category).ToArray();
			if (array.Length != 0)
			{
				AudioList clip = array[Random.Range(0, array.Length)];
				PlayClip(clip, pitch, loop: true);
			}
		}

		public void LoopRandomClip(AudioCategory category)
		{
			LoopRandomClip(category, 1f);
		}

		public void StopClip(AudioList clip)
		{
			if (_audioSources == null)
			{
				throw new NullReferenceException("_audioSources");
			}
			if (_audioSources[clip.Index].isPlaying)
			{
				_audioSources[clip.Index].Stop();
			}
		}

		public void StopAll()
		{
			if (_audioSources == null)
			{
				throw new NullReferenceException("_audioSources");
			}
			AudioList[] values = AudioList.Values;
			foreach (AudioList clip in values)
			{
				StopClip(clip);
			}
		}

		public void StopAll(AudioCategory category)
		{
			if (_audioSources == null)
			{
				throw new NullReferenceException("_audioSources");
			}
			AudioList[] array = AudioList.Values.Where((AudioList entry) => entry.Category == category).ToArray();
			AudioList[] array2 = array;
			foreach (AudioList clip in array2)
			{
				StopClip(clip);
			}
		}

		public AudioClip GetClip(AudioList clip)
		{
			if (_audioSources != null)
			{
				return _audioSources[clip.Index].clip;
			}
			throw new NullReferenceException("_audioSources");
		}

		public void PlayClipPositioned(AudioCategory category, Vector3 targetPosition, float pitch = 1f)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (_audioSources == null)
			{
				throw new NullReferenceException("_audioSources");
			}
			AudioList randomClip = GetRandomClip(category);
			PlayClip(randomClip, pitch, loop: false, targetPosition);
		}

		public void FadeOut(AudioList clip, float duration)
		{
			int index = clip.Index;
			if (_audioSources[index].isPlaying)
			{
				if (_activeFades.ContainsKey(index))
				{
					((MonoBehaviour)this).StopCoroutine(_activeFades[index]);
					_activeFades.Remove(index);
				}
				_activeFades[index] = ((MonoBehaviour)this).StartCoroutine(FadeRoutine(_audioSources[index], 0f, duration, stopAtEnd: true, index));
			}
		}

		public void FadeIn(AudioList clip, float duration, float pitch = 1f, bool loop = false)
		{
			int index = clip.Index;
			AudioSource val = _audioSources[index];
			if (!val.isPlaying)
			{
				val.volume = 0f;
				val.pitch = pitch;
				val.loop = loop;
				val.Play();
			}
			if (_activeFades.ContainsKey(index))
			{
				((MonoBehaviour)this).StopCoroutine(_activeFades[index]);
				_activeFades.Remove(index);
			}
			_activeFades[index] = ((MonoBehaviour)this).StartCoroutine(FadeRoutine(val, clip.Volume, duration, stopAtEnd: false, index));
		}

		private IEnumerator FadeRoutine(AudioSource source, float targetVolume, float duration, bool stopAtEnd, int index)
		{
			float startVolume = source.volume;
			float elapsed = 0f;
			while (elapsed < duration)
			{
				elapsed += Time.deltaTime;
				source.volume = Mathf.Lerp(startVolume, targetVolume, elapsed / duration);
				yield return null;
			}
			source.volume = targetVolume;
			if (stopAtEnd && targetVolume <= 0f)
			{
				source.Stop();
			}
			_activeFades.Remove(index);
		}

		public static AudioList GetRandomClip(AudioCategory category)
		{
			AudioList[] array = AudioList.Values.Where((AudioList entry) => entry.Category == category).ToArray();
			if (array.Length != 0)
			{
				return array[Random.Range(0, array.Length)];
			}
			throw new InvalidOperationException($"No clips found for category {category}");
		}
	}
	public static class SoundLoader
	{
		public static async Task<AudioClip> LoadAudio(string path)
		{
			ScaryCompany.Logger.LogInfo((object)("[SoundLoader] Loading " + path));
			string uri = "file:///" + path.Replace("\\", "/");
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(uri, GetAudioType(path));
			try
			{
				UnityWebRequestAsyncOperation operation = request.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				if ((int)request.result != 1)
				{
					ScaryCompany.Logger.LogError((object)("[SoundLoader] Failed: " + request.error));
					return null;
				}
				AudioClip clip = DownloadHandlerAudioClip.GetContent(request);
				((Object)clip).name = Path.GetFileName(path);
				return clip;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static AudioType GetAudioType(string path)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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)
			string text = Path.GetExtension(path).ToLower();
			if (1 == 0)
			{
			}
			AudioType result = (AudioType)(text switch
			{
				".wav" => 20, 
				".ogg" => 14, 
				".mp3" => 13, 
				_ => 0, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
}