using System;
using System.Collections;
using System.Diagnostics;
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 LCSimonTendoPlaylistsMod.Patches;
using Microsoft.CodeAnalysis;
using STSharedAudioLib;
using UnityEngine;

[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: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("LCSimonTendoPlaylistsMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Creates playlists for objects that get sounds from multiple mods of mine.")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1")]
[assembly: AssemblyProduct("LCSimonTendoPlaylistsMod")]
[assembly: AssemblyTitle("LCSimonTendoPlaylistsMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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 LCSimonTendoPlaylistsMod
{
	public class Configs
	{
		public static ConfigEntry<bool> Examples;

		public Configs(ConfigFile cfg)
		{
			Examples = cfg.Bind<bool>("Examples", "Add Extra Songs", false, "If true, adds some Boombox songs to the Disco Ball and Record Player, to demonstrate how this mod and STSharedAudioLib work.");
		}
	}
	public class PlaylistsManager : MonoBehaviour
	{
		private static ManualLogSource Logger;

		public static PlaylistsManager Instance;

		public AudioSource audio2D;

		private Coroutine fadeOutMusicCoroutine;

		private void Awake()
		{
			Instance = this;
			Logger = Plugin.Logger;
			audio2D = ((Component)this).gameObject.AddComponent<AudioSource>();
			audio2D.playOnAwake = false;
			audio2D.dopplerLevel = 0f;
			audio2D.spatialBlend = 0f;
			audio2D.loop = true;
		}

		public void StartLoadingMusic()
		{
			if (!((Object)(object)StartOfRoundPatch.LoadingScreenPlaylist == (Object)null) && StartOfRoundPatch.LoadingScreenPlaylist.weightedClipsList != null && StartOfRoundPatch.LoadingScreenPlaylist.weightedClipsList.Count != 0)
			{
				if (fadeOutMusicCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(fadeOutMusicCoroutine);
					fadeOutMusicCoroutine = null;
				}
				if (audio2D.isPlaying)
				{
					audio2D.Stop();
				}
				audio2D.clip = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.LoadingScreenPlaylist, true);
				audio2D.volume = 1f;
				audio2D.Play();
			}
		}

		public void StopLoadingMusic()
		{
			if (fadeOutMusicCoroutine == null)
			{
				fadeOutMusicCoroutine = ((MonoBehaviour)this).StartCoroutine(FadeOutMusic());
			}
		}

		private IEnumerator FadeOutMusic()
		{
			while (audio2D.volume > 0.1f)
			{
				AudioSource obj = audio2D;
				obj.volume -= Time.deltaTime * 0.067f;
				yield return null;
			}
			audio2D.volume = 0f;
			audio2D.Stop();
			fadeOutMusicCoroutine = null;
		}
	}
	[BepInPlugin("LCSimonTendoPlaylistsMod", "LCSimonTendoPlaylistsMod", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static Configs MyConfig { get; internal set; }

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin LCSimonTendoPlaylistsMod is loaded!");
			new Harmony("LCSimonTendoPlaylistsMod").PatchAll();
			MyConfig = new Configs(((BaseUnityPlugin)this).Config);
			if (Configs.Examples.Value)
			{
				Logger.LogInfo((object)"Config [Examples] is set to TRUE. A few boombox songs will be added to the Disco Ball and Record Player.");
			}
		}

		public static void PrintNewAudioClip(GameObject objectPlaying, AudioClip clipPlaying)
		{
			if ((Object)(object)objectPlaying == (Object)null)
			{
				Logger.LogWarning((object)"PrintNewAudioClip() received null: OBJECT");
			}
			else if ((Object)(object)clipPlaying == (Object)null)
			{
				Logger.LogWarning((object)"PrintNewAudioClip() received null: CLIP");
			}
			else
			{
				Logger.LogDebug((object)(((Object)objectPlaying).name + " - now playing: " + ((Object)clipPlaying).name));
			}
		}

		public static GameObject SearchForObject(string name, Transform parentTransform = null)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Logger.LogDebug((object)("Starting search for " + name));
			GameObject[] array = Object.FindObjectsByType<GameObject>((FindObjectsSortMode)0);
			GameObject[] array2 = array;
			GameObject result;
			foreach (GameObject val in array2)
			{
				if (((Object)val).name == name)
				{
					result = val;
					Logger.LogDebug((object)("Found existing " + ((Object)val).name + ", using as parent."));
					return result;
				}
			}
			result = new GameObject(name);
			if ((Object)(object)parentTransform != (Object)null)
			{
				result.transform.SetParent(parentTransform, false);
			}
			Logger.LogDebug((object)("Did not find existing " + name + ", instantiating new " + ((Object)result).name));
			return result;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LCSimonTendoPlaylistsMod";

		public const string PLUGIN_NAME = "LCSimonTendoPlaylistsMod";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}
namespace LCSimonTendoPlaylistsMod.Patches
{
	public class AnimatedItemPatch
	{
		[HarmonyPatch]
		public class NewAnimatedItem
		{
			[HarmonyPrefix]
			[HarmonyPatch(typeof(AnimatedItem), "Start")]
			public static void StartPostfix(AnimatedItem __instance)
			{
				if (((Object)((Component)__instance).gameObject).name == "OldPhone(Clone)")
				{
					__instance.grabAudio = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.OldPhonePlaylist, false);
					Plugin.PrintNewAudioClip(((Component)__instance).gameObject, __instance.grabAudio);
				}
				else if (((Object)((Component)__instance).gameObject).name == "RobotToy(Clone)")
				{
					__instance.grabAudio = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.ToyRobotPlaylist, false);
					Plugin.PrintNewAudioClip(((Component)__instance).gameObject, __instance.grabAudio);
				}
			}
		}
	}
	public class AnimatedObjectTriggerPatch
	{
		[HarmonyPatch]
		public class NewAnimatedObjectTrigger
		{
			[HarmonyPrefix]
			[HarmonyPatch(typeof(AnimatedObjectTrigger), "PlayAudio")]
			public static void PlayAudioPrefix(AnimatedObjectTrigger __instance)
			{
				Transform parent = ((Component)__instance).gameObject.transform.parent;
				if (((parent != null) ? ((Object)parent).name : null) == "RecordPlayerContainer(Clone)" && !__instance.thisAudioSource.isPlaying)
				{
					AudioClip playWhileTrue = SharedAudioMethods.AudioClipGetNextInAudioList(__instance.playWhileTrue, StartOfRoundPatch.RecordPlayerPlaylist, false);
					__instance.playWhileTrue = playWhileTrue;
					Plugin.PrintNewAudioClip(((Component)((Component)__instance).transform.parent).gameObject, __instance.playWhileTrue);
				}
				Transform parent2 = ((Component)__instance).gameObject.transform.parent;
				if (((parent2 != null) ? ((Object)parent2).name : null) == "PlushiePJManContainer(Clone)")
				{
					__instance.boolFalseAudios[0] = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.PlushiePlaylist, false);
					Plugin.PrintNewAudioClip(((Component)((Component)__instance).transform.parent).gameObject, __instance.boolFalseAudios[0]);
				}
				Transform parent3 = ((Component)__instance).gameObject.transform.parent;
				if (((parent3 != null) ? ((Object)parent3).name : null) == "PumpkinUnlockableContainer(Clone)")
				{
					__instance.boolFalseAudios[0] = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.PumpkinPlaylist, false);
					Plugin.PrintNewAudioClip(((Component)((Component)__instance).transform.parent).gameObject, __instance.boolFalseAudios[0]);
				}
			}
		}
	}
	public class CozyLightsPatch
	{
		[HarmonyPatch]
		public class NewCozyLights
		{
			[HarmonyPrefix]
			[HarmonyPatch(typeof(CozyLights), "SetAudio")]
			public static void SetAudioPrefix(CozyLights __instance, bool ___cozyLightsOn)
			{
				Transform parent = ((Component)__instance).gameObject.transform.parent;
				if (((parent != null) ? ((Object)parent).name : null) == "DiscoBallContainer(Clone)" && ___cozyLightsOn && !__instance.turnOnAudio.isPlaying)
				{
					AudioClip clip = SharedAudioMethods.AudioClipGetNextInAudioList(__instance.turnOnAudio.clip, StartOfRoundPatch.DiscoBallPlaylist, false);
					__instance.turnOnAudio.clip = clip;
					Plugin.PrintNewAudioClip(((Component)((Component)__instance).transform.parent).gameObject, __instance.turnOnAudio.clip);
				}
			}
		}
	}
	public class RoundManagerPatch
	{
		[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoad")]
		public class NewStartOfRoundSceneManagerOnLoad
		{
			[HarmonyPrefix]
			public static void StartLoadingScreenMusic()
			{
				if ((Object)(object)PlaylistsManager.Instance != (Object)null)
				{
					PlaylistsManager.Instance.StartLoadingMusic();
				}
			}
		}

		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingNewLevelClientRpc")]
		public class NewRoundManagerFinishGeneratingNewLevelClientRpc
		{
			[HarmonyPostfix]
			public static void StopLoadingScreenMusic()
			{
				if ((Object)(object)PlaylistsManager.Instance != (Object)null)
				{
					PlaylistsManager.Instance.StopLoadingMusic();
				}
			}
		}
	}
	public class ShipBuildModeManagerPatch
	{
		[HarmonyPatch]
		public class NewShipBuildModeManager
		{
			[HarmonyPrefix]
			[HarmonyPatch(typeof(ShipBuildModeManager), "PlaceShipObject")]
			public static void PlaceShipObjectPrefix(ref PlaceableShipObject placeableObject)
			{
				Transform parent = ((Component)placeableObject).gameObject.transform.parent;
				if (((parent != null) ? ((Object)parent).name : null) == "PlushiePJManContainer(Clone)")
				{
					placeableObject.placeObjectSFX = SharedAudioMethods.AudioClipGetRandomByWeight(StartOfRoundPatch.PlushiePlaylist, false);
					Plugin.PrintNewAudioClip(((Component)((Component)placeableObject).transform.parent).gameObject, placeableObject.placeObjectSFX);
				}
			}
		}
	}
	public class StartOfRoundPatch
	{
		[HarmonyPatch]
		public class NewStartOfRound
		{
			[HarmonyPostfix]
			[HarmonyPatch(typeof(StartOfRound), "Awake")]
			public static void AwakePostfix(StartOfRound __instance)
			{
				//IL_0401: Unknown result type (might be due to invalid IL or missing references)
				//IL_0407: Expected O, but got Unknown
				if (!alreadyAddedToOrigins)
				{
					alreadyAddedToOrigins = true;
					foreach (Item items in __instance.allItemsList.itemsList)
					{
						if (((Object)items).name == "Phone")
						{
							OldPhonePlaylist = SharedAudioMethods.AudioListCreateNew(items.spawnPrefab, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(items.spawnPrefab.GetComponent<AnimatedItem>().grabAudio, OldPhonePlaylist, true, 100, false);
						}
						else if (((Object)items).name == "RobotToy")
						{
							ToyRobotPlaylist = SharedAudioMethods.AudioListCreateNew(items.spawnPrefab, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(items.spawnPrefab.GetComponent<AnimatedItem>().grabAudio, ToyRobotPlaylist, true, 100, false);
						}
					}
					foreach (UnlockableItem unlockable in __instance.unlockablesList.unlockables)
					{
						if (unlockable.unlockableName == "Disco Ball")
						{
							DiscoBallPlaylist = SharedAudioMethods.AudioListCreateNew(unlockable.prefabObject, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(((Component)unlockable.prefabObject.transform.GetChild(0)).GetComponent<CozyLights>().turnOnAudio.clip, DiscoBallPlaylist, false, 100, false);
							if (Configs.Examples.Value)
							{
								SharedAudioMethods.AudioClipAddNew(__instance.allItemsList.itemsList[1].spawnPrefab.GetComponent<BoomboxItem>().musicAudios[2], DiscoBallPlaylist, true, 100, false);
								SharedAudioMethods.AudioClipAddNew(__instance.allItemsList.itemsList[1].spawnPrefab.GetComponent<BoomboxItem>().musicAudios[4], DiscoBallPlaylist, true, 100, false);
							}
						}
						else if (unlockable.unlockableName == "Record player")
						{
							RecordPlayerPlaylist = SharedAudioMethods.AudioListCreateNew(unlockable.prefabObject, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(((Component)unlockable.prefabObject.transform.GetChild(3)).GetComponent<AnimatedObjectTrigger>().playWhileTrue, RecordPlayerPlaylist, true, 100, false);
							if (Configs.Examples.Value)
							{
								SharedAudioMethods.AudioClipAddNew(__instance.allItemsList.itemsList[1].spawnPrefab.GetComponent<BoomboxItem>().musicAudios[0], RecordPlayerPlaylist, true, 100, false);
								SharedAudioMethods.AudioClipAddNew(__instance.allItemsList.itemsList[1].spawnPrefab.GetComponent<BoomboxItem>().musicAudios[1], RecordPlayerPlaylist, true, 100, false);
								SharedAudioMethods.AudioClipAddNew(__instance.allItemsList.itemsList[1].spawnPrefab.GetComponent<BoomboxItem>().musicAudios[3], RecordPlayerPlaylist, true, 100, false);
							}
						}
						else if (unlockable.unlockableName == "Plushie pajama man")
						{
							PlushiePlaylist = SharedAudioMethods.AudioListCreateNew(unlockable.prefabObject, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(((Component)unlockable.prefabObject.transform.GetChild(2)).GetComponent<AnimatedObjectTrigger>().boolFalseAudios[0], PlushiePlaylist, true, 100, false);
						}
						else if (unlockable.unlockableName == "JackOLantern")
						{
							PumpkinPlaylist = SharedAudioMethods.AudioListCreateNew(unlockable.prefabObject, true, "LCSimonTendoPlaylistsMod", 100);
							SharedAudioMethods.AudioClipAddNew(((Component)unlockable.prefabObject.transform.GetChild(2)).GetComponent<AnimatedObjectTrigger>().boolFalseAudios[0], PumpkinPlaylist, true, 100, false);
						}
					}
				}
				GameObject val = Plugin.SearchForObject("SimonTendoManagers", ((Component)__instance).transform.parent);
				GameObject val2 = new GameObject("LCSimonTendoPlaylistsMod");
				val2.transform.SetParent(val.transform);
				val2.AddComponent<PlaylistsManager>();
				GenericPlaylistsContainer = SharedAudioMethods.GetSharedAudioComponent(val2, true, (string)null, 0, false);
				LoadingScreenPlaylist = SharedAudioMethods.AudioListCreateNew(GenericPlaylistsContainer, true, "LCSimonTendoPlaylistsMod - Loading Screen", 100);
			}
		}

		private static bool alreadyAddedToOrigins;

		public static AudioList OldPhonePlaylist;

		public static AudioList ToyRobotPlaylist;

		public static AudioList DiscoBallPlaylist;

		public static AudioList RecordPlayerPlaylist;

		public static AudioList PlushiePlaylist;

		public static AudioList PumpkinPlaylist;

		public static SharedAudioComponent GenericPlaylistsContainer;

		public static AudioList LoadingScreenPlaylist;
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}