using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using Discord;
using HarmonyLib;
using Jukebox.Components;
using Jukebox.Input;
using Jukebox.UI;
using Jukebox.UI.Elements;
using Jukebox.UI.Windows;
using Jukebox.Utils;
using JukeboxCore.Assets;
using JukeboxCore.Collections;
using JukeboxCore.Components;
using JukeboxCore.Models.Preferences;
using JukeboxCore.Models.Song;
using JukeboxCore.Utils;
using Newtonsoft.Json;
using SettingsMenu.Components;
using SettingsMenu.Components.Pages;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Jukebox")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Jukebox")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B01B8657-61B6-4BC3-BFAF-F43D4C264B4B")]
[assembly: AssemblyFileVersion("2.1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.1.0.0")]
namespace Jukebox
{
	[BepInProcess("ULTRAKILL.exe")]
	[BepInPlugin("dev.flazhik.jukebox", "Jukebox", "2.1.0")]
	public class JukeboxPlugin : BaseUnityPlugin
	{
		[ExternalAsset("Assets/Jukebox/Bootstrap.prefab", typeof(GameObject))]
		private static GameObject _bootstrap;

		private static readonly string CatalogDir;

		private static Harmony _harmony;

		private static bool _motDShown;

		private static bool _init;

		static JukeboxPlugin()
		{
			CatalogDir = Path.Combine(PathsUtils.AssemblyPath, "Assets");
		}

		private void Awake()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_004b: Expected O, but got Unknown
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			Addressables.InitializeAsync().WaitForCompletion();
			Addressables.LoadContentCatalogAsync(Path.Combine(CatalogDir, "catalog.json"), true, (string)null).WaitForCompletion();
			_harmony = new Harmony("dev.flazhik.jukebox");
			Startup();
		}

		private void Startup()
		{
			_harmony.PatchAll();
			FileInfo fileInfo = new FileInfo(Path.Combine(PathsUtils.AssemblyPath, "cookies.txt"));
			if (fileInfo.Exists)
			{
				fileInfo.Delete();
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (scene != SceneManager.GetActiveScene())
			{
				return;
			}
			switch (SceneHelper.CurrentScene)
			{
			case "Bootstrap":
				SetDefaultPrefsValues();
				break;
			case "Main Menu":
				if (!_init)
				{
					MonoSingleton<AssetsManager>.Instance.LoadAssets(Resources.Jukebox);
					MonoSingleton<AssetsManager>.Instance.RegisterPrefabs(Assembly.GetExecutingAssembly());
					_init = true;
				}
				break;
			case "Endless":
				Object.Instantiate<GameObject>(_bootstrap);
				if (!_motDShown)
				{
					((MonoBehaviour)MonoSingleton<JukeboxManager>.Instance).StartCoroutine(MotD());
				}
				break;
			}
		}

		private static void SetDefaultPrefsValues()
		{
			foreach (KeyValuePair<string, object> item in new Dictionary<string, object>
			{
				{ "jukebox.volumeBoost", 0f },
				{ "jukebox.individualBoostPerTrack", false },
				{ "jukebox.showTrackPanelIndefinitely", false },
				{ "jukebox.alwaysPlayIntro", true },
				{ "jukebox.discordAndSteamIntegration", true },
				{ "jukebox.enableTracksPreview", true },
				{ "jukebox.preventDuplicateTracks", false },
				{ "jukebox.nowPlayingHud", true },
				{ "jukebox.enableCalmThemes", true },
				{ "jukebox.songPanelStyle", 0 },
				{ "jukebox.currentPlaylist", "slot1" },
				{ "jukebox.calmThemeEnemiesThreshold", 2 },
				{ "jukebox.effects.parry", null },
				{ "jukebox.effects.wavecomplete", null },
				{ "jukebox.effects.gameover", null },
				{ "jukebox.effects.aww", null },
				{ "jukebox.effects.terminal-music", null },
				{ "jukebox.downloader.separateFolderPerPlaylist", true }
			})
			{
				MonoSingleton<PrefsManager>.Instance.defaultValues.Add(item.Key, item.Value);
			}
		}

		private static IEnumerator MotD()
		{
			yield return (object)new WaitForSeconds(1.5f);
			InputAction menu = MonoSingleton<JukeboxInputs>.Instance.Menu;
			string text = GeneralExtensions.Join<InputBinding>((IEnumerable<InputBinding>)(object)menu.bindings, (Func<InputBinding, string>)((InputBinding binding) => InputExtensions.GetBindingDisplayStringWithoutOverride(menu, binding, (DisplayStringOptions)0)), ", ");
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Jukebox menu is available by pressing <color=orange>" + text + "</color>", "", "", 0, false, false, true);
			_motDShown = true;
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "dev.flazhik.jukebox";

		public const string NAME = "Jukebox";

		public const string VERSION = "2.1.0";
	}
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("Jukebox.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] Jukebox => (byte[])ResourceManager.GetObject("Jukebox", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace Jukebox.Utils
{
	public static class FloatExtensions
	{
		public static string SecondsToHumanReadable(this float value)
		{
			int num = (int)value;
			int num2 = num / 60;
			int num3 = num - num2 * 60;
			return $"{num2:00}:{num3:00}";
		}
	}
	public static class IntExtensions
	{
		public static int Mod(this int num, int mod)
		{
			return (num % mod + mod) % mod;
		}
	}
	public abstract class ReflectionUtils
	{
		private const BindingFlags PrivateFields = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static T GetPrivate<T>(object instance, Type classType, string field)
		{
			FieldInfo field2 = classType.GetField(field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return (T)((field2 != null) ? field2.GetValue(instance) : null);
		}

		public static void SetPrivate<T, TV>(T instance, Type classType, string field, TV value)
		{
			FieldInfo field2 = classType.GetField(field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField);
			if (field2 != null)
			{
				field2.SetValue(instance, value);
			}
		}
	}
	public static class ScrollingTextUnscaled
	{
		public static IEnumerator ShowText(TMP_Text text, string message, float secondsBetweenLetters = 0.005f, AudioSource clickAudio = null)
		{
			int currentLetter = 0;
			text.text = "";
			while (currentLetter < message.Length)
			{
				int num;
				if (message[currentLetter] == '<')
				{
					while (message[currentLetter] != '>' && currentLetter <= message.Length)
					{
						num = currentLetter + 1;
						currentLetter = num;
					}
				}
				else if (currentLetter < message.Length - 1)
				{
					while (currentLetter < message.Length - 1 && message[currentLetter + 1] == ' ')
					{
						num = currentLetter + 1;
						currentLetter = num;
					}
				}
				num = currentLetter + 1;
				currentLetter = num;
				text.text = message.Substring(0, currentLetter);
				if ((Object)(object)clickAudio != (Object)null && message[currentLetter - 1] != '\n' && message[currentLetter - 1] != ' ')
				{
					clickAudio.Play();
				}
				yield return (object)new WaitForSecondsRealtime(secondsBetweenLetters);
			}
		}

		public static IEnumerator HideText(TMP_Text text, float secondsBetweenLetters = 0.005f)
		{
			int currentLetter = text.text.Length - 1;
			string message = text.text;
			while (currentLetter >= 0)
			{
				int num;
				if (text.text[currentLetter] == '>')
				{
					while (text.text[currentLetter] != '<' && currentLetter >= 0)
					{
						num = currentLetter - 1;
						currentLetter = num;
					}
				}
				num = currentLetter - 1;
				currentLetter = num;
				text.text = message.Substring(0, currentLetter + 1);
				yield return (object)new WaitForSecondsRealtime(secondsBetweenLetters);
			}
		}
	}
}
namespace Jukebox.UI
{
	public class JukeboxCredits : MonoBehaviour
	{
		[SerializeField]
		private TMP_Text[] terminalText;

		[SerializeField]
		private AudioSource click;

		[SerializeField]
		private GameObject firstWindow;

		[SerializeField]
		private GameObject secondWindow;

		[SerializeField]
		private List<GameObject> lastWindows;

		private string[] originalText;

		private void Awake()
		{
			originalText = terminalText.Select((TMP_Text t) => t.text).ToArray();
		}

		private void OnEnable()
		{
			firstWindow.SetActive(false);
			secondWindow.SetActive(false);
			foreach (GameObject lastWindow in lastWindows)
			{
				lastWindow.SetActive(false);
			}
			TMP_Text[] array = terminalText;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].text = string.Empty;
			}
			((MonoBehaviour)this).StartCoroutine(WindowsRoutine());
		}

		private IEnumerator WindowsRoutine()
		{
			yield return TerminalTextRoutine(0);
			firstWindow.SetActive(true);
			yield return TerminalTextRoutine(1);
			yield return TerminalTextRoutine(2);
			secondWindow.SetActive(true);
			yield return TerminalTextRoutine(3);
			yield return TerminalTextRoutine(4);
			foreach (GameObject lastWindow in lastWindows)
			{
				lastWindow.SetActive(true);
			}
		}

		private IEnumerator TerminalTextRoutine(int index)
		{
			return ScrollingTextUnscaled.ShowText(terminalText[index], originalText[index], 0.01f, click);
		}
	}
	public class JukeboxCustomContentButton : CustomContentButton
	{
		[SerializeField]
		public GameObject introAndLoopIcon;

		[SerializeField]
		public GameObject calmThemeIcon;
	}
	public class JukeboxUI : MonoBehaviour
	{
		[SerializeField]
		public GameObject jukeboxMenuTemplate;

		[SerializeField]
		public GameObject playbackMenuTemplate;

		[SerializeField]
		public GameObject nowPlayingHudTemplate;

		[SerializeField]
		public GameObject nowPlayingHudClassicTemplate;

		private GameObject jukeboxMenu;

		private GameObject playbackMenu;

		private ReadOnlyCollection<JukeboxWindow> windows;

		public void OpenDownloader()
		{
			JukeboxMenuWindow component = jukeboxMenu.GetComponent<JukeboxMenuWindow>();
			component.Open();
			component.OpenDownloader();
		}

		protected void Awake()
		{
			InstantiateUI();
			windows = new ReadOnlyCollection<JukeboxWindow>(new List<JukeboxWindow>
			{
				jukeboxMenu.GetComponent<JukeboxWindow>(),
				playbackMenu.GetComponent<JukeboxPlaybackWindow>()
			});
			foreach (JukeboxWindow window in windows)
			{
				((Component)window).gameObject.SetActive(false);
			}
		}

		protected void Update()
		{
			ManageWindows();
		}

		private void ManageWindows()
		{
			if (GameIsPaused())
			{
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Pause.WasPerformedThisFrame)
			{
				foreach (JukeboxWindow window in windows)
				{
					if (window.IsOpened())
					{
						window.Close();
					}
				}
				return;
			}
			JukeboxWindow jukeboxWindow = windows.FirstOrDefault((JukeboxWindow w) => w.hotkey.ToInputAction().WasPerformedThisFrame());
			if ((Object)(object)jukeboxWindow != (Object)null)
			{
				foreach (JukeboxWindow window2 in windows)
				{
					if (InputExtensions.IsActionEqual(window2.hotkey.ToInputAction(), jukeboxWindow.hotkey.ToInputAction(), (string)null))
					{
						window2.Toggle();
					}
					else
					{
						window2.Close();
					}
				}
			}
			if (!windows.Any((JukeboxWindow w) => GameStateManager.Instance.IsStateActive(w.StateKey())) && MonoSingleton<OptionsManager>.Instance.paused)
			{
				MonoSingleton<JukeboxPauseManager>.Instance.UnPause();
			}
		}

		private void InstantiateUI()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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)
			GameObject val = new GameObject
			{
				name = "JukeboxCanvas"
			};
			val.AddComponent<Canvas>();
			GameObject val2 = GameObject.Find("/Canvas");
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)1;
			component.sortingOrder = val2.GetComponent<Canvas>().sortingOrder + 1;
			val.AddComponent<CanvasScaler>();
			val.AddComponent<GraphicRaycaster>();
			jukeboxMenu = Object.Instantiate<GameObject>(jukeboxMenuTemplate, val2.transform);
			playbackMenu = Object.Instantiate<GameObject>(playbackMenuTemplate, val2.transform);
			Object.Instantiate<GameObject>(nowPlayingHudTemplate, GameObject.Find("/Player/Main Camera/HUD Camera/HUD/GunCanvas").transform, false);
			Object.Instantiate<GameObject>(nowPlayingHudClassicTemplate, val2.transform.Find("Crosshair Filler"), false);
		}

		private static bool GameIsPaused()
		{
			return GameStateManager.Instance.IsStateActive("pause");
		}
	}
	public class ScrollUIImageUnscaled : MonoBehaviour
	{
		private RawImage img;

		public float xSpeed;

		public float ySpeed;

		private void Start()
		{
			img = ((Component)this).GetComponent<RawImage>();
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			Rect uvRect = img.uvRect;
			Vector2 val = ((Rect)(ref uvRect)).position + new Vector2(xSpeed, ySpeed) * Time.unscaledDeltaTime;
			while ((double)val.x > 1.0)
			{
				val.x -= 1f;
			}
			while ((double)val.x < -1.0)
			{
				val.x += 1f;
			}
			while ((double)val.y > 1.0)
			{
				val.y -= 1f;
			}
			while ((double)val.y < -1.0)
			{
				val.y += 1f;
			}
			RawImage obj = img;
			uvRect = img.uvRect;
			Vector2 val2 = ((Rect)(ref uvRect)).position + new Vector2(xSpeed, ySpeed) * Time.unscaledDeltaTime;
			uvRect = img.uvRect;
			obj.uvRect = new Rect(val2, ((Rect)(ref uvRect)).size);
		}
	}
}
namespace Jukebox.UI.Windows
{
	public class JukeboxMenuWindow : JukeboxWindow
	{
		[SerializeField]
		protected Button[] buttons;

		[SerializeField]
		protected GameObject activeBgObject;

		[SerializeField]
		protected GameObject generalSettings;

		[SerializeField]
		protected Button downloaderButton;

		[SerializeField]
		protected GameObject downloaderPage;

		public override string StateKey()
		{
			return "jukeboxMenu";
		}

		protected override void Awake()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			base.Awake();
			Button[] array = buttons;
			foreach (Button button in array)
			{
				((UnityEvent)button.onClick).AddListener((UnityAction)delegate
				{
					SetActiveButton(button);
				});
			}
			JukeboxMusicPlayer.OnNextSong += OnNextSong;
		}

		public void OnNextSong(JukeboxSong song)
		{
			if (song.IsCustom)
			{
				ReflectionUtils.GetPrivate<Slider>(generalSettings.GetComponentInChildren<SettingsSlider>(true), typeof(SettingsSlider), "slider").value = MonoSingleton<JukeboxManager>.Instance.player.VolumeBoost;
			}
		}

		public void OpenDownloader()
		{
			SettingsMenu component = ((Component)this).gameObject.GetComponent<SettingsMenu>();
			if (!ReflectionUtils.GetPrivate<bool>(component, typeof(SettingsMenu), "initialized"))
			{
				component.Initialize();
			}
			component.SetActivePage(downloaderPage);
			SetActiveButton(downloaderButton);
		}

		protected void OnDestroy()
		{
			JukeboxMusicPlayer.OnNextSong -= OnNextSong;
		}

		private void SetActiveButton(Button button)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			activeBgObject.transform.SetParent(((Component)button).transform);
			activeBgObject.transform.SetSiblingIndex(0);
			activeBgObject.transform.localPosition = Vector3.zero;
		}
	}
	public class JukeboxPlaybackWindow : JukeboxWindow
	{
		public override string StateKey()
		{
			return "jukeboxPlayback";
		}
	}
	public abstract class JukeboxWindow : MonoBehaviour
	{
		[SerializeField]
		public InputActionReference hotkey;

		public abstract string StateKey();

		public void Open()
		{
			((Component)this).gameObject.SetActive(true);
			MonoSingleton<JukeboxPauseManager>.Instance.Pause(StateKey(), ((Component)this).gameObject);
		}

		public void Close()
		{
			GameStateManager.Instance.PopState(StateKey());
			((Component)this).gameObject.SetActive(false);
		}

		public void Toggle()
		{
			if (IsOpened())
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		protected virtual void Awake()
		{
			if ((Object)(object)hotkey != (Object)null)
			{
				hotkey = InputActionReference.Create(MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindAction(hotkey.ToInputAction().id));
			}
		}

		public bool IsOpened()
		{
			return ((Component)this).gameObject.activeSelf;
		}
	}
}
namespace Jukebox.UI.Themes
{
	public class ThemeEnemySettings : MonoBehaviour
	{
		[SerializeField]
		public TMP_Text title;

		[SerializeField]
		public Image icon;

		[SerializeField]
		public GameObject radianceBg;

		[SerializeField]
		public Toggle toggle;

		[SerializeField]
		public Counter counter;
	}
	public class ThemeSettingsMenu : MonoBehaviour
	{
		[SerializeField]
		private Counter threshold;

		[SerializeField]
		private GameObject enemyTemplate;

		[SerializeField]
		private GameObject regularEnemies;

		[SerializeField]
		private GameObject radiantEnemies;

		[SerializeField]
		private Button[] tabButtons;

		[SerializeField]
		private GameObject activeTab;

		[SerializeField]
		private List<AssetReferenceT<SpawnableObject>> enemies;

		private void Awake()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			JukeboxThemesManager themesManager = MonoSingleton<JukeboxThemesManager>.Instance;
			threshold.SetDefaultValue(MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.calmThemeEnemiesThreshold", 0));
			threshold.OnChanged += OnThresholdChanged;
			Button[] array = tabButtons;
			foreach (Button button in array)
			{
				((UnityEvent)button.onClick).AddListener((UnityAction)delegate
				{
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					activeTab.transform.SetParent(((Component)button).transform);
					activeTab.transform.SetSiblingIndex(0);
					activeTab.transform.localPosition = Vector3.zero;
				});
			}
			foreach (AssetReferenceT<SpawnableObject> enemy2 in enemies)
			{
				AsyncOperationHandle<SpawnableObject> val = enemy2.LoadAssetAsync();
				SpawnableObject enemy = val.WaitForCompletion();
				Addressables.Release<SpawnableObject>(val);
				Dictionary<bool, ThemeEnemySettings> respectiveSettings = new Dictionary<bool, ThemeEnemySettings>();
				GameObject[] array2 = (GameObject[])(object)new GameObject[2] { regularEnemies, radiantEnemies };
				foreach (GameObject val2 in array2)
				{
					GameObject val3 = Object.Instantiate<GameObject>(enemyTemplate, val2.transform);
					bool radiant = (Object)(object)val2 == (Object)(object)radiantEnemies;
					Sprite gridIcon = enemy.gridIcon;
					ThemeEnemySettings enemySettings = val3.GetComponent<ThemeEnemySettings>();
					enemySettings.icon.sprite = gridIcon;
					enemySettings.title.text = (radiant ? ("Radiant " + enemy.objectName) : enemy.objectName);
					enemySettings.radianceBg.SetActive(radiant);
					int? thresholdFor = themesManager.GetThresholdFor(enemy.enemyType, radiant);
					if (!thresholdFor.HasValue)
					{
						enemySettings.counter.SetDefaultValue(0);
					}
					else
					{
						enemySettings.counter.SetDefaultValue(thresholdFor.Value);
					}
					enemySettings.toggle.isOn = thresholdFor.HasValue;
					enemySettings.counter.OnChanged += delegate(int value)
					{
						//IL_002c: Unknown result type (might be due to invalid IL or missing references)
						enemySettings.toggle.isOn = true;
						themesManager.SetThresholdFor(enemy.enemyType, value, radiant);
					};
					((UnityEvent<bool>)(object)enemySettings.toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool on)
					{
						//IL_005a: Unknown result type (might be due to invalid IL or missing references)
						//IL_001e: Unknown result type (might be due to invalid IL or missing references)
						if (on)
						{
							themesManager.SetThresholdFor(enemy.enemyType, enemySettings.counter.Value, radiant);
						}
						else
						{
							themesManager.DisableThresholdFor(enemy.enemyType, radiant);
						}
					});
					respectiveSettings[radiant] = enemySettings;
					val3.SetActive(true);
				}
				respectiveSettings[false].counter.OnChanged += delegate(int value)
				{
					//IL_0011: 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)
					int? thresholdFor2 = themesManager.GetThresholdFor(enemy.enemyType, radiant: true);
					if (!thresholdFor2.HasValue || thresholdFor2.Value > value)
					{
						themesManager.SetThresholdFor(enemy.enemyType, value, radiant: true);
						respectiveSettings[true].toggle.isOn = true;
						respectiveSettings[true].counter.Value = value;
					}
				};
				((UnityEvent<bool>)(object)respectiveSettings[false].toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool on)
				{
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					if (on && !themesManager.GetThresholdFor(enemy.enemyType, radiant: true).HasValue)
					{
						respectiveSettings[true].toggle.isOn = true;
						respectiveSettings[true].counter.Value = respectiveSettings[false].counter.Value;
					}
				});
			}
		}

		private void OnDestroy()
		{
			threshold.OnChanged -= OnThresholdChanged;
		}

		private static void OnThresholdChanged(int value)
		{
			MonoSingleton<PrefsManager>.Instance.SetIntLocal("jukebox.calmThemeEnemiesThreshold", value);
		}
	}
}
namespace Jukebox.UI.SongPanel
{
	public class ClassicSongPanel : SongPanel
	{
		protected override SongPanelStyle Style => SongPanelStyle.Classic;

		protected override IEnumerator FadeIn(JukeboxSongMetadata metadata)
		{
			float time = 0f;
			while ((double)time < (double)panelApproachTime)
			{
				time += Time.unscaledDeltaTime;
				panelGroup.alpha = (active ? (time / panelApproachTime) : 0f);
				yield return null;
			}
			panelGroup.alpha = (active ? 1 : 0);
		}

		protected override IEnumerator Await()
		{
			float time = panelStayTime;
			while ((double)time > 0.0 || showIndefinitely)
			{
				panelGroup.alpha = (active ? 1 : 0);
				if ((double)time > 0.0)
				{
					time -= Time.unscaledDeltaTime;
				}
				yield return null;
			}
		}

		protected override IEnumerator FadeOut()
		{
			float time = panelApproachTime;
			while ((double)time > 0.0)
			{
				time -= Time.unscaledDeltaTime;
				panelGroup.alpha = (active ? (time / panelApproachTime) : 0f);
				yield return null;
			}
			panelGroup.alpha = 0f;
		}
	}
	public class JukeboxSongPanel : SongPanel
	{
		[SerializeField]
		public Vector2 startDimensions;

		[SerializeField]
		public Vector2 targetDimensions;

		private Coroutine rollingTextRoutine;

		protected override SongPanelStyle Style => SongPanelStyle.Jukebox;

		protected override IEnumerator FadeIn(JukeboxSongMetadata metadata)
		{
			((Graphic)base.text).color = new Color(1f, 1f, 1f, 1f);
			RectTransform rect = ((Component)panelGroup).GetComponent<RectTransform>();
			rect.sizeDelta = startDimensions;
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#999>" + metadata.Artist + "</color>") : string.Empty);
			if (rollingTextRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rollingTextRoutine);
			}
			base.text.text = string.Empty;
			rollingTextRoutine = ((MonoBehaviour)this).StartCoroutine(ScrollingTextUnscaled.ShowText(base.text, metadata.Title.ToUpper() + " " + text, 0.022f));
			float time = 0f;
			while (time < panelApproachTime)
			{
				panelGroup.alpha = (active ? 1 : 0);
				time += Time.unscaledDeltaTime;
				if (time > panelApproachTime)
				{
					time = panelApproachTime;
				}
				rect.sizeDelta = startDimensions + (targetDimensions - startDimensions) * time / panelApproachTime;
				yield return null;
			}
		}

		protected override IEnumerator Await()
		{
			float time = panelStayTime;
			while ((double)time > 0.0 || showIndefinitely)
			{
				panelGroup.alpha = (active ? 1 : 0);
				if ((double)time > 0.0)
				{
					time -= Time.unscaledDeltaTime;
				}
				yield return null;
			}
		}

		protected override IEnumerator FadeOut()
		{
			rollingTextRoutine = ((MonoBehaviour)this).StartCoroutine(ScrollingTextUnscaled.HideText(text, 0.022f));
			RectTransform rect = ((Component)panelGroup).GetComponent<RectTransform>();
			float time = panelApproachTime;
			yield return (object)new WaitUntil((Func<bool>)(() => text.text.Length <= 20));
			while ((double)time > 0.0)
			{
				panelGroup.alpha = (active ? 1 : 0);
				time -= Time.unscaledDeltaTime;
				if (time < 0f)
				{
					time = 0f;
				}
				rect.sizeDelta = startDimensions + (targetDimensions - startDimensions) * time / panelApproachTime;
				yield return null;
			}
			panelGroup.alpha = 0f;
		}
	}
	public class PlaylistSelectable : DirectoryTreeBrowser<JukeboxSong>
	{
		[SerializeField]
		public GameObject selectPlaylistPanel;

		[SerializeField]
		public string playlistName;

		[SerializeField]
		public Button button;

		[SerializeField]
		public GameObject empty;

		protected override int maxPageLength => 6;

		protected override IDirectoryTree<JukeboxSong> baseDirectory
		{
			get
			{
				JukeboxPlaylist val;
				using (StreamReader streamReader = new StreamReader(File.Open(JukeboxPlaylist.PathForPlaylist(playlistName), FileMode.OpenOrCreate)))
				{
					val = JsonConvert.DeserializeObject<JukeboxPlaylist>(streamReader.ReadToEnd());
				}
				List<SongIdentifier> source = ((val != null) ? ((Playlist)val).ids : new List<SongIdentifier>());
				return (IDirectoryTree<JukeboxSong>)(object)new FakeDirectoryTree<JukeboxSong>("Songs", from id in source
					where (int)id.type != 1 || File.Exists(id.path)
					select MonoSingleton<JukeboxSongsLoader>.Instance.Load(id), (IEnumerable<IDirectoryTree<JukeboxSong>>)null, (IDirectoryTree<JukeboxSong>)null);
			}
		}

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				MonoSingleton<PrefsManager>.Instance.SetStringLocal("jukebox.currentPlaylist", playlistName);
				MonoSingleton<JukeboxManager>.Instance.playlistEditor.ReloadPlaylist();
				selectPlaylistPanel.SetActive(false);
			});
		}

		private void OnEnable()
		{
			base.currentDirectory = ((DirectoryTreeBrowser<JukeboxSong>)this).baseDirectory;
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
		}

		protected override Action BuildLeaf(JukeboxSong item, int indexInPage)
		{
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemButtonTemplate.transform.parent);
			go.SetActive(true);
			go.GetComponent<Image>().sprite = item.Metadata.Icon;
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			base.Rebuild(setToPageZero);
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
			empty.SetActive(!base.currentDirectory.files.Any());
		}
	}
	public abstract class SongPanel : MonoBehaviour
	{
		[SerializeField]
		public CanvasGroup panelGroup;

		[SerializeField]
		public Sprite defaultIcon;

		[SerializeField]
		public float panelApproachTime;

		[SerializeField]
		public float panelStayTime;

		public TMP_Text text;

		public Image icon;

		protected bool showIndefinitely;

		protected bool active;

		private Coroutine displayRoutine;

		protected abstract SongPanelStyle Style { get; }

		protected abstract IEnumerator FadeIn(JukeboxSongMetadata metadata);

		protected abstract IEnumerator Await();

		protected abstract IEnumerator FadeOut();

		public void Awake()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			JukeboxMusicPlayer.OnNextSong += OnNextSong;
			JukeboxMusicPlayer.OnStop += OnStop;
			showIndefinitely = MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.showTrackPanelIndefinitely", false);
			active = MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)Style;
		}

		public void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			JukeboxMusicPlayer.OnNextSong -= OnNextSong;
			JukeboxMusicPlayer.OnStop -= OnStop;
		}

		private IEnumerator ShowPanelRoutine(JukeboxSongMetadata metadata)
		{
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#999>" + metadata.Artist + "</color>") : string.Empty);
			this.text.text = metadata.Title.ToUpper() + " " + text;
			icon.sprite = (((Object)(object)metadata.Icon != (Object)null) ? metadata.Icon : defaultIcon);
			yield return FadeIn(metadata);
			yield return Await();
			yield return FadeOut();
		}

		private void OnNextSong(JukeboxSong song)
		{
			active = MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)Style;
			if (displayRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(displayRoutine);
			}
			displayRoutine = ((MonoBehaviour)this).StartCoroutine(ShowPanelRoutine(song.Metadata));
		}

		private void OnStop()
		{
			active = false;
		}

		private void OnPrefChanged(string key, object value)
		{
			if (key.Equals("jukebox.showTrackPanelIndefinitely"))
			{
				showIndefinitely = (bool)value;
			}
			if (key.Equals("jukebox.songPanelStyle"))
			{
				active = (int)value == (int)Style;
			}
		}
	}
	public class SongPanelOption : MonoBehaviour
	{
		private static readonly Color Active = new Color(0.68f, 0.68f, 0.68f, 0.25f);

		private static readonly Color Inactive = new Color(0f, 0f, 0f, 0.59f);

		public SongPanelStyle style;

		private void Start()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)((Component)this).gameObject.GetComponent<Image>()).color = ((MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)style) ? Active : Inactive);
		}

		public void Select()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Button[] componentsInChildren = ((Component)((Component)this).transform.parent).GetComponentsInChildren<Button>();
			foreach (Button val in componentsInChildren)
			{
				((Graphic)((Component)val).gameObject.GetComponent<Image>()).color = (((Object)(object)val == (Object)(object)((Component)this).gameObject.GetComponent<Button>()) ? Active : Inactive);
			}
			MonoSingleton<PrefsManager>.Instance.SetIntLocal("jukebox.songPanelStyle", (int)style);
		}
	}
	public enum SongPanelStyle
	{
		Jukebox,
		Classic
	}
}
namespace Jukebox.UI.Elements
{
	public class Counter : MonoBehaviour
	{
		[SerializeField]
		private TextMeshProUGUI textValue;

		[SerializeField]
		private CounterButton increase;

		[SerializeField]
		private CounterButton decrease;

		[SerializeField]
		private int minValue;

		[SerializeField]
		private int maxValue;

		private int tmpValue;

		private IEnumerator changeValueRoutine;

		private int value;

		public int Value
		{
			get
			{
				return value;
			}
			set
			{
				this.value = value;
				((TMP_Text)textValue).text = Value.ToString();
				this.OnChanged?.Invoke(value);
			}
		}

		public event Action<int> OnChanged;

		public void Awake()
		{
			AddEvents(increase, delegate
			{
				tmpValue = ChangeValue((int i) => i + 1);
			});
			AddEvents(decrease, delegate
			{
				tmpValue = ChangeValue((int i) => i - 1);
			});
		}

		public void SetDefaultValue(int defaultValue)
		{
			Value = defaultValue;
			tmpValue = defaultValue;
			((TMP_Text)textValue).text = defaultValue.ToString();
		}

		private void AddEvents(CounterButton button, Action<int> callback)
		{
			button.OnDown += delegate
			{
				changeValueRoutine = ChangeValueRoutine(callback);
				((MonoBehaviour)this).StartCoroutine(changeValueRoutine);
			};
			button.OnUp += SaveValue;
			button.OnExit += SaveValue;
		}

		private void SaveValue()
		{
			if (changeValueRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(changeValueRoutine);
			}
			Value = tmpValue;
			this.OnChanged?.Invoke(Value);
		}

		private IEnumerator ChangeValueRoutine(Action<int> callback)
		{
			callback(tmpValue);
			yield return (object)new WaitForSecondsRealtime(0.3f);
			while (true)
			{
				callback(tmpValue);
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
		}

		private int ChangeValue(Func<int, int> operation)
		{
			int result = ValidateOperation(operation);
			((TMP_Text)textValue).text = result.ToString();
			return result;
		}

		private int ValidateOperation(Func<int, int> operation)
		{
			int num = operation(tmpValue);
			if (num >= minValue && num <= maxValue)
			{
				return num;
			}
			return tmpValue;
		}
	}
	public class CounterButton : Button
	{
		public bool pressed;

		public event Action OnDown;

		public event Action OnUp;

		public event Action OnExit;

		public override void OnPointerDown(PointerEventData eventData)
		{
			pressed = true;
			((Selectable)this).OnPointerDown(eventData);
			this.OnDown?.Invoke();
		}

		public override void OnPointerUp(PointerEventData eventData)
		{
			pressed = false;
			((Selectable)this).OnPointerUp(eventData);
			this.OnUp?.Invoke();
		}

		public override void OnPointerExit(PointerEventData eventData)
		{
			((Selectable)this).OnPointerExit(eventData);
			if (pressed)
			{
				this.OnExit?.Invoke();
			}
			pressed = false;
		}
	}
}
namespace Jukebox.UI.Effects
{
	public class SoundEffectButton : MonoBehaviour
	{
		[SerializeField]
		private string prefsKey;

		[SerializeField]
		private TMP_Text title;

		[SerializeField]
		private TMP_Text fileNameText;

		[SerializeField]
		private TMP_Text browserWindowTitle;

		protected void Awake()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			ChangeFileName(MonoSingleton<PrefsManager>.Instance.GetStringLocal(prefsKey, (string)null));
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				browserWindowTitle.text = "Select file for " + title.text;
			});
		}

		protected void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

		private void OnPrefChanged(string key, object value)
		{
			if (key.Equals(prefsKey))
			{
				ChangeFileName((string)value);
			}
		}

		private void ChangeFileName(string fileName)
		{
			fileNameText.text = ((fileName != null) ? new FileInfo(fileName).Name : "Default");
		}
	}
}
namespace Jukebox.UI.Decorators
{
	public class ControlBindDecorator : MonoBehaviour
	{
		[SerializeField]
		public InputActionReference action;

		protected void Awake()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			InputAction val = MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindAction(action.ToInputAction().id);
			((Component)this).GetComponentInChildren<ControlsOptionsKey>().RebuildBindings(val, MonoSingleton<InputManager>.Instance.InputSource.Actions.KeyboardMouseScheme);
		}
	}
	public abstract class UIDecorator<T> : MonoBehaviour where T : MonoBehaviour
	{
		[SerializeField]
		public GameObject hint;

		protected GameObject control;

		protected abstract GameObject Template();

		protected abstract void Init();

		public void Start()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			control = Object.Instantiate<GameObject>(Template(), ((Component)this).transform);
			control.transform.position = ((Component)this).transform.position;
			Object.Destroy((Object)(object)hint);
			Init();
			Object.Destroy((Object)(object)((Component)this).GetComponent<T>());
		}
	}
	public class SliderDecorator : UIDecorator<SliderDecorator>
	{
		[AddressableAsset("Assets/Prefabs/UI/Settings/Elements/Slider Button.prefab", typeof(GameObject))]
		private static GameObject sliderTemplate;

		[SerializeField]
		public float minValue;

		[SerializeField]
		public float maxValue;

		[SerializeField]
		public SliderValueToTextConfig sliderConfig;

		protected override GameObject Template()
		{
			return sliderTemplate;
		}

		protected override void Init()
		{
			Slider componentInChildren = ((Component)this).GetComponentInChildren<Slider>();
			componentInChildren.minValue = minValue;
			componentInChildren.maxValue = maxValue;
			ReflectionUtils.GetPrivate<SliderValueToText>(((Component)this).GetComponentInChildren<SettingsSlider>(), typeof(SettingsSlider), "sliderValueToText").ConfigureFrom(sliderConfig);
		}
	}
}
namespace Jukebox.Patches
{
	[HarmonyPatch(typeof(AudioMixerController))]
	public static class AudioMixerControllerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(AudioMixerController), "Update")]
		public static void AudioMixerController_Update_Postfix(AudioMixerController __instance)
		{
			if (!((Object)(object)MonoSingleton<JukeboxManager>.Instance == (Object)null))
			{
				__instance.musicSound.SetFloat("allVolume", __instance.CalculateVolume(__instance.musicVolume) + MonoSingleton<JukeboxManager>.Instance.player.VolumeBoost);
			}
		}
	}
	[HarmonyPatch(typeof(DiscordController))]
	public static class DiscordControllerPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UpdateActivityHandler <>9__0_0;

			internal void <DiscordController_UpdateWave_Prefix>b__0_0(Result _)
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(DiscordController), "UpdateWave")]
		public static bool DiscordController_UpdateWave_Prefix(int wave)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			if (JukeboxMusicPlayer.CurrentSong == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if ((Object)(object)DiscordController.Instance == (Object)null)
			{
				return false;
			}
			bool @private = ReflectionUtils.GetPrivate<bool>(DiscordController.Instance, typeof(DiscordController), "disabled");
			Activity private2 = ReflectionUtils.GetPrivate<Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity");
			ActivityManager private3 = ReflectionUtils.GetPrivate<ActivityManager>(DiscordController.Instance, typeof(DiscordController), "activityManager");
			Discord private4 = ReflectionUtils.GetPrivate<Discord>(DiscordController.Instance, typeof(DiscordController), "discord");
			if (@private)
			{
				return false;
			}
			private2.Details = $"WAVE: {wave} | \ud83c\udfb5 {JukeboxMusicPlayer.CurrentSong.ArtistAndTrack}";
			ReflectionUtils.SetPrivate<DiscordController, Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity", private2);
			if (private4 == null || private3 == null)
			{
				return false;
			}
			Activity val = private2;
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				UpdateActivityHandler val2 = delegate
				{
				};
				<>c.<>9__0_0 = val2;
				obj = (object)val2;
			}
			private3.UpdateActivity(val, (UpdateActivityHandler)obj);
			return false;
		}
	}
	[HarmonyPatch(typeof(FinalCyberRank))]
	public static class FinalCyberRankPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(FinalCyberRank), "GameOver")]
		public static bool FinalCyberRank_GameOver_Prefix()
		{
			if ((Object)(object)MonoSingleton<JukeboxManager>.Instance.player != (Object)null)
			{
				MonoSingleton<JukeboxManager>.Instance.player.Stop();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InputActions))]
	public static class InputActionsPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void InputActions_Constructor_Postfix(InputActions __instance)
		{
			if (__instance.asset.FindActionMap("Jukebox", false) == null)
			{
				MergeInputActionAssets(__instance);
			}
		}

		private static void MergeInputActionAssets(InputActions ukInputActions)
		{
			if (Resources.FindObjectsOfTypeAll(typeof(InputActionAsset)).Length == 0)
			{
				Debug.LogError((object)"Couldn't load InputActionAsset");
				return;
			}
			string text = "{\r\n                \"maps\": [\r\n                    {\r\n                        \"name\": \"Jukebox\",\r\n                        \"id\": \"9dda5277-7734-4ec3-ad76-c8c0e5763d02\",\r\n                        \"actions\": [\r\n                            {\r\n                                \"name\": \"Next Track\",\r\n                                \"type\": \"Button\",\r\n                                \"id\": \"09c701ba-74bc-4818-80a7-d1049e88ed97\",\r\n                                \"expectedControlType\": \"Button\",\r\n                                \"processors\": \"\",\r\n                                \"interactions\": \"\",\r\n                                \"initialStateCheck\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"Jukebox Menu\",\r\n                                \"type\": \"Button\",\r\n                                \"id\": \"2031a43b-3913-4384-a334-02669e72c30d\",\r\n                                \"expectedControlType\": \"Button\",\r\n                                \"processors\": \"\",\r\n                                \"interactions\": \"\",\r\n                                \"initialStateCheck\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"Disable Player\",\r\n                                \"type\": \"Button\",\r\n                                \"id\": \"3675ceba-90d0-46f5-b634-d6c13d208ff6\",\r\n                                \"expectedControlType\": \"Button\",\r\n                                \"processors\": \"\",\r\n                                \"interactions\": \"\",\r\n                                \"initialStateCheck\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"Playback Menu\",\r\n                                \"type\": \"Button\",\r\n                                \"id\": \"fa8430f8-91e7-454b-91f7-8b0147642ef9\",\r\n                                \"expectedControlType\": \"Button\",\r\n                                \"processors\": \"\",\r\n                                \"interactions\": \"\",\r\n                                \"initialStateCheck\": false\r\n                            }\r\n                        ],\r\n                        \"bindings\": [\r\n                            {\r\n                                \"name\": \"\",\r\n                                \"id\": \"8ec3310e-3f25-46a8-9a97-347d624fb616\",\r\n                                \"path\": \"<Keyboard>/f3\",\r\n                                \"interactions\": \"\",\r\n                                \"processors\": \"\",\r\n                                \"groups\": \"Keyboard & Mouse\",\r\n                                \"action\": \"Next Track\",\r\n                                \"isComposite\": false,\r\n                                \"isPartOfComposite\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"\",\r\n                                \"id\": \"b6df442f-c08f-4187-940a-9b684fa729c5\",\r\n                                \"path\": \"<Keyboard>/f4\",\r\n                                \"interactions\": \"\",\r\n                                \"processors\": \"\",\r\n                                \"groups\": \"Keyboard & Mouse\",\r\n                                \"action\": \"Jukebox Menu\",\r\n                                \"isComposite\": false,\r\n                                \"isPartOfComposite\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"\",\r\n                                \"id\": \"48676d48-feb2-406e-bc66-91f1aa7b11f1\",\r\n                                \"path\": \"<Keyboard>/backquote\",\r\n                                \"interactions\": \"\",\r\n                                \"processors\": \"\",\r\n                                \"groups\": \"Keyboard & Mouse\",\r\n                                \"action\": \"Playback Menu\",\r\n                                \"isComposite\": false,\r\n                                \"isPartOfComposite\": false\r\n                            },\r\n                            {\r\n                                \"name\": \"\",\r\n                                \"id\": \"b86c9dc7-c6a1-4490-8aaa-bcb7dc1aa3cd\",\r\n                                \"path\": \"<Keyboard>/f10\",\r\n                                \"interactions\": \"\",\r\n                                \"processors\": \"\",\r\n                                \"groups\": \"Keyboard & Mouse\",\r\n                                \"action\": \"Disable Player\",\r\n                                \"isComposite\": false,\r\n                                \"isPartOfComposite\": false\r\n                            }\r\n                        ]\r\n                    }\r\n                ]\r\n            }";
			InputActionSetupExtensions.AddActionMap(ukInputActions.asset, InputActionMap.FromJson(text)[0]);
		}
	}
	[HarmonyPatch(typeof(InputManager))]
	public static class InputManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(InputManager), "Rebind")]
		public static bool InputManager_Rebind_Prefix(InputManager __instance, InputAction action, int? existingIndex, Action onComplete, Action onCancel, InputControlScheme scheme)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (action.actionMap.name != "Jukebox")
			{
				return true;
			}
			__instance.WaitForButton((Action<string>)delegate(string path)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: 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_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				if (path == "<Mouse>/leftButton")
				{
					onComplete?.Invoke();
				}
				else if (((IEnumerable<InputBinding>)(object)action.bindings).Any((InputBinding binding) => InputSystem.FindControl(((InputBinding)(ref binding)).path) == InputSystem.FindControl(path)))
				{
					onComplete?.Invoke();
				}
				else
				{
					BindingSyntax val = ((!existingIndex.HasValue) ? InputActionSetupExtensions.AddBinding(action, default(InputBinding)) : InputActionSetupExtensions.ChangeBinding(action, existingIndex.GetValueOrDefault()));
					val = ((BindingSyntax)(ref val)).WithPath(path);
					((BindingSyntax)(ref val)).WithGroup(((InputControlScheme)(ref scheme)).bindingGroup);
					__instance.actionModified?.Invoke(action);
					if (onComplete != null)
					{
						onComplete();
					}
				}
			}, (Action)delegate
			{
				onCancel?.Invoke();
			}, ((IEnumerable<DeviceRequirement>)(object)((InputControlScheme)(ref scheme)).deviceRequirements).Select((DeviceRequirement requirement) => ((DeviceRequirement)(ref requirement)).controlPath).ToList());
			return false;
		}
	}
	[HarmonyPatch(typeof(ScreenZone))]
	public static class ScreenZonePatch
	{
		private static PreviewHelper _helper;

		private static ScreenZone _cgTerminal;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ScreenZone), "Awake")]
		public static void ScreenZone_Awake_Postfix(ScreenZone __instance)
		{
			if (!(((Object)__instance).name != "Cybergrind Shop"))
			{
				PreviewHelper previewHelper = default(PreviewHelper);
				if (!((Component)__instance).TryGetComponent<PreviewHelper>(ref previewHelper))
				{
					((Component)__instance).gameObject.AddComponent<PreviewHelper>();
				}
				_cgTerminal = __instance;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ScreenZone), "Update")]
		public static bool ScreenZone_Update_Prefix(bool ___inZone, ScreenZone __instance)
		{
			if ((Object)(object)_cgTerminal != (Object)(object)__instance)
			{
				return true;
			}
			if ((Object)(object)_helper == (Object)null)
			{
				PreviewHelper helper = default(PreviewHelper);
				if (!((Component)__instance).TryGetComponent<PreviewHelper>(ref helper))
				{
					return true;
				}
				_helper = helper;
			}
			_helper.inZone = ___inZone;
			return true;
		}
	}
	[HarmonyPatch(typeof(SteamController))]
	public static class SteamControllerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamController), "UpdateWave")]
		public static bool SteamController_UpdateWave_Prefix(int wave)
		{
			if (JukeboxMusicPlayer.CurrentSong == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if (!SteamClient.IsValid)
			{
				return false;
			}
			SteamFriends.SetRichPresence("wave", $"WAVE: {wave} | \ud83c\udfb5 {JukeboxMusicPlayer.CurrentSong.ArtistAndTrack}");
			return false;
		}
	}
}
namespace Jukebox.Input
{
	[ConfigureSingleton(/*Could not decode attribute arguments.*/)]
	public class JukeboxInputs : MonoSingleton<JukeboxInputs>
	{
		private InputActionMap jukeboxActionMap;

		public InputAction Menu { get; private set; }

		public InputAction Playback { get; private set; }

		public InputAction NextTrack { get; private set; }

		public InputAction DisablePlayer { get; private set; }

		protected void Awake()
		{
			base.Awake();
			jukeboxActionMap = MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindActionMap("Jukebox", false);
			Menu = jukeboxActionMap.FindAction("Jukebox Menu", false);
			Playback = jukeboxActionMap.FindAction("Playback Menu", false);
			NextTrack = jukeboxActionMap.FindAction("Next Track", false);
			DisablePlayer = jukeboxActionMap.FindAction("Disable Player", false);
		}
	}
}
namespace Jukebox.Components
{
	public class CybergrindEffectsChanger : MonoBehaviour
	{
		private const string TerminalPath = "/FirstRoom/Room/Cybergrind Shop/Music";

		private CrowdReactions crowdReactions;

		private PrefsManager prefsManager;

		private AudioClip awwDefault;

		private AudioClip cheerDefault;

		private AudioClip cheerLongDefault;

		private AudioClip terminalMusicDefault;

		private AudioClip gameOverDefault;

		private static AudioSource EndMusicAudioSource
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				return ((Scene)(ref activeScene)).GetRootGameObjects().First((GameObject o) => ((Object)o).name == "EndMusic").GetComponent<AudioSource>();
			}
		}

		private static AudioSource MenuMusicAudioSource => GameObject.Find("/FirstRoom/Room/Cybergrind Shop/Music").GetComponent<AudioSource>();

		private void Awake()
		{
			crowdReactions = MonoSingleton<CrowdReactions>.Instance;
			prefsManager = MonoSingleton<PrefsManager>.Instance;
			awwDefault = Object.Instantiate<AudioClip>(crowdReactions.aww, ((Component)this).gameObject.transform);
			cheerDefault = Object.Instantiate<AudioClip>(crowdReactions.cheer, ((Component)this).gameObject.transform);
			cheerLongDefault = Object.Instantiate<AudioClip>(crowdReactions.cheerLong, ((Component)this).gameObject.transform);
			terminalMusicDefault = Object.Instantiate<AudioClip>(MenuMusicAudioSource.clip, ((Component)this).gameObject.transform);
			gameOverDefault = Object.Instantiate<AudioClip>(EndMusicAudioSource.clip, ((Component)this).gameObject.transform);
			((MonoBehaviour)this).StartCoroutine(Setup());
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

		private void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

		private IEnumerator Setup()
		{
			yield return PrepareParrySfx();
			yield return PrepareWaveCompleteSfx();
			yield return PrepareAwwSfx();
			yield return PrepareGameOverSfx();
			yield return PrepareTerminalMusic();
		}

		private IEnumerator PrepareParrySfx()
		{
			yield return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.parry", (string)null), delegate(AudioClip clip)
			{
				crowdReactions.cheer = clip;
			}, cheerDefault);
		}

		private IEnumerator PrepareWaveCompleteSfx()
		{
			yield return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.wavecomplete", (string)null), delegate(AudioClip clip)
			{
				crowdReactions.cheerLong = clip;
			}, cheerLongDefault);
		}

		private IEnumerator PrepareAwwSfx()
		{
			yield return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.aww", (string)null), delegate(AudioClip clip)
			{
				crowdReactions.aww = clip;
			}, awwDefault);
		}

		private IEnumerator PrepareGameOverSfx()
		{
			yield return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.gameover", (string)null), delegate(AudioClip clip)
			{
				EndMusicAudioSource.clip = clip;
			}, gameOverDefault);
		}

		private IEnumerator PrepareTerminalMusic()
		{
			AudioSource terminalMusic = MenuMusicAudioSource;
			yield return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.terminal-music", (string)null), delegate(AudioClip clip)
			{
				terminalMusic.Stop();
				terminalMusic.volume = 1f;
				terminalMusic.clip = clip;
				terminalMusic.Play();
			}, terminalMusicDefault);
		}

		private IEnumerator PrepareClip(string path, Action<AudioClip> callback, AudioClip fallback)
		{
			if (path != null)
			{
				yield return Download(new FileInfo(path), callback);
			}
			else
			{
				callback(fallback);
			}
		}

		private IEnumerator Download(FileSystemInfo path, Action<AudioClip> callback)
		{
			DownloadHandlerAudioClip handler = new DownloadHandlerAudioClip(new Uri(path.FullName).AbsoluteUri, CustomMusicFileBrowser.extensionTypeDict[path.Extension.ToLower()]);
			UnityWebRequest wr = new UnityWebRequest(new Uri(path.FullName).AbsoluteUri, "GET", (DownloadHandler)(object)handler, (UploadHandler)null);
			try
			{
				yield return wr.SendWebRequest();
				if (wr.responseCode == 200)
				{
					callback(handler.audioClip);
				}
			}
			finally
			{
				((IDisposable)wr)?.Dispose();
			}
		}

		private void OnPrefChanged(string key, object value)
		{
			switch (key)
			{
			case "jukebox.effects.wavecomplete":
				((MonoBehaviour)this).StartCoroutine(PrepareWaveCompleteSfx());
				break;
			case "jukebox.effects.aww":
				((MonoBehaviour)this).StartCoroutine(PrepareAwwSfx());
				break;
			case "jukebox.effects.gameover":
				((MonoBehaviour)this).StartCoroutine(PrepareGameOverSfx());
				break;
			case "jukebox.effects.terminal-music":
				((MonoBehaviour)this).StartCoroutine(PrepareTerminalMusic());
				break;
			case "jukebox.effects.parry":
				ReflectionUtils.GetPrivate<AudioSource>(crowdReactions, typeof(CrowdReactions), "aud").Stop();
				((MonoBehaviour)this).StartCoroutine(PrepareParrySfx());
				break;
			}
		}
	}
	public class JukeboxEffectsBrowser : DirectoryTreeBrowser<FileInfo>
	{
		private static readonly DirectoryInfo EffectsDirectory = new DirectoryInfo(Path.Combine(PathsUtils.ApplicationPath, "Cybergrind", "Effects"));

		[SerializeField]
		private JukeboxTerminalPanel navigator;

		[SerializeField]
		private GameObject effectsMenu;

		private string currentPrefKey;

		protected override int maxPageLength => 3;

		protected override IDirectoryTree<FileInfo> baseDirectory => (IDirectoryTree<FileInfo>)new FileDirectoryTree(EffectsDirectory, (IDirectoryTree<FileInfo>)null);

		public void NextPage()
		{
			base.SetPage((base.currentPage != base.maxPages - 1) ? (base.currentPage + 1) : 0);
		}

		public void PreviousPage()
		{
			base.SetPage((base.currentPage == 0) ? (base.maxPages - 1) : (base.currentPage - 1));
		}

		public void SetCurrentPrefKey(string key)
		{
			currentPrefKey = key;
		}

		public void ResetToDefault()
		{
			MonoSingleton<PrefsManager>.Instance.SetStringLocal(currentPrefKey, (string)null);
		}

		protected override Action BuildLeaf(FileInfo item, int indexInPage)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemParent);
			CustomContentButton component = go.GetComponent<CustomContentButton>();
			component.text.text = item.Name;
			go.SetActive(true);
			((UnityEvent)component.button.onClick).AddListener((UnityAction)delegate
			{
				MonoSingleton<PrefsManager>.Instance.SetStringLocal(currentPrefKey, item.FullName);
				navigator.GoToNoMenu(effectsMenu);
			});
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		public void OpenEffectsFolder()
		{
			Application.OpenURL(new Uri(EffectsDirectory.FullName).AbsoluteUri);
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
			base.Rebuild(setToPageZero);
		}
	}
	public class JukeboxMusicChanger : MonoBehaviour
	{
		private enum ThemeVariation
		{
			Battle,
			Calm
		}

		private const int FadeSpeed = 1;

		public AudioSource clean;

		public AudioSource battle;

		private JukeboxThemesManager themesManager;

		private Coroutine updateRoutine;

		private ThemeVariation currentTheme;

		private static bool CalmThemesAllowed => MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.enableCalmThemes", false);

		public void Awake()
		{
			themesManager = MonoSingleton<JukeboxThemesManager>.Instance;
		}

		private void Update()
		{
			if (!((Object)(object)clean.clip == (Object)null))
			{
				if (currentTheme == ThemeVariation.Calm)
				{
					clean.volume = Mathf.MoveTowards(clean.volume, 1f, 1f * Time.deltaTime);
					battle.volume = Mathf.MoveTowards(battle.volume, 0f, 1f * Time.deltaTime);
				}
				else
				{
					clean.volume = Mathf.MoveTowards(clean.volume, 0f, 1f * Time.deltaTime);
					battle.volume = Mathf.MoveTowards(battle.volume, 1f, 1f * Time.deltaTime);
				}
			}
		}

		public void ChangeTo(AudioClip battleTheme, AudioClip calmTheme)
		{
			if (updateRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(updateRoutine);
			}
			battle.time = 0f;
			clean.time = 0f;
			clean.clip = calmTheme;
			battle.clip = battleTheme;
			battle.Play();
			battle.volume = 1f;
			if ((Object)(object)clean.clip != (Object)null)
			{
				clean.Play();
				if (CalmThemesAllowed && themesManager.FewEnemies)
				{
					clean.volume = 1f;
					battle.volume = 0f;
				}
			}
			updateRoutine = ((MonoBehaviour)this).StartCoroutine(SlowUpdate());
		}

		private IEnumerator SlowUpdate()
		{
			while (true)
			{
				if (CalmThemesAllowed && themesManager.FewEnemies)
				{
					PlayCalmTheme();
				}
				else
				{
					PlayBattleTheme();
				}
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
		}

		private void PlayBattleTheme()
		{
			if (currentTheme != 0)
			{
				currentTheme = ThemeVariation.Battle;
				if ((Object)(object)clean.clip != (Object)null)
				{
					battle.timeSamples = clean.timeSamples;
				}
			}
		}

		private void PlayCalmTheme()
		{
			if (currentTheme != ThemeVariation.Calm)
			{
				currentTheme = ThemeVariation.Calm;
				if ((Object)(object)clean.clip != (Object)null)
				{
					clean.timeSamples = battle.timeSamples;
				}
			}
		}
	}
	public class JukeboxThemesManager : MonoSingleton<JukeboxThemesManager>
	{
		private static readonly string PreferencesPath = Path.Combine(Directory.GetParent(Application.dataPath).FullName, "Preferences", "JukeboxThemes.json");

		private PrefsManager prefsManager;

		private EnemyTracker enemyTracker;

		private JukeboxThemesConfig preferences = new JukeboxThemesConfig();

		private bool isDirty;

		public bool FewEnemies
		{
			get
			{
				if (EnemiesAlive <= CalmThemeThreshold)
				{
					return SpecialEnemiesThresholdReached();
				}
				return false;
			}
		}

		private int CalmThemeThreshold => prefsManager.GetIntLocal("jukebox.calmThemeEnemiesThreshold", 0);

		private int EnemiesAlive => enemyTracker.enemies.Count((EnemyIdentifier enemy) => !enemy.dead);

		protected override void Awake()
		{
			base.Awake();
			prefsManager = MonoSingleton<PrefsManager>.Instance;
			enemyTracker = MonoSingleton<EnemyTracker>.Instance;
			LoadPreferences();
			((MonoBehaviour)this).InvokeRepeating("SlowUpdate", 0f, 3f);
		}

		private void SlowUpdate()
		{
			if (isDirty)
			{
				SavePreferences();
				isDirty = false;
			}
		}

		protected override void OnDestroy()
		{
			SavePreferences();
			isDirty = false;
			base.OnDestroy();
		}

		public int? GetThresholdFor(EnemyType type, bool radiant = false)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<EnemyType, int> dictionary = (radiant ? preferences.calmTheme.specialRadiantEnemies : preferences.calmTheme.specialEnemies);
			if (!dictionary.ContainsKey(type))
			{
				return null;
			}
			return dictionary[type];
		}

		public void SetThresholdFor(EnemyType type, int value, bool radiant = false)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			(radiant ? preferences.calmTheme.specialRadiantEnemies : preferences.calmTheme.specialEnemies)[type] = value;
			isDirty = true;
		}

		public void DisableThresholdFor(EnemyType type, bool radiant)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<EnemyType, int> dictionary = (radiant ? preferences.calmTheme.specialRadiantEnemies : preferences.calmTheme.specialEnemies);
			if (dictionary.ContainsKey(type))
			{
				dictionary.Remove(type);
			}
			isDirty = true;
		}

		private bool SpecialEnemiesThresholdReached()
		{
			return (from enemy in enemyTracker.enemies
				where !enemy.dead
				group enemy by new { enemy.enemyType, enemy.hasRadianceEffected }).All(group =>
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				if (group.Key.hasRadianceEffected)
				{
					if (preferences.calmTheme.specialRadiantEnemies.ContainsKey(group.Key.enemyType))
					{
						return preferences.calmTheme.specialRadiantEnemies[group.Key.enemyType] >= group.Count();
					}
					return true;
				}
				return !preferences.calmTheme.specialEnemies.ContainsKey(group.Key.enemyType) || preferences.calmTheme.specialEnemies[group.Key.enemyType] >= group.Count();
			});
		}

		private void LoadPreferences()
		{
			JukeboxThemesConfig val;
			using (StreamReader streamReader = new StreamReader(File.Open(PreferencesPath, FileMode.OpenOrCreate)))
			{
				val = JsonConvert.DeserializeObject<JukeboxThemesConfig>(streamReader.ReadToEnd());
			}
			if (val?.calmTheme == null)
			{
				SavePreferences();
			}
			else
			{
				preferences = val.Equalize();
			}
			isDirty = true;
		}

		private void SavePreferences()
		{
			File.WriteAllText(PreferencesPath, JsonConvert.SerializeObject((object)preferences));
		}
	}
	public class DeckShuffled<T> : IEnumerable<T>, IEnumerable
	{
		private List<T> current;

		public DeckShuffled(IEnumerable<T> target)
		{
			current = Randomize(target).ToList();
		}

		public void Reshuffle()
		{
			if (current.Count > 1)
			{
				IEnumerable<T> source = current.Take(Mathf.FloorToInt((float)(current.Count / 2)));
				IEnumerable<T> source2 = current.Skip(Mathf.FloorToInt((float)(current.Count / 2)));
				current = Randomize(source).Concat(Randomize(source2)).ToList();
			}
		}

		private static IEnumerable<T> Randomize(IEnumerable<T> source)
		{
			T[] arr = source.ToArray();
			int i = arr.Length - 1;
			while (i > 0)
			{
				int swapIndex = Random.Range(0, i + 1);
				yield return arr[swapIndex];
				arr[swapIndex] = arr[i];
				int num = i - 1;
				i = num;
			}
			yield return arr[0];
		}

		public IEnumerator<T> GetEnumerator()
		{
			return current.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return current.GetEnumerator();
		}
	}
	public class JukeboxFileBrowser : DirectoryTreeBrowser<JukeboxSong>
	{
		[SerializeField]
		private JukeboxTerminalPanel navigator;

		[SerializeField]
		private JukeboxPlaylistEditor playlistEditorLogic;

		[SerializeField]
		private GameObject playlistEditor;

		[Header("Load all warning")]
		[SerializeField]
		private TMP_Text loadAllWarningText;

		[SerializeField]
		private GameObject yesAndNoButtons;

		[SerializeField]
		private GameObject imADumbassButton;

		[SerializeField]
		private Sprite youtubeIcon;

		protected override int maxPageLength => 4;

		protected override IDirectoryTree<JukeboxSong> baseDirectory => (IDirectoryTree<JukeboxSong>)new JukeboxFileTree(PathsUtils.MusicPath, (IDirectoryTree<JukeboxSong>)null);

		public void NextPage()
		{
			base.SetPage((base.currentPage != base.maxPages - 1) ? (base.currentPage + 1) : 0);
		}

		public void PreviousPage()
		{
			base.SetPage((base.currentPage == 0) ? (base.maxPages - 1) : (base.currentPage - 1));
		}

		public void LoadAllFromCurrentFolder()
		{
			foreach (JukeboxSong file in base.currentDirectory.files)
			{
				playlistEditorLogic.playlist.Add(file.Id);
			}
			((DirectoryTreeBrowser<JukeboxSong>)playlistEditorLogic).Rebuild(true);
		}

		public void SetWarningText()
		{
			if (!base.currentDirectory.files.Any())
			{
				yesAndNoButtons.SetActive(false);
				imADumbassButton.SetActive(true);
				loadAllWarningText.text = ((!base.currentDirectory.children.Any()) ? "Oh, I get it. \"Yes, I would like to add a whopping total of 0 songs\". Very funny." : "This folder contains no songs.");
			}
			else if (base.currentDirectory.files.Count() == 1)
			{
				loadAllWarningText.text = "It's a single song in there, but ok. Would you like me to add it?";
			}
			else
			{
				loadAllWarningText.text = $"Do you want to add <color=green>{base.currentDirectory.files.Count()}</color> tracks " + "from the folder <color=yellow>" + base.currentDirectory.name + "</color> to your playlist?";
			}
		}

		public void Refresh()
		{
			((DirectoryTreeBrowser<JukeboxSong>)this).baseDirectory.Refresh();
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
		}

		protected override Action BuildLeaf(JukeboxSong song, int indexInPage)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemParent, false);
			JukeboxCustomContentButton component = go.GetComponent<JukeboxCustomContentButton>();
			JukeboxSongMetadata metadata = song.Metadata;
			((UnityEvent)((CustomContentButton)component).button.onClick).AddListener((UnityAction)delegate
			{
				int count = ((Playlist)playlistEditorLogic.playlist).Count;
				int page = ((DirectoryTreeBrowser<JukeboxSong>)playlistEditorLogic).PageOf(count);
				playlistEditorLogic.playlist.Add(song.Id);
				((DirectoryTreeBrowser<JukeboxSong>)playlistEditorLogic).SetPage(page);
				playlistEditorLogic.Select(count);
				navigator.GoToNoMenu(playlistEditor);
			});
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#gray>" + metadata.Artist + "</color>") : string.Empty);
			((CustomContentButton)component).text.text = metadata.Title + " " + text;
			((CustomContentButton)component).icon.sprite = metadata.Icon;
			component.introAndLoopIcon.SetActive(metadata.Composite.GotIntroAndLoop);
			component.calmThemeIcon.SetActive(metadata.Composite.GotCalmTheme || metadata.Composite.GotCalmLoop || metadata.Composite.GotCalmIntro);
			go.SetActive(true);
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		protected override Action BuildDirectory(IDirectoryTree<JukeboxSong> folder, int indexInPage)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			GameObject btn = Object.Instantiate<GameObject>(base.folderButtonTemplate, base.itemParent, false);
			((UnityEventBase)btn.GetComponent<Button>().onClick).RemoveAllListeners();
			((UnityEvent)btn.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				base.StepDown(folder);
			});
			btn.GetComponentInChildren<TMP_Text>().text = folder.name;
			btn.SetActive(true);
			if (folder.name == "YouTube" && folder.parent?.parent == null)
			{
				((Component)btn.transform.Find("Icon")).GetComponent<Image>().sprite = youtubeIcon;
			}
			return delegate
			{
				Object.Destroy((Object)(object)btn);
			};
		}
	}
	[ConfigureSingleton(/*Could not decode attribute arguments.*/)]
	public class JukeboxManager : MonoSingleton<JukeboxManager>
	{
		private const string CanvasPath = "/Canvas";

		private const string CybergrindShopPath = "/FirstRoom/Room/Cybergrind Shop";

		private const string PanelPath = "/FirstRoom/Room/Cybergrind Shop/Canvas/Background/Main Panel";

		[SerializeField]
		public GameObject songPanel;

		[SerializeField]
		public JukeboxPlaylistEditor playlistEditor;

		[SerializeField]
		public JukeboxMusicPlayer player;

		[SerializeField]
		private GameObject terminalPanel;

		[SerializeField]
		private GameObject musicLogic;

		[SerializeField]
		private GameObject musicChanger;

		protected void Awake()
		{
			base.Awake();
			ReplaceOriginalLogic();
			SetupTerminal();
			SetupSongPanel();
		}

		private void SetupTerminal()
		{
			GameObject val = GameObject.Find("/FirstRoom/Room/Cybergrind Shop/Canvas/Background/Main Panel");
			terminalPanel.transform.SetParent(val.transform, false);
		}

		private void ReplaceOriginalLogic()
		{
			Transform val = GameObject.Find("/FirstRoom/Room/Cybergrind Shop").transform.Find("Logic");
			Object.Destroy((Object)(object)((Component)val.Find("Music")).gameObject);
			musicLogic.transform.parent = val;
			CustomMusicPlayer obj = Resources.FindObjectsOfTypeAll<CustomMusicPlayer>()[0];
			Transform parent = ((Component)obj).transform.parent;
			Object.Destroy((Object)(object)((Component)obj).gameObject);
			musicChanger.transform.parent = ((Component)parent).transform;
		}

		private void SetupSongPanel()
		{
			GameObject val = GameObject.Find("/Canvas");
			Object.Destroy((Object)(object)((Component)val.transform.Find("SongPanel")).gameObject);
			songPanel.transform.SetParent(val.transform, false);
		}
	}
	public class JukeboxMusicPlayer : MonoBehaviour
	{
		[SerializeField]
		private JukeboxPlaylistEditor playlistEditor;

		[SerializeField]
		private JukeboxSongsLoader loader;

		[SerializeField]
		private JukeboxMusicChanger changer;

		private Coroutine playlistRoutine;

		private bool forcedChange;

		private bool stopped;

		private bool allowVolumeBoost;

		private static float VolumeBoostValue => MonoSingleton<PrefsManager>.Instance.GetFloatLocal("jukebox.volumeBoost", 0f);

		private static bool AlwaysPlayIntro => MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.alwaysPlayIntro", false);

		private static bool IndividualBoostPerTrack => MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.individualBoostPerTrack", false);

		public AudioSource Source => changer.battle;

		public static JukeboxSong CurrentSong { get; private set; }

		public static int CurrentSongIndex { get; private set; }

		public float VolumeBoost { get; private set; }

		public static event Action<JukeboxSong> OnNextSong;

		public static event Action<IEnumerable<SongIdentifier>> OnOrderChange;

		public static event Action OnStop;

		public void Awake()
		{
			changer = ((Component)this).gameObject.GetComponent<JukeboxMusicChanger>();
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			MonoSingleton<JukeboxInputs>.Instance.DisablePlayer.performed += OnPlayerDisabled;
		}

		public void OnDestroy()
		{
			CurrentSong = null;
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			MonoSingleton<JukeboxInputs>.Instance.DisablePlayer.performed -= OnPlayerDisabled;
		}

		public void OnEnable()
		{
			StartPlaylist();
		}

		public void StartPlaylist()
		{
			stopped = false;
			if (((Playlist)playlistEditor.playlist).Count < 1)
			{
				Debug.LogError((object)"No songs in playlist, somehow. Not starting playlist routine...");
			}
			else
			{
				playlistRoutine = ((MonoBehaviour)this).StartCoroutine(PlaylistRoutine());
			}
		}

		public void Stop()
		{
			stopped = true;
		}

		public void StopPlaylist()
		{
			Source.Stop();
			((MonoBehaviour)this).StopCoroutine(playlistRoutine);
			CurrentSong = null;
			stopped = true;
		}

		public void ChangeTrack(int index)
		{
			CurrentSongIndex = index;
			forcedChange = true;
		}

		private IEnumerator PlaylistRoutine()
		{
			WaitUntil songFinished = new WaitUntil((Func<bool>)(() => ((!Source.isPlaying && Application.isFocused) || MonoSingleton<JukeboxInputs>.Instance.NextTrack.WasPerformedThisFrame() || forcedChange) && !stopped));
			bool firstSong2 = true;
			JukeboxPlaylist playlist = playlistEditor.playlist;
			IEnumerable<SongIdentifier> shuffled = (((Playlist)playlist).shuffled ? new DeckShuffled<SongIdentifier>(((Playlist)playlist).ids).AsEnumerable() : ((Playlist)playlist).ids.AsEnumerable());
			while (!stopped)
			{
				if (shuffled is DeckShuffled<SongIdentifier> deckShuffled)
				{
					deckShuffled.Reshuffle();
				}
				List<SongIdentifier> currentOrder = shuffled.ToList();
				JukeboxMusicPlayer.OnOrderChange?.Invoke(currentOrder);
				CurrentSongIndex = (((int)((Playlist)playlist).loopMode == 1) ? currentOrder.FindIndex((SongIdentifier id) => object.Equals(id, ((Playlist)playlist).ids[((Playlist)playlist).selected])) : 0);
				while (CurrentSongIndex < currentOrder.Count)
				{
					forcedChange = false;
					SongIdentifier val = currentOrder[CurrentSongIndex];
					JukeboxSong song = loader.Load(val);
					NextSong(song);
					PresenceController.UpdateCyberGrindWave(MonoSingleton<EndlessGrid>.Instance.currentWave);
					yield return song.Acquire(Play(firstSong2));
					firstSong2 = false;
					CurrentSongIndex++;
					IEnumerator Play(bool firstSong)
					{
						if ((firstSong || AlwaysPlayIntro) && (Object)(object)song.IntroClip != (Object)null)
						{
							changer.ChangeTo(song.IntroClip, song.CalmIntroClip);
							yield return songFinished;
						}
						int clipsPlayed = 0;
						for (int i = 0; i < song.Clips.Count; i++)
						{
							if (stopped)
							{
								break;
							}
							do
							{
								JukeboxMusicChanger jukeboxMusicChanger = changer;
								AudioClip battleTheme = song.Clips[i];
								List<AudioClip> calmClips = song.CalmClips;
								jukeboxMusicChanger.ChangeTo(battleTheme, (calmClips != null && calmClips.Count > i) ? song.CalmClips[i] : null);
								yield return songFinished;
								int num = clipsPlayed + 1;
								clipsPlayed = num;
							}
							while ((int)((Playlist)playlist).loopMode == 1 && !stopped && !forcedChange && !MonoSingleton<JukeboxInputs>.Instance.NextTrack.WasPerformedThisFrame());
							if ((int)((Playlist)playlist).loopMode != 1 && song.MaxClipsIfNotRepeating > 0 && clipsPlayed >= song.MaxClipsIfNotRepeating)
							{
								break;
							}
						}
					}
				}
			}
		}

		private void OnPlayerDisabled(CallbackContext _)
		{
			if (!stopped)
			{
				StopPlaylist();
				JukeboxMusicPlayer.OnStop?.Invoke();
			}
			else
			{
				StartPlaylist();
			}
		}

		private void OnPrefChanged(string key, object value)
		{
			if (!(key == "jukebox.volumeBoost"))
			{
				if (key == "jukebox.individualBoostPerTrack")
				{
					VolumeBoost = CalculateBoostFor(CurrentSong);
				}
				return;
			}
			if (IndividualBoostPerTrack)
			{
				JukeboxSong currentSong = CurrentSong;
				if (currentSong != null && currentSong.IsCustom)
				{
					MonoSingleton<JukeboxVolumeManager>.Instance.SetVolumeBoostFor(CurrentSong.Id.path, (float)value);
				}
			}
			VolumeBoost = (float)value;
		}

		private void NextSong(JukeboxSong song)
		{
			CurrentSong = song;
			allowVolumeBoost = song.IsCustom;
			VolumeBoost = CalculateBoostFor(song);
			JukeboxMusicPlayer.OnNextSong?.Invoke(song);
		}

		private float CalculateBoostFor(JukeboxSong song)
		{
			if (!allowVolumeBoost)
			{
				return 0f;
			}
			if (!IndividualBoostPerTrack)
			{
				return VolumeBoostValue;
			}
			if (song != null)
			{
				float? volumeBoostFor = MonoSingleton<JukeboxVolumeManager>.Instance.GetVolumeBoostFor(song.Id.path);
				if (volumeBoostFor.HasValue)
				{
					return volumeBoostFor.GetValueOrDefault();
				}
			}
			return VolumeBoostValue;
		}
	}
	[ConfigureSingleton(/*Could not decode attribute arguments.*/)]
	public class JukeboxPauseManager : MonoSingleton<JukeboxPauseManager>
	{
		public void Pause(string stateKey, GameObject window)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0050: Expected O, but got Unknown
			((Behaviour)MonoSingleton<NewMovement>.Instance).enabled = false;
			MonoSingleton<CameraController>.Instance.activated = false;
			MonoSingleton<GunControl>.Instance.activated = false;
			GameStateManager.Instance.RegisterState(new GameState(stateKey, (GameObject[])(object)new GameObject[1] { window })
			{
				cursorLock = (LockMode)2,
				cameraInputLock = (LockMode)1,
				playerInputLock = (LockMode)1
			});
			MonoSingleton<OptionsManager>.Instance.paused = true;
		}

		public void UnPause()
		{
			Time.timeScale = MonoSingleton<TimeController>.Instance.timeScale * MonoSingleton<TimeController>.Instance.timeScaleModifier;
			MonoSingleton<OptionsManager>.Instance.paused = false;
			MonoSingleton<CameraController>.Instance.activated = true;
			((Behaviour)MonoSingleton<NewMovement>.Instance).enabled = true;
			MonoSingleton<GunControl>.Instance.activated = true;
		}
	}
	public class JukeboxPlayback : DirectoryTreeBrowser<SongIdentifier>
	{
		[SerializeField]
		private Sprite defaultIcon;

		[SerializeField]
		private GameObject disclaimer;

		[SerializeField]
		private GameObject buttonsSection;

		private readonly List<Transform> buttons = new List<Transform>();

		private IEnumerable<SongIdentifier> order = new List<SongIdentifier>();

		protected override int maxPageLength => 6;

		protected override IDirectoryTree<SongIdentifier> baseDirectory => (IDirectoryTree<SongIdentifier>)(object)new FakeDirectoryTree<SongIdentifier>("Playlist", order, (IEnumerable<IDirectoryTree<SongIdentifier>>)null, (IDirectoryTree<SongIdentifier>)null);

		private CustomContentButton CurrentButton
		{
			get
			{
				Transform? obj = buttons.ElementAtOrDefault(JukeboxMusicPlayer.CurrentSongIndex % ((DirectoryTreeBrowser<SongIdentifier>)this).maxPageLength);
				if (obj == null)
				{
					return null;
				}
				return ((Component)obj).GetComponent<CustomContentButton>();
			}
		}

		protected void Awake()
		{
			JukeboxMusicPlayer.OnOrderChange += OnOrderChange;
			JukeboxMusicPlayer.OnNextSong += OnNextSong;
		}

		protected void OnDestroy()
		{
			JukeboxMusicPlayer.OnOrderChange -= OnOrderChange;
			JukeboxMusicPlayer.OnNextSong -= OnNextSong;
		}

		protected void OnEnable()
		{
			base.GoToBase();
		}

		public void NextPage()
		{
			base.SetPage((base.currentPage != base.maxPages - 1) ? (base.currentPage + 1) : 0);
		}

		public void PreviousPage()
		{
			base.SetPage((base.currentPage == 0) ? (base.maxPages - 1) : (base.currentPage - 1));
		}

		protected override Action BuildLeaf(SongIdentifier id, int indexInPage)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			JukeboxSongMetadata metadata = MonoSingleton<JukeboxSongsLoader>.Instance.Load(id).Metadata;
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemButtonTemplate.transform.parent);
			CustomContentButton component = go.GetComponent<CustomContentButton>();
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#gray>" + metadata.Artist + "</color>") : string.Empty);
			component.text.text = metadata.Title + " " + text;
			component.icon.sprite = (((Object)(object)metadata.Icon != (Object)null) ? metadata.Icon : defaultIcon);
			go.SetActive(true);
			buttons.Add(go.transform);
			if (base.PageOf(JukeboxMusicPlayer.CurrentSongIndex) == base.currentPage && (Object)(object)component == (Object)(object)CurrentButton)
			{
				((Graphic)component.border).color = new Color(0.5f, 0.5f, 0.5f, 0.5f);
				Object.Destroy((Object)(object)go.GetComponent<Button>());
			}
			else
			{
				((UnityEvent)component.button.onClick).AddListener((UnityAction)delegate
				{
					MonoSingleton<JukeboxManager>.Instance.player.ChangeTrack(base.currentPage * ((DirectoryTreeBrowser<SongIdentifier>)this).maxPageLength + indexInPage - 1);
				});
			}
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		private void OnOrderChange(IEnumerable<SongIdentifier> songs)
		{
			order = songs;
			((DirectoryTreeBrowser<SongIdentifier>)this).Rebuild(true);
		}

		private void OnNextSong(JukeboxSong _)
		{
			buttonsSection.SetActive(true);
			disclaimer.SetActive(false);
			((DirectoryTreeBrowser<SongIdentifier>)this).Rebuild(false);
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			buttons.Clear();
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
			base.Rebuild(setToPageZero);
		}
	}
	public class JukeboxPlaylistEditor : DirectoryTreeBrowser<JukeboxSong>
	{
		private readonly Dictionary<Transform, Coroutine> changeAnchorRoutines = new Dictionary<Transform, Coroutine>();

		private readonly List<Transform> buttons = new List<Transform>();

		[SerializeField]
		private JukeboxSongsLoader loader;

		[SerializeField]
		private JukeboxSoundtrackBrowser browser;

		[SerializeField]
		private Sprite defaultIcon;

		[SerializeField]
		private Sprite loopSprite;

		[SerializeField]
		private Sprite loopOnceSprite;

		[Header("UI Elements")]
		[SerializeField]
		private Image loopModeImage;

		[SerializeField]
		private Image shuffleImage;

		[SerializeField]
		private RectTransform selectedControls;

		[SerializeField]
		private List<Transform> anchors;

		public JukeboxPlaylist playlist = new JukeboxPlaylist();

		protected override int maxPageLength => anchors.Count;

		protected override IDirectoryTree<JukeboxSong> baseDirectory => (IDirectoryTree<JukeboxSong>)(object)new FakeDirectoryTree<JukeboxSong>("Songs", ((Playlist)playlist).ids.Select((SongIdentifier id) => loader.Load(id)), (IEnumerable<IDirectoryTree<JukeboxSong>>)null, (IDirectoryTree<JukeboxSong>)null);

		private JukeboxCustomContentButton CurrentButton
		{
			get
			{
				Transform? obj = buttons.ElementAtOrDefault(((Playlist)playlist).selected % ((DirectoryTreeBrowser<JukeboxSong>)this).maxPageLength);
				if (obj == null)
				{
					return null;
				}
				return ((Component)obj).GetComponent<JukeboxCustomContentButton>();
			}
		}

		private void Start()
		{
			ReloadPlaylist();
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChange));
		}

		public void ReloadPlaylist()
		{
			//IL_0009: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				LoadPlaylist();
			}
			catch (JsonReaderException val)
			{
				JsonReaderException val2 = val;
				Debug.LogError((object)("Error loading Playlist.json: '" + ((Exception)(object)val2).Message + "'. Recreating file."));
				File.Delete(JukeboxPlaylist.currentPath);
				LoadPlaylist();
			}
			Select(((Playlist)playlist).selected);
			SetLoopMode(((Playlist)playlist).loopMode);
			SetShuffle(((Playlist)playlist).shuffled);
			((Playlist)playlist).OnChanged += SavePlaylist;
		}

		private void OnDestroy()
		{
			((Playlist)playlist).OnChanged -= SavePlaylist;
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChange));
		}

		public void SavePlaylist()
		{
			File.WriteAllText(JukeboxPlaylist.currentPath, JsonConvert.SerializeObject((object)playlist));
		}

		public void LoadPlaylist()
		{
			Debug.Log((object)("Loading Playlist " + JukeboxPlaylist.currentPath));
			JukeboxPlaylist val;
			using (StreamReader streamReader = new StreamReader(File.Open(JukeboxPlaylist.currentPath, FileMode.OpenOrCreate)))
			{
				val = JsonConvert.DeserializeObject<JukeboxPlaylist>(streamReader.ReadToEnd());
			}
			if (val == null)
			{
				CreateEmpty();
			}
			else
			{
				val.RemoveNonExisting();
				if (((Playlist)val).ids.Count == 0)
				{
					CreateEmpty();
				}
				else
				{
					playlist = val;
				}
				base.currentDirectory = ((DirectoryTreeBrowser<JukeboxSong>)this).baseDirectory;
				((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
			}
			if (MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.preventDuplicateTracks", false))
			{
				playlist.RemoveDuplicates();
			}
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
			void CreateEmpty()
			{
				Debug.Log((object)("No saved playlist found at " + JukeboxPlaylist.currentPath + ". Creating default..."));
				CreateDefaultPlaylist();
			}
		}

		public void Remove()
		{
			((Playlist)playlist).Remove(((Playlist)playlist).selected);
			if (((Playlist)playlist).selected >= ((Playlist)playlist).ids.Count)
			{
				Select(((Playlist)playlist).Count - 1);
			}
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(false);
		}

		public void ClearPlaylist()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			((Playlist)playlist).ids.Clear();
			AssetReferenceSoundtrackSong val = browser.rootFolder[0];
			playlist.Add(new SongIdentifier(((AssetReference)val).AssetGUID, (IdentifierType)0));
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
		}

		public void NextPage()
		{
			base.SetPage((base.currentPage != base.maxPages - 1) ? (base.currentPage + 1) : 0);
		}

		public void PreviousPage()
		{
			base.SetPage((base.currentPage == 0) ? (base.maxPages - 1) : (base.currentPage - 1));
		}

		public void MoveUp()
		{
			Move(-1);
		}

		public void MoveDown()
		{
			Move(1);
		}

		public void Move(int amount)
		{
			int num = ((Playlist)playlist).selected % ((DirectoryTreeBrowser<JukeboxSong>)this).maxPageLength;
			int index = num + amount;
			int count = ((Playlist)playlist).ids.Count;
			bool num2 = base.PageOf(((Playlist)playlist).selected) == base.PageOf((((Playlist)playlist).selected + amount).Mod(count));
			((Playlist)playlist).Swap(((Playlist)playlist).selected, (((Playlist)playlist).selected + amount).Mod(count));
			if (num2)
			{
				ChangeAnchorOf(buttons[num], anchors[index]);
				ChangeAnchorOf((Transform)(object)selectedControls, anchors[index]);
				ChangeAnchorOf(buttons[index], anchors[num]);
				JukeboxCustomContentButton currentButton = CurrentButton;
				buttons.RemoveAt(num);
				buttons.Insert(index, ((Component)currentButton).transform);
				Select(((Playlist)playlist).selected + amount, rebuild: false);
			}
			else
			{
				((Component)selectedControls).gameObject.SetActive(false);
				Select((((Playlist)playlist).selected + amount).Mod(count));
			}
		}

		public void ChangeAnchorOf(Transform obj, Transform anchor, float time = 0.15f)
		{
			if (changeAnchorRoutines.ContainsKey(obj))
			{
				if (changeAnchorRoutines[obj] != null)
				{
					((MonoBehaviour)this).StopCoroutine(changeAnchorRoutines[obj]);
				}
				changeAnchorRoutines.Remove(obj);
			}
			changeAnchorRoutines.Add(obj, ((MonoBehaviour)this).StartCoroutine(ChangeAnchorOverTime()));
			IEnumerator ChangeAnchorOverTime()
			{
				float t = 0f;
				while ((double)t < (double)time && (double)time > 0.0)
				{
					obj.position = Vector3.MoveTowards(obj.position, anchor.position, Time.deltaTime * 2f);
					if (!((double)Vector3.Distance(obj.position, anchor.position) > (double)Mathf.Epsilon))
					{
						break;
					}
					yield return null;
				}
				obj.position = anchor.position;
			}
		}

		public void ToggleLoopMode()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			SetLoopMode((LoopMode)(((int)((Playlist)playlist).loopMode == 0) ? 1 : 0));
		}

		private void SetLoopMode(LoopMode mode)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			((Playlist)playlist).loopMode = mode;
			loopModeImage.sprite = (((int)((Playlist)playlist).loopMode == 0) ? loopSprite : loopOnceSprite);
		}

		public void ToggleShuffle()
		{
			SetShuffle(!((Playlist)playlist).shuffled);
		}

		private void SetShuffle(bool shuffle)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			((Playlist)playlist).shuffled = shuffle;
			((Graphic)shuffleImage).color = (shuffle ? Color.white : Color.gray);
		}

		public void Select(int newIndex, bool rebuild = true)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if (newIndex < 0 || newIndex >= ((Playlist)playlist).Count)
			{
				Debug.LogWarning((object)"Attempted to set current index outside bounds of playlist");
				return;
			}
			int num = ((base.PageOf(newIndex) == base.currentPage) ? 1 : 0);
			if (Object.op_Implicit((Object)(object)CurrentButton))
			{
				((Graphic)((CustomContentButton)CurrentButton).border).color = Color.white;
				if ((Object)(object)((CustomContentButton)CurrentButton).iconInset != (Object)null)
				{
					((Graphic)((CustomContentButton)CurrentButton).iconInset).color = Color.white;
				}
			}
			int selected = ((Playlist)playlist).selected;
			((Playlist)playlist).selected = newIndex;
			if (base.PageOf(selected) < base.PageOf(newIndex))
			{
				ChangeAnchorOf((Transform)(object)selectedControls, anchors.First(), 0f);
			}
			else if (base.PageOf(selected) > base.PageOf(newIndex))
			{
				ChangeAnchorOf((Transform)(object)selectedControls, anchors.Last(), 0f);
			}
			if (Object.op_Implicit((Object)(object)CurrentButton))
			{
				((Graphic)((CustomContentButton)CurrentButton).border).color = Color.red;
				if ((Object)(object)((CustomContentButton)CurrentButton).iconInset != (Object)null)
				{
					((Graphic)((CustomContentButton)CurrentButton).iconInset).color = Color.red;
				}
			}
			Transform val = anchors[((Playlist)playlist).selected % ((DirectoryTreeBrowser<JukeboxSong>)this).maxPageLength];
			if (num != 0)
			{
				((Component)selectedControls).gameObject.SetActive(true);
				ChangeAnchorOf((Transform)(object)selectedControls, val);
			}
			else
			{
				((Component)selectedControls).gameObject.SetActive(false);
				((Component)selectedControls).transform.position = val.position;
			}
			if (rebuild)
			{
				((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(false);
				if (MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.enableTracksPreview", false) && MonoSingleton<FistControl>.Instance.shopping)
				{
					JukeboxSong song = loader.Load(((Playlist)playlist).ids[newIndex]);
					Object.FindObjectOfType<PreviewHelper>().PlayPreview(song);
				}
			}
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			foreach (KeyValuePair<Transform, Coroutine> changeAnchorRoutine in changeAnchorRoutines)
			{
				if (changeAnchorRoutine.Value != null)
				{
					((MonoBehaviour)this).StopCoroutine(changeAnchorRoutine.Value);
				}
			}
			changeAnchorRoutines.Clear();
			buttons.Clear();
			base.Rebuild(setToPageZero);
			if (buttons.Count < ((DirectoryTreeBrowser<JukeboxSong>)this).maxPageLength)
			{
				ChangeAnchorOf(base.plusButton.transform, anchors[buttons.Count], 0f);
			}
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
		}

		protected override Action BuildLeaf(JukeboxSong song, int currentIndex)
		{
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			JukeboxSongMetadata metadata = song.Metadata;
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemButtonTemplate.transform.parent);
			JukeboxCustomContentButton contentButton = go.GetComponent<JukeboxCustomContentButton>();
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#gray>" + metadata.Artist + "</color>") : string.Empty);
			((CustomContentButton)contentButton).text.text = metadata.Title + " " + text;
			((CustomContentButton)contentButton).icon.sprite = (((Object)(object)metadata.Icon != (Object)null) ? metadata.Icon : defaultIcon);
			contentButton.introAndLoopIcon.SetActive(metadata.Composite.GotIntroAndLoop);
			contentButton.calmThemeIcon.SetActive(metadata.Composite.GotCalmTheme || metadata.Composite.GotCalmLoop || metadata.Composite.GotCalmIntro);
			go.SetActive(true);
			ChangeAnchorOf(go.transform, anchors[currentIndex], 0f);
			buttons.Add(go.transform);
			if (base.PageOf(((Playlist)playlist).selected) == base.currentPage && (Object)(object)contentButton == (Object)(object)CurrentButton)
			{
				((Graphic)((CustomContentButton)contentButton).border).color = Color.red;
				if ((Object)(object)((CustomContentButton)CurrentButton).iconInset != (Object)null)
				{
					((Graphic)((CustomContentButton)CurrentButton).iconInset).color = Color.red;
				}
				((Component)selectedControls).gameObject.SetActive(true);
				ChangeAnchorOf((Transform)(object)selectedControls, anchors[currentIndex]);
				return delegate
				{
					((Component)selectedControls).gameObject.SetActive(false);
					Object.Destroy((Object)(object)go);
				};
			}
			((UnityEvent)((CustomContentButton)contentButton).button.onClick).AddListener((UnityAction)delegate
			{
				Select(buttons.IndexOf(((Component)contentButton).transform) + base.currentPage * ((DirectoryTreeBrowser<JukeboxSong>)this).maxPageLength);
			});
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		private void CreateDefaultPlaylist()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			foreach (AssetReferenceSoundtrackSong item in browser.rootFolder)