using System;
using System.Collections;
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.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
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("BoomBoxOverhaulV2")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BoomBoxOverhaulV2")]
[assembly: AssemblyTitle("BoomBoxOverhaulV2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BoomBoxOverhaul;

internal static class BoomBoxOverhaulNet
{
	[CompilerGenerated]
	private sealed class <BootLoop>d__15 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <BootLoop>d__15(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			TryBindToNetworkManager();
			if ((Object)(object)boundManager != (Object)null && handlersRegistered && boundManager.IsServer)
			{
				BroadcastSyncSettings(Plugin.LocalVolumeOnly.Value);
			}
			<>2__current = (object)new WaitForSeconds(1f);
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private const string MsgRequestPlay = "BoomBoxOverhaul_RequestPlay";

	private const string MsgPrepareTrack = "BoomBoxOverhaul_PrepareTrack";

	private const string MsgNotifyReady = "BoomBoxOverhaul_NotifyReady";

	private const string MsgBeginPlayback = "BoomBoxOverhaul_BeginPlayback";

	private const string MsgRequestStop = "BoomBoxOverhaul_RequestStop";

	private const string MsgStopPlayback = "BoomBoxOverhaul_StopPlayback";

	private const string MsgRejectPlay = "BoomBoxOverhaul_RejectPlay";

	private const string MsgSetVolume = "BoomBoxOverhaul_SetVolume";

	private const string MsgApplyVolume = "BoomBoxOverhaul_ApplyVolume";

	private const string MsgSyncSettings = "BoomBoxOverhaul_SyncSettings";

	private static MonoBehaviour host;

	private static bool initialized;

	private static bool handlersRegistered;

	private static NetworkManager boundManager;

	public static void Initialize(MonoBehaviour coroutineHost)
	{
		if (!initialized)
		{
			initialized = true;
			host = coroutineHost;
			host.StartCoroutine(BootLoop());
		}
	}

	[IteratorStateMachine(typeof(<BootLoop>d__15))]
	private static IEnumerator BootLoop()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <BootLoop>d__15(0);
	}

	private static void TryBindToNetworkManager()
	{
		NetworkManager singleton = NetworkManager.Singleton;
		if (!((Object)(object)singleton == (Object)null))
		{
			if ((Object)(object)boundManager != (Object)(object)singleton)
			{
				UnregisterHandlers();
				boundManager = singleton;
				handlersRegistered = false;
				Plugin.Log("BoomBoxOverhaul bound to NetworkManager.");
			}
			if (!handlersRegistered)
			{
				RegisterHandlers();
			}
		}
	}

	private static void RegisterHandlers()
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Expected O, but got Unknown
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Expected O, but got Unknown
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Expected O, but got Unknown
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Expected O, but got Unknown
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Expected O, but got Unknown
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Expected O, but got Unknown
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Expected O, but got Unknown
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Expected O, but got Unknown
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Expected O, but got Unknown
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Expected O, but got Unknown
		if (!((Object)(object)boundManager == (Object)null) && boundManager.CustomMessagingManager != null)
		{
			CustomMessagingManager customMessagingManager = boundManager.CustomMessagingManager;
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_RequestPlay", new HandleNamedMessageDelegate(OnRequestPlay));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_PrepareTrack", new HandleNamedMessageDelegate(OnPrepareTrack));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_NotifyReady", new HandleNamedMessageDelegate(OnNotifyReady));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_BeginPlayback", new HandleNamedMessageDelegate(OnBeginPlayback));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_RequestStop", new HandleNamedMessageDelegate(OnRequestStop));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_StopPlayback", new HandleNamedMessageDelegate(OnStopPlayback));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_RejectPlay", new HandleNamedMessageDelegate(OnRejectPlay));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_SetVolume", new HandleNamedMessageDelegate(OnSetVolume));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_ApplyVolume", new HandleNamedMessageDelegate(OnApplyVolume));
			customMessagingManager.RegisterNamedMessageHandler("BoomBoxOverhaul_SyncSettings", new HandleNamedMessageDelegate(OnSyncSettings));
			handlersRegistered = true;
			Plugin.Log("BoomBoxOverhaul network handlers registered.");
		}
	}

	private static void UnregisterHandlers()
	{
		if (!((Object)(object)boundManager == (Object)null) && boundManager.CustomMessagingManager != null && handlersRegistered)
		{
			CustomMessagingManager customMessagingManager = boundManager.CustomMessagingManager;
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_RequestPlay");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_PrepareTrack");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_NotifyReady");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_BeginPlayback");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_RequestStop");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_StopPlayback");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_RejectPlay");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_SetVolume");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_ApplyVolume");
			customMessagingManager.UnregisterNamedMessageHandler("BoomBoxOverhaul_SyncSettings");
			handlersRegistered = false;
			Plugin.Log("BoomBoxOverhaul network handlers unregistered.");
		}
	}

	public static UnifiedBoomboxController GetController(ulong networkObjectId)
	{
		if ((Object)(object)boundManager == (Object)null || boundManager.SpawnManager == null)
		{
			return null;
		}
		if (!boundManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectId, out var value))
		{
			return null;
		}
		return ((Component)value).GetComponent<UnifiedBoomboxController>();
	}

	public static void SendRequestPlay(ulong networkObjectId, string url)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: 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 ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsClient)
		{
			Plugin.Warn("SendRequestPlay failed: network not ready.");
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(8192, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
			((FastBufferWriter)(ref val)).WriteValueSafe(url, false);
			boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_RequestPlay", 0uL, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
		Plugin.Log("Sent play request for object " + networkObjectId);
	}

	public static void BroadcastPrepareTrack(ulong networkObjectId, string canonicalUrl, string videoId, int playlistIndex, string[] playlistIds)
	{
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			Plugin.Warn("BroadcastPrepareTrack failed: server network not ready.");
			return;
		}
		ulong[] connectedClientIds = GetConnectedClientIds();
		FastBufferWriter val = default(FastBufferWriter);
		for (int i = 0; i < connectedClientIds.Length; i++)
		{
			((FastBufferWriter)(ref val))..ctor(16384, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(canonicalUrl, false);
				((FastBufferWriter)(ref val)).WriteValueSafe(videoId, false);
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref playlistIndex, default(ForPrimitives));
				int num = playlistIds.Length;
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				for (int j = 0; j < playlistIds.Length; j++)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playlistIds[j], false);
				}
				boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_PrepareTrack", connectedClientIds[i], val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		Plugin.Log("Broadcast prepare track for object " + networkObjectId);
	}

	public static void SendNotifyReady(ulong networkObjectId, bool success)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: 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_0080: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsClient)
		{
			Plugin.Warn("SendNotifyReady failed: network not ready.");
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
			((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref success, default(ForPrimitives));
			boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_NotifyReady", 0uL, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
		Plugin.Log("Sent ready state " + success + " for object " + networkObjectId);
	}

	public static void BroadcastBeginPlaybackReadyOnly(ulong networkObjectId, string videoId, HashSet<ulong> readyClientIds)
	{
		//IL_0062: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			Plugin.Warn("BroadcastBeginPlaybackReadyOnly failed: server network not ready.");
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		foreach (ulong readyClientId in readyClientIds)
		{
			((FastBufferWriter)(ref val))..ctor(2048, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(videoId, false);
				boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_BeginPlayback", readyClientId, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		Plugin.Log("Broadcast begin playback to ready clients only: " + readyClientIds.Count);
	}

	public static void SendRequestStop(ulong networkObjectId)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: 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)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsClient)
		{
			Plugin.Warn("SendRequestStop failed: network not ready.");
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(128, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
			boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_RequestStop", 0uL, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
		Plugin.Log("Sent stop request for object " + networkObjectId);
	}

	public static void BroadcastStopPlayback(ulong networkObjectId)
	{
		//IL_005a: 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_007a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			Plugin.Warn("BroadcastStopPlayback failed: server network not ready.");
			return;
		}
		ulong[] connectedClientIds = GetConnectedClientIds();
		FastBufferWriter val = default(FastBufferWriter);
		for (int i = 0; i < connectedClientIds.Length; i++)
		{
			((FastBufferWriter)(ref val))..ctor(128, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_StopPlayback", connectedClientIds[i], val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		Plugin.Log("Broadcast stop playback for object " + networkObjectId);
	}

	public static void SendRejectPlay(ulong targetClientId, ulong networkObjectId, string reason)
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: 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)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(2048, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
			((FastBufferWriter)(ref val)).WriteValueSafe(reason, false);
			boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_RejectPlay", targetClientId, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
	}

	public static void SendSetVolume(ulong networkObjectId, float volume)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: 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_0065: 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)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsClient)
		{
			Plugin.Warn("SendSetVolume failed: network not ready.");
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
			((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref volume, default(ForPrimitives));
			boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_SetVolume", 0uL, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
	}

	public static void BroadcastApplyVolume(ulong networkObjectId, float volume)
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: 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_008b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			Plugin.Warn("BroadcastApplyVolume failed: server network not ready.");
			return;
		}
		ulong[] connectedClientIds = GetConnectedClientIds();
		FastBufferWriter val = default(FastBufferWriter);
		for (int i = 0; i < connectedClientIds.Length; i++)
		{
			((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref volume, default(ForPrimitives));
				boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_ApplyVolume", connectedClientIds[i], val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
	}

	public static void BroadcastSyncSettings(bool localVolumeOnly)
	{
		//IL_0049: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boundManager == (Object)null || !handlersRegistered || !boundManager.IsServer)
		{
			return;
		}
		ulong[] connectedClientIds = GetConnectedClientIds();
		FastBufferWriter val = default(FastBufferWriter);
		for (int i = 0; i < connectedClientIds.Length; i++)
		{
			((FastBufferWriter)(ref val))..ctor(64, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref localVolumeOnly, default(ForPrimitives));
				boundManager.CustomMessagingManager.SendNamedMessage("BoomBoxOverhaul_SyncSettings", connectedClientIds[i], val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		Plugin.Log("Broadcast synced settings. LocalVolumeOnly = " + localVolumeOnly);
	}

	private static void OnRequestPlay(ulong senderClientId, FastBufferReader reader)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		Plugin.Log("OnRequestPlay received from client " + senderClientId);
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		string url = default(string);
		((FastBufferReader)(ref reader)).ReadValueSafe(ref url, false);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ServerHandlePlay(senderClientId, url);
		}
		else
		{
			Plugin.Warn("OnRequestPlay could not find controller for object " + networkObjectId);
		}
	}

	private static void OnPrepareTrack(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//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_0050: 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)
		Plugin.Log("OnPrepareTrack received");
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		string canonicalUrl = default(string);
		((FastBufferReader)(ref reader)).ReadValueSafe(ref canonicalUrl, false);
		string videoId = default(string);
		((FastBufferReader)(ref reader)).ReadValueSafe(ref videoId, false);
		int playlistIndex = default(int);
		((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref playlistIndex, default(ForPrimitives));
		int num = default(int);
		((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
		string[] array = new string[num];
		for (int i = 0; i < num; i++)
		{
			((FastBufferReader)(ref reader)).ReadValueSafe(ref array[i], false);
		}
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ClientPrepareTrack(canonicalUrl, videoId, playlistIndex, array);
		}
		else
		{
			Plugin.Warn("OnPrepareTrack could not find controller for object " + networkObjectId);
		}
	}

	private static void OnNotifyReady(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		bool success = default(bool);
		((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref success, default(ForPrimitives));
		Plugin.Log("OnNotifyReady received from " + senderClientId + " success=" + success);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ServerNotifyReady(senderClientId, success);
		}
		else
		{
			Plugin.Warn("OnNotifyReady could not find controller for object " + networkObjectId);
		}
	}

	private static void OnBeginPlayback(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		Plugin.Log("OnBeginPlayback received");
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		string videoId = default(string);
		((FastBufferReader)(ref reader)).ReadValueSafe(ref videoId, false);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ClientBeginPlayback(videoId);
		}
		else
		{
			Plugin.Warn("OnBeginPlayback could not find controller for object " + networkObjectId);
		}
	}

	private static void OnRequestStop(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ServerHandleStop();
		}
		else
		{
			Plugin.Warn("OnRequestStop could not find controller for object " + networkObjectId);
		}
	}

	private static void OnStopPlayback(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ClientStopPlayback();
		}
		else
		{
			Plugin.Warn("OnStopPlayback could not find controller for object " + networkObjectId);
		}
	}

	private static void OnRejectPlay(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		string reason = default(string);
		((FastBufferReader)(ref reader)).ReadValueSafe(ref reason, false);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ClientRejectPlay(reason);
		}
	}

	private static void OnSetVolume(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		float volume = default(float);
		((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref volume, default(ForPrimitives));
		Plugin.Log("OnSetVolume received from " + senderClientId + " volume=" + volume);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ServerHandleSetVolume(volume);
		}
		else
		{
			Plugin.Warn("OnSetVolume could not find controller for object " + networkObjectId);
		}
	}

	private static void OnApplyVolume(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		ulong networkObjectId = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
		float volume = default(float);
		((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref volume, default(ForPrimitives));
		Plugin.Log("OnApplyVolume received volume=" + volume);
		UnifiedBoomboxController controller = GetController(networkObjectId);
		if ((Object)(object)controller != (Object)null)
		{
			controller.ClientApplyNetworkVolume(volume);
		}
		else
		{
			Plugin.Warn("OnApplyVolume could not find controller for object " + networkObjectId);
		}
	}

	private static void OnSyncSettings(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		bool syncedLocalVolumeOnly = default(bool);
		((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref syncedLocalVolumeOnly, default(ForPrimitives));
		Plugin.SyncedLocalVolumeOnly = syncedLocalVolumeOnly;
		Plugin.HasSyncedVolumeMode = true;
		Plugin.Log("Received synced settings. LocalVolumeOnly = " + syncedLocalVolumeOnly);
	}

	private static ulong[] GetConnectedClientIds()
	{
		List<ulong> list = new List<ulong>();
		if ((Object)(object)boundManager == (Object)null || boundManager.ConnectedClients == null)
		{
			return list.ToArray();
		}
		foreach (KeyValuePair<ulong, NetworkClient> connectedClient in boundManager.ConnectedClients)
		{
			list.Add(connectedClient.Key);
		}
		return list.ToArray();
	}
}
public class BoomBoxOverhaulNetBoot : MonoBehaviour
{
	private void Awake()
	{
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
	}

	private void Start()
	{
		BoomBoxOverhaulNet.Initialize((MonoBehaviour)(object)this);
	}
}
internal static class CacheManager
{
	public static string BuildTrackBasePath(string videoId)
	{
		return Path.Combine(Plugin.CacheFolder, videoId);
	}

	public static string BuildAudioPath(string videoId)
	{
		return BuildTrackBasePath(videoId) + ".mp3";
	}

	public static string BuildMetaPath(string videoId)
	{
		return BuildTrackBasePath(videoId) + ".txt";
	}

	public static bool HasTrack(string videoId)
	{
		return File.Exists(BuildAudioPath(videoId));
	}

	public static void Touch(string path)
	{
		try
		{
			if (File.Exists(path))
			{
				File.SetLastWriteTimeUtc(path, DateTime.UtcNow);
			}
		}
		catch
		{
		}
	}

	public static void WriteMeta(string videoId, string title)
	{
		try
		{
			File.WriteAllText(BuildMetaPath(videoId), title ?? "");
		}
		catch
		{
		}
	}

	public static string ReadMeta(string videoId)
	{
		try
		{
			string path = BuildMetaPath(videoId);
			if (File.Exists(path))
			{
				return File.ReadAllText(path);
			}
		}
		catch
		{
		}
		return "";
	}

	public static void Prune()
	{
		try
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(Plugin.CacheFolder);
			FileInfo[] files = directoryInfo.GetFiles("*.mp3");
			List<FileInfo> list = new List<FileInfo>(files);
			list.Sort((FileInfo a, FileInfo b) => b.LastWriteTimeUtc.CompareTo(a.LastWriteTimeUtc));
			for (int i = Plugin.MaxCacheFiles.Value; i < list.Count; i++)
			{
				try
				{
					string fullName = list[i].FullName;
					string text = Path.Combine(list[i].DirectoryName ?? Plugin.CacheFolder, Path.GetFileNameWithoutExtension(fullName));
					File.Delete(fullName);
					string path = text + ".txt";
					if (File.Exists(path))
					{
						File.Delete(path);
					}
				}
				catch
				{
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Warn("Cache prune failed: " + ex);
		}
	}
}
internal sealed class DependencyState
{
	public string YtDlpPath;

	public string FfmpegPath;

	public bool IsReady()
	{
		return !string.IsNullOrEmpty(YtDlpPath) && !string.IsNullOrEmpty(FfmpegPath) && File.Exists(YtDlpPath) && File.Exists(FfmpegPath);
	}
}
internal static class DependencyBootstrapper
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass10_0
	{
		public Action action;

		public Exception caught;

		public bool done;

		internal void <RunBlockingTask>b__0()
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				caught = ex;
			}
			finally
			{
				done = true;
			}
		}
	}

	[CompilerGenerated]
	private sealed class <BootstrapCoroutine>d__7 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <BootstrapCoroutine>d__7(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				status = "Checking dependencies...";
				Plugin.Log(status);
				<>2__current = RunBlockingTask(delegate
				{
					try
					{
						ResolveYtDlp();
						ResolveFfmpeg();
						if (state.IsReady())
						{
							status = "Dependencies ready.";
							Plugin.Log(status);
						}
						else
						{
							Plugin.Warn("Dependencies not fully ready. Status: " + status);
						}
					}
					catch (Exception ex)
					{
						status = "Dependency bootstrap failed: " + ex.Message;
						Plugin.Error(status);
						Plugin.Error(ex.ToString());
					}
				});
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunBlockingTask>d__10 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Action action;

		private <>c__DisplayClass10_0 <>8__1;

		private Thread <thread>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunBlockingTask>d__10(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<thread>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass10_0();
				<>8__1.action = action;
				<>8__1.done = false;
				<>8__1.caught = null;
				<thread>5__2 = new Thread((ThreadStart)delegate
				{
					try
					{
						<>8__1.action();
					}
					catch (Exception caught)
					{
						<>8__1.caught = caught;
					}
					finally
					{
						<>8__1.done = true;
					}
				});
				<thread>5__2.IsBackground = true;
				<thread>5__2.Start();
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!<>8__1.done)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (<>8__1.caught != null)
			{
				Plugin.Error("Dependency worker thread failed: " + <>8__1.caught);
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static readonly object Gate = new object();

	private static bool started;

	private static string status = "Dependency check not started.";

	private static DependencyState state = new DependencyState();

	public static string GetStatus()
	{
		return status;
	}

	public static DependencyState GetState()
	{
		return state;
	}

	public static void EnsureStarted(MonoBehaviour host)
	{
		lock (Gate)
		{
			if (started)
			{
				Plugin.Log("Dependency bootstrap already started.");
				return;
			}
			started = true;
			Plugin.Log("Dependency bootstrap starting.");
			host.StartCoroutine(BootstrapCoroutine());
		}
	}

	[IteratorStateMachine(typeof(<BootstrapCoroutine>d__7))]
	private static IEnumerator BootstrapCoroutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <BootstrapCoroutine>d__7(0);
	}

	private static void ResolveYtDlp()
	{
		Plugin.Log("Checking for yt-dlp...");
		string text = Path.Combine(Plugin.ToolsFolder, "yt-dlp.exe");
		if (File.Exists(text))
		{
			state.YtDlpPath = text;
			status = "Using local yt-dlp.";
			Plugin.Log("yt-dlp found in tools folder: " + text);
			return;
		}
		if (Plugin.SearchPathForTools.Value)
		{
			string text2 = FileSystemHelpers.TryFindOnPath("yt-dlp.exe");
			if (!string.IsNullOrEmpty(text2))
			{
				state.YtDlpPath = text2;
				status = "Using PATH yt-dlp.";
				Plugin.Log("yt-dlp found on PATH: " + text2);
				return;
			}
		}
		if (!Plugin.AutoDownloadYtDlp.Value)
		{
			status = "yt-dlp missing.";
			Plugin.Warn("yt-dlp not found and auto-download is disabled.");
			return;
		}
		try
		{
			status = "Downloading yt-dlp...";
			Plugin.Log(status);
			using (WebClient webClient = new WebClient())
			{
				webClient.Headers.Add("User-Agent", "BoomBoxOverhaul/2.0.0");
				webClient.DownloadFile("https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe", text);
			}
			state.YtDlpPath = text;
			status = "yt-dlp downloaded successfully.";
			Plugin.Log("yt-dlp ready at: " + text);
		}
		catch (Exception ex)
		{
			status = "Failed downloading yt-dlp: " + ex.Message;
			Plugin.Error(status);
		}
	}

	private static void ResolveFfmpeg()
	{
		Plugin.Log("Checking for ffmpeg...");
		string text = Path.Combine(Plugin.ToolsFolder, "ffmpeg.exe");
		if (File.Exists(text))
		{
			state.FfmpegPath = text;
			status = "Using local ffmpeg.";
			Plugin.Log("ffmpeg found in tools folder: " + text);
			return;
		}
		if (Plugin.SearchPathForTools.Value)
		{
			string text2 = FileSystemHelpers.TryFindOnPath("ffmpeg.exe");
			if (!string.IsNullOrEmpty(text2))
			{
				state.FfmpegPath = text2;
				status = "Using PATH ffmpeg.";
				Plugin.Log("ffmpeg found on PATH: " + text2);
				return;
			}
		}
		if (!Plugin.AutoDownloadFfmpeg.Value)
		{
			status = "ffmpeg missing.";
			Plugin.Warn("ffmpeg not found and auto-download is disabled.");
			return;
		}
		string text3 = ((Plugin.FfmpegZipUrl.Value == null) ? "" : Plugin.FfmpegZipUrl.Value.Trim());
		if (string.IsNullOrEmpty(text3))
		{
			text3 = "https://github.com/yt-dlp/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl.zip";
			Plugin.Warn("ffmpeg ZIP URL was empty, falling back to built-in default.");
		}
		try
		{
			status = "Downloading FFmpeg...";
			Plugin.Log(status);
			string text4 = Path.Combine(Plugin.ToolsFolder, "ffmpeg_package.zip");
			string text5 = Path.Combine(Plugin.ToolsFolder, "ffmpeg_extract");
			if (File.Exists(text4))
			{
				File.Delete(text4);
			}
			if (Directory.Exists(text5))
			{
				Directory.Delete(text5, recursive: true);
			}
			using (WebClient webClient = new WebClient())
			{
				webClient.Headers.Add("User-Agent", "BoomBoxOverhaul/2.0.0");
				webClient.DownloadFile(text3, text4);
			}
			Plugin.Log("FFmpeg archive downloaded: " + text4);
			ZipFile.ExtractToDirectory(text4, text5);
			Plugin.Log("FFmpeg archive extracted.");
			string[] files = Directory.GetFiles(text5, "ffmpeg.exe", SearchOption.AllDirectories);
			string[] files2 = Directory.GetFiles(text5, "ffprobe.exe", SearchOption.AllDirectories);
			if (files.Length != 0)
			{
				File.Copy(files[0], text, overwrite: true);
				state.FfmpegPath = text;
				Plugin.Log("ffmpeg ready at: " + text);
				if (files2.Length != 0)
				{
					string text6 = Path.Combine(Plugin.ToolsFolder, "ffprobe.exe");
					File.Copy(files2[0], text6, overwrite: true);
					Plugin.Log("ffprobe ready at: " + text6);
				}
				status = "ffmpeg downloaded successfully.";
			}
			else
			{
				status = "ffmpeg.exe not found in archive.";
				Plugin.Warn(status);
			}
		}
		catch (Exception ex)
		{
			status = "Failed resolving ffmpeg: " + ex.Message;
			Plugin.Error(status);
		}
	}

	[IteratorStateMachine(typeof(<RunBlockingTask>d__10))]
	private static IEnumerator RunBlockingTask(Action action)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunBlockingTask>d__10(0)
		{
			action = action
		};
	}
}
internal static class FileSystemHelpers
{
	public static void TryDeleteDirectoryContents(string path)
	{
		try
		{
			if (!Directory.Exists(path))
			{
				return;
			}
			string[] files = Directory.GetFiles(path);
			for (int i = 0; i < files.Length; i++)
			{
				try
				{
					File.Delete(files[i]);
				}
				catch
				{
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Error("Failed clearing directory contents for '" + path + "': " + ex);
		}
	}

	public static string TryFindOnPath(string exeName)
	{
		try
		{
			string environmentVariable = Environment.GetEnvironmentVariable("PATH");
			if (string.IsNullOrEmpty(environmentVariable))
			{
				return null;
			}
			string[] array = environmentVariable.Split(Path.PathSeparator);
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					string text = array[i];
					if (!string.IsNullOrEmpty(text))
					{
						string text2 = Path.Combine(text.Trim(), exeName);
						if (File.Exists(text2))
						{
							return text2;
						}
					}
				}
				catch
				{
				}
			}
		}
		catch
		{
		}
		return null;
	}
}
[Serializable]
internal sealed class TrackInfo
{
	public string videoId = "";

	public string title = "";

	public string sourceUrl = "";

	public string cachePath = "";

	public float durationSeconds = 0f;
}
internal sealed class PlaylistState
{
	public readonly List<string> VideoIds = new List<string>();

	public int Index = 0;

	public bool HasCurrent()
	{
		return Index >= 0 && Index < VideoIds.Count;
	}

	public string GetCurrentId()
	{
		if (!HasCurrent())
		{
			return null;
		}
		return VideoIds[Index];
	}

	public string Advance()
	{
		Index++;
		return GetCurrentId();
	}

	public void Shuffle(Random rng)
	{
		for (int num = VideoIds.Count - 1; num > 0; num--)
		{
			int index = rng.Next(num + 1);
			string value = VideoIds[num];
			VideoIds[num] = VideoIds[index];
			VideoIds[index] = value;
		}
	}
}
[HarmonyPatch(typeof(BoomboxItem))]
public static class BoomboxItemPatches
{
	[HarmonyPostfix]
	[HarmonyPatch("Start")]
	public static void StartPostfix(BoomboxItem __instance, ref Item ___itemProperties)
	{
		try
		{
			if (Plugin.InfiniteBattery.Value)
			{
				___itemProperties.requiresBattery = false;
			}
			if ((Object)(object)((Component)__instance).GetComponent<UnifiedBoomboxController>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<UnifiedBoomboxController>();
			}
		}
		catch (Exception ex)
		{
			Plugin.Error("Boombox Start patch failed: " + ex);
		}
	}

	[HarmonyTranspiler]
	[HarmonyPatch("PocketItem")]
	public static IEnumerable<CodeInstruction> PocketItemTranspiler(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		try
		{
			int num = -1;
			int num2 = -1;
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode != OpCodes.Call)
				{
					continue;
				}
				string text = ((object)list[i]).ToString();
				if (text == null || text.IndexOf("BoomboxItem::StartMusic", StringComparison.Ordinal) < 0)
				{
					continue;
				}
				num2 = i;
				for (int num3 = i; num3 >= 0; num3--)
				{
					if (list[num3].opcode == OpCodes.Ldarg_0)
					{
						num = num3;
						break;
					}
				}
				break;
			}
			if (num > -1 && num2 > -1 && num2 >= num)
			{
				list.RemoveRange(num, num2 - num + 1);
				Plugin.Log("Patched BoomboxItem.PocketItem to preserve playback.");
			}
			else
			{
				Plugin.Warn("PocketItem patch could not find BoomboxItem::StartMusic block.");
			}
		}
		catch (Exception ex)
		{
			Plugin.Error("PocketItem transpiler failed: " + ex);
		}
		return list.AsEnumerable();
	}
}
[BepInPlugin("henreh.boomboxoverhaul", "BoomBoxOverhaulV2", "2.0.2")]
public class Plugin : BaseUnityPlugin
{
	public const string ModGuid = "henreh.boomboxoverhaul";

	public const string ModName = "BoomBoxOverhaulV2";

	public const string ModVersion = "2.0.2";

	internal static Plugin Instance;

	internal static Harmony Harmony;

	internal static ConfigEntry<bool> InfiniteBattery;

	internal static ConfigEntry<bool> KeepPlayingPocketed;

	internal static ConfigEntry<float> VolumeStep;

	internal static ConfigEntry<float> DefaultVolume;

	internal static ConfigEntry<KeyCode> OpenUiKey;

	internal static ConfigEntry<KeyCode> VolumeUpKey;

	internal static ConfigEntry<KeyCode> VolumeDownKey;

	internal static ConfigEntry<int> MaxCacheFiles;

	internal static ConfigEntry<float> ReadyTimeoutSeconds;

	internal static ConfigEntry<bool> AutoplayPlaylist;

	internal static ConfigEntry<bool> ShufflePlaylist;

	internal static ConfigEntry<int> MaxTrackSeconds;

	internal static ConfigEntry<bool> DeleteCacheOnBoot;

	internal static ConfigEntry<bool> LocalVolumeOnly;

	internal static ConfigEntry<bool> AutoDownloadYtDlp;

	internal static ConfigEntry<bool> AutoDownloadFfmpeg;

	internal static ConfigEntry<string> FfmpegZipUrl;

	internal static ConfigEntry<bool> SearchPathForTools;

	internal static bool SyncedLocalVolumeOnly = true;

	internal static bool HasSyncedVolumeMode = false;

	internal static string PluginFolder = "";

	internal static string CacheFolder = "";

	internal static string ToolsFolder = "";

	private void Awake()
	{
		//IL_02db: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e5: Expected O, but got Unknown
		//IL_031e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0324: Expected O, but got Unknown
		Instance = this;
		InfiniteBattery = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "InfiniteBattery", true, "Boombox does not require battery.");
		KeepPlayingPocketed = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "KeepPlayingPocketed", true, "Boombox keeps playing when pocketed.");
		VolumeStep = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "VolumeStep", 0.1f, "Volume increment/decrement amount.");
		DefaultVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "DefaultVolume", 1f, "Default local boombox volume.");
		OpenUiKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Input", "OpenUiKey", (KeyCode)98, "Open URL input UI.");
		VolumeUpKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Input", "VolumeUpKey", (KeyCode)61, "Increase boombox volume.");
		VolumeDownKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Input", "VolumeDownKey", (KeyCode)45, "Decrease boombox volume.");
		MaxCacheFiles = ((BaseUnityPlugin)this).Config.Bind<int>("Cache", "MaxCacheFiles", 15, "Maximum amount of downloaded tracks to keep.");
		ReadyTimeoutSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Networking", "ReadyTimeoutSeconds", 20f, "How long the server waits for clients to prepare before starting anyway.");
		AutoplayPlaylist = ((BaseUnityPlugin)this).Config.Bind<bool>("Playlist", "AutoplayPlaylist", true, "Automatically continue to next playlist track.");
		ShufflePlaylist = ((BaseUnityPlugin)this).Config.Bind<bool>("Playlist", "ShufflePlaylist", false, "Shuffle playlist order after resolving entries.");
		MaxTrackSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("Downloads", "MaxTrackSeconds", 1800, "Maximum allowed track duration in seconds.");
		DeleteCacheOnBoot = ((BaseUnityPlugin)this).Config.Bind<bool>("Cache", "DeleteCacheOnBoot", true, "Clear cache when the plugin loads.");
		LocalVolumeOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "LocalVolumeOnly", false, "If true, volume changes are local only. If false, boombox volume is shared server-wide.");
		AutoDownloadYtDlp = ((BaseUnityPlugin)this).Config.Bind<bool>("Dependencies", "AutoDownloadYtDlp", true, "Automatically download yt-dlp if it is missing.");
		AutoDownloadFfmpeg = ((BaseUnityPlugin)this).Config.Bind<bool>("Dependencies", "AutoDownloadFfmpeg", true, "Automatically download ffmpeg if it is missing.");
		FfmpegZipUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Dependencies", "FfmpegZipUrl", "https://github.com/yt-dlp/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl.zip", "FFmpeg ZIP URL.");
		SearchPathForTools = ((BaseUnityPlugin)this).Config.Bind<bool>("Dependencies", "SearchPathForTools", true, "Search PATH for yt-dlp and ffmpeg.");
		PluginFolder = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? Paths.PluginPath;
		ToolsFolder = Path.Combine(PluginFolder, "tools");
		CacheFolder = Path.Combine(PluginFolder, "cache");
		Directory.CreateDirectory(ToolsFolder);
		Directory.CreateDirectory(CacheFolder);
		if (DeleteCacheOnBoot.Value)
		{
			FileSystemHelpers.TryDeleteDirectoryContents(CacheFolder);
		}
		Harmony = new Harmony("henreh.boomboxoverhaul");
		Harmony.PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"BoomBoxOverhaulV2 2.0.2 loaded.");
		DependencyBootstrapper.EnsureStarted((MonoBehaviour)(object)this);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Dependency bootstrap started.");
		GameObject val = new GameObject("BoomBoxOverhaulNetBoot");
		((Object)val).hideFlags = (HideFlags)61;
		val.AddComponent<BoomBoxOverhaulNetBoot>();
		Object.DontDestroyOnLoad((Object)(object)val);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"BoomBoxOverhaul network boot started.");
	}

	internal static bool UseLocalVolumeOnly()
	{
		if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsClient && HasSyncedVolumeMode)
		{
			return SyncedLocalVolumeOnly;
		}
		return LocalVolumeOnly.Value;
	}

	internal static void Log(string msg)
	{
		if ((Object)(object)Instance != (Object)null)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)msg);
		}
	}

	internal static void Warn(string msg)
	{
		if ((Object)(object)Instance != (Object)null)
		{
			((BaseUnityPlugin)Instance).Logger.LogWarning((object)msg);
		}
	}

	internal static void Error(string msg)
	{
		if ((Object)(object)Instance != (Object)null)
		{
			((BaseUnityPlugin)Instance).Logger.LogError((object)msg);
		}
	}
}
public class UnifiedBoomboxController : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass38_0
	{
		public bool fetchOk;

		public string canonicalUrl;

		public string videoId;

		public TrackInfo info;

		internal void <PrepareTrackLocalCoroutine>b__0()
		{
			fetchOk = YtDlpBridge.FetchTrack(canonicalUrl, videoId, out info);
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass45_0
	{
		public Action action;

		public Exception caught;

		public bool done;

		internal void <RunBlockingTask>b__0()
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				caught = ex;
			}
			finally
			{
				done = true;
			}
		}
	}

	[CompilerGenerated]
	private sealed class <PrepareTrackLocalCoroutine>d__38 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public string canonicalUrl;

		public string videoId;

		public UnifiedBoomboxController <>4__this;

		private <>c__DisplayClass38_0 <>8__1;

		private string <fileUrl>5__2;

		private UnityWebRequest <req>5__3;

		private AudioClip <clip>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PrepareTrackLocalCoroutine>d__38(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 2)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>8__1 = null;
			<fileUrl>5__2 = null;
			<req>5__3 = null;
			<clip>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Invalid comparison between Unknown and I4
			bool result;
			try
			{
				switch (<>1__state)
				{
				default:
					result = false;
					break;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass38_0();
					<>8__1.canonicalUrl = canonicalUrl;
					<>8__1.videoId = videoId;
					<>8__1.fetchOk = false;
					<>8__1.info = new TrackInfo();
					Plugin.Log("Preparing local track download for: " + <>8__1.videoId);
					Plugin.Log("Downloading track: " + <>8__1.videoId);
					<>2__current = <>4__this.RunBlockingTask(delegate
					{
						<>8__1.fetchOk = YtDlpBridge.FetchTrack(<>8__1.canonicalUrl, <>8__1.videoId, out <>8__1.info);
					});
					<>1__state = 1;
					result = true;
					break;
				case 1:
					<>1__state = -1;
					if (!<>8__1.fetchOk || !File.Exists(<>8__1.info.cachePath))
					{
						<>4__this.statusText = "Download failed please try a new link, sorry!";
						Plugin.Warn("Download failed for: " + <>8__1.videoId);
						if ((Object)(object)<>4__this.Boombox != (Object)null && (Object)(object)((NetworkBehaviour)<>4__this.Boombox).NetworkObject != (Object)null)
						{
							BoomBoxOverhaulNet.SendNotifyReady(((NetworkBehaviour)<>4__this.Boombox).NetworkObject.NetworkObjectId, success: false);
						}
						result = false;
					}
					else
					{
						Plugin.Log("Download COMPLETE: " + <>8__1.videoId);
						Plugin.Log("Local track download complete for: " + <>8__1.videoId);
						<>4__this.statusText = "Loading clip...";
						<fileUrl>5__2 = "file:///" + <>8__1.info.cachePath.Replace("\\", "/");
						<req>5__3 = UnityWebRequestMultimedia.GetAudioClip(<fileUrl>5__2, (AudioType)13);
						<>1__state = -3;
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 2;
						result = true;
					}
					break;
				case 2:
					<>1__state = -3;
					if ((int)<req>5__3.result != 1)
					{
						<>4__this.statusText = "Clip load failed";
						Plugin.Warn("Clip load failed for: " + <>8__1.videoId);
						if ((Object)(object)<>4__this.Boombox != (Object)null && (Object)(object)((NetworkBehaviour)<>4__this.Boombox).NetworkObject != (Object)null)
						{
							BoomBoxOverhaulNet.SendNotifyReady(((NetworkBehaviour)<>4__this.Boombox).NetworkObject.NetworkObjectId, success: false);
						}
						result = false;
						<>m__Finally1();
						break;
					}
					<clip>5__4 = DownloadHandlerAudioClip.GetContent(<req>5__3);
					((Object)<clip>5__4).name = (string.IsNullOrEmpty(<>8__1.info.title) ? <>8__1.videoId : <>8__1.info.title);
					if ((Object)(object)<>4__this.Audio.clip != (Object)null && (Object)(object)<>4__this.Audio.clip != (Object)(object)<clip>5__4)
					{
						try
						{
							Object.Destroy((Object)(object)<>4__this.Audio.clip);
						}
						catch
						{
						}
					}
					<>4__this.Audio.clip = <clip>5__4;
					<>4__this.tooltipScrollIndex = 0;
					<>4__this.tooltipScrollTimer = 0f;
					<>4__this.ApplyLocalVolume();
					<>4__this.statusText = "Ready: " + ((Object)<clip>5__4).name;
					Plugin.Log("Clip READY: " + <>8__1.videoId);
					Plugin.Log("Local clip ready for: " + <>8__1.videoId);
					if ((Object)(object)<>4__this.Boombox != (Object)null && (Object)(object)((NetworkBehaviour)<>4__this.Boombox).NetworkObject != (Object)null)
					{
						BoomBoxOverhaulNet.SendNotifyReady(((NetworkBehaviour)<>4__this.Boombox).NetworkObject.NetworkObjectId, success: true);
					}
					<clip>5__4 = null;
					<>m__Finally1();
					<req>5__3 = null;
					result = false;
					break;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
			return result;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<req>5__3 != null)
			{
				((IDisposable)<req>5__3).Dispose();
			}
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunBlockingTask>d__45 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Action action;

		public UnifiedBoomboxController <>4__this;

		private <>c__DisplayClass45_0 <>8__1;

		private Thread <thread>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunBlockingTask>d__45(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<thread>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass45_0();
				<>8__1.action = action;
				<>8__1.done = false;
				<>8__1.caught = null;
				<thread>5__2 = new Thread((ThreadStart)delegate
				{
					try
					{
						<>8__1.action();
					}
					catch (Exception caught)
					{
						<>8__1.caught = caught;
					}
					finally
					{
						<>8__1.done = true;
					}
				});
				<thread>5__2.IsBackground = true;
				<thread>5__2.Start();
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!<>8__1.done)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (<>8__1.caught != null)
			{
				Plugin.Error("Background task failed: " + <>8__1.caught);
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ServerWaitForReadyThenPlay>d__40 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public UnifiedBoomboxController <>4__this;

		private float <timeout>5__1;

		private float <start>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ServerWaitForReadyThenPlay>d__40(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<timeout>5__1 = Mathf.Max(1f, Plugin.ReadyTimeoutSeconds.Value);
				<start>5__2 = Time.time;
				Plugin.Log("Waiting for clients to prepare track. Expected: " + <>4__this.expectedClients.Count);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (Time.time - <start>5__2 < <timeout>5__1)
			{
				if (<>4__this.expectedClients.Count <= 0 || <>4__this.readyClients.Count < <>4__this.expectedClients.Count)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				Plugin.Log("All expected clients are ready. Starting playback immediately.");
			}
			if (<>4__this.readyClients.Count == 0)
			{
				<>4__this.ClientRejectPlay("No client prepared track");
				<>4__this.isPreparing = false;
				Plugin.Warn("No clients were ready before timeout.");
				return false;
			}
			if (<>4__this.readyClients.Count < <>4__this.expectedClients.Count)
			{
				Plugin.Warn("Timeout reached. Starting playback for ready clients only. Ready: " + <>4__this.readyClients.Count + " / Expected: " + <>4__this.expectedClients.Count);
			}
			else
			{
				Plugin.Log("Starting playback for all expected clients.");
			}
			if ((Object)(object)<>4__this.Boombox != (Object)null && (Object)(object)((NetworkBehaviour)<>4__this.Boombox).NetworkObject != (Object)null)
			{
				BoomBoxOverhaulNet.BroadcastBeginPlaybackReadyOnly(((NetworkBehaviour)<>4__this.Boombox).NetworkObject.NetworkObjectId, <>4__this.currentVideoId, <>4__this.readyClients);
			}
			<>4__this.isPreparing = false;
			<>4__this.isPlayingCustom = true;
			<>4__this.statusText = "Playing (" + <>4__this.readyClients.Count + "/" + <>4__this.expectedClients.Count + " ready)";
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public BoomboxItem Boombox;

	public AudioSource Audio;

	private float localVolume = 1f;

	private bool uiOpen = false;

	private string pendingUrl = "";

	private string statusText = "Idle";

	private PlaylistState playlist = new PlaylistState();

	private string currentVideoId = "";

	private bool isPreparing = false;

	private bool isPlayingCustom = false;

	private readonly HashSet<ulong> readyClients = new HashSet<ulong>();

	private readonly HashSet<ulong> expectedClients = new HashSet<ulong>();

	private readonly HashSet<ulong> failedClients = new HashSet<ulong>();

	private Coroutine localLoadRoutine;

	private Coroutine serverWaitRoutine;

	private bool suppressVanillaStopOnce = false;

	private bool cameraLocked = false;

	private float tooltipScrollTimer = 0f;

	private int tooltipScrollIndex = 0;

	private void Awake()
	{
		Plugin.Log("UnifiedBoomboxController attached to boombox.");
		Boombox = ((Component)this).GetComponent<BoomboxItem>();
		AudioSource[] components = ((Component)this).GetComponents<AudioSource>();
		Audio = null;
		for (int i = 0; i < components.Length; i++)
		{
			if ((Object)(object)components[i] != (Object)null && (Object)(object)components[i] != (Object)(object)Boombox.boomboxAudio && ((Object)components[i]).name == "BoomBoxOverhaulAudio")
			{
				Audio = components[i];
				break;
			}
		}
		if ((Object)(object)Audio == (Object)null)
		{
			Audio = ((Component)this).gameObject.AddComponent<AudioSource>();
			((Object)Audio).name = "BoomBoxOverhaulAudio";
		}
		Audio.playOnAwake = false;
		Audio.loop = false;
		Audio.spatialBlend = 1f;
		Audio.rolloffMode = (AudioRolloffMode)1;
		Audio.maxDistance = 30f;
		localVolume = Mathf.Clamp(Plugin.DefaultVolume.Value, 0f, 2f);
		ApplyLocalVolume();
		UpdateTooltip();
	}

	private void Update()
	{
		HandleInput();
		bool flag = false;
		tooltipScrollTimer += Time.deltaTime;
		if (tooltipScrollTimer >= 0.25f)
		{
			tooltipScrollTimer = 0f;
			tooltipScrollIndex++;
			flag = true;
		}
		if (uiOpen && !isPlayingCustom)
		{
			StopVanillaBoomboxAudio();
		}
		UpdateTooltip();
		if (flag)
		{
			RefreshHeldItemTooltip();
		}
		if (uiOpen)
		{
			UpdateCameraLock();
		}
		else if (cameraLocked)
		{
			SetCameraLocked(locked: false);
		}
		if (isPlayingCustom && (Object)(object)Audio != (Object)null && !Audio.isPlaying && !isPreparing)
		{
			OnTrackEndedLocal();
		}
	}

	private void HandleInput()
	{
		//IL_0007: 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_016f: Unknown result type (might be due to invalid IL or missing references)
		if (IsConfiguredKeyPressed(Plugin.OpenUiKey.Value) && IsHeldByLocalPlayer())
		{
			uiOpen = !uiOpen;
			if (uiOpen)
			{
				StopAllBoomboxAudioForUi();
			}
			SetCameraLocked(uiOpen);
			Plugin.Log("Toggled boombox UI: " + (uiOpen ? "Open" : "Closed"));
		}
		if (IsConfiguredKeyPressed(Plugin.VolumeUpKey.Value) && IsRelevantToLocalPlayer())
		{
			float volume = Mathf.Clamp(localVolume + Plugin.VolumeStep.Value, 0f, 2f);
			if (Plugin.UseLocalVolumeOnly())
			{
				localVolume = volume;
				ApplyLocalVolume();
				Plugin.Log("Applied local-only volume up: " + localVolume);
			}
			else if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
			{
				Plugin.Log("Sending shared volume up request: " + volume);
				BoomBoxOverhaulNet.SendSetVolume(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, volume);
			}
			else
			{
				localVolume = volume;
				ApplyLocalVolume();
				Plugin.Warn("NetworkObject missing, fell back to local volume up.");
			}
		}
		if (IsConfiguredKeyPressed(Plugin.VolumeDownKey.Value) && IsRelevantToLocalPlayer())
		{
			float volume2 = Mathf.Clamp(localVolume - Plugin.VolumeStep.Value, 0f, 2f);
			if (Plugin.UseLocalVolumeOnly())
			{
				localVolume = volume2;
				ApplyLocalVolume();
				Plugin.Log("Applied local-only volume down: " + localVolume);
			}
			else if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
			{
				Plugin.Log("Sending shared volume down request: " + volume2);
				BoomBoxOverhaulNet.SendSetVolume(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, volume2);
			}
			else
			{
				localVolume = volume2;
				ApplyLocalVolume();
				Plugin.Warn("NetworkObject missing, fell back to local volume down.");
			}
		}
	}

	private bool IsConfiguredKeyPressed(KeyCode keyCode)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: 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_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Expected I4, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Invalid comparison between Unknown and I4
		Keyboard current = Keyboard.current;
		if (current == null)
		{
			return false;
		}
		if ((int)keyCode <= 9)
		{
			if ((int)keyCode == 8)
			{
				return ((ButtonControl)current.backspaceKey).wasPressedThisFrame;
			}
			if ((int)keyCode == 9)
			{
				return ((ButtonControl)current.tabKey).wasPressedThisFrame;
			}
		}
		else
		{
			if ((int)keyCode == 13)
			{
				return ((ButtonControl)current.enterKey).wasPressedThisFrame;
			}
			switch (keyCode - 32)
			{
			default:
				if ((int)keyCode != 271)
				{
					break;
				}
				return ((ButtonControl)current.numpadEnterKey).wasPressedThisFrame;
			case 65:
				return ((ButtonControl)current.aKey).wasPressedThisFrame;
			case 66:
				return ((ButtonControl)current.bKey).wasPressedThisFrame;
			case 67:
				return ((ButtonControl)current.cKey).wasPressedThisFrame;
			case 68:
				return ((ButtonControl)current.dKey).wasPressedThisFrame;
			case 69:
				return ((ButtonControl)current.eKey).wasPressedThisFrame;
			case 70:
				return ((ButtonControl)current.fKey).wasPressedThisFrame;
			case 71:
				return ((ButtonControl)current.gKey).wasPressedThisFrame;
			case 72:
				return ((ButtonControl)current.hKey).wasPressedThisFrame;
			case 73:
				return ((ButtonControl)current.iKey).wasPressedThisFrame;
			case 74:
				return ((ButtonControl)current.jKey).wasPressedThisFrame;
			case 75:
				return ((ButtonControl)current.kKey).wasPressedThisFrame;
			case 76:
				return ((ButtonControl)current.lKey).wasPressedThisFrame;
			case 77:
				return ((ButtonControl)current.mKey).wasPressedThisFrame;
			case 78:
				return ((ButtonControl)current.nKey).wasPressedThisFrame;
			case 79:
				return ((ButtonControl)current.oKey).wasPressedThisFrame;
			case 80:
				return ((ButtonControl)current.pKey).wasPressedThisFrame;
			case 81:
				return ((ButtonControl)current.qKey).wasPressedThisFrame;
			case 82:
				return ((ButtonControl)current.rKey).wasPressedThisFrame;
			case 83:
				return ((ButtonControl)current.sKey).wasPressedThisFrame;
			case 84:
				return ((ButtonControl)current.tKey).wasPressedThisFrame;
			case 85:
				return ((ButtonControl)current.uKey).wasPressedThisFrame;
			case 86:
				return ((ButtonControl)current.vKey).wasPressedThisFrame;
			case 87:
				return ((ButtonControl)current.wKey).wasPressedThisFrame;
			case 88:
				return ((ButtonControl)current.xKey).wasPressedThisFrame;
			case 89:
				return ((ButtonControl)current.yKey).wasPressedThisFrame;
			case 90:
				return ((ButtonControl)current.zKey).wasPressedThisFrame;
			case 16:
				return ((ButtonControl)current.digit0Key).wasPressedThisFrame;
			case 17:
				return ((ButtonControl)current.digit1Key).wasPressedThisFrame;
			case 18:
				return ((ButtonControl)current.digit2Key).wasPressedThisFrame;
			case 19:
				return ((ButtonControl)current.digit3Key).wasPressedThisFrame;
			case 20:
				return ((ButtonControl)current.digit4Key).wasPressedThisFrame;
			case 21:
				return ((ButtonControl)current.digit5Key).wasPressedThisFrame;
			case 22:
				return ((ButtonControl)current.digit6Key).wasPressedThisFrame;
			case 23:
				return ((ButtonControl)current.digit7Key).wasPressedThisFrame;
			case 24:
				return ((ButtonControl)current.digit8Key).wasPressedThisFrame;
			case 25:
				return ((ButtonControl)current.digit9Key).wasPressedThisFrame;
			case 13:
				return ((ButtonControl)current.minusKey).wasPressedThisFrame;
			case 29:
				return ((ButtonControl)current.equalsKey).wasPressedThisFrame;
			case 0:
				return ((ButtonControl)current.spaceKey).wasPressedThisFrame;
			case 59:
				return ((ButtonControl)current.leftBracketKey).wasPressedThisFrame;
			case 61:
				return ((ButtonControl)current.rightBracketKey).wasPressedThisFrame;
			case 27:
				return ((ButtonControl)current.semicolonKey).wasPressedThisFrame;
			case 7:
				return ((ButtonControl)current.quoteKey).wasPressedThisFrame;
			case 12:
				return ((ButtonControl)current.commaKey).wasPressedThisFrame;
			case 14:
				return ((ButtonControl)current.periodKey).wasPressedThisFrame;
			case 15:
				return ((ButtonControl)current.slashKey).wasPressedThisFrame;
			case 60:
				return ((ButtonControl)current.backslashKey).wasPressedThisFrame;
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 8:
			case 9:
			case 10:
			case 11:
			case 26:
			case 28:
			case 30:
			case 31:
			case 32:
			case 33:
			case 34:
			case 35:
			case 36:
			case 37:
			case 38:
			case 39:
			case 40:
			case 41:
			case 42:
			case 43:
			case 44:
			case 45:
			case 46:
			case 47:
			case 48:
			case 49:
			case 50:
			case 51:
			case 52:
			case 53:
			case 54:
			case 55:
			case 56:
			case 57:
			case 58:
			case 62:
			case 63:
			case 64:
				break;
			}
		}
		return false;
	}

	private void OnGUI()
	{
		//IL_0055: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Unknown result type (might be due to invalid IL or missing references)
		if (!uiOpen || !IsHeldByLocalPlayer())
		{
			if (cameraLocked)
			{
				SetCameraLocked(locked: false);
			}
			return;
		}
		Cursor.lockState = (CursorLockMode)0;
		Cursor.visible = true;
		GUI.Box(new Rect(20f, 20f, 520f, 180f), "BoomBoxOverhaulV2 By Henreh :D");
		GUI.Label(new Rect(35f, 50f, 460f, 20f), "Paste YouTube video or playlist URL:");
		pendingUrl = GUI.TextField(new Rect(35f, 72f, 470f, 22f), pendingUrl, 1000);
		GUI.Label(new Rect(35f, 97f, 470f, 20f), "State: " + statusText);
		GUI.Label(new Rect(35f, 115f, 470f, 20f), "Dependencies: " + DependencyBootstrapper.GetStatus());
		GUI.Label(new Rect(35f, 133f, 470f, 20f), "Volume: " + Mathf.RoundToInt(localVolume * 100f) + "%");
		bool enabled = GUI.enabled;
		GUI.enabled = DependencyBootstrapper.GetState().IsReady();
		if (GUI.Button(new Rect(35f, 155f, 80f, 20f), "Play"))
		{
			Plugin.Log("Play button pressed.");
			if (string.IsNullOrEmpty(pendingUrl))
			{
				Plugin.Warn("Play failed: URL empty");
			}
			else if ((Object)(object)Boombox == (Object)null)
			{
				Plugin.Warn("Play failed: Boombox null");
			}
			else if ((Object)(object)((NetworkBehaviour)Boombox).NetworkObject == (Object)null)
			{
				Plugin.Warn("Play failed: Boombox.NetworkObject null");
			}
			else
			{
				Plugin.Log("Sending play request → NetworkObjectId=" + ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId + " URL=" + pendingUrl.Trim());
				BoomBoxOverhaulNet.SendRequestPlay(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, pendingUrl.Trim());
			}
		}
		GUI.enabled = enabled;
		if (GUI.Button(new Rect(125f, 155f, 80f, 20f), "Stop"))
		{
			Plugin.Log("Stop button pressed.");
			if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
			{
				Plugin.Log("Sending stop request → NetworkObjectId=" + ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId);
				BoomBoxOverhaulNet.SendRequestStop(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId);
			}
			else
			{
				Plugin.Warn("Stop failed: Boombox or NetworkObject missing");
			}
		}
	}

	private void ApplyLocalVolume()
	{
		if ((Object)(object)Audio != (Object)null)
		{
			Audio.volume = localVolume;
		}
		UpdateTooltip();
		RefreshHeldItemTooltip();
	}

	private void RefreshHeldItemTooltip()
	{
		try
		{
			PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.currentlyHeldObjectServer == (Object)null) && (Object)(object)val.currentlyHeldObjectServer == (Object)(object)Boombox)
			{
				val.currentlyHeldObjectServer.EquipItem();
			}
		}
		catch (Exception ex)
		{
			Plugin.Warn("Failed to refresh held item tooltip: " + ex);
		}
	}

	private void StopVanillaBoomboxAudio()
	{
		try
		{
			if (!((Object)(object)Boombox == (Object)null))
			{
				if ((Object)(object)Boombox.boomboxAudio != (Object)null && (Object)(object)Boombox.boomboxAudio != (Object)(object)Audio)
				{
					Boombox.boomboxAudio.Stop();
				}
				Boombox.isPlayingMusic = false;
			}
		}
		catch (Exception ex)
		{
			Plugin.Warn("Failed to stop vanilla boombox audio: " + ex);
		}
	}

	private void StopAllBoomboxAudioForUi()
	{
		StopVanillaBoomboxAudio();
		if ((Object)(object)Audio != (Object)null && (Object)(object)Audio != (Object)(object)Boombox.boomboxAudio && !isPlayingCustom)
		{
			Audio.Stop();
		}
	}

	private void SetCameraLocked(bool locked)
	{
		cameraLocked = locked;
		try
		{
			PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if ((Object)(object)val != (Object)null && val.playerActions != null)
			{
				if (locked)
				{
					val.playerActions.Disable();
				}
				else
				{
					val.playerActions.Enable();
				}
			}
			Cursor.lockState = (CursorLockMode)((!locked) ? 1 : 0);
			Cursor.visible = locked;
		}
		catch (Exception ex)
		{
			Plugin.Warn("SetCameraLocked failed: " + ex);
		}
	}

	private void UpdateCameraLock()
	{
		if (!uiOpen)
		{
			if (cameraLocked)
			{
				SetCameraLocked(locked: false);
			}
			return;
		}
		if (!IsHeldByLocalPlayer())
		{
			uiOpen = false;
			SetCameraLocked(locked: false);
			return;
		}
		try
		{
			PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if ((Object)(object)val != (Object)null && val.playerActions != null)
			{
				val.playerActions.Disable();
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
		catch (Exception ex)
		{
			Plugin.Warn("Camera lock failed: " + ex);
		}
	}

	private string GetScrollingTrackText()
	{
		string text = "None";
		if ((Object)(object)Audio != (Object)null && (Object)(object)Audio.clip != (Object)null && !string.IsNullOrEmpty(((Object)Audio.clip).name))
		{
			text = ((Object)Audio.clip).name;
		}
		else if (!string.IsNullOrEmpty(currentVideoId))
		{
			text = currentVideoId;
		}
		if (string.IsNullOrEmpty(text))
		{
			return "None";
		}
		if (text.Length <= 28)
		{
			return text;
		}
		string text2 = text + "   ";
		string text3 = text2 + text2;
		if (tooltipScrollIndex >= text2.Length)
		{
			tooltipScrollIndex = 0;
		}
		return text3.Substring(tooltipScrollIndex, 28);
	}

	private void UpdateTooltip()
	{
		//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_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)Boombox == (Object)null) && !((Object)(object)((GrabbableObject)Boombox).itemProperties == (Object)null))
		{
			string scrollingTrackText = GetScrollingTrackText();
			Item itemProperties = ((GrabbableObject)Boombox).itemProperties;
			string[] array = new string[5];
			KeyCode value = Plugin.OpenUiKey.Value;
			array[0] = "[" + ((object)(KeyCode)(ref value)).ToString() + "] URL Menu";
			string[] obj = new string[7] { "[", null, null, null, null, null, null };
			value = Plugin.VolumeDownKey.Value;
			obj[1] = ((object)(KeyCode)(ref value)).ToString();
			obj[2] = "/";
			value = Plugin.VolumeUpKey.Value;
			obj[3] = ((object)(KeyCode)(ref value)).ToString();
			obj[4] = "] Volume: ";
			obj[5] = Mathf.RoundToInt(localVolume * 100f).ToString();
			obj[6] = "%";
			array[1] = string.Concat(obj);
			array[2] = "Track: " + scrollingTrackText;
			array[3] = "State: " + statusText;
			array[4] = "Deps: " + DependencyBootstrapper.GetStatus();
			itemProperties.toolTips = array;
		}
	}

	private bool IsHeldByLocalPlayer()
	{
		try
		{
			return (Object)(object)Boombox != (Object)null && (Object)(object)((GrabbableObject)Boombox).playerHeldBy != (Object)null && (Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null && (Object)(object)((GrabbableObject)Boombox).playerHeldBy == (Object)(object)GameNetworkManager.Instance.localPlayerController;
		}
		catch
		{
			return false;
		}
	}

	private bool IsRelevantToLocalPlayer()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		if (IsHeldByLocalPlayer())
		{
			return true;
		}
		try
		{
			PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return Vector3.Distance(((Component)val).transform.position, ((Component)this).transform.position) <= 15f;
		}
		catch
		{
			return false;
		}
	}

	private void PopulateExpectedClients()
	{
		expectedClients.Clear();
		if ((Object)(object)NetworkManager.Singleton == (Object)null || NetworkManager.Singleton.ConnectedClients == null)
		{
			return;
		}
		foreach (KeyValuePair<ulong, NetworkClient> connectedClient in NetworkManager.Singleton.ConnectedClients)
		{
			expectedClients.Add(connectedClient.Key);
		}
		Plugin.Log("Expected clients for boombox playback: " + expectedClients.Count);
	}

	public void ServerHandlePlay(ulong requesterClientId, string url)
	{
		Plugin.Log("ServerHandlePlay called from client " + requesterClientId + " URL=" + url);
		if (!DependencyBootstrapper.GetState().IsReady())
		{
			Plugin.Warn("ServerHandlePlay rejected: dependencies not ready");
			if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
			{
				BoomBoxOverhaulNet.SendRejectPlay(requesterClientId, ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, "Dependencies not ready");
			}
			return;
		}
		if (!UrlHelpers.IsLikelyYoutubeUrl(url))
		{
			Plugin.Warn("ServerHandlePlay rejected: invalid URL");
			if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
			{
				BoomBoxOverhaulNet.SendRejectPlay(requesterClientId, ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, "Invalid URL");
			}
			return;
		}
		currentVideoId = "";
		isPreparing = true;
		isPlayingCustom = false;
		statusText = "Resolving...";
		readyClients.Clear();
		expectedClients.Clear();
		failedClients.Clear();
		playlist = new PlaylistState();
		tooltipScrollIndex = 0;
		tooltipScrollTimer = 0f;
		StopVanillaBoomboxAudio();
		if (UrlHelpers.IsPlaylistOnlyUrl(url))
		{
			if (!YtDlpBridge.ResolvePlaylistIds(url, out var ids) || ids.Count == 0)
			{
				Plugin.Warn("Playlist resolve failed");
				if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
				{
					BoomBoxOverhaulNet.SendRejectPlay(requesterClientId, ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, "Playlist resolve failed");
				}
				isPreparing = false;
				return;
			}
			playlist.VideoIds.AddRange(ids);
			playlist.Index = 0;
			currentVideoId = playlist.GetCurrentId() ?? "";
		}
		else
		{
			string text = UrlHelpers.TryExtractVideoId(url);
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Warn("Could not parse video id");
				if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
				{
					BoomBoxOverhaulNet.SendRejectPlay(requesterClientId, ((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, "Could not parse video id");
				}
				isPreparing = false;
				return;
			}
			playlist.VideoIds.Add(text);
			playlist.Index = 0;
			currentVideoId = text;
		}
		if ((Object)(object)Boombox == (Object)null || (Object)(object)((NetworkBehaviour)Boombox).NetworkObject == (Object)null)
		{
			Plugin.Warn("ServerHandlePlay aborted: Boombox or NetworkObject missing");
			isPreparing = false;
			return;
		}
		PopulateExpectedClients();
		string canonicalUrl = "https://www.youtube.com/watch?v=" + currentVideoId;
		Plugin.Log("Broadcasting prepare track for " + currentVideoId);
		BoomBoxOverhaulNet.BroadcastPrepareTrack(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, canonicalUrl, currentVideoId, playlist.Index, playlist.VideoIds.ToArray());
		if (serverWaitRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(serverWaitRoutine);
		}
		serverWaitRoutine = ((MonoBehaviour)this).StartCoroutine(ServerWaitForReadyThenPlay());
	}

	public void ClientRejectPlay(string reason)
	{
		Plugin.Warn("ClientRejectPlay: " + reason);
		statusText = reason;
		isPreparing = false;
	}

	public void ClientPrepareTrack(string canonicalUrl, string videoId, int playlistIndex, string[] playlistIds)
	{
		Plugin.Log("ClientPrepareTrack START → " + videoId);
		currentVideoId = videoId;
		playlist.VideoIds.Clear();
		playlist.VideoIds.AddRange(playlistIds);
		playlist.Index = playlistIndex;
		statusText = "Preparing...";
		isPreparing = true;
		isPlayingCustom = false;
		tooltipScrollIndex = 0;
		tooltipScrollTimer = 0f;
		StopVanillaBoomboxAudio();
		if (localLoadRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(localLoadRoutine);
		}
		localLoadRoutine = ((MonoBehaviour)this).StartCoroutine(PrepareTrackLocalCoroutine(canonicalUrl, videoId));
	}

	[IteratorStateMachine(typeof(<PrepareTrackLocalCoroutine>d__38))]
	private IEnumerator PrepareTrackLocalCoroutine(string canonicalUrl, string videoId)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PrepareTrackLocalCoroutine>d__38(0)
		{
			<>4__this = this,
			canonicalUrl = canonicalUrl,
			videoId = videoId
		};
	}

	public void ServerNotifyReady(ulong clientId, bool success)
	{
		if (success)
		{
			readyClients.Add(clientId);
			failedClients.Remove(clientId);
			Plugin.Log("Client ready for boombox playback: " + clientId);
		}
		else
		{
			failedClients.Add(clientId);
			readyClients.Remove(clientId);
			Plugin.Warn("Client failed to prepare boombox playback: " + clientId);
		}
	}

	[IteratorStateMachine(typeof(<ServerWaitForReadyThenPlay>d__40))]
	private IEnumerator ServerWaitForReadyThenPlay()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ServerWaitForReadyThenPlay>d__40(0)
		{
			<>4__this = this
		};
	}

	public void ClientBeginPlayback(string videoId)
	{
		Plugin.Log("ClientBeginPlayback → " + videoId);
		currentVideoId = videoId;
		isPreparing = false;
		isPlayingCustom = true;
		statusText = "Playing";
		tooltipScrollIndex = 0;
		tooltipScrollTimer = 0f;
		if ((Object)(object)Audio != (Object)null && (Object)(object)Audio.clip != (Object)null)
		{
			suppressVanillaStopOnce = true;
			StopVanillaBoomboxAudio();
			Audio.Stop();
			Audio.time = 0f;
			Audio.Play();
		}
		else
		{
			Plugin.Warn("ClientBeginPlayback received but Audio or Audio.clip was null");
		}
	}

	public void ServerHandleStop()
	{
		Plugin.Log("ServerHandleStop called");
		if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
		{
			BoomBoxOverhaulNet.BroadcastStopPlayback(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId);
		}
	}

	public void ClientStopPlayback()
	{
		Plugin.Log("ClientStopPlayback called");
		isPreparing = false;
		isPlayingCustom = false;
		statusText = "Stopped";
		if (localLoadRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(localLoadRoutine);
			localLoadRoutine = null;
		}
		if ((Object)(object)Audio != (Object)null)
		{
			Audio.Stop();
		}
	}

	private void OnTrackEndedLocal()
	{
		if (!Plugin.AutoplayPlaylist.Value || (Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
		{
			isPlayingCustom = false;
			statusText = "Finished";
			return;
		}
		if (playlist.VideoIds.Count <= 1)
		{
			isPlayingCustom = false;
			statusText = "Finished";
			return;
		}
		string value = playlist.Advance();
		if (string.IsNullOrEmpty(value))
		{
			isPlayingCustom = false;
			statusText = "Playlist ended";
			return;
		}
		currentVideoId = value;
		statusText = "Next track...";
		readyClients.Clear();
		expectedClients.Clear();
		failedClients.Clear();
		tooltipScrollIndex = 0;
		tooltipScrollTimer = 0f;
		if (!((Object)(object)Boombox == (Object)null) && !((Object)(object)((NetworkBehaviour)Boombox).NetworkObject == (Object)null))
		{
			StopVanillaBoomboxAudio();
			PopulateExpectedClients();
			string canonicalUrl = "https://www.youtube.com/watch?v=" + currentVideoId;
			Plugin.Log("Broadcasting next prepare track for " + currentVideoId);
			BoomBoxOverhaulNet.BroadcastPrepareTrack(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, canonicalUrl, currentVideoId, playlist.Index, playlist.VideoIds.ToArray());
			if (serverWaitRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(serverWaitRoutine);
			}
			serverWaitRoutine = ((MonoBehaviour)this).StartCoroutine(ServerWaitForReadyThenPlay());
		}
	}

	[IteratorStateMachine(typeof(<RunBlockingTask>d__45))]
	private IEnumerator RunBlockingTask(Action action)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunBlockingTask>d__45(0)
		{
			<>4__this = this,
			action = action
		};
	}

	public bool ShouldSuppressVanillaStop()
	{
		if (!Plugin.KeepPlayingPocketed.Value)
		{
			return false;
		}
		if (suppressVanillaStopOnce)
		{
			suppressVanillaStopOnce = false;
			return true;
		}
		return isPlayingCustom;
	}

	public void ServerHandleSetVolume(float volume)
	{
		if (Plugin.LocalVolumeOnly.Value)
		{
			Plugin.Log("Server rejected shared volume change because LocalVolumeOnly is enabled on host.");
			return;
		}
		float volume2 = Mathf.Clamp(volume, 0f, 2f);
		if ((Object)(object)Boombox != (Object)null && (Object)(object)((NetworkBehaviour)Boombox).NetworkObject != (Object)null)
		{
			Plugin.Log("Broadcasting shared volume: " + volume2);
			BoomBoxOverhaulNet.BroadcastApplyVolume(((NetworkBehaviour)Boombox).NetworkObject.NetworkObjectId, volume2);
		}
	}

	public void ClientApplyNetworkVolume(float volume)
	{
		Plugin.Log("ClientApplyNetworkVolume → " + volume);
		localVolume = Mathf.Clamp(volume, 0f, 2f);
		ApplyLocalVolume();
	}
}
internal static class UrlHelpers
{
	private static readonly Regex WatchRegex = new Regex("(?:youtube\\.com\\/watch\\?[^#\\s]*\\bv=)([A-Za-z0-9_-]{6,})", RegexOptions.IgnoreCase | RegexOptions.Compiled);

	private static readonly Regex ShortRegex = new Regex("(?:youtu\\.be\\/)([A-Za-z0-9_-]{6,})", RegexOptions.IgnoreCase | RegexOptions.Compiled);

	private static readonly Regex PlaylistRegex = new Regex("(?:[?&]list=)([A-Za-z0-9_-]+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);

	public static bool IsLikelyYoutubeUrl(string url)
	{
		if (string.IsNullOrEmpty(url))
		{
			return false;
		}
		return url.IndexOf("youtube.com/", StringComparison.OrdinalIgnoreCase) >= 0 || url.IndexOf("youtu.be/", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	public static string TryExtractVideoId(string url)
	{
		if (string.IsNullOrEmpty(url))
		{
			return null;
		}
		Match match = WatchRegex.Match(url);
		if (match.Success)
		{
			return match.Groups[1].Value;
		}
		Match match2 = ShortRegex.Match(url);
		if (match2.Success)
		{
			return match2.Groups[1].Value;
		}
		return null;
	}

	public static string TryExtractPlaylistId(string url)
	{
		if (string.IsNullOrEmpty(url))
		{
			return null;
		}
		Match match = PlaylistRegex.Match(url);
		if (match.Success)
		{
			return match.Groups[1].Value;
		}
		return null;
	}

	public static bool IsPlaylistOnlyUrl(string url)
	{
		string value = TryExtractPlaylistId(url);
		string value2 = TryExtractVideoId(url);
		return !string.IsNullOrEmpty(value) && string.IsNullOrEmpty(value2);
	}
}
internal static class YtDlpBridge
{
	public static bool ResolvePlaylistIds(string url, out List<string> ids)
	{
		ids = new List<string>();
		try
		{
			DependencyState state = DependencyBootstrapper.GetState();
			if (!state.IsReady() || string.IsNullOrEmpty(state.YtDlpPath))
			{
				return false;
			}
			string args = "--flat-playlist --print \"%(id)s\" \"" + EscapeArg(url) + "\"";
			if (!RunProcess(state.YtDlpPath, args, out var stdout, out var stderr, 120000))
			{
				Plugin.Warn("yt-dlp playlist resolve failed: " + stderr);
				return false;
			}
			using (StringReader stringReader = new StringReader(stdout))
			{
				while (true)
				{
					string text = stringReader.ReadLine();
					if (text == null)
					{
						break;
					}
					text = text.Trim();
					if (text.Length > 0)
					{
						ids.Add(text);
					}
				}
			}
			if (Plugin.ShufflePlaylist.Value && ids.Count > 1)
			{
				Random random = new Random();
				for (int num = ids.Count - 1; num > 0; num--)
				{
					int index = random.Next(num + 1);
					string value = ids[num];
					ids[num] = ids[index];
					ids[index] = value;
				}
			}
			return ids.Count > 0;
		}
		catch (Exception ex)
		{
			Plugin.Error("ResolvePlaylistIds exception: " + ex);
			return false;
		}
	}

	public static bool FetchTrack(string sourceUrl, string videoId, out TrackInfo info)
	{
		info = new TrackInfo();
		info.videoId = videoId;
		info.sourceUrl = sourceUrl;
		info.cachePath = CacheManager.BuildAudioPath(videoId);
		try
		{
			DependencyState state = DependencyBootstrapper.GetState();
			if (!state.IsReady() || string.IsNullOrEmpty(state.YtDlpPath) || string.IsNullOrEmpty(state.FfmpegPath))
			{
				return false;
			}
			if (File.Exists(info.cachePath))
			{
				CacheManager.Touch(info.cachePath);
				info.title = CacheManager.ReadMeta(videoId);
				return true;
			}
			string text = CacheManager.BuildTrackBasePath(videoId) + "_tmp";
			string text2 = text + ".mp3";
			if (File.Exists(text2))
			{
				try
				{
					File.Delete(text2);
				}
				catch
				{
				}
			}
			string args = "--no-playlist --print \"%(title)s|||%(duration)s|||%(id)s\" \"" + EscapeArg(sourceUrl) + "\"";
			if (RunProcess(state.YtDlpPath, args, out var stdout, out var _, 120000))
			{
				string[] array = stdout.Trim().Split(new string[1] { "|||" }, StringSplitOptions.None);
				if (array.Length >= 3)
				{
					info.title = array[0];
					if (float.TryParse(array[1], out var result))
					{
						info.durationSeconds = result;
					}
				}
			}
			if (Plugin.MaxTrackSeconds.Value > 0 && info.durationSeconds > (float)Plugin.MaxTrackSeconds.Value)
			{
				return false;
			}
			string value = Path.GetDirectoryName(state.FfmpegPath) ?? Plugin.ToolsFolder;
			string args2 = "--no-playlist --extract-audio --audio-format mp3 --audio-quality 0 --ffmpeg-location \"" + EscapeArg(value) + "\" --output \"" + EscapeArg(text) + ".%(ext)s\" \"" + EscapeArg(sourceUrl) + "\"";
			if (!RunProcess(state.YtDlpPath, args2, out var _, out var stderr2, 900000))
			{
				Plugin.Warn("Download failed: " + stderr2);
				return false;
			}
			if (!File.Exists(text2))
			{
				return false;
			}
			if (File.Exists(info.cachePath))
			{
				File.Delete(info.cachePath);
			}
			File.Move(text2, info.cachePath);
			CacheManager.Touch(info.cachePath);
			CacheManager.WriteMeta(videoId, info.title);
			CacheManager.Prune();
			return true;
		}
		catch (Exception ex)
		{
			Plugin.Error("FetchTrack exception: " + ex);
			return false;
		}
	}

	private static bool RunProcess(string exePath, string args, out string stdout, out string stderr, int timeoutMs)
	{
		stdout = "";
		stderr = "";
		try
		{
			using Process process = new Process();
			process.StartInfo = new ProcessStartInfo
			{
				FileName = exePath,
				Arguments = args,
				WorkingDirectory = Plugin.ToolsFolder,
				UseShellExecute = false,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				CreateNoWindow = true,
				StandardOutputEncoding = Encoding.UTF8,
				StandardErrorEncoding = Encoding.UTF8
			};
			process.Start();
			stdout = process.StandardOutput.ReadToEnd();
			stderr = process.StandardError.ReadToEnd();
			if (!process.WaitForExit(timeoutMs))
			{
				try
				{
					process.Kill();
				}
				catch
				{
				}
				stderr += "\nProcess timed out.";
				return false;
			}
			return process.ExitCode == 0;
		}
		catch (Exception ex)
		{
			stderr = ex.ToString();
			return false;
		}
	}

	private static string EscapeArg(string value)
	{
		return value.Replace("\"", "\\\"");
	}
}