using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PaApi;
using SimpleJSON;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CustomMenuSongs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("place holder")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0c5373bdea0737966097ed1f70c878ce0addfa98")]
[assembly: AssemblyProduct("CustomMenuSongs")]
[assembly: AssemblyTitle("CustomMenuSongs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CustomMenuSongs
{
	[HarmonyPatch(typeof(DataManager))]
	public static class DataManagerPatch
	{
		[HarmonyPatch("OnEnable")]
		[HarmonyPostfix]
		private static void PostStart(DataManager __instance)
		{
			if (Plugin.CustomSongs.Count == 0)
			{
				return;
			}
			JSONNode val = JSONNode.Parse("{ name : Custom  Shuffle,values : Custom_Shuffle}");
			val["name"] = JSONNode.op_Implicit("Custom Shuffle");
			DataManager.inst.interfaceSettings["MenuMusic"].Add(val);
			foreach (AudioClip customSong in Plugin.CustomSongs)
			{
				JSONNode val2 = JSONNode.Parse("{ name : val,values : val}");
				val2["name"] = JSONNode.op_Implicit(((Object)customSong).name);
				val2["values"] = JSONNode.op_Implicit(((Object)customSong).name);
				DataManager.inst.interfaceSettings["MenuMusic"].Add(val2);
			}
		}
	}
	[HarmonyPatch(typeof(AudioManager))]
	public static class AudioManagerPatch
	{
		private static bool _hasInitialized;

		[HarmonyPatch("OnAwake")]
		[HarmonyPostfix]
		private static void PostStart(AudioManager __instance)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			//IL_00c5: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			if (_hasInitialized)
			{
				return;
			}
			_hasInitialized = true;
			Plugin.CustomSongs.AddRange(((SerializableDictionary<string, MusicGroup>)(object)__instance.library.musicClips)["menu"].music);
			List<AudioClip> list = new List<AudioClip>(((SerializableDictionary<string, MusicGroup>)(object)__instance.library.musicClips)["arcade_dream"].music);
			list.AddRange(Plugin.CustomSongs);
			((SerializableDictionary<string, MusicGroup>)(object)__instance.library.musicClips).Add("MenuShuffle", new MusicGroup
			{
				music = list.ToArray(),
				AlwaysRandom = true
			});
			((SerializableDictionary<string, MusicGroup>)(object)__instance.library.musicClips).Add("CustomMenu", new MusicGroup
			{
				music = Plugin.CustomSongs.ToArray(),
				AlwaysRandom = true
			});
			foreach (AudioClip customSong in Plugin.CustomSongs)
			{
				MusicClipClass musicClips = __instance.library.musicClips;
				string name = ((Object)customSong).name;
				MusicGroup val = new MusicGroup();
				val.music = (AudioClip[])(object)new AudioClip[1] { customSong };
				((SerializableDictionary<string, MusicGroup>)(object)musicClips).Add(name, val);
			}
		}

		[HarmonyPatch("PlayMusic", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static bool PrePlayMusic(AudioManager __instance, string _musicName)
		{
			if (__instance.currentSongGroup == "corruption" && _musicName == "arcade_dream")
			{
				__instance.currentSongGroup = "";
				return !Plugin.ChooseSong();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(UIElement))]
	internal static class SplashScreenPatch
	{
		[HarmonyPatch("ExecUIEvent")]
		[HarmonyPrefix]
		internal static bool ChooseSong(string _func)
		{
			if (_func != "apply_menu_music")
			{
				return true;
			}
			if (SingletonBase<AudioManager>.Inst.currentSongGroup == "menu_intro")
			{
				return false;
			}
			return !Plugin.ChooseSong();
		}
	}
	[BepInPlugin("me.ytarame.CustomMenuSong", "CustomMenuSong", "1.0.0")]
	[BepInProcess("Project Arrhythmia.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static List<AudioClip> CustomSongs = new List<AudioClip>();

		public static ConfigEntry<int> SongChoice;

		internal static ManualLogSource Logger;

		private Harmony _harmony;

		private const string Guid = "me.ytarame.CustomMenuSong";

		private const string Name = "CustomMenuSong";

		private const string Version = "1.0.0";

		private void Awake()
		{
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			string path = Paths.GameRootPath + "\\CustomMenuSongs";
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
			string[] files = Directory.GetFiles(path, "*.ogg");
			string[] files2 = Directory.GetFiles(path, "*.mp3");
			string[] files3 = Directory.GetFiles(path, "*.wav");
			ParseAudioFiles(files, (AudioType)14);
			ParseAudioFiles(files2, (AudioType)13);
			ParseAudioFiles(files3, (AudioType)20);
			SongChoice = ((BaseUnityPlugin)this).Config.Bind<int>("Music", "MenuMusicMusicChoice", 0, "which song is selected to play in the menu. 0 is default, 1 is shuffle, 2 is custom songs only shuffle, 3+ is a specific custom song");
			List<string> list = new List<string>(new <>z__ReadOnlyArray<string>(new string[3] { "Default", "Shuffle", "Custom Shuffle" }));
			foreach (AudioClip customSong in CustomSongs)
			{
				list.Add(((Object)customSong).name);
			}
			list.Add("Corrupted Menu");
			string[] names = list.ToArray();
			SettingsHelper.RegisterModSettings("me.ytarame.CustomMenuSong", "Menu Song", (Color?)null, ((BaseUnityPlugin)this).Config, (Action<SettingsBuilder>)delegate(SettingsBuilder builder)
			{
				builder.Spacer();
				builder.Slider("Song Choice", (float)SongChoice.Value, 1f, (UnityAction<float>)delegate(float x)
				{
					SongChoice.Value = (int)x;
					ChooseSong();
				}, (VisualType)0, names);
			});
			_harmony = new Harmony("me.ytarame.CustomMenuSong");
			_harmony.PatchAll();
			Logger.LogInfo((object)"Plugin me.ytarame.CustomMenuSong is loaded!");
		}

		private void ParseAudioFiles(string[] audioPaths, AudioType audioType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			foreach (string text in audioPaths)
			{
				UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(text, audioType);
				audioClip.SendWebRequest();
				while (!audioClip.isDone)
				{
					Task.Delay(5).Wait();
				}
				if ((int)audioClip.result == 1)
				{
					AudioClip content = DownloadHandlerAudioClip.GetContent(audioClip);
					((Object)content).name = Path.GetFileNameWithoutExtension(text);
					CustomSongs.Add(content);
				}
			}
		}

		internal static bool ChooseSong()
		{
			int value = SongChoice.Value;
			int num = value;
			int num2 = num;
			if (num2 > 0)
			{
				switch (num2)
				{
				case 1:
					SingletonBase<AudioManager>.Inst.PlayMusic("MenuShuffle", true);
					return true;
				case 2:
					SingletonBase<AudioManager>.Inst.PlayMusic("CustomMenu", true);
					return true;
				default:
				{
					int num3 = value - 3;
					if (num3 >= CustomSongs.Count)
					{
						return false;
					}
					SingletonBase<AudioManager>.Inst.PlayMusic(CustomSongs[num3], true);
					return true;
				}
				}
			}
			return false;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "CustomMenuSongs";

		public const string PLUGIN_NAME = "CustomMenuSongs";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}