using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using FMOD;
using FMODUnity;
using HarmonyLib;
using NAudio.Wave;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YTJukebox;
using YTJukebox.NetcodePatcher;
using YTJukeboxMod;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("YTJukebox")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("YTJukebox")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9b1282b3-5681-43cf-8520-b19bac8ef9e5")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
namespace YTJukebox
{
	public class YTNetworkManager : NetworkBehaviour
	{
		private int playersDownloaded = 0;

		public static YTNetworkManager instance;

		public static bool skipStop;

		private void Awake()
		{
			instance = this;
			skipStop = false;
		}

		[ServerRpc(RequireOwnership = false)]
		public void TriggerDownloadServerRpc(string inputURL, ulong JukeboxID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(787366507u, val, (RpcDelivery)0);
				bool flag = inputURL != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(inputURL, false);
				}
				BytePacker.WriteValueBitPacked(val2, JukeboxID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 787366507u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost))
			{
				BroadcastDownloadClientRpc(inputURL, JukeboxID);
			}
		}

		[ClientRpc]
		private void BroadcastDownloadClientRpc(string inputURL, ulong JukeboxID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1072384151u, val, (RpcDelivery)0);
				bool flag = inputURL != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(inputURL, false);
				}
				BytePacker.WriteValueBitPacked(val2, JukeboxID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1072384151u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				StartDownloadFileAsync(inputURL, JukeboxID);
			}
		}

		private async void StartDownloadFileAsync(string inputURL, ulong JukeboxID)
		{
			Log.Info("Download started on client for URL: " + inputURL);
			NotifyDownloadCompleteServerRpc(JukeboxID, await Download.GetCustomSong(inputURL));
		}

		[ClientRpc]
		public void StopTrackClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1874522741u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1874522741u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Audio.StopCustomTrack();
				}
			}
		}

		[ClientRpc]
		public void ChangeVolumeClientRpc(byte v)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(945115242u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<byte>(ref v, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 945115242u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Audio.ChangeVolume(v);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void NotifyDownloadCompleteServerRpc(ulong JukeboxID, bool success)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2223158115u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, JukeboxID);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref success, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2223158115u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost) && success)
			{
				playersDownloaded++;
				if (playersDownloaded == PlayerManager.Instance.players.Count)
				{
					Log.Info("All players have completed the download.");
					playersDownloaded = 0;
					PlayCustomTrackClientRpc(JukeboxID);
				}
			}
		}

		[ClientRpc]
		private void PlayCustomTrackClientRpc(ulong JukeboxID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1543763232u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, JukeboxID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1543763232u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					GameObject inputJukebox = ReturnObjectFromID(JukeboxID);
					Audio.PlayCustomTrack(inputJukebox);
				}
			}
		}

		[ClientRpc]
		public void SetSyncClientRpc(ulong JukeboxID, bool input)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(404505024u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, JukeboxID);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref input, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 404505024u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			List<GameObject> allJukeboxes = Audio.GetAllJukeboxes();
			skipStop = true;
			if (input)
			{
				foreach (GameObject item2 in allJukeboxes)
				{
					Jukebox component = item2.GetComponent<Jukebox>();
					component.PlayerStopServerRpc();
				}
				foreach (GameObject jukebox in Audio.jukeboxList)
				{
					Jukebox component2 = jukebox.GetComponent<Jukebox>();
					component2.PlayerPlayServerRpc((byte)99);
				}
				Audio.jukeboxList.Clear();
				Audio.jukeboxList = allJukeboxes;
			}
			else
			{
				foreach (GameObject item3 in allJukeboxes)
				{
					Jukebox component3 = item3.GetComponent<Jukebox>();
					component3.PlayerStopServerRpc();
				}
				foreach (GameObject jukebox2 in Audio.jukeboxList)
				{
					Jukebox component4 = jukebox2.GetComponent<Jukebox>();
					component4.PlayerPlayServerRpc((byte)99);
				}
				GameObject item = ReturnObjectFromID(JukeboxID);
				Audio.jukeboxList.Clear();
				Audio.jukeboxList.Add(item);
			}
			skipStop = false;
		}

		private GameObject ReturnObjectFromID(ulong JukeboxID)
		{
			NetworkObject val = NetworkManager.Singleton.SpawnManager.SpawnedObjects[JukeboxID];
			return ((Component)val).gameObject;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(787366507u, new RpcReceiveHandler(__rpc_handler_787366507), "TriggerDownloadServerRpc");
			((NetworkBehaviour)this).__registerRpc(1072384151u, new RpcReceiveHandler(__rpc_handler_1072384151), "BroadcastDownloadClientRpc");
			((NetworkBehaviour)this).__registerRpc(1874522741u, new RpcReceiveHandler(__rpc_handler_1874522741), "StopTrackClientRpc");
			((NetworkBehaviour)this).__registerRpc(945115242u, new RpcReceiveHandler(__rpc_handler_945115242), "ChangeVolumeClientRpc");
			((NetworkBehaviour)this).__registerRpc(2223158115u, new RpcReceiveHandler(__rpc_handler_2223158115), "NotifyDownloadCompleteServerRpc");
			((NetworkBehaviour)this).__registerRpc(1543763232u, new RpcReceiveHandler(__rpc_handler_1543763232), "PlayCustomTrackClientRpc");
			((NetworkBehaviour)this).__registerRpc(404505024u, new RpcReceiveHandler(__rpc_handler_404505024), "SetSyncClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_787366507(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string inputURL = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref inputURL, false);
				}
				ulong jukeboxID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((YTNetworkManager)(object)target).TriggerDownloadServerRpc(inputURL, jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1072384151(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string inputURL = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref inputURL, false);
				}
				ulong jukeboxID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((YTNetworkManager)(object)target).BroadcastDownloadClientRpc(inputURL, jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1874522741(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((YTNetworkManager)(object)target).StopTrackClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_945115242(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				byte v = default(byte);
				((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref v, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((YTNetworkManager)(object)target).ChangeVolumeClientRpc(v);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2223158115(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong jukeboxID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref jukeboxID);
				bool success = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref success, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((YTNetworkManager)(object)target).NotifyDownloadCompleteServerRpc(jukeboxID, success);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1543763232(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong jukeboxID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((YTNetworkManager)(object)target).PlayCustomTrackClientRpc(jukeboxID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_404505024(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong jukeboxID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref jukeboxID);
				bool input = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref input, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((YTNetworkManager)(object)target).SetSyncClientRpc(jukeboxID, input);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "YTNetworkManager";
		}
	}
}
namespace YTJukeboxMod
{
	internal static class Audio
	{
		private static IWavePlayer waveOut;

		private static MediaFoundationReader mediaReader;

		private static StereoVolumeSampleProvider stereoProvider;

		public static GameObject activeJukebox;

		public static List<GameObject> jukeboxList;

		public static GameObject localPlayer;

		private static readonly float maxDistance = 80f;

		public static void OnWorldLoad()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (waveOut == null)
			{
				WaveOutEvent val = new WaveOutEvent
				{
					DesiredLatency = 50,
					NumberOfBuffers = 8
				};
				waveOut = (IWavePlayer)(object)val;
			}
			GetLocalPlayer().ContinueWith(delegate(Task<GameObject> task)
			{
				localPlayer = task.Result;
			});
			jukeboxList = new List<GameObject>();
		}

		public static void SetActiveJukebox(Jukebox JukeboxComponent)
		{
			activeJukebox = ((Component)JukeboxComponent).gameObject;
		}

		public static void StopCustomTrack()
		{
			if (waveOut != null && mediaReader != null)
			{
				waveOut.Stop();
				((Stream)(object)mediaReader).Dispose();
				((IDisposable)waveOut).Dispose();
				Log.Info("Track stopped.");
			}
		}

		public static void PlayCustomTrack(GameObject inputJukebox)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			Jukebox component = inputJukebox.GetComponent<Jukebox>();
			jukeboxList.Clear();
			jukeboxList.Add(inputJukebox);
			ChangeVolume(component.volume.Value);
			component.PlayerPlayServerRpc((byte)99);
			if (File.Exists(ModPaths.customSong))
			{
				StopCustomTrack();
				mediaReader = new MediaFoundationReader(ModPaths.customSong);
				stereoProvider = new StereoVolumeSampleProvider(WaveExtensionMethods.ToSampleProvider((IWaveProvider)(object)mediaReader))
				{
					LeftVolume = 1f,
					RightVolume = 1f
				};
				WaveExtensionMethods.Init(waveOut, (ISampleProvider)(object)stereoProvider, false);
				waveOut.Play();
			}
		}

		public static void ChangeVolume(byte Volume)
		{
			if (waveOut != null)
			{
				float volume = Mathf.Clamp01((float)(int)Volume / 100f);
				waveOut.Volume = volume;
			}
		}

		public static void UpdateAudioSpatial()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)localPlayer != (Object)null) || jukeboxList.Count <= 0)
			{
				return;
			}
			Vector3 position = localPlayer.transform.position;
			float num = 0f;
			float num2 = 0f;
			foreach (GameObject jukebox in jukeboxList)
			{
				if ((Object)(object)jukebox != (Object)null)
				{
					Vector3 position2 = jukebox.transform.position;
					Jukebox component = jukebox.GetComponent<Jukebox>();
					float num3 = Mathf.Max(2f, Vector3.Distance(position, position2));
					float num4 = Mathf.Clamp01((num3 - 2f) / (maxDistance - 2f));
					float num5 = Mathf.Pow(1f - num4, 10f) * ((float)(int)component.volume.Value / 100f);
					Vector3 val = position - position2;
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					float num6 = Vector3.Dot(normalized, localPlayer.transform.right);
					float num7 = num5 * Mathf.Clamp01(1f - num6);
					float num8 = num5 * Mathf.Clamp01(1f + num6);
					num = Mathf.Clamp01(num + num7);
					num2 = Mathf.Clamp01(num2 + num8);
				}
			}
			stereoProvider.LeftVolume = num;
			stereoProvider.RightVolume = num2;
		}

		public static List<GameObject> GetAllJukeboxes()
		{
			Type typeFromHandle = typeof(JukeboxManager);
			FieldInfo field = typeFromHandle.GetField("_jukeboxes", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ushort, Jukebox> dictionary = field.GetValue(JukeboxManager.Instance) as Dictionary<ushort, Jukebox>;
			List<GameObject> list = new List<GameObject>();
			foreach (KeyValuePair<ushort, Jukebox> item in dictionary)
			{
				Jukebox value = item.Value;
				if ((Object)(object)value != (Object)null)
				{
					GameObject gameObject = ((Component)value).gameObject;
					list.Add(gameObject);
				}
			}
			return list;
		}

		public static async Task<GameObject> GetLocalPlayer()
		{
			GameObject localPlayer = null;
			while ((Object)(object)localPlayer == (Object)null)
			{
				PlayerNet[] players = Object.FindObjectsOfType<PlayerNet>();
				PlayerNet[] array = players;
				foreach (PlayerNet playerNet in array)
				{
					NetworkBehaviour networkBehaviour = ((Component)playerNet).GetComponent<NetworkBehaviour>();
					if ((Object)(object)networkBehaviour != (Object)null && networkBehaviour.IsOwner)
					{
						localPlayer = ((Component)playerNet).gameObject;
						break;
					}
				}
				if ((Object)(object)localPlayer == (Object)null)
				{
					await Task.Delay(500);
				}
			}
			return localPlayer;
		}
	}
	public class StereoVolumeSampleProvider : ISampleProvider
	{
		private readonly ISampleProvider source;

		private float leftVolume = 1f;

		private float rightVolume = 1f;

		public float LeftVolume
		{
			get
			{
				return leftVolume;
			}
			set
			{
				leftVolume = Math.Max(0f, Math.Min(1f, value));
			}
		}

		public float RightVolume
		{
			get
			{
				return rightVolume;
			}
			set
			{
				rightVolume = Math.Max(0f, Math.Min(1f, value));
			}
		}

		public WaveFormat WaveFormat => source.WaveFormat;

		public StereoVolumeSampleProvider(ISampleProvider source)
		{
			if (source.WaveFormat.Channels != 2)
			{
				throw new ArgumentException("Source sample provider must be stereo");
			}
			this.source = source;
		}

		public int Read(float[] buffer, int offset, int count)
		{
			int num = source.Read(buffer, offset, count);
			for (int i = 0; i < num; i += 2)
			{
				buffer[offset + i + 1] *= leftVolume;
				buffer[offset + i] *= rightVolume;
			}
			return num;
		}
	}
	public static class Download
	{
		private static string lastURL;

		private static readonly string ffmpegURL = "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip";

		private static readonly string ytDlpURL = "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe";

		public static async Task GetDependencies()
		{
			await DownloadYtDlp();
			await DownloadFfmpeg();
		}

		private static async Task DownloadYtDlp()
		{
			try
			{
				Log.Info("Downloading yt-dlp...");
				using (WebClient webClient = new WebClient())
				{
					await webClient.DownloadFileTaskAsync(new Uri(ytDlpURL), ModPaths.yt_dlp);
				}
				Log.Info("yt-dlp downloaded successfully!");
			}
			catch (Exception ex2)
			{
				Exception ex = ex2;
				Log.Error("Failed to download yt-dlp: " + ex.Message);
			}
		}

		private static async Task DownloadFfmpeg()
		{
			try
			{
				string ffmpegTempZipPath = Path.Combine(ModPaths.dependencies, "ffmpeg.zip");
				Log.Info("Downloading ffmpeg...");
				using (WebClient webClient = new WebClient())
				{
					await webClient.DownloadFileTaskAsync(new Uri(ffmpegURL), ffmpegTempZipPath);
				}
				Log.Info("ffmpeg downloaded successfully!");
				await Task.Run(delegate
				{
					ExtractFfmpeg(ffmpegTempZipPath, ModPaths.dependencies);
				});
				File.Delete(ffmpegTempZipPath);
			}
			catch (Exception ex2)
			{
				Exception ex = ex2;
				Log.Error("Failed to download ffmpeg: " + ex.Message);
			}
		}

		private static void ExtractFfmpeg(string zipPath, string extractPath)
		{
			try
			{
				Log.Info("Extracting ffmpeg...");
				using ZipArchive zipArchive = ZipFile.OpenRead(zipPath);
				ZipArchiveEntry zipArchiveEntry = zipArchive.Entries.FirstOrDefault((ZipArchiveEntry entry) => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase));
				if (zipArchiveEntry != null)
				{
					string destinationFileName = Path.Combine(extractPath, "ffmpeg.exe");
					zipArchiveEntry.ExtractToFile(destinationFileName, overwrite: true);
					Log.Info("ffmpeg.exe extracted successfully!");
				}
				else
				{
					Log.Error("ffmpeg.exe not found in the zip archive!");
				}
			}
			catch (Exception ex)
			{
				Log.Error("Failed to extract ffmpeg: " + ex.Message);
			}
		}

		public static async Task<bool> GetCustomSong(string URLInput)
		{
			if (!URLInput.StartsWith("http"))
			{
				return false;
			}
			if (lastURL != null && lastURL == URLInput && File.Exists(ModPaths.customSong))
			{
				return true;
			}
			Log.Info("Play button pressed with URL: " + URLInput);
			if (File.Exists(ModPaths.customSong))
			{
				File.Delete(ModPaths.customSong);
			}
			ProcessStartInfo ytDlpProcess = new ProcessStartInfo
			{
				FileName = ModPaths.yt_dlp,
				Arguments = "--ffmpeg-location \"" + ModPaths.ffmpeg + "\" -f bestaudio -x --audio-format wav -o \"" + ModPaths.customSong + "\" " + URLInput,
				UseShellExecute = false,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				CreateNoWindow = true
			};
			using Process process = new Process();
			process.StartInfo = ytDlpProcess;
			process.Start();
			string output = await process.StandardOutput.ReadToEndAsync();
			string error = await process.StandardError.ReadToEndAsync();
			process.WaitForExit();
			if (process.ExitCode == 0)
			{
				lastURL = URLInput;
				Log.Info("yt-dlp finished successfully");
				Log.Info("Output: " + output);
				return true;
			}
			Log.Error("yt-dlp encountered an error: " + error);
			return false;
		}
	}
	internal static class HarmonyPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class NetManagerPatch
		{
			private static void Postfix(ref SteamManager __instance)
			{
				((Component)__instance).GetComponent<NetworkManager>().AddNetworkPrefab(Plugin.instance.ytRpcPrefab);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class PlayerManagerStartPatch
		{
			private static void Postfix()
			{
				main.OnWorldLoad();
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class LeaveWorldPatch
		{
			private static void Postfix()
			{
				Audio.StopCustomTrack();
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class PlayPatch
		{
			private static void Postfix(byte id)
			{
				if (id != 99)
				{
					YTNetworkManager.instance.StopTrackClientRpc();
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class StopPatch
		{
			private static void Postfix()
			{
				if (!YTNetworkManager.skipStop)
				{
					YTNetworkManager.instance.StopTrackClientRpc();
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class NextPatch
		{
			private static void Postfix()
			{
				YTNetworkManager.instance.StopTrackClientRpc();
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class PrevPatch
		{
			private static void Postfix()
			{
				YTNetworkManager.instance.StopTrackClientRpc();
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class VolumePatch
		{
			private static void Postfix(byte v)
			{
				YTNetworkManager.instance.ChangeVolumeClientRpc(v);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class InteractPatch
		{
			private static void Postfix(Jukebox __instance, Event e, ushort itemDataId, uint itemId)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				if ((int)e == 1)
				{
					Audio.activeJukebox = ((Component)__instance).gameObject;
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class SyncPatch
		{
			private static void Postfix(Jukebox __instance, bool v)
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				ulong networkObjectId = gameObject.GetComponent<NetworkObject>().NetworkObjectId;
				YTNetworkManager.instance.SetSyncClientRpc(networkObjectId, v);
			}
		}

		private static Plugin main;

		public static void Init()
		{
			main = Plugin.instance;
		}
	}
	public static class ModPaths
	{
		public static string root;

		public static string customSong;

		public static string dependencies;

		public static string ffmpeg;

		public static string yt_dlp;

		public static void SetPaths()
		{
			root = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			customSong = Path.Combine(root, "AudioTrack.wav");
			dependencies = Path.Combine(root, "Dependencies");
			ffmpeg = Path.Combine(dependencies, "ffmpeg.exe");
			yt_dlp = Path.Combine(dependencies, "yt-dlp.exe");
		}
	}
	[BepInPlugin("com.tomdom.ytjukebox", "YTJukebox", "1.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin instance;

		public GameObject ytRpcPrefab;

		public NetworkManager networkManager;

		private void Awake()
		{
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			ModPaths.SetPaths();
			if (!Directory.Exists(ModPaths.dependencies))
			{
				List<string> list = new List<string> { "NAudio.Core.dll", "NAudio.Wasapi.dll", "NAudio.WinMM.dll", "NAudio.dll", "ytbIcon.png", "ytnetcode" };
				Directory.CreateDirectory(ModPaths.dependencies);
				foreach (string item in list)
				{
					string text = Path.Combine(ModPaths.root, item);
					string destFileName = Path.Combine(ModPaths.dependencies, item);
					if (File.Exists(text))
					{
						File.Move(text, destFileName);
					}
				}
			}
			AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			instance = this;
			string text2 = Path.Combine(ModPaths.dependencies, "ytnetcode");
			AssetBundle val = AssetBundle.LoadFromFile(text2);
			ytRpcPrefab = val.LoadAsset<GameObject>("Assets/YTJukebox/YTNetworkManager.prefab");
			ytRpcPrefab.AddComponent<YTNetworkManager>();
			if (!File.Exists(ModPaths.yt_dlp) || !File.Exists(ModPaths.ffmpeg))
			{
				Log.Info("yt-dlp or ffmpeg not found! triggering download");
				Task.Run(async delegate
				{
					await Download.GetDependencies();
				});
			}
			HarmonyPatches.Init();
			Harmony val2 = new Harmony("com.tomdom.ytjukebox");
			val2.PatchAll();
		}

		public void OnWorldLoad()
		{
			Audio.OnWorldLoad();
			AddEmptyTrack();
			UI.CreateCustomUI();
			GameObject val = GameObject.Find("SteamNetManager");
			networkManager = val.GetComponent<NetworkManager>();
			if (networkManager.IsHost)
			{
				GameObject val2 = Object.Instantiate<GameObject>(ytRpcPrefab);
				val2.GetComponent<NetworkObject>().Spawn(false);
			}
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)UI.GameCanvas) && Input.GetKeyDown((KeyCode)27) && UI.Youtube.activeSelf)
			{
				UI.Youtube.SetActive(false);
				UI.Jukebox.SetActive(true);
				((Behaviour)UI.gameMenu).enabled = true;
			}
		}

		private void FixedUpdate()
		{
			Audio.UpdateAudioSpatial();
		}

		private void AddEmptyTrack()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0060: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			GUID val = default(GUID);
			val.Data1 = -502618873;
			val.Data2 = 1190340663;
			val.Data3 = 1799067022;
			val.Data4 = -1538532083;
			GUID guid = val;
			if (!JukeboxManager.Instance.tracks.ContainsKey(99))
			{
				JukeboxManager.Instance.tracks.Add(99, new JukeboxTrack
				{
					id = 99,
					eventRef = new EventReference
					{
						Guid = guid
					},
					name = "",
					questId = 0
				});
			}
		}

		private static Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
		{
			string path = new AssemblyName(args.Name).Name + ".dll";
			string[] array = new string[2]
			{
				Path.Combine(ModPaths.root, path),
				Path.Combine(ModPaths.dependencies, path)
			};
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (File.Exists(text))
				{
					return Assembly.LoadFrom(text);
				}
			}
			return null;
		}

		public void LogInfo(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}

		public void LogError(string message)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)message);
		}

		public void LogWarning(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)message);
		}
	}
	public static class Log
	{
		public static void Info(string message)
		{
			Plugin.instance.LogInfo(message);
		}

		public static void Error(string message)
		{
			Plugin.instance.LogError(message);
		}

		public static void Warning(string message)
		{
			Plugin.instance.LogWarning(message);
		}
	}
	internal static class UI
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Sprite, bool> <>9__9_0;

			public static UnityAction <>9__9_1;

			public static Func<Sprite, bool> <>9__10_0;

			public static Func<Sprite, bool> <>9__10_1;

			public static Func<Sprite, bool> <>9__11_0;

			public static Func<TMP_FontAsset, bool> <>9__11_1;

			public static Func<TMP_FontAsset, bool> <>9__11_2;

			public static Func<Sprite, bool> <>9__12_0;

			public static Func<TMP_FontAsset, bool> <>9__12_1;

			public static UnityAction <>9__12_2;

			internal bool <CreateYTButton>b__9_0(Sprite s)
			{
				return ((Object)s).name == "btn_rectangle_01_n_bluegray";
			}

			internal void <CreateYTButton>b__9_1()
			{
				Jukebox.SetActive(false);
				Youtube.SetActive(true);
				((Behaviour)gameMenu).enabled = false;
			}

			internal bool <CreateYTUI>b__10_0(Sprite s)
			{
				return ((Object)s).name == "frame_stageframe_02_d";
			}

			internal bool <CreateYTUI>b__10_1(Sprite s)
			{
				return ((Object)s).name == "frame_listframe_01_n";
			}

			internal bool <CreateInputField>b__11_0(Sprite s)
			{
				return ((Object)s).name == "textfield_activity_0";
			}

			internal bool <CreateInputField>b__11_1(TMP_FontAsset f)
			{
				return ((Object)f).name == "Lato-Regular SDF";
			}

			internal bool <CreateInputField>b__11_2(TMP_FontAsset f)
			{
				return ((Object)f).name == "Lato-Regular SDF";
			}

			internal bool <CreatePlayButton>b__12_0(Sprite s)
			{
				return ((Object)s).name == "btn_rectangle_01_n_bluegray";
			}

			internal bool <CreatePlayButton>b__12_1(TMP_FontAsset f)
			{
				return ((Object)f).name == "Lato-Regular SDF";
			}

			internal void <CreatePlayButton>b__12_2()
			{
				if ((Object)(object)Audio.activeJukebox != (Object)null)
				{
					ulong networkObjectId = Audio.activeJukebox.GetComponent<NetworkObject>().NetworkObjectId;
					YTNetworkManager.instance.TriggerDownloadServerRpc(inputField.text, networkObjectId);
				}
				else
				{
					Log.Error("No active jukebox found when attempting to trigger download.");
				}
			}
		}

		private static GameObject JukeBoxControls;

		public static GameObject Youtube;

		public static GameObject Jukebox;

		public static GameObject GameCanvas;

		public static GameMenu gameMenu;

		private static TMP_InputField inputField;

		private static Sprite CreateSprite(string filePath)
		{
			//IL_002d: 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)
			Texture2D val = LoadTextureFromFile(filePath);
			return ((Object)(object)val != (Object)null) ? Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f)) : null;
		}

		private static Texture2D LoadTextureFromFile(string filePath)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (!File.Exists(filePath))
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2);
			return ImageConversion.LoadImage(val, File.ReadAllBytes(filePath)) ? val : null;
		}

		public static void CreateCustomUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Youtube = new GameObject("YoutubeUI");
			Jukebox = GameObject.Find("Common/GameCanvas/Jukebox Screen");
			GameCanvas = GameObject.Find("Common/GameCanvas");
			JukeBoxControls = GameObject.Find("Common/GameCanvas/Jukebox Screen/Panel/Controls");
			gameMenu = GameCanvas.GetComponent<GameMenu>();
			CreateYTButton();
			CreateYTUI();
		}

		private static void CreateYTButton()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			GameObject val = new GameObject("YtbButton");
			val.transform.SetParent(JukeBoxControls.transform, false);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => ((Object)s).name == "btn_rectangle_01_n_bluegray"));
			val2.type = (Type)1;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(60f, 60f);
			GameObject val3 = new GameObject("Image");
			val3.transform.SetParent(val.transform, false);
			Image val4 = val3.AddComponent<Image>();
			val4.sprite = CreateSprite(Path.Combine(ModPaths.dependencies, "ytbIcon.png"));
			((Graphic)val4).color = new Color(0.1451f, 0.1137f, 0.1529f, 1f);
			val3.GetComponent<RectTransform>().sizeDelta = new Vector2(40f, 28f);
			((Transform)val3.GetComponent<RectTransform>()).localPosition = Vector3.zero;
			Button val5 = val.AddComponent<Button>();
			ButtonClickedEvent onClick = val5.onClick;
			object obj = <>c.<>9__9_1;
			if (obj == null)
			{
				UnityAction val6 = delegate
				{
					Jukebox.SetActive(false);
					Youtube.SetActive(true);
					((Behaviour)gameMenu).enabled = false;
				};
				<>c.<>9__9_1 = val6;
				obj = (object)val6;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
		}

		private static void CreateYTUI()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00fb: 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_0111: Expected O, but got Unknown
			Youtube.transform.SetParent(GameCanvas.transform, false);
			Youtube.SetActive(false);
			Image val = Youtube.AddComponent<Image>();
			val.sprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => ((Object)s).name == "frame_stageframe_02_d"));
			val.type = (Type)1;
			Youtube.GetComponent<RectTransform>().sizeDelta = new Vector2(800f, 300f);
			GameObject val2 = new GameObject("Frame");
			val2.transform.SetParent(Youtube.transform, false);
			Image val3 = val2.AddComponent<Image>();
			val3.sprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => ((Object)s).name == "frame_listframe_01_n"));
			val3.type = (Type)1;
			val2.GetComponent<RectTransform>().sizeDelta = new Vector2(760f, 260f);
			GameObject val4 = new GameObject("MainContainer");
			val4.transform.SetParent(val2.transform, false);
			CreateInputField(val4);
			CreatePlayButton(val4);
		}

		private static void CreateInputField(GameObject parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("URLInputField");
			val.transform.SetParent(parent.transform, false);
			val.transform.localPosition = new Vector3(0f, 50f, 0f);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => ((Object)s).name == "textfield_activity_0"));
			val2.type = (Type)1;
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(700f, 40f);
			GameObject val3 = new GameObject("InputText");
			val3.transform.SetParent(val.transform, false);
			TextMeshProUGUI val4 = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val4).font = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name == "Lato-Regular SDF"));
			((TMP_Text)val4).fontSize = 24f;
			((Graphic)val4).color = Color.white;
			((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(680f, 30f);
			((Transform)component2).localPosition = Vector3.zero;
			inputField = val.AddComponent<TMP_InputField>();
			inputField.textViewport = component;
			inputField.textComponent = (TMP_Text)(object)val4;
			GameObject val5 = new GameObject("PlaceholderText");
			val5.transform.SetParent(val.transform, false);
			TextMeshProUGUI val6 = val5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val6).font = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name == "Lato-Regular SDF"));
			((TMP_Text)val6).fontSize = 24f;
			((Graphic)val6).color = Color.gray;
			((TMP_Text)val6).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val6).text = "Enter URL here...";
			val5.GetComponent<RectTransform>().sizeDelta = new Vector2(680f, 30f);
			((Transform)val5.GetComponent<RectTransform>()).localPosition = Vector3.zero;
			inputField.placeholder = (Graphic)(object)val6;
		}

		private static void CreatePlayButton(GameObject parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			GameObject val = new GameObject("PlayButton");
			val.transform.SetParent(parent.transform, false);
			val.transform.localPosition = new Vector3(0f, -45f, 0f);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => ((Object)s).name == "btn_rectangle_01_n_bluegray"));
			val2.type = (Type)1;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(120f, 60f);
			GameObject val3 = new GameObject("PlayText");
			val3.transform.SetParent(val.transform, false);
			TextMeshProUGUI val4 = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val4).font = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name == "Lato-Regular SDF"));
			((TMP_Text)val4).fontSize = 30f;
			((Graphic)val4).color = Color.white;
			((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val4).text = "Play";
			RectTransform component = val3.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(120f, 60f);
			((Transform)component).localPosition = Vector3.zero;
			component.anchorMax = new Vector2(0.5f, 0.6f);
			Button val5 = val.AddComponent<Button>();
			ButtonClickedEvent onClick = val5.onClick;
			object obj = <>c.<>9__12_2;
			if (obj == null)
			{
				UnityAction val6 = delegate
				{
					if ((Object)(object)Audio.activeJukebox != (Object)null)
					{
						ulong networkObjectId = Audio.activeJukebox.GetComponent<NetworkObject>().NetworkObjectId;
						YTNetworkManager.instance.TriggerDownloadServerRpc(inputField.text, networkObjectId);
					}
					else
					{
						Log.Error("No active jukebox found when attempting to trigger download.");
					}
				};
				<>c.<>9__12_2 = val6;
				obj = (object)val6;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace YTJukebox.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}