using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using Discord;
using HarmonyLib;
using Jukebox.Components;
using Jukebox.Components.HUD;
using Jukebox.Components.Player;
using Jukebox.Input;
using Jukebox.Patches;
using Jukebox.RTLTMPro;
using Jukebox.UI;
using Jukebox.UI.Elements;
using Jukebox.UI.Windows;
using Jukebox.Utils;
using JukeboxCore.Collections;
using JukeboxCore.Components;
using JukeboxCore.Events;
using JukeboxCore.Logging;
using JukeboxCore.Models.Preferences;
using JukeboxCore.Playback;
using JukeboxCore.Songs;
using JukeboxCore.Songs.Models;
using JukeboxCore.Subtitles;
using JukeboxCore.Utils;
using Microsoft.CodeAnalysis;
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.3.2.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("2.3.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Jukebox
{
	[BepInProcess("ULTRAKILL.exe")]
	[BepInPlugin("dev.flazhik.jukebox", "Jukebox", "2.3.2")]
	public class JukeboxPlugin : BaseUnityPlugin
	{
		private static GameObject _bootstrap;

		public static 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			JukeboxLogger.Initialize(((BaseUnityPlugin)this).Logger);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Addressables.InitializeAsync().WaitForCompletion();
			Addressables.LoadContentCatalogAsync(Path.Combine(catalogDir, "catalog.json"), true, (string)null).WaitForCompletion();
			_harmony = new Harmony("dev.flazhik.jukebox");
			Startup();
		}

		private void Start()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			_bootstrap = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Jukebox/Bootstrap.prefab").WaitForCompletion();
			InputActionsPatch.Load();
			HudFontMaterials.Load();
			JukeboxCustomSongMetadata.Load();
		}

		private void OnDestroy()
		{
			JukeboxLogger.Shutdown();
		}

		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();
				SetDefaultGlyphSubstitution();
				break;
			case "Main Menu":
				if (!_init)
				{
					_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.resumeLastSong", false },
				{ "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.displaySubtitles", true },
				{ "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 void SetDefaultGlyphSubstitution()
		{
			TMP_Settings.missingGlyphCharacter = 63;
		}

		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("CGME menu is available by pressing <color=orange>" + text + "</color>", "", "", 0, false, false, true);
			_motDShown = true;
		}
	}
	public static class JukeboxPluginInfo
	{
		public const string Guid = "dev.flazhik.jukebox";

		public const string Name = "Jukebox";

		public const string Version = "2.3.2";
	}
}
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 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 (currentLetter < message.Length && message[currentLetter] != '>')
					{
						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)
		{
			string message = text.text;
			int currentLetter = message.Length - 1;
			while (currentLetter >= 0)
			{
				int num;
				if (message[currentLetter] == '>')
				{
					while (currentLetter >= 0 && message[currentLetter] != '<')
					{
						num = currentLetter - 1;
						currentLetter = num;
					}
				}
				num = currentLetter - 1;
				currentLetter = num;
				text.text = message.Substring(0, currentLetter + 1);
				yield return (object)new WaitForSecondsRealtime(secondsBetweenLetters);
			}
		}

		public static IEnumerator Reveal(TMP_Text text, float secondsBetweenLetters = 0.005f, AudioSource clickAudio = null)
		{
			text.ForceMeshUpdate(false, false);
			int total = text.textInfo.characterCount;
			int visible = 0;
			text.maxVisibleCharacters = 0;
			while (visible < total)
			{
				visible = (text.maxVisibleCharacters = visible + 1);
				if ((Object)(object)clickAudio != (Object)null)
				{
					clickAudio.Play();
				}
				yield return (object)new WaitForSecondsRealtime(secondsBetweenLetters);
			}
		}

		public static IEnumerator Conceal(TMP_Text text, float secondsBetweenLetters = 0.005f)
		{
			int visible = text.maxVisibleCharacters;
			while (visible > 0)
			{
				visible = (text.maxVisibleCharacters = visible - 1);
				yield return (object)new WaitForSecondsRealtime(secondsBetweenLetters);
			}
		}
	}
	public static class TmpTextExtensions
	{
		public static void SetPreservingRtl(this TMP_Text text, string value)
		{
			RtlUtils.Set(text, value);
		}
	}
}
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 whatIsNewMenuTemplate;

		[SerializeField]
		public GameObject nowPlayingHudTemplate;

		[SerializeField]
		public GameObject nowPlayingHudClassicTemplate;

		private GameObject jukeboxMenu;

		private GameObject playbackMenu;

		private GameObject whatIsNew;

		private ReadOnlyCollection<JukeboxWindow> windows;

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

		protected void Update()
		{
			ManageWindows();
		}

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

		private void ManageWindows()
		{
			if (GameIsPaused())
			{
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Pause.WasPerformedThisFrame)
			{
				foreach (JukeboxWindow item in windows.Where((JukeboxWindow window) => window.IsOpened()))
				{
					item.Close();
				}
				return;
			}
			JukeboxWindow jukeboxWindow = windows.FirstOrDefault((JukeboxWindow w) => (Object)(object)w.hotkey != (Object)null && w.hotkey.ToInputAction().WasPerformedThisFrame());
			if ((Object)(object)jukeboxWindow != (Object)null)
			{
				foreach (JukeboxWindow window in windows)
				{
					if ((Object)(object)window.hotkey != (Object)null && InputExtensions.IsActionEqual(window.hotkey.ToInputAction(), jukeboxWindow.hotkey.ToInputAction(), (string)null))
					{
						window.Toggle();
					}
					else
					{
						window.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);
			whatIsNew = Object.Instantiate<GameObject>(whatIsNewMenuTemplate, 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 IEnumerator WhatIsNewRoutine()
		{
			yield return (object)new WaitForSeconds(1.4f);
			whatIsNew.GetComponent<WhatsNew>().Open();
		}

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

		public float ySpeed;

		private RawImage img;

		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;

		private IPlaybackController player;

		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);
				});
			}
			player = (IPlaybackController)(object)MonoSingleton<JukeboxManager>.Instance?.player;
			IPlaybackController obj = player;
			if (obj != null)
			{
				obj.OnNextAudioClip += NextAudioClip;
			}
		}

		protected void OnDestroy()
		{
			player.OnNextAudioClip -= NextAudioClip;
		}

		public void NextAudioClip(ClipChangedArgs clip)
		{
			if (clip.NewSong && clip.Song.IsCustom)
			{
				ReflectionUtils.GetPrivate<Slider>((object)generalSettings.GetComponentInChildren<SettingsSlider>(true), typeof(SettingsSlider), "slider").value = player.State.VolumeBoost;
			}
		}

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

		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;

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

		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();
			}
		}

		public bool IsOpened()
		{
			return ((Component)this).gameObject.activeSelf;
		}
	}
	public class WhatsNew : JukeboxWindow
	{
		private const string PrefsKey = "Jukebox.2.3.0-Release";

		private void Start()
		{
			if (PlayerPrefs.GetInt("Jukebox.2.3.0-Release") != 1)
			{
				PlayerPrefs.SetInt("Jukebox.2.3.0-Release", 1);
			}
			else
			{
				Close();
			}
		}

		public override string StateKey()
		{
			return "jukebox.whatisnew";
		}
	}
}
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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: 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)
		{
			PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
			if (instance != null)
			{
				instance.SetIntLocal("jukebox.calmThemeEnemiesThreshold", value);
			}
		}
	}
}
namespace Jukebox.UI.Subtitles
{
	public class SubtitlesPanel : MonoBehaviour
	{
		[SerializeField]
		public CanvasGroup panelGroup;

		[SerializeField]
		public TMP_Text text;

		[SerializeField]
		public float approachTime;

		[SerializeField]
		public Material fontMaterial;

		private bool displaySubtitles;

		private Coroutine displayRoutine;

		private IPlaybackController player;

		public void Awake()
		{
			player = (IPlaybackController)(object)MonoSingleton<JukeboxManager>.Instance?.player;
			if (player == null)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			player.OnSubtitleChanged += OnSubtitleChanged;
			player.OnStop += OnStop;
			displaySubtitles = MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.displaySubtitles", false);
			Stall();
		}

		public void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			if (player != null)
			{
				player.OnSubtitleChanged -= OnSubtitleChanged;
				player.OnStop -= OnStop;
			}
		}

		public void RestoreFontMaterial()
		{
			if ((Object)(object)fontMaterial != (Object)null)
			{
				text.fontMaterial = fontMaterial;
			}
		}

		private void OnSubtitleChanged(string contents)
		{
			if (displaySubtitles)
			{
				if (string.IsNullOrEmpty(contents))
				{
					StartFade(0f);
					return;
				}
				text.text = contents;
				StartFade(1f);
				text.ForceMeshUpdate(false, false);
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)((Component)this).transform.parent).GetComponent<RectTransform>());
			}
		}

		private void OnStop()
		{
			Stall();
		}

		private void OnPrefChanged(string key, object value)
		{
			if (key.Equals("jukebox.displaySubtitles"))
			{
				displaySubtitles = (bool)value;
				if (!displaySubtitles)
				{
					Stall();
				}
			}
		}

		private void StartFade(float target)
		{
			if (displayRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(displayRoutine);
			}
			displayRoutine = null;
			if (!Mathf.Approximately(panelGroup.alpha, target))
			{
				displayRoutine = ((MonoBehaviour)this).StartCoroutine(Fade(target));
			}
		}

		private IEnumerator Fade(float target)
		{
			float start = panelGroup.alpha;
			float time = 0f;
			while (time < approachTime)
			{
				time += Time.unscaledDeltaTime;
				panelGroup.alpha = Mathf.Lerp(start, target, time / approachTime);
				yield return null;
			}
			panelGroup.alpha = target;
		}

		private void Stall()
		{
			if (displayRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(displayRoutine);
				displayRoutine = null;
			}
			text.text = string.Empty;
			panelGroup.alpha = 0f;
		}
	}
}
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)text).color = new Color(1f, 1f, 1f, 1f);
			RectTransform rect = ((Component)panelGroup).GetComponent<RectTransform>();
			rect.sizeDelta = startDimensions;
			if (rollingTextRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rollingTextRoutine);
			}
			rollingTextRoutine = ((MonoBehaviour)this).StartCoroutine(ScrollingTextUnscaled.Reveal(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.Conceal(text, 0.022f));
			RectTransform rect = ((Component)panelGroup).GetComponent<RectTransform>();
			float time = panelApproachTime;
			yield return (object)new WaitUntil((Func<bool>)(() => text.maxVisibleCharacters <= 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", source.Where((SongIdentifier id) => (int)id.type != 1 || File.Exists(id.path)).Select(delegate(SongIdentifier id)
				{
					JukeboxSongsLoader instance = MonoSingleton<JukeboxSongsLoader>.Instance;
					return (instance == null) ? null : instance.Get(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
			{
				PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
				if (instance != null)
				{
					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 active;

		protected bool showIndefinitely;

		private Coroutine displayRoutine;

		private IPlaybackController player;

		protected abstract SongPanelStyle Style { get; }

		public void Awake()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			player = (IPlaybackController)(object)MonoSingleton<JukeboxManager>.Instance.player;
			player.OnNextAudioClip += NextAudioClip;
			player.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));
			player.OnNextAudioClip -= NextAudioClip;
			player.OnStop -= OnStop;
		}

		protected abstract IEnumerator FadeIn(JukeboxSongMetadata metadata);

		protected abstract IEnumerator Await();

		protected abstract IEnumerator FadeOut();

		private IEnumerator ShowPanelRoutine(JukeboxSongMetadata metadata)
		{
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#999>" + metadata.Artist + "</color>") : string.Empty);
			this.text.SetPreservingRtl(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 NextAudioClip(ClipChangedArgs clip)
		{
			if (clip.NewSong)
			{
				active = MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)Style;
				if (displayRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(displayRoutine);
				}
				displayRoutine = ((MonoBehaviour)this).StartCoroutine(ShowPanelRoutine(clip.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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)this).gameObject.GetComponent<Image>();
			PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
			((Graphic)component).color = ((((instance != null) ? new int?(instance.GetIntLocal("jukebox.songPanelStyle", 0)) : ((int?)null)) == (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);
			}
			PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
			if (instance != null)
			{
				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 IEnumerator changeValueRoutine;

		private int tmpValue;

		[CompilerGenerated]
		private int <Value>k__BackingField;

		public int Value
		{
			[CompilerGenerated]
			get
			{
				return <Value>k__BackingField;
			}
			set
			{
				<Value>k__BackingField = 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;
		}
	}
	public class RewindSlider : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler
	{
		[SerializeField]
		public Slider slider;

		[NonSerialized]
		public bool beingDragged;

		public event Action<float> OnValueChanged;

		public void OnPointerDown(PointerEventData eventData)
		{
			beingDragged = true;
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			beingDragged = false;
			this.OnValueChanged?.Invoke(slider.value);
		}
	}
}
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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
			ChangeFileName((instance != null) ? instance.GetStringLocal(prefsKey, (string)null) : 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_0047: Unknown result type (might be due to invalid IL or missing references)
			InputManager instance = MonoSingleton<InputManager>.Instance;
			InputAction val = ((instance != null) ? instance.InputSource.Actions.asset.FindAction(action.ToInputAction().id) : null);
			((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;

		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>());
		}

		protected abstract GameObject Template();

		protected abstract void Init();
	}
}
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.State.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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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)
			//IL_0132: Expected O, but got Unknown
			JukeboxMusicPlayer jukeboxMusicPlayer = MonoSingleton<JukeboxManager>.Instance?.player;
			if ((Object)(object)jukeboxMusicPlayer == (Object)null || jukeboxMusicPlayer.State.Song == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if ((Object)(object)DiscordController.Instance == (Object)null)
			{
				return false;
			}
			Activity val = ReflectionUtils.GetPrivate<Activity>((object)DiscordController.Instance, typeof(DiscordController), "cachedActivity");
			string details = val.Details;
			try
			{
				bool num = ReflectionUtils.GetPrivate<bool>((object)DiscordController.Instance, typeof(DiscordController), "disabled");
				ActivityManager val2 = ReflectionUtils.GetPrivate<ActivityManager>((object)DiscordController.Instance, typeof(DiscordController), "activityManager");
				Discord val3 = ReflectionUtils.GetPrivate<Discord>((object)DiscordController.Instance, typeof(DiscordController), "discord");
				if (num)
				{
					return false;
				}
				val.Details = $"WAVE: {wave} | \ud83c\udfb5 {jukeboxMusicPlayer.State.Song.ArtistAndTrack}";
				ReflectionUtils.SetPrivate<DiscordController, Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity", val);
				if (val3 == null || val2 == null)
				{
					return false;
				}
				Activity val4 = val;
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					UpdateActivityHandler val5 = delegate
					{
					};
					<>c.<>9__0_0 = val5;
					obj = (object)val5;
				}
				val2.UpdateActivity(val4, (UpdateActivityHandler)obj);
				return false;
			}
			catch (Exception)
			{
				val.Details = details;
				ReflectionUtils.SetPrivate<DiscordController, Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity", val);
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(FinalCyberRank))]
	public static class FinalCyberRankPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(FinalCyberRank), "GameOver")]
		public static void FinalCyberRank_GameOver_Prefix()
		{
			JukeboxMusicPlayer jukeboxMusicPlayer = MonoSingleton<JukeboxManager>.Instance?.player;
			if ((Object)(object)jukeboxMusicPlayer != (Object)null && MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.resumeLastSong", false) && jukeboxMusicPlayer.State.Song != null && (Object)(object)jukeboxMusicPlayer.Source.clip != (Object)null)
			{
				JukeboxPreferencesManager instance = MonoSingleton<JukeboxPreferencesManager>.Instance;
				instance.SetPlaybackPosition(jukeboxMusicPlayer.State.Song.Id, jukeboxMusicPlayer.State.ClipIndex, jukeboxMusicPlayer.Source.time);
				instance.ForceSavePreferences();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FinalCyberRank), "Appear")]
		public static void FinalCyberRank_Appear_Postfix(FinalCyberRank __instance)
		{
			JukeboxMusicPlayer jukeboxMusicPlayer = MonoSingleton<JukeboxManager>.Instance?.player;
			if (jukeboxMusicPlayer != null && __instance.toAppear[0].activeSelf && !jukeboxMusicPlayer.State.Stopped)
			{
				MonoSingleton<JukeboxManager>.Instance?.player.Stop();
			}
		}
	}
	[HarmonyPatch(typeof(InputActions))]
	public static class InputActionsPatch
	{
		private const string ActionMapName = "Jukebox";

		private static InputActionAsset _controls;

		public static void Load()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			_controls = Addressables.LoadAssetAsync<InputActionAsset>((object)"Assets/Jukebox/JukeboxControls.inputactions").WaitForCompletion();
		}

		[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)
			{
				JukeboxLogger.Log.LogError((object)"Couldn't load InputActionAsset");
			}
			else if (ukInputActions.asset.FindActionMap("Jukebox", false) == null)
			{
				ukInputActions.Disable();
				InputActionSetupExtensions.AddActionMap(ukInputActions.asset, InputActionMap.FromJson(_controls.ToJson())[0]);
				ukInputActions.Enable();
			}
		}
	}
	[HarmonyPatch(typeof(InputManager))]
	public static class InputManagerPatch
	{
		private const string ActionMapName = "Jukebox";

		private static FileInfo JukeboxBindingsFile => new FileInfo(Path.Combine(PrefsManager.PrefsPath, "JukeboxBinds.json"));

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InputManager), "Awake")]
		public static void InputManager_Awake_Postfix(InputManager __instance)
		{
			__instance.InputSource.Disable();
			if (JukeboxBindingsFile.Exists)
			{
				JsonConvert.DeserializeObject<JsonBindingMap>(File.ReadAllText(JukeboxBindingsFile.FullName)).ApplyTo(__instance.InputSource.Actions.asset);
			}
			__instance.UpgradeBindings();
			__instance.InputSource.Enable();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InputManager), "OnDisable")]
		public static void InputManager_OnDisable_Postfix(InputManager __instance)
		{
			SaveBindings(__instance, __instance.InputSource.Actions.asset);
		}

		[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;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InputManager), "SaveBindings")]
		public static void InputManager_SaveBindings_Postfix(InputManager __instance, InputActionAsset asset)
		{
			SaveBindings(__instance, asset);
		}

		private static void SaveBindings(InputManager instance, InputActionAsset asset)
		{
			File.WriteAllText(JukeboxBindingsFile.FullName, JsonConvert.SerializeObject((object)BindingMapJson(asset, instance), (Formatting)1));
		}

		private static JsonBindingMap BindingMapJson(InputActionAsset asset, InputManager instance)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			InputControlScheme scheme = instance.InputSource.Actions.KeyboardMouseScheme;
			InputActionAsset baseAsset = instance.defaultActions;
			JsonBindingMap val = new JsonBindingMap
			{
				controlScheme = ((InputControlScheme)(ref scheme)).bindingGroup
			};
			foreach (InputAction item in from a in (IEnumerable<InputAction>)asset
				let action = baseAsset.FindAction(a.id)
				where action.actionMap.name == "Jukebox" && !InputExtensions.IsActionEqual(a, action, ((InputControlScheme)(ref scheme)).bindingGroup)
				select a)
			{
				val.AddAction(item);
			}
			return val;
		}
	}
	[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)
		{
			JukeboxMusicPlayer jukeboxMusicPlayer = MonoSingleton<JukeboxManager>.Instance?.player;
			if ((Object)(object)jukeboxMusicPlayer == (Object)null || jukeboxMusicPlayer.State.Song == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if (!SteamClient.IsValid)
			{
				return false;
			}
			SteamFriends.SetRichPresence("wave", $"WAVE: {wave} | \ud83c\udfb5 {jukeboxMusicPlayer.State.Song.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 RandomTrack { get; private set; }

		public InputAction DisablePlayer { get; private set; }

		public void Awake()
		{
			InputManager instance = MonoSingleton<InputManager>.Instance;
			jukeboxActionMap = ((instance != null) ? instance.InputSource.Actions.asset.FindActionMap("Jukebox", false) : null);
			InputActionMap obj = jukeboxActionMap;
			Menu = ((obj != null) ? obj.FindAction("Jukebox Menu", false) : null);
			InputActionMap obj2 = jukeboxActionMap;
			Playback = ((obj2 != null) ? obj2.FindAction("Playback Menu", false) : null);
			InputActionMap obj3 = jukeboxActionMap;
			NextTrack = ((obj3 != null) ? obj3.FindAction("Next Track", false) : null);
			InputActionMap obj4 = jukeboxActionMap;
			RandomTrack = ((obj4 != null) ? obj4.FindAction("Random Track", false) : null);
			InputActionMap obj5 = jukeboxActionMap;
			DisablePlayer = ((obj5 != null) ? obj5.FindAction("Disable Player", false) : null);
		}
	}
}
namespace Jukebox.Components
{
	public class CybergrindEffectsChanger : MonoBehaviour
	{
		private const string TerminalPath = "/FirstRoom/Room/Cybergrind Shop/Music";

		private const string ParryParam = "jukebox.effects.parry";

		private const string WaveParam = "jukebox.effects.wavecomplete";

		private const string AwwParam = "jukebox.effects.aww";

		private const string GameOverParam = "jukebox.effects.gameover";

		private const string TerminalMusicParam = "jukebox.effects.terminal-music";

		private AudioClip awwDefault;

		private AudioClip cheerDefault;

		private AudioClip cheerLongDefault;

		private AudioClip gameOverDefault;

		private AudioClip terminalMusicDefault;

		private CrowdReactions crowdReactions;

		private PrefsManager prefsManager;

		[CompilerGenerated]
		private AudioSource <EndMusicSource>k__BackingField;

		[CompilerGenerated]
		private AudioSource <MenuMusicSource>k__BackingField;

		[CompilerGenerated]
		private AudioSource <CrowdAudioSource>k__BackingField;

		private AudioSource EndMusicSource
		{
			get
			{
				//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)
				if ((Object)(object)<EndMusicSource>k__BackingField == (Object)null)
				{
					Scene activeScene = SceneManager.GetActiveScene();
					<EndMusicSource>k__BackingField = ((Scene)(ref activeScene)).GetRootGameObjects().First((GameObject o) => ((Object)o).name == "EndMusic").GetComponent<AudioSource>();
				}
				return <EndMusicSource>k__BackingField;
			}
		}

		private AudioSource MenuMusicSource
		{
			get
			{
				if ((Object)(object)<MenuMusicSource>k__BackingField == (Object)null)
				{
					<MenuMusicSource>k__BackingField = GameObject.Find("/FirstRoom/Room/Cybergrind Shop/Music").GetComponent<AudioSource>();
				}
				return <MenuMusicSource>k__BackingField;
			}
		}

		private AudioSource CrowdAudioSource
		{
			get
			{
				if ((Object)(object)<CrowdAudioSource>k__BackingField == (Object)null)
				{
					<CrowdAudioSource>k__BackingField = ReflectionUtils.GetPrivate<AudioSource>((object)crowdReactions, typeof(CrowdReactions), "aud");
				}
				return <CrowdAudioSource>k__BackingField;
			}
		}

		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>(MenuMusicSource.clip, ((Component)this).gameObject.transform);
			gameOverDefault = Object.Instantiate<AudioClip>(EndMusicSource.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()
		{
			return PrepareClip(prefsManager.GetStringLocal("jukebox.effects.parry", (string)null), delegate(AudioClip clip)
			{
				crowdReactions.cheer = clip;
			}, cheerDefault);
		}

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

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

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

		private IEnumerator PrepareTerminalMusic()
		{
			AudioSource terminalMusic = MenuMusicSource;
			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 (string.IsNullOrEmpty(path))
			{
				callback(fallback);
			}
			else
			{
				yield return Download(new FileInfo(path), callback);
			}
		}

		private IEnumerator Download(FileSystemInfo path, Action<AudioClip> callback)
		{
			string absoluteUri = new Uri(path.FullName).AbsoluteUri;
			if (!CustomMusicFileBrowser.extensionTypeDict.TryGetValue(path.Extension.ToLower(), out var value))
			{
				JukeboxLogger.Log.LogWarning((object)("Unsupported audio file extension: " + path.Extension));
				yield break;
			}
			DownloadHandlerAudioClip handler = new DownloadHandlerAudioClip(absoluteUri, value);
			UnityWebRequest wr = new UnityWebRequest(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":
				CrowdAudioSource.Stop();
				((MonoBehaviour)this).StartCoroutine(PrepareParrySfx());
				break;
			}
		}
	}
	public class DeckShuffled<T> : IEnumerable<T>, IEnumerable
	{
		private List<T> current = Randomize(target).ToList();

		public DeckShuffled(IEnumerable<T> target)
		{
		}

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return current.GetEnumerator();
		}

		public void Reshuffle()
		{
			if (current.Count > 1)
			{
				current = Randomize(current).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 class JukeboxEffectsBrowser : DirectoryTreeBrowser<FileInfo>
	{
		private static readonly DirectoryInfo EffectsDirectory = new DirectoryInfo(PathsUtils.EffectsPath);

		[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()
		{
			PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
			if (instance != null)
			{
				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
			{
				PrefsManager instance = MonoSingleton<PrefsManager>.Instance;
				if (instance != null)
				{
					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 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);
			});
			CompositeProperties compositeProperties = metadata.GetCompositeProperties();
			string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#gray>" + metadata.Artist + "</color>") : string.Empty);
			((CustomContentButton)component).text.SetPreservingRtl(metadata.Title + " " + text);
			((CustomContentButton)component).icon.sprite = metadata.Icon;
			component.introAndLoopIcon.SetActive(compositeProperties.GotIntroAndLoop);
			component.calmThemeIcon.SetActive(compositeProperties.GotCalmTheme || compositeProperties.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>().SetPreservingRtl(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 GameObject subtitlesPanel;

		[SerializeField]
		public JukeboxPlaylistEditor playlistEditor;

		[SerializeField]
		public JukeboxMusicPlayer player;

		[SerializeField]
		private GameObject terminalPanel;

		[SerializeField]
		private GameObject musicLogic;

		[SerializeField]
		private GameObject musicChanger;

		protected void Awake()
		{
			ReplaceOriginalLogic();
			SetupTerminal();
			SetupSongPanel();
			SetupSubtitlesPanel();
		}

		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);
		}

		private void SetupSubtitlesPanel()
		{
			GameObject val = GameObject.Find("/Canvas");
			subtitlesPanel.transform.SetParent(val.transform, false);
		}
	}
	public class JukeboxMusicChanger : MonoBehaviour
	{
		private enum ThemeVariation
		{
			Battle,
			Calm
		}

		private const int FadeSpeed = 1;

		public AudioSource clean;

		public AudioSource battle;

		private ThemeVariation currentTheme;

		private JukeboxThemesManager themesManager;

		private Coroutine updateRoutine;

		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, float startingFrom = 0f)
		{
			if (updateRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(updateRoutine);
			}
			clean.clip = calmTheme;
			battle.clip = battleTheme;
			battle.Play();
			battle.time = startingFrom;
			battle.volume = 1f;
			if ((Object)(object)clean.clip != (Object)null)
			{
				clean.Play();
				clean.time = startingFrom;
				if (CalmThemesAllowed && themesManager.FewEnemies)
				{
					clean.volume = 1f;
					battle.volume = 0f;
				}
			}
			updateRoutine = ((MonoBehaviour)this).StartCoroutine(SlowUpdate());
		}

		public void RewindTo(float position = 0f)
		{
			Seek(clean, position);
			Seek(battle, position);
			static void Seek(AudioSource source, float pos)
			{
				if (!((Object)(object)source == (Object)null) && !((Object)(object)source.clip == (Object)null))
				{
					int num = Mathf.RoundToInt(Mathf.Clamp(pos, 0f, source.clip.length) * (float)source.clip.frequency);
					source.timeSamples = Mathf.Clamp(num, 0, source.clip.samples - 1);
				}
			}
		}

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

		private void PlayBattleTheme()
		{
			if (currentTheme != ThemeVariation.Battle)
			{
				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 JukeboxMusicPlayer : MonoBehaviour, IPlaybackController
	{
		private enum Command
		{
			NextTrack,
			RandomTrack,
			JumpTo,
			None
		}

		[SerializeField]
		private JukeboxPlaylistEditor playlistEditor;

		[SerializeField]
		private JukeboxSongsLoader loader;

		[SerializeField]
		private JukeboxMusicChanger changer;

		private PlaybackOrder playbackOrder;

		private JukeboxTrackPlayer trackPlayer;

		private Coroutine currentPlaylistRoutine;

		private JukeboxSongSession currentSession;

		private Command pendingPlayerCommand;

		private int jumpTo;

		private bool allowVolumeBoost;

		private SubtitleTrack lastSubtitleTrack;

		private int subtitleIndex = -1;

		private Coroutine rewindRoutine;

		public PlaybackState State { get; } = new PlaybackState();

		public AudioSource Source => changer.battle;

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

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

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

		public event Action<ClipChangedArgs> OnNextAudioClip;

		public event Action<IEnumerable<SongIdentifier>> OnOrderChange;

		public event Action OnStop;

		public event Action<string> OnSubtitleChanged;

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

		public void OnEnable()
		{
			StartPlaylist();
		}

		private void OnDisable()
		{
			if (ResumeLastSong && State.Song != null)
			{
				JukeboxPreferencesManager instance = MonoSingleton<JukeboxPreferencesManager>.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					instance.SetPlaybackPosition(State.Song.Id, State.ClipIndex, Source.time);
					instance.ForceSavePreferences();
				}
			}
		}

		public void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			MonoSingleton<JukeboxInputs>.Instance.DisablePlayer.performed -= OnPlayerDisabled;
			MonoSingleton<JukeboxInputs>.Instance.NextTrack.performed -= OnNextTrack;
			MonoSingleton<JukeboxInputs>.Instance.RandomTrack.performed -= OnRandomTrack;
			StopCurrentRoutines();
			State.Song = null;
		}

		private void Update()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			SubtitleTrack subtitles = State.Subtitles;
			if (subtitles != lastSubtitleTrack)
			{
				lastSubtitleTrack = subtitles;
				subtitleIndex = -1;
			}
			int num = ((subtitles != null) ? subtitles.IndexAt(Source.time, subtitleIndex) : (-1));
			if (num != subtitleIndex)
			{
				subtitleIndex = num;
				PlaybackState state = State;
				object subtitleLine;
				if (num >= 0)
				{
					SubtitleLine val = subtitles.Lines[num];
					subtitleLine = ((SubtitleLine)(ref val)).Text;
				}
				else
				{
					subtitleLine = null;
				}
				state.SubtitleLine = (string)subtitleLine;
				this.OnSubtitleChanged?.Invoke(State.SubtitleLine);
			}
		}

		public void Stop()
		{
			State.Stopped = true;
		}

		public void ChangeTrack(int index)
		{
			jumpTo = index;
			pendingPlayerCommand = Command.JumpTo;
		}

		public void RewindTo(float position)
		{
			if (rewindRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rewindRoutine);
			}
			rewindRoutine = ((MonoBehaviour)this).StartCoroutine(RewindRoutine(position));
		}

		private IEnumerator RewindRoutine(float position)
		{
			JukeboxSongSession obj = currentSession;
			JukeboxCustomSongSession val = (JukeboxCustomSongSession)(object)((obj is JukeboxCustomSongSession) ? obj : null);
			if (val == null || State.ClipIndex < 0)
			{
				changer.RewindTo(position);
				rewindRoutine = null;
				yield break;
			}
			if (val.IsFullyLoaded(State.ClipIndex))
			{
				changer.RewindTo(position);
				rewindRoutine = null;
				yield break;
			}
			AudioClip battleClip = null;
			AudioClip calmClip = null;
			yield return val.LoadFullyFor(State.ClipIndex, (Action<AudioClip, AudioClip>)delegate(AudioClip battle, AudioClip calm)
			{
				battleClip = battle;
				calmClip = calm;
			});
			if ((Object)(object)battleClip == (Object)null)
			{
				changer.RewindTo(position);
				rewindRoutine = null;
			}
			else
			{
				changer.ChangeTo(battleClip, calmClip, position);
				rewindRoutine = null;
			}
		}

		public void StartPlaylist()
		{
			if (((Playlist)playlistEditor.playlist).Count < 1)
			{
				JukeboxLogger.Log.LogError((object)"No songs in playlist, somehow. Not starting playlist routine...");
				return;
			}
			StopCurrentRoutines();
			State.Stopped = false;
			pendingPlayerCommand = Command.None;
			playbackOrder = new PlaybackOrder(playlistEditor.playlist);
			currentPlaylistRoutine = ((MonoBehaviour)this).StartCoroutine(PlaylistRoutine());
		}

		public void StopPlaylist()
		{
			Source.Stop();
			StopCurrentRoutines();
			State.Song = null;
			State.Subtitles = null;
			State.Stopped = true;
			pendingPlayerCommand = Command.None;
			State.ClipIndex = -1;
			State.ClipCount = 0;
		}

		private void StopCurrentRoutines()
		{
			if (currentPlaylistRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(currentPlaylistRoutine);
				currentPlaylistRoutine = null;
			}
			if (rewindRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rewindRoutine);
				rewindRoutine = null;
			}
			JukeboxSongSession obj = currentSession;
			if (obj != null)
			{
				obj.Dispose();
			}
			currentSession = null;
		}

		private IEnumerator PlaylistRoutine()
		{
			JukeboxPreferencesManager instance = MonoSingleton<JukeboxPreferencesManager>.Instance;
			PlayStartingFrom resume = instance.GetPlaybackPosition();
			instance.ResetPlaybackPosition();
			bool flag = true;
			while (!State.Stopped)
			{
				List<SongIdentifier> order = playbackOrder.BuildOrder();
				this.OnOrderChange?.Invoke(order);
				int index = playbackOrder.StartIndex(order);
				PlayStartingFrom trackToResume = null;
				if (flag && ResumeLastSong && resume != null)
				{
					SongIdentifier resumeId = new SongIdentifier(resume.Path, resume.Type);
					int num = order.FindIndex((SongIdentifier id) => object.Equals(id, resumeId));
					if (num >= 0 && loader.Get(resumeId) != null)
					{
						index = num;
						trackToResume = resume;
						resume = null;
					}
				}
				int unplayable = 0;
				while (!State.Stopped)
				{
					State.SongIndex = index;
					JukeboxSongSession val = loader.CreateSession(loader.Get(order[index]));
					if (val == null)
					{
						JukeboxLogger.Log.LogWarning((object)("Unable to load " + order[index].path + ", skipping"));
						int num2 = unplayable + 1;
						unplayable = num2;
						if (num2 >= order.Count)
						{
							JukeboxLogger.Log.LogError((object)"No playable tracks in the playlist, stopping");
							State.Stopped = true;
							break;
						}
						int num3 = ResolveNext(index, order.Count);
						if (num3 < 0)
						{
							break;
						}
						index = num3;
					}
					else
					{
						unplayable = 0;
						currentSession = val;
						PresenceController.UpdateCyberGrindWave(MonoSingleton<EndlessGrid>.Instance.currentWave);
						yield return val.Load(trackPlayer.Play(val, flag, trackToResume, Interrupted, IsLoopOne));
						currentSession = null;
						flag = false;
						trackToResume = null;
						int num4 = ResolveNext(index, order.Count);
						if (num4 < 0)
						{
							break;
						}
						index = num4;
					}
				}
			}
		}

		private int ResolveNext(int cursor, int count)
		{
			int num = pendingPlayerCommand switch
			{
				Command.RandomTrack => PlaybackOrder.RandomIndex(count), 
				Command.JumpTo => jumpTo, 
				_ => cursor + 1, 
			};
			pendingPlayerCommand = Command.None;
			if (num >= count)
			{
				return -1;
			}
			return num;
		}

		private bool Interrupted()
		{
			if (pendingPlayerCommand == Command.None)
			{
				return State.Stopped;
			}
			return true;
		}

		private bool IsLoopOne()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			return (int)((Playlist)playlistEditor.playlist).loopMode == 1;
		}

		private void OnNextTrack(CallbackContext _)
		{
			pendingPlayerCommand = Command.NextTrack;
		}

		private void OnRandomTrack(CallbackContext _)
		{
			pendingPlayerCommand = Command.RandomTrack;
		}

		private void OnPlayerDisabled(CallbackContext _)
		{
			if (!State.Stopped)
			{
				StopPlaylist();
				this.OnStop?.Invoke();
			}
			else
			{
				StartPlaylist();
			}
		}

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

		private void NextAudioClip(JukeboxSong song, bool newSong)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			State.Song = song;
			allowVolumeBoost = song.IsCustom;
			State.VolumeBoost = CalculateBoostFor(song);
			this.OnNextAudioClip?.Invoke(new ClipChangedArgs(song, newSong));
		}

		private float CalculateBoostFor(JukeboxSong song)
		{
			if (!allowVolumeBoost)
			{
				return 0f;
			}
			if (IndividualBoostPerTrack && song != null)
			{
				float? volumeBoostFor = MonoSingleton<JukeboxPreferencesManager>.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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if (instance != null)
			{
				((Behaviour)instance).enabled = false;
			}
			CameraController instance2 = MonoSingleton<CameraController>.Instance;
			if (instance2 != null)
			{
				instance2.activated = false;
			}
			GunControl instance3 = MonoSingleton<GunControl>.Instance;
			if (instance3 != null)
			{
				instance3.activated = false;
			}
			GameStateManager.Instance.RegisterState(new GameState(stateKey, (GameObject[])(object)new GameObject[1] { window })
			{
				cursorLock = (LockMode)2,
				cameraInputLock = (LockMode)1,
				playerInputLock = (LockMode)1
			});
			OptionsManager instance4 = MonoSingleton<OptionsManager>.Instance;
			if (instance4 != null)
			{
				instance4.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;

		[SerializeField]
		private RewindSlider rewindSlider;

		[SerializeField]
		private TMP_Text currentTimestamp;

		[SerializeField]
		private TMP_Text totalLength;

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

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

		[NonSerialized]
		private IPlaybackController player;

		protected override int maxPageLength => 5;

		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(player.State.SongIndex % ((DirectoryTreeBrowser<SongIdentifier>)this).maxPageLength);
				if (obj == null)
				{
					return null;
				}
				return ((Component)obj).GetComponent<CustomContentButton>();
			}
		}

		protected void Awake()
		{
			player = (IPlaybackController)(object)MonoSingleton<JukeboxManager>.Instance?.player;
			IPlaybackController obj = player;
			if (obj != null)
			{
				obj.OnOrderChange += OnOrderChange;
			}
			IPlaybackController obj2 = player;
			if (obj2 != null)
			{
				obj2.OnNextAudioClip += NextAudioClip;
			}
			IPlaybackController obj3 = player;
			if (obj3 != null)
			{
				obj3.OnStop += OnStop;
			}
			rewindSlider.OnValueChanged += delegate(float position)
			{
				player.RewindTo(position);
				rewindSlider.slider.value = position;
			};
		}

		private void Update()
		{
			if (!((Object)(object)player.Source == (Object)null) && !((Object)(object)player.Source.clip == (Object)null))
			{
				if (!rewindSlider.beingDragged)
				{
					rewindSlider.slider.value = player.Source.time;
				}
				currentTimestamp.text = player.Source.time.SecondsToHumanReadable();
			}
		}

		protected void OnEnable()
		{
			if (!object.Equals(base.currentDirectory, ((DirectoryTreeBrowser<SongIdentifier>)this).baseDirectory))
			{
				base.currentDirectory = ((DirectoryTreeBrowser<SongIdentifier>)this).baseDirectory;
				((DirectoryTreeBrowser<SongIdentifier>)this).Rebuild(false);
				base.SetPage(Mathf.Clamp(player.State.SongIndex / ((DirectoryTreeBrowser<SongIdentifier>)this).maxPageLength, 0, base.maxPages - 1));
			}
		}

		protected void OnDestroy()
		{
			player.OnStop -= OnStop;
			player.OnOrderChange -= OnOrderChange;
			player.OnNextAudioClip -= NextAudioClip;
		}

		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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			JukeboxSong obj = MonoSingleton<JukeboxSongsLoader>.Instance.Get(id);
			JukeboxSongMetadata val = ((obj != null) ? obj.Metadata : null);
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemButtonTemplate.transform.parent);
			CustomContentButton component = go.GetComponent<CustomContentButton>();
			string text = ((!string.IsNullOrEmpty(val.Artist)) ? ("<color=#gray>" + val.Artist + "</color>") : string.Empty);
			component.text.SetPreservingRtl(val.Title + " " + text);
			component.icon.sprite = (((Object)(object)val.Icon != (Object)null) ? val.Icon : defaultIcon);
			go.SetActive(true);
			buttons.Add(go.transform);
			if (base.PageOf(player.State.SongIndex) == 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
				{
					player.ChangeTrack(base.currentPage * ((DirectoryTreeBrowser<SongIdentifier>)this).maxPageLength + indexInPage);
				});
			}
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

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

		private void NextAudioClip(ClipChangedArgs clip)
		{
			AudioClip clip2 = player.Source.clip;
			rewindSlider.slider.value = 0f;
			rewindSlider.slider.maxValue = clip2.length;
			totalLength.text = clip2.length.SecondsToHumanReadable();
			buttonsSection.SetActive(true);
			((Selectable)rewindSlider.slider).interactable = true;
			disclaimer.SetActive(false);
			((DirectoryTreeBrowser<SongIdentifier>)this).Rebuild(false);
		}

		private void OnStop()
		{
			((Selectable)rewindSlider.slider).interactable = 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>
	{
		[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();

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

		private readonly Dictionary<Transform, Coroutine> changeAnchorRoutines = new Dictionary<Transform, Coroutine>();

		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.Get(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));
		}

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

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

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

		public void LoadPlaylist()
		{
			JukeboxLogger.Log.LogInfo((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.RemoveUnplayable();
				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()
			{
				JukeboxLogger.Log.LogInfo((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 !