using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SleepeyDev.OnTogetherLocalPlaylist.Net;
using SleepeyDev.OnTogetherLocalPlaylist.Patches;
using SleepeyDev.OnTogetherLocalPlaylist.Platform;
using SleepeyDev.OnTogetherLocalPlaylist.Playlist;
using SleepeyDev.OnTogetherLocalPlaylist.Share;
using SleepeyDev.OnTogetherLocalPlaylist.UI;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SleepeyDev")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.6.0.0")]
[assembly: AssemblyInformationalVersion("0.6.0+63ead13a0b394a0e0ee425c279a9e5b8a274470f")]
[assembly: AssemblyProduct("OnTogetherLocalPlaylist")]
[assembly: AssemblyTitle("OnTogetherLocalPlaylist")]
[assembly: AssemblyVersion("0.6.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist
{
	public static class HarmonyBootstrap
	{
		private static readonly Type[] PatchClasses = new Type[4]
		{
			typeof(SoundManagerPatches),
			typeof(UIManagerPatches),
			typeof(LifecyclePatches),
			typeof(UiBuildPatches)
		};

		public static void ApplyAll()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("com.sleepeydev.ontogether.localplaylist");
			int num = 0;
			Type[] patchClasses = PatchClasses;
			foreach (Type type in patchClasses)
			{
				try
				{
					val.CreateClassProcessor(type).Patch();
					num++;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Patch class " + type.Name + " failed to apply (that feature is off): " + ex.Message));
				}
			}
			Plugin.Log.LogInfo((object)("Applied " + num + "/" + PatchClasses.Length + " patch classes."));
		}
	}
	public static class MainThread
	{
		private static readonly ConcurrentQueue<Action> Queue = new ConcurrentQueue<Action>();

		public static void Post(Action action)
		{
			if (action != null)
			{
				Queue.Enqueue(action);
			}
		}

		public static void Drain(int maxPerFrame = 64)
		{
			for (int i = 0; i < maxPerFrame; i++)
			{
				if (!Queue.TryDequeue(out var result))
				{
					break;
				}
				try
				{
					result();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Main-thread action threw: " + ex));
				}
			}
		}
	}
	public static class ModConfig
	{
		private const int CurrentLayoutVersion = 7;

		private static readonly string Sep = Path.DirectorySeparatorChar.ToString();

		public static ConfigEntry<int> LayoutVersion;

		public static ConfigEntry<bool> PlaylistEnabled;

		public static ConfigEntry<string> MusicFolder;

		public static ConfigEntry<string> MixtapeName;

		public static ConfigEntry<bool> IncludeSubfolders;

		public static ConfigEntry<bool> AllowTrackerFormats;

		public static ConfigEntry<int> MaxTracks;

		public static ConfigEntry<bool> SeekBarEnabled;

		public static ConfigEntry<bool> SeekBarOnVanillaMixtapes;

		public static ConfigEntry<float> PanelGrow;

		public static ConfigEntry<float> SeekBarX;

		public static ConfigEntry<float> SeekBarY;

		public static ConfigEntry<float> SeekBarWidth;

		public static ConfigEntry<float> SeekTimeX;

		public static ConfigEntry<float> SeekTimeFontScale;

		public static ConfigEntry<bool> ModPanelEnabled;

		public static ConfigEntry<float> ModPanelHeight;

		public static ConfigEntry<float> ModRowTextRight;

		public static ConfigEntry<float> ModRowButtonRight;

		public static ConfigEntry<float> ModRowButtonWidth;

		public static ConfigEntry<float> ModRowButtonGap;

		public static ConfigEntry<float> ModRowTextWidth;

		public static ConfigEntry<bool> PickFolderByFile;

		public static ConfigEntry<float> ModRowHeight;

		public static ConfigEntry<float> ModRowFontScale;

		public static ConfigEntry<string> PickFolderLabel;

		public static ConfigEntry<string> ReloadLabel;

		public static ConfigEntry<bool> WatchFolder;

		public static ConfigEntry<int> WatchDebounceMs;

		public static ConfigEntry<bool> SharingEnabled;

		public static ConfigEntry<string> LiveTapeName;

		public static ConfigEntry<int> MaxListeners;

		public static ConfigEntry<int> ListenLatencyMs;

		public static ConfigEntry<bool> VerboseLogging;

		public static ConfigEntry<bool> DumpUi;

		public static ConfigEntry<KeyCode> DumpUiKey;

		public static ConfigEntry<bool> ProbeSeek;

		public static void Bind(ConfigFile cfg)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Expected O, but got Unknown
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Expected O, but got Unknown
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Expected O, but got Unknown
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Expected O, but got Unknown
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Expected O, but got Unknown
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Expected O, but got Unknown
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Expected O, but got Unknown
			PlaylistEnabled = cfg.Bind<bool>("Playlist", "Enabled", true, "Master switch for the local music mixtape.");
			MusicFolder = cfg.Bind<string>("Playlist", "MusicFolder", "", "Folder scanned for music. Leave empty to disable.\nExample: D:" + Sep + "Music" + Sep + "Focus\nSupported: .mp3 .ogg .wav .aif .aiff\nNetwork paths are not supported by Unity's audio loader - map a drive letter instead.\nThe Folder... button on the mini music player sets this without editing the file.");
			MixtapeName = cfg.Bind<string>("Playlist", "MixtapeName", "Local", "Name shown on the mixtape in the in-game music player.");
			IncludeSubfolders = cfg.Bind<bool>("Playlist", "IncludeSubfolders", true, "Scan subfolders of MusicFolder as well.");
			AllowTrackerFormats = cfg.Bind<bool>("Playlist", "AllowTrackerFormats", false, "Also accept tracker modules (.it .mod .s3m .xm). Off by default: they are rare and\nthe decoder behaviour on Windows standalone is not verified.");
			MaxTracks = cfg.Bind<int>("Playlist", "MaxTracks", 300, new ConfigDescription("Safety cap on how many files are added to the mixtape.\nThe game builds one clickable button per track when the list is shown, so very\nlarge numbers cost a visible hitch the first time the music panel opens.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 5000), Array.Empty<object>()));
			SeekBarEnabled = cfg.Bind<bool>("UI", "SeekBarEnabled", true, "Show a scrub bar on the mini music player, so you can jump to any point in a track.");
			SeekBarOnVanillaMixtapes = cfg.Bind<bool>("UI", "SeekBarOnVanillaMixtapes", true, "Also show the scrub bar while one of the game's own mixtapes is selected.");
			PanelGrow = cfg.Bind<float>("UI", "PanelGrow", 44f, new ConfigDescription("Extra height added to the mini music player so the scrub row has its own space instead\nof being crammed against the bottom edge. The top edge stays put; the panel grows\ndownwards, and the hover box that keeps the panel open is moved to match.\n0 leaves the panel exactly as the game draws it - then move the bar with SeekBarY.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 160f), Array.Empty<object>()));
			SeekBarX = cfg.Bind<float>("UI", "SeekBarX", -14f, new ConfigDescription("Centre of the scrub bar, horizontally. The default lines its left edge up with the\nvolume slider above it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-500f, 500f), Array.Empty<object>()));
			SeekBarY = cfg.Bind<float>("UI", "SeekBarY", -112f, new ConfigDescription("Height of the scrub bar. The panel's visible bottom is at -118 unmodified, or\n-118 minus PanelGrow with the default growth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-280f, 140f), Array.Empty<object>()));
			SeekBarWidth = cfg.Bind<float>("UI", "SeekBarWidth", 628f, new ConfigDescription("Width of the scrub bar in pixels.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(100f, 900f), Array.Empty<object>()));
			SeekTimeX = cfg.Bind<float>("UI", "SeekTimeX", 440f, new ConfigDescription("RIGHT edge of the time readout - the label is right-aligned, like the artist name it\nis cloned from. The panel's visible right edge is at 448.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-500f, 500f), Array.Empty<object>()));
			SeekTimeFontScale = cfg.Bind<float>("UI", "SeekTimeFontScale", 0.72f, new ConfigDescription("Size of the time readout relative to the artist name.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 1.5f), Array.Empty<object>()));
			ModPanelEnabled = cfg.Bind<bool>("UI", "ModPanelEnabled", true, "Add a row under the scrub bar with the current music folder, a folder picker and a\nReload button. Turning it off also removes the extra panel height it needs.");
			ModPanelHeight = cfg.Bind<float>("UI", "ModPanelHeight", 46f, new ConfigDescription("How far below the scrub bar that row sits, and how much extra panel height it takes.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(24f, 120f), Array.Empty<object>()));
			ModRowTextRight = cfg.Bind<float>("UI", "ModRowTextRight", -106f, new ConfigDescription("RIGHT edge of the status label, which is left-aligned inside ModRowTextWidth.\nIt has to clear the leftmost button; with four buttons that is around -106.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-500f, 500f), Array.Empty<object>()));
			ModRowTextWidth = cfg.Bind<float>("UI", "ModRowTextWidth", 320f, new ConfigDescription("Width of the status label's box.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(100f, 700f), Array.Empty<object>()));
			ModRowButtonRight = cfg.Bind<float>("UI", "ModRowButtonRight", 430f, new ConfigDescription("RIGHT edge of the Reload button; the folder button sits just left of it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-500f, 500f), Array.Empty<object>()));
			ModRowButtonWidth = cfg.Bind<float>("UI", "ModRowButtonWidth", 124f, new ConfigDescription("Width of each button on the row. Four of them plus the status label have to fit\ninside the panel's 896 px, so there is not much room to grow.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(60f, 320f), Array.Empty<object>()));
			ModRowButtonGap = cfg.Bind<float>("UI", "ModRowButtonGap", 10f, new ConfigDescription("Space between the buttons.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 60f), Array.Empty<object>()));
			PickFolderByFile = cfg.Bind<bool>("UI", "PickFolderByFile", false, "Choose the folder by picking any track inside it, instead of selecting the folder itself.\nWindows' folder mode hides files, so a music folder with no subfolders looks empty - if\nthat bothers you more than picking a file does, set this to true.");
			ModRowHeight = cfg.Bind<float>("UI", "ModRowHeight", 38f, new ConfigDescription("Height of the folder and reload buttons.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 90f), Array.Empty<object>()));
			ModRowFontScale = cfg.Bind<float>("UI", "ModRowFontScale", 0.55f, new ConfigDescription("Button caption size relative to the artist name.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 1.5f), Array.Empty<object>()));
			PickFolderLabel = cfg.Bind<string>("UI", "PickFolderLabel", "Folder...", "Caption of the button that opens the Windows folder dialog.");
			ReloadLabel = cfg.Bind<string>("UI", "ReloadLabel", "Reload", "Caption of the rescan button.");
			WatchFolder = cfg.Bind<bool>("Playlist", "WatchFolder", true, "Notice files added to or removed from the music folder while the game is running.");
			WatchDebounceMs = cfg.Bind<int>("Playlist", "WatchDebounceMs", 1500, new ConfigDescription("How long the folder must be quiet before a change triggers a rescan. This is also what\nkeeps a half-copied file from being read: Windows reports a file as created before its\nbytes have finished arriving. Raise it if you copy over a slow drive.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(250, 10000), Array.Empty<object>()));
			SharingEnabled = cfg.Bind<bool>("Sharing", "Enabled", true, "Allow listening to, and broadcasting to, other players who have this mod.\nNothing is sent to anyone until you press Share, and nothing is received until you\npress Listen. Players without the mod are never contacted at all.");
			LiveTapeName = cfg.Bind<string>("Sharing", "LiveTapeName", "Shared", "Name of the extra mixtape used for listening to someone else.");
			MaxListeners = cfg.Bind<int>("Sharing", "MaxListeners", 6, new ConfigDescription("How many people may listen to you at once. Each one costs roughly your own\nbitrate in upload while their next track transfers.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 16), Array.Empty<object>()));
			ListenLatencyMs = cfg.Bind<int>("Sharing", "ListenLatencyMs", 250, new ConfigDescription("How far behind the broadcaster to sit. Some slack absorbs network jitter; without\nit the listener would keep trying to play audio the broadcaster has not sent yet.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2000), Array.Empty<object>()));
			VerboseLogging = cfg.Bind<bool>("Diagnostics", "VerboseLogging", false, "Log every scanned file, clip load, eviction and stall repair. Noisy; for bug reports.");
			DumpUi = cfg.Bind<bool>("Diagnostics", "DumpUi", false, "Dump the music-player UI tree to the log when it is built. Attach the log to a bug\nreport if a widget lands in the wrong place.");
			DumpUiKey = cfg.Bind<KeyCode>("Diagnostics", "DumpUiKey", (KeyCode)284, "Key that dumps that tree on demand. F4-F6 and F10-F11 are taken by Day and Night,\nF7-F9 by FrameCare and BlueSage, so F1-F3 are the free ones.");
			ProbeSeek = cfg.Bind<bool>("Diagnostics", "ProbeSeek", true, "Log the cost and read-back accuracy of the first seek. Cheap, and it is what turns\n'seeking does not work' into a report someone can act on.");
			MigrateLayout(cfg);
		}

		private static void MigrateLayout(ConfigFile cfg)
		{
			LayoutVersion = cfg.Bind<int>("UI", "LayoutVersion", 0, "Internal. Bumped when the mod ships new default widget positions, which resets the\nposition values above to those defaults. Set it to 0 by hand to force that reset.");
			if (LayoutVersion.Value < 7)
			{
				ResetToDefault<float>(PanelGrow);
				ResetToDefault<float>(SeekBarX);
				ResetToDefault<float>(SeekBarY);
				ResetToDefault<float>(SeekBarWidth);
				ResetToDefault<float>(SeekTimeX);
				ResetToDefault<float>(SeekTimeFontScale);
				ResetToDefault<float>(ModPanelHeight);
				ResetToDefault<float>(ModRowTextRight);
				ResetToDefault<float>(ModRowButtonRight);
				ResetToDefault<float>(ModRowButtonWidth);
				ResetToDefault<float>(ModRowHeight);
				ResetToDefault<float>(ModRowFontScale);
				ResetToDefault<float>(ModRowButtonGap);
				ResetToDefault<float>(ModRowTextWidth);
				Plugin.Log.LogInfo((object)("Applied the 0.3.1 music player layout (previous version: " + LayoutVersion.Value + "). Your own tweaks to those positions were reset."));
				LayoutVersion.Value = 7;
			}
		}

		private static void ResetToDefault<T>(ConfigEntry<T> entry)
		{
			if (entry != null)
			{
				entry.Value = (T)((ConfigEntryBase)entry).DefaultValue;
			}
		}
	}
	public sealed class ModRoot : MonoBehaviour
	{
		public static ModRoot Instance { get; private set; }

		public static void Create()
		{
			//IL_0013: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("OTLP_ModRoot")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<ModRoot>();
			}
		}

		public static Coroutine Run(IEnumerator routine)
		{
			if ((Object)(object)Instance == (Object)null || routine == null)
			{
				return null;
			}
			return ((MonoBehaviour)Instance).StartCoroutine(routine);
		}

		public static void Stop(Coroutine routine)
		{
			if ((Object)(object)Instance != (Object)null && routine != null)
			{
				((MonoBehaviour)Instance).StopCoroutine(routine);
			}
		}

		private void Update()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			MainThread.Drain();
			try
			{
				MixtapeBridge.Tick();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("MixtapeBridge.Tick threw, disabling: " + ex));
				MixtapeBridge.Disable();
			}
			try
			{
				ShareController.Tick();
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)("ShareController.Tick threw, sharing stopped: " + ex2));
				ShareController.Shutdown();
			}
			try
			{
				FolderWatcher.Tick();
			}
			catch (Exception ex3)
			{
				Plugin.Log.LogError((object)("FolderWatcher.Tick threw, watching stopped: " + ex3));
				FolderWatcher.Disarm();
			}
			if (ModConfig.DumpUiKey != null && Input.GetKeyDown(ModConfig.DumpUiKey.Value))
			{
				UiBuilder.DumpNow();
			}
		}
	}
	[BepInPlugin("com.sleepeydev.ontogether.localplaylist", "On-Together Local Playlist", "0.6.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.sleepeydev.ontogether.localplaylist";

		public static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				ModConfig.Bind(((BaseUnityPlugin)this).Config);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Config binding failed - some features will switch themselves off: " + ex));
			}
			ModRoot.Create();
			HarmonyBootstrap.ApplyAll();
			ShareController.Init();
			if (ModConfig.MusicFolder != null)
			{
				ModConfig.MusicFolder.SettingChanged += delegate
				{
					MainThread.Post(delegate
					{
						FolderWatcher.Sync();
						ReloadCoordinator.Request(ReloadReason.FolderChanged);
					});
				};
			}
			Log.LogInfo((object)("Local Playlist " + ((BaseUnityPlugin)this).Info.Metadata.Version?.ToString() + " ready."));
			Refl.LogHealth();
		}
	}
	public static class Refl
	{
		private static readonly List<string> Missing = new List<string>();

		public static readonly FieldRef<SoundManager, AudioSource> MixtapeMusic = Field<SoundManager, AudioSource>("_mixtapeMusic");

		public static readonly FieldRef<SoundManager, int> SongIndex = Field<SoundManager, int>("_songIndex");

		public static readonly FieldRef<SoundManager, int> MixtapeIndex = Field<SoundManager, int>("_mixtapeIndex");

		public static readonly FieldRef<SoundManager, bool> IsPlayingFlag = Field<SoundManager, bool>("_isPlaying");

		public static readonly MethodInfo PlayMixtape = Method(typeof(SoundManager), "PlayMixtape");

		public static readonly FieldRef<UIManager, Slider> MixTapeVolumeSlider = Field<UIManager, Slider>("_mixTapeVolumeSlider");

		public static readonly FieldRef<UIManager, TMP_Text> ArtistNameLabel = Field<UIManager, TMP_Text>("_artistName");

		public static readonly FieldRef<UIManager, Button> SongButtonPrefab = Field<UIManager, Button>("_songButtonPrefab");

		public static readonly FieldRef<UIManager, float> MusicTimer = Field<UIManager, float>("_musicTimer");

		public static readonly FieldRef<UIManager, Transform> MusicCorner1 = Field<UIManager, Transform>("_musicCorner1");

		public static bool PlaylistReady
		{
			get
			{
				if (MixtapeMusic != null && SongIndex != null && MixtapeIndex != null && IsPlayingFlag != null)
				{
					return PlayMixtape != null;
				}
				return false;
			}
		}

		public static bool SeekUiReady
		{
			get
			{
				if (PlaylistReady && MixTapeVolumeSlider != null)
				{
					return ArtistNameLabel != null;
				}
				return false;
			}
		}

		public static bool ModPanelReady
		{
			get
			{
				if (PlaylistReady && MixTapeVolumeSlider != null && ArtistNameLabel != null)
				{
					return SongButtonPrefab != null;
				}
				return false;
			}
		}

		private static FieldRef<TOwner, TField> Field<TOwner, TField>(string name)
		{
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(TOwner), name);
				if (fieldInfo == null || !typeof(TField).IsAssignableFrom(fieldInfo.FieldType))
				{
					Missing.Add(typeof(TOwner).Name + "." + name);
					return null;
				}
				return AccessTools.FieldRefAccess<TOwner, TField>(name);
			}
			catch (Exception)
			{
				Missing.Add(typeof(TOwner).Name + "." + name);
				return null;
			}
		}

		private static MethodInfo Method(Type owner, string name)
		{
			MethodInfo methodInfo = AccessTools.Method(owner, name, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Missing.Add(owner.Name + "." + name + "()");
			}
			return methodInfo;
		}

		public static void LogHealth()
		{
			if (Missing.Count == 0)
			{
				Plugin.Log.LogInfo((object)"Game handles: all resolved.");
				return;
			}
			Plugin.Log.LogWarning((object)("Game handles missing (the game was probably updated): " + string.Join(", ", Missing.ToArray())));
			Plugin.Log.LogWarning((object)("Feature availability - local playlist: " + (PlaylistReady ? "on" : "OFF") + ", seek bar: " + (SeekUiReady ? "on" : "OFF") + ", folder row: " + (ModPanelReady ? "on" : "OFF")));
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.UI
{
	public sealed class DragWatcher : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler
	{
		public bool IsDragging { get; private set; }

		public event Action Down;

		public event Action Up;

		public static DragWatcher Attach(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return null;
			}
			DragWatcher component = go.GetComponent<DragWatcher>();
			if (!((Object)(object)component != (Object)null))
			{
				return go.AddComponent<DragWatcher>();
			}
			return component;
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			if (!IsDragging)
			{
				IsDragging = true;
				Fire(this.Down);
			}
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			Release();
		}

		private void Update()
		{
			if (IsDragging && !Input.GetMouseButton(0))
			{
				Release();
			}
		}

		private void OnDisable()
		{
			if (IsDragging)
			{
				Release();
			}
		}

		private void Release()
		{
			if (IsDragging)
			{
				IsDragging = false;
				Fire(this.Up);
			}
		}

		private void Fire(Action a)
		{
			if (a == null)
			{
				return;
			}
			try
			{
				a();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("DragWatcher handler threw: " + ex));
			}
		}
	}
	public static class GameUi
	{
		public const string Prefix = "OTLP_";

		public static Transform Existing(Transform parent, string name)
		{
			if (!((Object)(object)parent == (Object)null))
			{
				return parent.Find(name);
			}
			return null;
		}

		public static Slider CloneSlider(Slider donor, Transform parent, string name)
		{
			if ((Object)(object)donor == (Object)null || (Object)(object)parent == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)donor).gameObject, parent, false);
			((Object)val).name = name;
			Slider component = val.GetComponent<Slider>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			ClearListeners<float>((UnityEvent<float>)(object)component.onValueChanged);
			StripLocalizers(val);
			val.SetActive(true);
			return component;
		}

		public static GameObject CloneObject(GameObject donor, Transform parent, string name)
		{
			if ((Object)(object)donor == (Object)null || (Object)(object)parent == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(donor, parent, false);
			((Object)obj).name = name;
			StripLocalizers(obj);
			obj.SetActive(true);
			return obj;
		}

		public static TMP_Text CloneLabel(TMP_Text donor, Transform parent, string name, string text)
		{
			if ((Object)(object)donor == (Object)null || (Object)(object)parent == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)donor).gameObject, parent, false);
			((Object)val).name = name;
			TMP_Text component = val.GetComponent<TMP_Text>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			StripLocalizers(val);
			StaticText.Apply(component, text);
			val.SetActive(true);
			return component;
		}

		public static void ClearListeners<T>(UnityEvent<T> evt)
		{
			if (evt != null)
			{
				for (int num = ((UnityEventBase)evt).GetPersistentEventCount() - 1; num >= 0; num--)
				{
					((UnityEventBase)evt).SetPersistentListenerState(num, (UnityEventCallState)0);
				}
				((UnityEventBase)evt).RemoveAllListeners();
			}
		}

		public static void ClearListeners(UnityEvent evt)
		{
			if (evt != null)
			{
				for (int num = ((UnityEventBase)evt).GetPersistentEventCount() - 1; num >= 0; num--)
				{
					((UnityEventBase)evt).SetPersistentListenerState(num, (UnityEventCallState)0);
				}
				((UnityEventBase)evt).RemoveAllListeners();
			}
		}

		public static int StripScripts(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			Assembly assembly = typeof(SoundManager).Assembly;
			int num = 0;
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Type type = ((object)val).GetType();
					bool flag = type.Name.IndexOf("Localize", StringComparison.Ordinal) >= 0;
					bool flag2 = type.Assembly == assembly;
					if (flag || flag2)
					{
						Object.Destroy((Object)(object)val);
						num++;
					}
				}
			}
			return num;
		}

		public static int StripLocalizers(GameObject root)
		{
			return StripScripts(root);
		}

		public static void Place(RectTransform rt, Vector2 anchoredPos, Vector2 sizeDelta)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rt == (Object)null)
			{
				return;
			}
			LayoutGroup val = (((Object)(object)((Transform)rt).parent == (Object)null) ? null : ((Component)((Transform)rt).parent).GetComponent<LayoutGroup>());
			if ((Object)(object)val == (Object)null)
			{
				rt.anchoredPosition = anchoredPos;
				rt.sizeDelta = sizeDelta;
				return;
			}
			HorizontalOrVerticalLayoutGroup val2 = (HorizontalOrVerticalLayoutGroup)(object)((val is HorizontalOrVerticalLayoutGroup) ? val : null);
			if ((Object)(object)val2 != (Object)null && val2.childControlHeight)
			{
				LayoutElement val3 = ((Component)rt).GetComponent<LayoutElement>();
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = ((Component)rt).gameObject.AddComponent<LayoutElement>();
				}
				val3.preferredHeight = sizeDelta.y;
			}
			else
			{
				rt.sizeDelta = new Vector2(rt.sizeDelta.x, sizeDelta.y);
			}
		}

		public static LayoutGroup DrivingLayout(Transform t)
		{
			if (!((Object)(object)t == (Object)null) && !((Object)(object)t.parent == (Object)null))
			{
				return ((Component)t.parent).GetComponent<LayoutGroup>();
			}
			return null;
		}

		public static void DropFocus()
		{
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
		}

		public static void DumpHierarchy(Transform root, string title, int maxDepth = 6)
		{
			if ((Object)(object)root == (Object)null)
			{
				Plugin.Log.LogInfo((object)("[dump] " + title + ": <null>"));
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[dump] ").Append(title).Append('\n');
			Describe(root, stringBuilder, 0, maxDepth);
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}

		private static void Describe(Transform t, StringBuilder sb, int depth, int maxDepth)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)t == (Object)null || depth > maxDepth)
			{
				return;
			}
			sb.Append(' ', depth * 2).Append(((Object)t).name);
			sb.Append("  [").Append(((Component)t).gameObject.activeSelf ? "on" : "off").Append(", sib ")
				.Append(t.GetSiblingIndex())
				.Append(']');
			Component[] components = ((Component)t).GetComponents<Component>();
			sb.Append("  {");
			for (int i = 0; i < components.Length; i++)
			{
				if (i > 0)
				{
					sb.Append(", ");
				}
				sb.Append(((Object)(object)components[i] == (Object)null) ? "<missing>" : ((object)components[i]).GetType().Name);
			}
			sb.Append('}');
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			if (val != null)
			{
				sb.Append("  aMin").Append(V(val.anchorMin)).Append(" aMax")
					.Append(V(val.anchorMax))
					.Append(" piv")
					.Append(V(val.pivot))
					.Append(" pos")
					.Append(V(val.anchoredPosition))
					.Append(" size")
					.Append(V(val.sizeDelta))
					.Append(" scale")
					.Append(V(((Transform)val).localScale));
			}
			LayoutGroup val2 = (((Object)(object)t.parent == (Object)null) ? null : ((Component)t.parent).GetComponent<LayoutGroup>());
			if ((Object)(object)val2 != (Object)null)
			{
				sb.Append("  [LAYOUT-DRIVEN by ").Append(((object)val2).GetType().Name).Append(']');
			}
			LayoutGroup component = ((Component)t).GetComponent<LayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				sb.Append("  ").Append(DescribeLayout(component));
			}
			Selectable component2 = ((Component)t).GetComponent<Selectable>();
			Slider val3 = (Slider)(object)((component2 is Slider) ? component2 : null);
			if (val3 != null)
			{
				sb.Append("  slider(persistent=").Append(((UnityEventBase)val3.onValueChanged).GetPersistentEventCount()).Append(')');
			}
			else
			{
				Button val4 = (Button)(object)((component2 is Button) ? component2 : null);
				if (val4 != null)
				{
					sb.Append("  button(persistent=").Append(((UnityEventBase)val4.onClick).GetPersistentEventCount()).Append(')');
				}
			}
			TMP_Text component3 = ((Component)t).GetComponent<TMP_Text>();
			if ((Object)(object)component3 != (Object)null)
			{
				string text = component3.text ?? "";
				if (text.Length > 40)
				{
					text = text.Substring(0, 40) + "...";
				}
				sb.Append("  text=\"").Append(text).Append('"');
			}
			sb.Append('\n');
			for (int j = 0; j < t.childCount; j++)
			{
				Describe(t.GetChild(j), sb, depth + 1, maxDepth);
			}
		}

		public static string DescribeLayout(LayoutGroup g)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)g == (Object)null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(((object)g).GetType().Name).Append("(pad ").Append(g.padding.left)
				.Append(',')
				.Append(g.padding.right)
				.Append(',')
				.Append(g.padding.top)
				.Append(',')
				.Append(g.padding.bottom)
				.Append(" align=")
				.Append(g.childAlignment);
			HorizontalOrVerticalLayoutGroup val = (HorizontalOrVerticalLayoutGroup)(object)((g is HorizontalOrVerticalLayoutGroup) ? g : null);
			if (val != null)
			{
				stringBuilder.Append(" spacing=").Append(val.spacing).Append(" ctrlW=")
					.Append(val.childControlWidth)
					.Append(" ctrlH=")
					.Append(val.childControlHeight)
					.Append(" expW=")
					.Append(val.childForceExpandWidth)
					.Append(" expH=")
					.Append(val.childForceExpandHeight)
					.Append(" reverse=")
					.Append(val.reverseArrangement);
			}
			return stringBuilder.Append(')').ToString();
		}

		private static string V(Vector2 v)
		{
			return "(" + v.x.ToString("0.##") + "," + v.y.ToString("0.##") + ")";
		}

		private static string V(Vector3 v)
		{
			return "(" + v.x.ToString("0.##") + "," + v.y.ToString("0.##") + ")";
		}
	}
	public static class MiniPlayer
	{
		public static float TotalGrow => Mathf.Max(0f, ModConfig.PanelGrow.Value) + (ModConfig.ModPanelEnabled.Value ? Mathf.Max(0f, ModConfig.ModPanelHeight.Value) : 0f);

		public static Transform Resolve(UIManager ui)
		{
			if ((Object)(object)ui == (Object)null || Refl.MixTapeVolumeSlider == null)
			{
				return null;
			}
			Slider val = Refl.MixTapeVolumeSlider.Invoke(ui);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).transform.parent == (Object)null)
			{
				return null;
			}
			return ((Component)val).transform.parent.parent;
		}

		public static void Grow(UIManager ui, Transform panel, float grow)
		{
			//IL_0049: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null || grow <= 0f)
			{
				return;
			}
			int num = 0;
			string[] array = new string[2] { "Image_Bg", "Image_Outline" };
			foreach (string text in array)
			{
				Transform obj = panel.Find(text);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null)
				{
					val.sizeDelta = new Vector2(val.sizeDelta.x, val.sizeDelta.y + grow);
					val.anchoredPosition = new Vector2(val.anchoredPosition.x, val.anchoredPosition.y - grow * 0.5f);
					num++;
				}
			}
			if (num == 0)
			{
				Plugin.Log.LogWarning((object)"Could not find the mini player's background to enlarge; set UI/PanelGrow = 0 if the layout looks wrong.");
				return;
			}
			if (Refl.MusicCorner1 != null)
			{
				Transform obj2 = Refl.MusicCorner1.Invoke(ui);
				RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if (val2 != null)
				{
					val2.anchoredPosition = new Vector2(val2.anchoredPosition.x, val2.anchoredPosition.y - grow);
				}
				else
				{
					Plugin.Log.LogWarning((object)"The music hover-box corner is not a RectTransform; the panel may close when you reach for the added controls.");
				}
			}
			Plugin.Log.LogInfo((object)("Mini player grown by " + grow + " px (" + num + " layer(s))."));
		}

		public static void KeepOpen(UIManager ui)
		{
			if ((Object)(object)ui != (Object)null && Refl.MusicTimer != null)
			{
				Refl.MusicTimer.Invoke(ui) = 0f;
			}
		}
	}
	public sealed class ModPanel : MonoBehaviour
	{
		private const string PathName = "OTLP_FolderPath";

		private const string PickName = "OTLP_PickFolder";

		private const string ReloadName = "OTLP_Reload";

		private const string ShareName = "OTLP_Share";

		private const string ListenName = "OTLP_Listen";

		private static bool _failed;

		private UIManager _ui;

		private TMP_Text _pathLabel;

		private string _shown;

		private Button _shareButton;

		private Button _listenButton;

		private TMP_Text _shareCaption;

		private TMP_Text _listenCaption;

		private string _shownShareCaption;

		private string _shownListenCaption;

		public static void Build(UIManager ui, Transform panel)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			if (_failed || !ModConfig.ModPanelEnabled.Value)
			{
				return;
			}
			if (!Refl.ModPanelReady)
			{
				Plugin.Log.LogWarning((object)"Folder row: game handles missing, skipping. The folder is still settable in the config file.");
				_failed = true;
			}
			else
			{
				if ((Object)(object)panel == (Object)null || (Object)(object)GameUi.Existing(panel, "OTLP_FolderPath") != (Object)null)
				{
					return;
				}
				float num = ModConfig.SeekBarY.Value - ModConfig.ModPanelHeight.Value;
				TMP_Text val = Refl.ArtistNameLabel.Invoke(ui);
				TMP_Text val2 = GameUi.CloneLabel(val, panel, "OTLP_FolderPath", "");
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogWarning((object)"Folder row: could not clone a label.");
					return;
				}
				RectTransform val3 = (RectTransform)val2.transform;
				val3.sizeDelta = new Vector2(ModConfig.ModRowTextWidth.Value, 34f);
				val3.anchoredPosition = new Vector2(ModConfig.ModRowTextRight.Value, num);
				val2.alignment = (TextAlignmentOptions)513;
				val2.fontSize = Mathf.Max(10f, val.fontSize * ModConfig.SeekTimeFontScale.Value);
				((Graphic)val2).raycastTarget = false;
				ModPanel modPanel = ((Component)val2).gameObject.AddComponent<ModPanel>();
				modPanel._ui = ui;
				modPanel._pathLabel = val2;
				float value = ModConfig.ModRowButtonWidth.Value;
				float value2 = ModConfig.ModRowButtonGap.Value;
				float value3 = ModConfig.ModRowButtonRight.Value;
				Button val4 = MakeButton(ui, panel, "OTLP_Reload", ModConfig.ReloadLabel.Value, value3, num, OnReload);
				value3 -= value + value2;
				Button val5 = MakeButton(ui, panel, "OTLP_PickFolder", ModConfig.PickFolderLabel.Value, value3, num, OnPickFolder);
				value3 -= value + value2;
				if (ModConfig.SharingEnabled.Value)
				{
					modPanel._listenButton = MakeButton(ui, panel, "OTLP_Listen", "Listen", value3, num, ShareController.ToggleListen);
					value3 -= value + value2;
					modPanel._shareButton = MakeButton(ui, panel, "OTLP_Share", "Share", value3, num, ShareController.ToggleBroadcast);
					modPanel._listenCaption = CaptionOf(modPanel._listenButton);
					modPanel._shareCaption = CaptionOf(modPanel._shareButton);
				}
				Plugin.Log.LogInfo((object)("Mod row added at y " + num + " (" + (((Object)(object)val5 != (Object)null) ? "folder " : "") + (((Object)(object)val4 != (Object)null) ? "reload " : "") + (((Object)(object)modPanel._shareButton != (Object)null) ? "share listen" : "") + ")."));
			}
		}

		private static TMP_Text CaptionOf(Button b)
		{
			if (!((Object)(object)b == (Object)null))
			{
				return ((Component)b).GetComponentInChildren<TMP_Text>(true);
			}
			return null;
		}

		private static Button MakeButton(UIManager ui, Transform panel, string name, string caption, float right, float y, Action onClick)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			Button val = FindButtonDonor(ui);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = GameUi.CloneObject(((Component)val).gameObject, panel, name);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Button component = val2.GetComponent<Button>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return null;
			}
			GameUi.ClearListeners((UnityEvent)(object)component.onClick);
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				try
				{
					onClick();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)(name + " click failed: " + ex));
				}
				GameUi.DropFocus();
			});
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = new Vector2(0.5f, 0.5f);
			val3.anchorMax = new Vector2(0.5f, 0.5f);
			val3.pivot = new Vector2(1f, 0.5f);
			((Transform)val3).localScale = Vector3.one;
			val3.sizeDelta = new Vector2(ModConfig.ModRowButtonWidth.Value, ModConfig.ModRowHeight.Value);
			val3.anchoredPosition = new Vector2(right, y);
			NormaliseChildren(val3);
			TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				StaticText.Apply(componentInChildren, caption);
				componentInChildren.alignment = (TextAlignmentOptions)514;
				componentInChildren.textWrappingMode = (TextWrappingModes)0;
				componentInChildren.overflowMode = (TextOverflowModes)0;
				TMP_Text val4 = Refl.ArtistNameLabel.Invoke(ui);
				if ((Object)(object)val4 != (Object)null)
				{
					componentInChildren.fontSize = Mathf.Max(10f, val4.fontSize * ModConfig.ModRowFontScale.Value);
				}
			}
			return component;
		}

		private static Button FindButtonDonor(UIManager ui)
		{
			string[] array = new string[2] { "GameUI/Panel_Request/Button_Reject", "GameUI/Panel_Request/Button_Accept" };
			foreach (string text in array)
			{
				Transform val = ((Component)ui).transform.Find(text);
				Button val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Button>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			Transform val3 = MiniPlayer.Resolve(ui);
			if ((Object)(object)val3 != (Object)null)
			{
				Transform val4 = val3.Find("ButtonMiniPlayerTabs/Button_Music");
				Button val5 = (((Object)(object)val4 != (Object)null) ? ((Component)val4).GetComponent<Button>() : null);
				if ((Object)(object)val5 != (Object)null)
				{
					Plugin.Log.LogInfo((object)"Folder row: using the mini player tab as the button donor.");
					return val5;
				}
			}
			Plugin.Log.LogWarning((object)"Folder row: falling back to the song-row prefab as a button donor; its decoration does not scale, so the buttons may look wrong.");
			if (Refl.SongButtonPrefab == null)
			{
				return null;
			}
			return Refl.SongButtonPrefab.Invoke(ui);
		}

		private static void NormaliseChildren(RectTransform root)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < ((Transform)root).childCount; i++)
			{
				Transform child = ((Transform)root).GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null && !(val.anchorMin != val.anchorMax))
				{
					val.anchorMin = Vector2.zero;
					val.anchorMax = Vector2.one;
					val.pivot = new Vector2(0.5f, 0.5f);
					val.offsetMin = Vector2.zero;
					val.offsetMax = Vector2.zero;
				}
			}
		}

		private static void OnPickFolder()
		{
			string start = (ModConfig.MusicFolder.Value ?? "").Trim().Trim('"');
			bool value = ModConfig.PickFolderByFile.Value;
			FolderPicker.Pick(value ? "Pick any track in your music folder" : "Open your music folder, then press Use this folder", start, value, delegate(string picked)
			{
				if (string.IsNullOrEmpty(picked))
				{
					Plugin.Log.LogInfo((object)"Folder picker: cancelled.");
				}
				else if (string.Equals(picked, start, StringComparison.OrdinalIgnoreCase))
				{
					Plugin.Log.LogInfo((object)"Folder picker: same folder, nothing to do.");
				}
				else
				{
					Plugin.Log.LogInfo((object)("Music folder set to " + picked));
					ModConfig.MusicFolder.Value = picked;
				}
			});
		}

		private static void OnReload()
		{
			ReloadCoordinator.Request(ReloadReason.Manual);
		}

		private void Update()
		{
			if (FolderPicker.IsOpen)
			{
				MiniPlayer.KeepOpen(_ui);
			}
			string text = (ReloadCoordinator.Busy ? "Scanning..." : Describe());
			string statusLine = ShareController.StatusLine;
			if (!string.IsNullOrEmpty(statusLine))
			{
				text = text + "   -   " + statusLine;
			}
			if (text != _shown)
			{
				_shown = text;
				StaticText.Apply(_pathLabel, text);
			}
			PumpShareButtons();
		}

		private void PumpShareButtons()
		{
			string shareButtonLabel = ShareController.ShareButtonLabel;
			if ((Object)(object)_shareCaption != (Object)null && shareButtonLabel != _shownShareCaption)
			{
				_shownShareCaption = shareButtonLabel;
				StaticText.Apply(_shareCaption, shareButtonLabel);
			}
			string listenButtonLabel = ShareController.ListenButtonLabel;
			if ((Object)(object)_listenCaption != (Object)null && listenButtonLabel != _shownListenCaption)
			{
				_shownListenCaption = listenButtonLabel;
				StaticText.Apply(_listenCaption, listenButtonLabel);
			}
			if ((Object)(object)_shareButton != (Object)null)
			{
				((Selectable)_shareButton).interactable = ShareController.CanBroadcast || ShareController.Mode == ShareMode.Broadcasting;
			}
			if ((Object)(object)_listenButton != (Object)null)
			{
				((Selectable)_listenButton).interactable = ShareController.AnyoneBroadcasting || ShareController.Mode == ShareMode.Listening;
			}
		}

		private static string Describe()
		{
			string text = (ModConfig.MusicFolder.Value ?? "").Trim().Trim('"');
			if (text.Length == 0)
			{
				return "No music folder chosen";
			}
			string text2;
			try
			{
				text2 = Path.GetFileName(text.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
			}
			catch (Exception)
			{
				text2 = text;
			}
			if (string.IsNullOrEmpty(text2))
			{
				text2 = text;
			}
			int count = PlaylistLibrary.Tracks.Count;
			string text3 = ((count == 1) ? "1 track" : (count + " tracks"));
			return text2 + "  -  " + text3;
		}

		public static void Reset()
		{
			_failed = false;
		}
	}
	public sealed class SeekBar : MonoBehaviour
	{
		private const string BarName = "OTLP_SeekBar";

		private const string LabelName = "OTLP_SeekTime";

		private static bool _failed;

		private Slider _slider;

		private TMP_Text _readout;

		private DragWatcher _watcher;

		private UIManager _ui;

		private int _shownSecond = -1;

		private int _shownTotal = -1;

		private bool _wasInteractable = true;

		private bool _probeLogged;

		private static float _lastSlowSeekLog = -999f;

		public static void Build(UIManager ui)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			if (_failed || !ModConfig.SeekBarEnabled.Value)
			{
				return;
			}
			if (!Refl.SeekUiReady)
			{
				Plugin.Log.LogWarning((object)"Seek bar: game handles missing, skipping.");
				_failed = true;
				return;
			}
			Slider val = Refl.MixTapeVolumeSlider.Invoke(ui);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Seek bar: no mixtape volume slider on this UIManager.");
				return;
			}
			Transform val2 = (((Object)(object)((Component)val).transform.parent != (Object)null) ? ((Component)val).transform.parent.parent : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Seek bar: the volume slider is not two levels inside the mini player.");
			}
			else
			{
				if ((Object)(object)GameUi.Existing(val2, "OTLP_SeekBar") != (Object)null)
				{
					return;
				}
				Slider val3 = GameUi.CloneSlider(val, val2, "OTLP_SeekBar");
				if ((Object)(object)val3 == (Object)null)
				{
					Plugin.Log.LogWarning((object)"Seek bar: cloning the volume slider failed.");
					return;
				}
				val3.minValue = 0f;
				val3.maxValue = 1f;
				val3.wholeNumbers = false;
				val3.SetValueWithoutNotify(0f);
				MakeTrackClickable(val3);
				RectTransform val4 = (RectTransform)((Component)val3).transform;
				val4.anchoredPosition = new Vector2(ModConfig.SeekBarX.Value, ModConfig.SeekBarY.Value);
				val4.sizeDelta = new Vector2(ModConfig.SeekBarWidth.Value, val4.sizeDelta.y);
				TMP_Text val5 = null;
				TMP_Text val6 = Refl.ArtistNameLabel.Invoke(ui);
				if ((Object)(object)val6 != (Object)null)
				{
					val5 = GameUi.CloneLabel(val6, val2, "OTLP_SeekTime", "--:-- / --:--");
					if ((Object)(object)val5 != (Object)null)
					{
						RectTransform val7 = (RectTransform)val5.transform;
						val7.anchoredPosition = new Vector2(ModConfig.SeekTimeX.Value, ModConfig.SeekBarY.Value);
						val7.sizeDelta = new Vector2(val7.sizeDelta.x, 34f);
						val5.alignment = (TextAlignmentOptions)516;
						val5.fontSize = Mathf.Max(10f, val6.fontSize * ModConfig.SeekTimeFontScale.Value);
						((Graphic)val5).raycastTarget = false;
					}
				}
				SeekBar seekBar = ((Component)val3).gameObject.AddComponent<SeekBar>();
				seekBar._slider = val3;
				seekBar._readout = val5;
				seekBar._ui = ui;
				seekBar._watcher = DragWatcher.Attach(((Component)val3).gameObject);
				seekBar._watcher.Up += seekBar.OnRelease;
				Plugin.Log.LogInfo((object)("Seek bar added to " + ((Object)val2).name + " at " + ((object)val4.anchoredPosition/*cast due to .constrained prefix*/).ToString() + " size " + ((object)val4.sizeDelta/*cast due to .constrained prefix*/).ToString()));
			}
		}

		private static void MakeTrackClickable(Slider bar)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Image val = ((Component)bar).gameObject.GetComponent<Image>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)bar).gameObject.AddComponent<Image>();
			}
			((Graphic)val).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)val).raycastTarget = true;
			if (ModConfig.VerboseLogging.Value)
			{
				Plugin.Log.LogInfo((object)"Seek bar: click-to-seek catcher attached.");
			}
		}

		private static void GrowPanel(UIManager ui, Transform panel)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			float value = ModConfig.PanelGrow.Value;
			if (value <= 0f)
			{
				return;
			}
			int num = 0;
			string[] array = new string[2] { "Image_Bg", "Image_Outline" };
			foreach (string text in array)
			{
				Transform obj = panel.Find(text);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null)
				{
					val.sizeDelta = new Vector2(val.sizeDelta.x, val.sizeDelta.y + value);
					val.anchoredPosition = new Vector2(val.anchoredPosition.x, val.anchoredPosition.y - value * 0.5f);
					num++;
				}
			}
			if (num == 0)
			{
				Plugin.Log.LogWarning((object)"Seek bar: could not find the mini player's background to enlarge; set UI/PanelGrow = 0 if the layout looks wrong.");
				return;
			}
			if (Refl.MusicCorner1 != null)
			{
				Transform obj2 = Refl.MusicCorner1.Invoke(ui);
				RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if (val2 != null)
				{
					val2.anchoredPosition = new Vector2(val2.anchoredPosition.x, val2.anchoredPosition.y - value);
				}
				else
				{
					Plugin.Log.LogWarning((object)"Seek bar: the music hover-box corner is not a RectTransform; the panel may close when you reach for the scrub bar.");
				}
			}
			Plugin.Log.LogInfo((object)("Mini player grown by " + value + " px (" + num + " layer(s))."));
		}

		public static void SetInteractable(bool value)
		{
			SeekBar[] array = Resources.FindObjectsOfTypeAll<SeekBar>();
			foreach (SeekBar seekBar in array)
			{
				if (!((Object)(object)seekBar == (Object)null) && !((Object)(object)seekBar._slider == (Object)null))
				{
					seekBar._wasInteractable = value;
					((Selectable)seekBar._slider).interactable = value;
				}
			}
		}

		public static void Reset()
		{
			_failed = false;
		}

		private void LateUpdate()
		{
			try
			{
				Pump();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Seek bar disabled after an error: " + ex));
				((Behaviour)this).enabled = false;
			}
		}

		private void Pump()
		{
			SoundManager i = MonoSingleton<SoundManager>.I;
			AudioSource val = (((Object)(object)i != (Object)null) ? Refl.MixtapeMusic.Invoke(i) : null);
			AudioClip val2 = (((Object)(object)val != (Object)null) ? val.clip : null);
			if (!((Object)(object)val2 != (Object)null) || val2.samples <= 1 || MixtapeBridge.IsSilence(val2) || (!ModConfig.SeekBarOnVanillaMixtapes.Value && !MixtapeBridge.IsOurs(i)))
			{
				if (_wasInteractable)
				{
					((Selectable)_slider).interactable = false;
				}
				_slider.SetValueWithoutNotify(0f);
				SetReadout(-1, -1);
				return;
			}
			if (!((Selectable)_slider).interactable && _wasInteractable)
			{
				((Selectable)_slider).interactable = true;
			}
			if ((Object)(object)_watcher != (Object)null && _watcher.IsDragging)
			{
				if ((Object)(object)_ui != (Object)null && Refl.MusicTimer != null)
				{
					Refl.MusicTimer.Invoke(_ui) = 0f;
				}
				double num = TotalSeconds(i, val2);
				SetReadout((int)((double)_slider.value * num), (int)num);
			}
			else
			{
				int samples = val2.samples;
				float num2 = ((samples > 0) ? Mathf.Clamp01((float)val.timeSamples / (float)samples) : 0f);
				_slider.SetValueWithoutNotify(num2);
				double num3 = TotalSeconds(i, val2);
				SetReadout((int)((double)num2 * num3), (int)num3);
			}
		}

		private void OnRelease()
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			GameUi.DropFocus();
			try
			{
				SoundManager i = MonoSingleton<SoundManager>.I;
				AudioSource val = (((Object)(object)i != (Object)null) ? Refl.MixtapeMusic.Invoke(i) : null);
				AudioClip val2 = (((Object)(object)val != (Object)null) ? val.clip : null);
				if (!((Object)(object)val2 == (Object)null) && val2.samples > 1 && !MixtapeBridge.IsSilence(val2))
				{
					int num = Mathf.Max(1, val2.frequency / 4);
					int timeSamples = Mathf.Clamp(Mathf.RoundToInt(_slider.value * (float)val2.samples), 0, Mathf.Max(0, val2.samples - num));
					Stopwatch stopwatch = Stopwatch.StartNew();
					val.timeSamples = timeSamples;
					stopwatch.Stop();
					if (ModConfig.ProbeSeek.Value && !_probeLogged)
					{
						_probeLogged = true;
						Plugin.Log.LogInfo((object)("Seek probe: requested sample " + timeSamples + ", read back " + val.timeSamples + ", clip '" + ((Object)val2).name + "' loadType=" + ((object)val2.loadType/*cast due to .constrained prefix*/).ToString() + ", took " + stopwatch.Elapsed.TotalMilliseconds.ToString("0.0") + " ms."));
					}
					else if (stopwatch.Elapsed.TotalMilliseconds > 4.0 && Time.unscaledTime - _lastSlowSeekLog > 30f)
					{
						_lastSlowSeekLog = Time.unscaledTime;
						Plugin.Log.LogInfo((object)("Seeking takes " + stopwatch.Elapsed.TotalMilliseconds.ToString("0.0") + " ms on this machine."));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Seek failed: " + ex));
			}
		}

		private static double TotalSeconds(SoundManager sm, AudioClip clip)
		{
			LocalTrack localTrack = MixtapeBridge.CurrentTrack(sm);
			if (localTrack != null && localTrack.Duration > 0.5)
			{
				return localTrack.Duration;
			}
			if (clip.frequency <= 0)
			{
				return 0.0;
			}
			return (double)clip.samples / (double)clip.frequency;
		}

		private void SetReadout(int seconds, int total)
		{
			if (!((Object)(object)_readout == (Object)null) && (seconds != _shownSecond || total != _shownTotal))
			{
				_shownSecond = seconds;
				_shownTotal = total;
				_readout.text = Clock(seconds) + " / " + Clock(total);
			}
		}

		private static string Clock(int seconds)
		{
			if (seconds < 0)
			{
				return "--:--";
			}
			int num = seconds / 60;
			int num2 = seconds % 60;
			return ((num < 10) ? "0" : "") + num + ":" + ((num2 < 10) ? "0" : "") + num2;
		}
	}
	public sealed class StaticText : MonoBehaviour
	{
		private TMP_Text _label;

		public string Text;

		public static StaticText Apply(TMP_Text label, string text)
		{
			if ((Object)(object)label == (Object)null)
			{
				return null;
			}
			StaticText staticText = ((Component)label).gameObject.GetComponent<StaticText>();
			if ((Object)(object)staticText == (Object)null)
			{
				staticText = ((Component)label).gameObject.AddComponent<StaticText>();
			}
			staticText._label = label;
			staticText.Text = text;
			label.text = text;
			return staticText;
		}

		private void OnEnable()
		{
			if ((Object)(object)_label != (Object)null && Text != null)
			{
				_label.text = Text;
			}
		}
	}
	public static class UiBuilder
	{
		private static UIManager _ui;

		public static void BuildMusicUi(UIManager ui)
		{
			if (!((Object)(object)ui == (Object)null))
			{
				_ui = ui;
				Transform val = MiniPlayer.Resolve(ui);
				if ((Object)(object)val != (Object)null && (Object)(object)GameUi.Existing(val, "OTLP_SeekBar") == (Object)null && (Object)(object)GameUi.Existing(val, "OTLP_FolderPath") == (Object)null)
				{
					MiniPlayer.Grow(ui, val, MiniPlayer.TotalGrow);
				}
				try
				{
					SeekBar.Build(ui);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Seek bar build failed: " + ex));
				}
				try
				{
					ModPanel.Build(ui, val);
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)("Folder row build failed: " + ex2));
				}
				if (ModConfig.DumpUi.Value)
				{
					DumpMusic();
				}
			}
		}

		public static void DumpNow()
		{
			DumpMusic();
		}

		private static void DumpMusic()
		{
			try
			{
				if (!((Object)(object)_ui == (Object)null) && Refl.MixTapeVolumeSlider != null)
				{
					Slider val = Refl.MixTapeVolumeSlider.Invoke(_ui);
					GameUi.DumpHierarchy(((Object)(object)val != (Object)null && (Object)(object)((Component)val).transform.parent != (Object)null) ? ((Component)val).transform.parent.parent : null, "mini music player (Panel_MiniPlayer)");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("UI dump (music) failed: " + ex));
			}
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.Share
{
	public static class Broadcaster
	{
		private sealed class Subscriber
		{
			public CSteamID Id;

			public uint Cursor;

			public int Credit;

			public uint WantedTrack;

			public readonly HashSet<uint> Has = new HashSet<uint>();

			public float LastSeen;
		}

		private sealed class Sending
		{
			public uint TrackId;

			public string Path;

			public long Bytes;

			public uint Crc32;

			public bool CrcReady;

			public string Title;

			public string Artist;

			public uint DurationMs;

			public WireFormat Format;

			public float LastOfferAt;
		}

		private const float BeaconInterval = 0.25f;

		private const float OfferInterval = 2f;

		private const int DefaultCredit = 8;

		private const int QueuedBytesCeiling = 524288;

		private const int AggregateBytesPerSecond = 524288;

		private static readonly Dictionary<ulong, Subscriber> Subs = new Dictionary<ulong, Subscriber>();

		private static readonly Dictionary<uint, Sending> Catalogue = new Dictionary<uint, Sending>();

		private static readonly byte[] ChunkBuf = new byte[32768];

		private static uint _sessionId;

		private static uint _seq;

		private static float _nextBeacon;

		private static float _budgetWindowStart;

		private static int _budgetSpent;

		private static uint _slot0;

		private static uint _slot1;

		public static bool Active { get; private set; }

		public static int ListenerCount => Subs.Count;

		public static void Start()
		{
			if (!Active)
			{
				Active = true;
				_sessionId = FreshSessionId();
				_seq = 0u;
				_slot0 = (_slot1 = 0u);
				Subs.Clear();
				Plugin.Log.LogInfo((object)("Broadcasting, session " + _sessionId + "."));
			}
		}

		public static void Stop()
		{
			//IL_0028: 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)
			if (!Active)
			{
				return;
			}
			Active = false;
			foreach (Subscriber value in Subs.Values)
			{
				P2PTransport.SendControl(value.Id, (byte[] b) => Messages.Bye(b, 0));
				P2PTransport.CloseChannels(value.Id);
			}
			Subs.Clear();
			Catalogue.Clear();
			Plugin.Log.LogInfo((object)"Stopped broadcasting.");
		}

		private static uint FreshSessionId()
		{
			return (uint)((int)(Environment.TickCount * 2654435761u) ^ -1640531527);
		}

		public static void OnMessage(CSteamID from, MsgType type, byte[] buf, int off, int len)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			switch (type)
			{
			case MsgType.Sub:
				OnSub(from, new Wire.Reader(buf, off, len));
				break;
			case MsgType.Want:
				OnWant(from, new Wire.Reader(buf, off, len));
				break;
			case MsgType.Have:
				OnHave(from, new Wire.Reader(buf, off, len));
				break;
			case MsgType.Ping:
				OnPing(from, new Wire.Reader(buf, off, len));
				break;
			case MsgType.Bye:
				Drop(from, "said goodbye");
				break;
			}
		}

		private static void OnSub(CSteamID from, Wire.Reader r)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			bool flag = r.U8() != 0;
			if (r.Failed)
			{
				return;
			}
			if (!flag)
			{
				Drop(from, "unsubscribed");
				return;
			}
			if (!Active)
			{
				P2PTransport.SendControl(from, (byte[] b) => Messages.SubAck(b, accepted: false, SubReason.NotBroadcasting, 0u));
				return;
			}
			if (!Subs.ContainsKey(from.m_SteamID) && Subs.Count >= Mathf.Max(1, ModConfig.MaxListeners.Value))
			{
				P2PTransport.SendControl(from, (byte[] b) => Messages.SubAck(b, accepted: false, SubReason.Full, 0u));
				return;
			}
			if (!Subs.TryGetValue(from.m_SteamID, out var value))
			{
				value = new Subscriber
				{
					Id = from
				};
				Subs[from.m_SteamID] = value;
				Plugin.Log.LogInfo((object)(NameOf(from) + " is now listening (" + Subs.Count + " total)."));
			}
			value.LastSeen = Time.unscaledTime;
			uint session = _sessionId;
			P2PTransport.SendControl(from, (byte[] b) => Messages.SubAck(b, accepted: true, SubReason.Ok, session));
		}

		private static void OnWant(CSteamID from, Wire.Reader r)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (Messages.DecodeWant(r, out var v) && v.SessionId == _sessionId && Subs.TryGetValue(from.m_SteamID, out var value))
			{
				value.LastSeen = Time.unscaledTime;
				value.WantedTrack = v.TrackId;
				value.Cursor = v.FromChunk;
				value.Credit = Mathf.Clamp((v.Window == 0) ? 8 : v.Window, 1, 64);
			}
		}

		private static void OnHave(CSteamID from, Wire.Reader r)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			uint num = r.U32();
			uint num2 = r.U32();
			if (!r.Failed && num == _sessionId && Subs.TryGetValue(from.m_SteamID, out var value))
			{
				value.LastSeen = Time.unscaledTime;
				value.Has.Add(num2);
				if (value.WantedTrack == num2)
				{
					value.Credit = 0;
				}
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)(NameOf(from) + " has track " + num2 + "."));
				}
			}
		}

		private static void OnPing(CSteamID from, Wire.Reader r)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			long t0 = r.I64();
			if (!r.Failed)
			{
				long t1 = Clock.NowUs();
				P2PTransport.SendControl(from, (byte[] b) => Messages.Pong(b, t0, t1));
			}
		}

		private static void Drop(CSteamID from, string why)
		{
			//IL_0005: 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)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (Subs.Remove(from.m_SteamID))
			{
				Plugin.Log.LogInfo((object)(NameOf(from) + " " + why + " (" + Subs.Count + " left)."));
				P2PTransport.CloseChannels(from);
			}
		}

		public static void OnPeerUnreachable(CSteamID peer)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (Subs.ContainsKey(peer.m_SteamID) && ModConfig.VerboseLogging.Value)
			{
				Plugin.Log.LogInfo((object)(NameOf(peer) + " is briefly unreachable; keeping the subscription."));
			}
		}

		public static void Tick(SoundManager sm)
		{
			if (Active && !((Object)(object)sm == (Object)null))
			{
				ResetBudgetWindow();
				UpdateSlots(sm);
				if (Time.unscaledTime >= _nextBeacon)
				{
					_nextBeacon = Time.unscaledTime + 0.25f;
					SendBeacons(sm);
				}
				PumpTransfers();
			}
		}

		private static void ResetBudgetWindow()
		{
			if (!(Time.unscaledTime - _budgetWindowStart < 1f))
			{
				_budgetWindowStart = Time.unscaledTime;
				_budgetSpent = 0;
			}
		}

		private static void UpdateSlots(SoundManager sm)
		{
			if (MixtapeBridge.Which(sm) != MixtapeBridge.Tape.Local)
			{
				return;
			}
			int num = Refl.SongIndex.Invoke(sm);
			LocalTrack localTrack = PlaylistLibrary.TrackAt(num);
			if (localTrack == null)
			{
				return;
			}
			uint num2 = Ids.For(localTrack);
			if (num2 != _slot0)
			{
				_slot0 = num2;
				Register(localTrack, num2);
				foreach (Subscriber value in Subs.Values)
				{
					value.Credit = 0;
				}
			}
			int count = PlaylistLibrary.Tracks.Count;
			if (count <= 1)
			{
				return;
			}
			LocalTrack localTrack2 = PlaylistLibrary.TrackAt((num + 1) % count);
			if (localTrack2 != null)
			{
				uint num3 = Ids.For(localTrack2);
				if (num3 != _slot1)
				{
					_slot1 = num3;
					Register(localTrack2, num3);
				}
			}
		}

		private static void Register(LocalTrack track, uint id)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (!Catalogue.ContainsKey(id))
			{
				long length;
				try
				{
					length = new FileInfo(track.Path).Length;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("Cannot offer " + track.Path + ": " + ex.Message));
					return;
				}
				Sending s = new Sending
				{
					TrackId = id,
					Path = track.Path,
					Bytes = length,
					Title = track.Song.Title,
					Artist = track.Song.Artist,
					DurationMs = (uint)Math.Max(0.0, track.Duration * 1000.0),
					Format = FormatOf(track.AudioType),
					LastOfferAt = -999f
				};
				Catalogue[id] = s;
				ThreadPool.QueueUserWorkItem(delegate
				{
					ComputeCrc(s);
				});
			}
		}

		private static void ComputeCrc(Sending s)
		{
			uint crc = 0u;
			try
			{
				byte[] array = new byte[65536];
				using FileStream fileStream = new FileStream(s.Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, array.Length);
				int count;
				while ((count = fileStream.Read(array, 0, array.Length)) > 0)
				{
					crc = Crc32.Update(crc, array, 0, count);
				}
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Exception e = ex2;
				MainThread.Post(delegate
				{
					Plugin.Log.LogWarning((object)("Checksumming " + s.Path + " failed: " + e.Message));
				});
				return;
			}
			MainThread.Post(delegate
			{
				s.Crc32 = crc;
				s.CrcReady = true;
			});
		}

		private static WireFormat FormatOf(AudioType t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if ((int)t <= 13)
			{
				if ((int)t == 2)
				{
					return WireFormat.Aiff;
				}
				if ((int)t == 13)
				{
					return WireFormat.Mp3;
				}
			}
			else
			{
				if ((int)t == 14)
				{
					return WireFormat.Ogg;
				}
				if ((int)t == 20)
				{
					return WireFormat.Wav;
				}
			}
			return WireFormat.Unknown;
		}

		private static void SendBeacons(SoundManager sm)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			bool num = MixtapeBridge.Which(sm) == MixtapeBridge.Tape.Local;
			AudioSource val = Refl.MixtapeMusic.Invoke(sm);
			uint posMs = 0u;
			long sentUs = Clock.NowUs();
			if (num && (Object)(object)val != (Object)null && (Object)(object)val.clip != (Object)null && !MixtapeBridge.IsSilence(val.clip) && val.clip.frequency > 0)
			{
				posMs = (uint)((long)val.timeSamples * 1000L / val.clip.frequency);
			}
			BeaconFlags flags = ((!num) ? BeaconFlags.Paused : ((!Refl.IsPlayingFlag.Invoke(sm)) ? BeaconFlags.Paused : ((!((Object)(object)val != (Object)null) || !((Object)(object)val.clip != (Object)null) || !MixtapeBridge.IsSilence(val.clip)) ? BeaconFlags.Playing : BeaconFlags.Buffering)));
			Beacon beacon = new Beacon
			{
				SessionId = _sessionId,
				TrackId = _slot0,
				Seq = _seq++,
				SentUs = sentUs,
				PosMs = posMs,
				Flags = flags,
				NextTrackId = _slot1
			};
			foreach (Subscriber value in Subs.Values)
			{
				P2PTransport.SendBeacon(value.Id, (byte[] b) => Messages.EncodeBeacon(b, in beacon));
			}
			SendOffers();
		}

		private static void SendOffers()
		{
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			uint[] array = new uint[2] { _slot0, _slot1 };
			foreach (uint num in array)
			{
				if (num == 0 || !Catalogue.TryGetValue(num, out var value) || !value.CrcReady || Time.unscaledTime - value.LastOfferAt < 2f)
				{
					continue;
				}
				value.LastOfferAt = Time.unscaledTime;
				Offer offer = new Offer
				{
					SessionId = _sessionId,
					Slot = ((num != _slot0) ? ((byte)1) : ((byte)0)),
					TrackId = value.TrackId,
					Bytes = (uint)Math.Min(value.Bytes, 4294967295L),
					DurationMs = value.DurationMs,
					Format = value.Format,
					Crc32 = value.Crc32,
					Title = value.Title,
					Artist = value.Artist
				};
				foreach (Subscriber value2 in Subs.Values)
				{
					if (!value2.Has.Contains(num))
					{
						P2PTransport.SendControl(value2.Id, (byte[] b) => Messages.EncodeOffer(b, in offer));
					}
				}
			}
		}

		private static void PumpTransfers()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			foreach (Subscriber value2 in Subs.Values)
			{
				if (value2.Credit <= 0 || value2.WantedTrack == 0 || !Catalogue.TryGetValue(value2.WantedTrack, out var value))
				{
					continue;
				}
				if (_budgetSpent >= 524288)
				{
					break;
				}
				if (P2PTransport.QueuedBytes(value2.Id) > 524288)
				{
					continue;
				}
				bool pastEnd;
				int num = ReadChunk(value, value2.Cursor, out pastEnd);
				if (pastEnd || num <= 0)
				{
					value2.Credit = 0;
					continue;
				}
				uint session = _sessionId;
				uint track = value.TrackId;
				uint idx = value2.Cursor;
				int count = num;
				if (P2PTransport.SendBulk(value2.Id, (byte[] b) => Messages.EncodeData(b, session, track, idx, ChunkBuf, 0, count)))
				{
					value2.Cursor++;
					value2.Credit--;
					_budgetSpent += count;
				}
				else
				{
					value2.Credit = 0;
				}
			}
		}

		private static int ReadChunk(Sending s, uint index, out bool pastEnd)
		{
			pastEnd = false;
			long num = (long)index * 32768L;
			if (num >= s.Bytes)
			{
				pastEnd = true;
				return 0;
			}
			int num2 = (int)Math.Min(32768L, s.Bytes - num);
			try
			{
				using FileStream fileStream = new FileStream(s.Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096);
				fileStream.Seek(num, SeekOrigin.Begin);
				int i;
				int num3;
				for (i = 0; i < num2; i += num3)
				{
					num3 = fileStream.Read(ChunkBuf, i, num2 - i);
					if (num3 <= 0)
					{
						break;
					}
				}
				return i;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Reading a chunk of " + s.Path + " failed: " + ex.Message));
				return 0;
			}
		}

		private static string NameOf(CSteamID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!Discovery.TryGetPeer(id, out var peer))
			{
				return id.m_SteamID.ToString();
			}
			return peer.Name;
		}
	}
	public static class Clock
	{
		private static readonly Stopwatch Watch = Stopwatch.StartNew();

		public static long NowUs()
		{
			return Watch.ElapsedTicks / (Stopwatch.Frequency / 1000000);
		}
	}
	public static class Ids
	{
		public static uint For(LocalTrack track)
		{
			if (track == null)
			{
				return 0u;
			}
			long num = 0L;
			long num2 = 0L;
			try
			{
				FileInfo fileInfo = new FileInfo(track.Path);
				num = fileInfo.Length;
				num2 = fileInfo.LastWriteTimeUtc.Ticks;
			}
			catch (Exception)
			{
			}
			uint num3 = 2166136261u;
			string text = track.Path ?? "";
			for (int i = 0; i < text.Length; i++)
			{
				num3 = (num3 ^ text[i]) * 16777619;
			}
			num3 = (num3 ^ (uint)(int)num) * 16777619;
			num3 = (num3 ^ (uint)(int)num2) * 16777619;
			if (num3 != 0)
			{
				return num3;
			}
			return 1u;
		}
	}
	public static class Listener
	{
		private sealed class Transfer
		{
			public Offer Offer;

			public Spool Spool;

			public string PartPath;

			public string FinalPath;

			public float LastWantAt;

			public bool Loading;

			public bool Failed;
		}

		private const float WantInterval = 1f;

		private const float PingInterval = 2f;

		private const float BroadcasterTimeout = 3f;

		private const ushort WantWindow = 8;

		private static readonly Dictionary<uint, Transfer> Transfers = new Dictionary<uint, Transfer>();

		private static readonly byte[] ChunkBuf = new byte[32768];

		private static readonly SyncMath.OffsetEstimator Offsets = new SyncMath.OffsetEstimator();

		private static readonly SyncMath.Smoother ErrorSmoother = new SyncMath.Smoother();

		private static CSteamID _host;

		private static uint _sessionId;

		private static float _lastBeaconAt;

		private static float _lastPingAt;

		private static Beacon _beacon;

		private static bool _haveBeacon;

		private static uint _playingTrack;

		private const long MaxTrackBytes = 67108864L;

		private const long MaxCacheBytes = 536870912L;

		private const int MaxConcurrentTransfers = 4;

		private static string _shownOnTape;

		public static bool Active { get; private set; }

		public static CSteamID Host => _host;

		public static string Status { get; private set; } = "";

		private static string CacheDir => Path.Combine(Application.temporaryCachePath, "OTLP-shared");

		public static void Join(CSteamID host)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || !(host == _host))
			{
				Leave();
				_host = host;
				Active = true;
				_haveBeacon = false;
				_lastBeaconAt = Time.unscaledTime;
				Offsets.Reset();
				ErrorSmoother.Reset();
				Status = "Connecting...";
				LiveTape.ShowStatus("Connecting...", NameOf(host));
				P2PTransport.SendControl(host, (byte[] b) => Messages.Sub(b, subscribe: true));
				Plugin.Log.LogInfo((object)("Asked " + NameOf(host) + " to share."));
			}
		}

		public static void Leave()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			P2PTransport.SendControl(_host, (byte[] b) => Messages.Sub(b, subscribe: false));
			P2PTransport.CloseChannels(_host);
			Active = false;
			_haveBeacon = false;
			_playingTrack = 0u;
			Status = "";
			foreach (Transfer value in Transfers.Values)
			{
				value.Spool?.Dispose();
			}
			Transfers.Clear();
			LiveTape.Clear();
			Plugin.Log.LogInfo((object)"Stopped listening.");
		}

		public static void OnMessage(CSteamID from, MsgType type, byte[] buf, int off, int len)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (Active && !(from != _host))
			{
				switch (type)
				{
				case MsgType.SubAck:
					OnSubAck(new Wire.Reader(buf, off, len));
					break;
				case MsgType.Offer:
					OnOffer(new Wire.Reader(buf, off, len));
					break;
				case MsgType.Data:
					OnData(new Wire.Reader(buf, off, len));
					break;
				case MsgType.Beacon:
					OnBeacon(new Wire.Reader(buf, off, len));
					break;
				case MsgType.Pong:
					OnPong(new Wire.Reader(buf, off, len));
					break;
				case MsgType.Bye:
					OnBye();
					break;
				}
			}
		}

		private static void OnSubAck(Wire.Reader r)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			bool flag = r.U8() != 0;
			SubReason r2 = (SubReason)r.U8();
			uint sessionId = r.U32();
			if (!r.Failed)
			{
				if (!flag)
				{
					Status = Describe(r2);
					LiveTape.ShowStatus(Status, NameOf(_host));
					Plugin.Log.LogInfo((object)("Refused: " + r2.ToString() + "."));
					Active = false;
				}
				else
				{
					_sessionId = sessionId;
					Status = "Waiting for audio";
					LiveTape.ShowStatus(Status, NameOf(_host));
				}
			}
		}

		private static string Describe(SubReason r)
		{
			return r switch
			{
				SubReason.Full => "That session is full", 
				SubReason.NotBroadcasting => "They stopped sharing", 
				SubReason.VersionMismatch => "Different mod version", 
				_ => "Refused", 
			};
		}

		private static void OnOffer(Wire.Reader r)
		{
			if (!Messages.DecodeOffer(r, out var o) || o.Bytes == 0 || o.ChunkCount <= 0 || (long)o.Bytes > 67108864L || o.Format == WireFormat.Unknown)
			{
				return;
			}
			if (Transfers.TryGetValue(o.TrackId, out var value))
			{
				value.Offer = o;
				if (value.Spool != null)
				{
					value.Spool.SessionId = o.SessionId;
				}
				return;
			}
			if (OpenTransfers() >= 4)
			{
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Ignoring an offer: already receiving " + 4 + "."));
				}
				return;
			}
			if (CacheBytes() + o.Bytes > 536870912)
			{
				Plugin.Log.LogWarning((object)("The shared-music cache has reached " + 512L + " MB; refusing more for now."));
				return;
			}
			string text = CachePath(o.TrackId, Extension(o.Format));
			if (File.Exists(text))
			{
				Transfer value2 = new Transfer
				{
					Offer = o,
					FinalPath = text
				};
				Transfers[o.TrackId] = value2;
				Send((byte[] b) => Messages.Have(b, _sessionId, o.TrackId));
				MaybePlay(o.TrackId);
				return;
			}
			string text2 = text + ".part";
			Spool spool;
			try
			{
				Directory.CreateDirectory(CacheDir);
				FileStream fs = new FileStream(text2, FileMode.Create, FileAccess.Write, FileShare.Read, 65536);
				spool = new Spool(o.TrackId, o.SessionId, o.Bytes, o.Crc32, new FileChunkStore(fs));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Cannot open a cache file for the shared track: " + ex.Message));
				return;
			}
			Transfers[o.TrackId] = new Transfer
			{
				Offer = o,
				Spool = spool,
				PartPath = text2,
				FinalPath = text,
				LastWantAt = -999f
			};
			if (ModConfig.VerboseLogging.Value)
			{
				Plugin.Log.LogInfo((object)("Offered '" + o.Title + "' (" + o.Bytes / 1024 + " KiB, " + o.ChunkCount + " chunks)."));
			}
		}

		private static int OpenTransfers()
		{
			int num = 0;
			foreach (Transfer value in Transfers.Values)
			{
				if (value.Spool != null)
				{
					num++;
				}
			}
			return num;
		}

		private static long CacheBytes()
		{
			try
			{
				if (!Directory.Exists(CacheDir))
				{
					return 0L;
				}
				long num = 0L;
				string[] files = Directory.GetFiles(CacheDir);
				foreach (string fileName in files)
				{
					num += new FileInfo(fileName).Length;
				}
				return num;
			}
			catch (Exception)
			{
				return 0L;
			}
		}

		private static bool LooksLikeAudio(string path, WireFormat format)
		{
			try
			{
				byte[] array = new byte[12];
				using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
				{
					if (fileStream.Read(array, 0, array.Length) < 4)
					{
						return false;
					}
				}
				return format switch
				{
					WireFormat.Mp3 => (array[0] == 73 && array[1] == 68 && array[2] == 51) || (array[0] == byte.MaxValue && (array[1] & 0xE0) == 224), 
					WireFormat.Ogg => array[0] == 79 && array[1] == 103 && array[2] == 103 && array[3] == 83, 
					WireFormat.Wav => array[0] == 82 && array[1] == 73 && array[2] == 70 && array[3] == 70 && array[8] == 87 && array[9] == 65 && array[10] == 86 && array[11] == 69, 
					WireFormat.Aiff => array[0] == 70 && array[1] == 79 && array[2] == 82 && array[3] == 77, 
					_ => false, 
				};
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void OnData(Wire.Reader r)
		{
			if (!Messages.DecodeData(r, ChunkBuf, out var sessionId, out var trackId, out var chunkIdx, out var count) || sessionId != _sessionId || !Transfers.TryGetValue(trackId, out var value) || value.Spool == null || !value.Spool.Accept(chunkIdx, ChunkBuf, count) || !value.Spool.Complete)
			{
				return;
			}
			value.Spool.Flush();
			value.Spool.Dispose();
			value.Spool = null;
			if (!Verify(value))
			{
				value.Failed = true;
				Plugin.Log.LogWarning((object)"The shared track arrived corrupt; discarding it.");
				SafeDelete(value.PartPath);
				Transfers.Remove(trackId);
				return;
			}
			if (!LooksLikeAudio(value.PartPath, value.Offer.Format))
			{
				value.Failed = true;
				Plugin.Log.LogWarning((object)("A peer sent something that is not " + value.Offer.Format.ToString() + " audio; discarding it without decoding."));
				SafeDelete(value.PartPath);
				Transfers.Remove(trackId);
				return;
			}
			try
			{
				if (File.Exists(value.FinalPath))
				{
					File.Delete(value.FinalPath);
				}
				File.Move(value.PartPath, value.FinalPath);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not finish the shared track: " + ex.Message));
				return;
			}
			Plugin.Log.LogInfo((object)("Received '" + value.Offer.Title + "'."));
			Send((byte[] b) => Messages.Have(b, _sessionId, trackId));
			MaybePlay(trackId);
		}

		private static bool Verify(Transfer t)
		{
			try
			{
				uint num = 0u;
				byte[] array = new byte[65536];
				using (FileStream fileStream = new FileStream(t.PartPath, FileMode.Open, FileAccess.Read))
				{
					int count;
					while ((count = fileStream.Read(array, 0, array.Length)) > 0)
					{
						num = Crc32.Update(num, array, 0, count);
					}
				}
				return num == t.Offer.Crc32;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void OnBeacon(Wire.Reader r)
		{
			if (Messages.DecodeBeacon(r, out var b) && b.SessionId == _sessionId)
			{
				_beacon = b;
				_haveBeacon = true;
				_lastBeaconAt = Time.unscaledTime;
				MaybePlay(b.TrackId);
			}
		}

		private static void OnPong(Wire.Reader r)
		{
			long t0Us = r.I64();
			long t1Us = r.I64();
			if (!r.Failed)
			{
				long t3Us = Clock.NowUs();
				Offsets.Push(SyncMath.Offset(t0Us, t1Us, t3Us), SyncMath.RoundTrip(t0Us, t3Us));
			}
		}

		private static void OnBye()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Status = "They stopped sharing";
			LiveTape.ShowStatus(Status, NameOf(_host));
			Leave();
		}

		public static void Tick(SoundManager sm)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			if (Time.unscaledTime - _lastBeaconAt > 3f && _haveBeacon)
			{
				Status = "Lost the broadcaster";
				LiveTape.ShowStatus(Status, NameOf(_host));
				_haveBeacon = false;
			}
			if (Time.unscaledTime - _lastPingAt >= 2f)
			{
				_lastPingAt = Time.unscaledTime;
				long t0 = Clock.NowUs();
				Send((byte[] b) => Messages.Ping(b, t0));
			}
			RequestChunks();
			UpdateStatus();
			Follow(sm);
		}

		private static void RequestChunks()
		{
			foreach (Transfer value in Transfers.Values)
			{
				if (value.Spool != null && !value.Failed && !(Time.unscaledTime - value.LastWantAt < 1f))
				{
					value.LastWantAt = Time.unscaledTime;
					Want want = new Want
					{
						SessionId = _sessionId,
						TrackId = value.Offer.TrackId,
						FromChunk = (uint)value.Spool.FirstMissing,
						Window = 8
					};
					Send((byte[] b) => Messages.EncodeWant(b, in want));
				}
			}
		}

		private static void UpdateStatus()
		{
			if (_haveBeacon)
			{
				if (Transfers.TryGetValue(_beacon.TrackId, out var value) && value.Spool != null)
				{
					Status = "Buffering " + Mathf.RoundToInt(value.Spool.Progress * 100f) + "%";
					PushToTape(Status, value.Offer.Title);
				}
				else if (_playingTrack == _beacon.TrackId)
				{
					Status = "Listening";
				}
			}
		}

		private static void PushToTape(string title, string artist)
		{
			LiveTape.ShowStatus(title, artist);
			if (title == _shownOnTape)
			{
				return;
			}
			_shownOnTape = title;
			SoundManager i = MonoSingleton<SoundManager>.I;
			if ((Object)(object)i == (Object)null || MixtapeBridge.Which(i) != MixtapeBridge.Tape.Live)
			{
				return;
			}
			UIManager i2 = MonoSingleton<UIManager>.I;
			if ((Object)(object)i2 == (Object)null)
			{
				return;
			}
			try
			{
				i2.UpdateSongInfo(i.GetSong());
			}
			catch (Exception)
			{
			}
		}

		private static void MaybePlay(uint trackId)
		{
			if (_haveBeacon && _beacon.TrackId == trackId && _playingTrack != trackId && Transfers.TryGetValue(trackId, out var value) && value.Spool == null && !value.Failed && !value.Loading && !string.IsNullOrEmpty(value.FinalPath) && File.Exists(value.FinalPath))
			{
				value.Loading = true;
				ModRoot.Run(LoadAndHandOver(value));
			}
		}

		private static IEnumerator LoadAndHandOver(Transfer t)
		{
			AudioType val = AudioTypeOf(t.Offer.Format);
			UnityWebRequest uwr = null;
			try
			{
				uwr = UnityWebRequestMultimedia.GetAudioClip(FileUrl.ForRequest(t.FinalPath), val);
				DownloadHandler downloadHandler = uwr.downloadHandler;
				DownloadHandlerAudioClip val2 = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val2 != null)
				{
					val2.streamAudio = true;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not open the shared track: " + ex.Message));
				UnityWebRequest obj = uwr;
				if (obj != null)
				{
					obj.Dispose();
				}
				t.Loading = false;
				yield break;
			}
			yield return uwr.SendWebRequest();
			if ((int)uwr.result != 1)
			{
				Plugin.Log.LogWarning((object)("Decoding the shared track failed: " + uwr.error));
				uwr.Dispose();
				t.Loading = false;
				yield break;
			}
			AudioClip val3 = null;
			try
			{
				val3 = DownloadHandlerAudioClip.GetContent(uwr);
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("Decoding the shared track threw: " + ex2.Message));
			}
			if ((Object)(object)val3 == (Object)null || val3.samples <= 0)
			{
				uwr.Dispose();
				t.Loading = false;
				yield break;
			}
			((Object)val3).name = t.Offer.Title;
			LiveTape.SetTrack(t.Offer.TrackId, t.Offer.Title, t.Offer.Artist, val3);
			_playingTrack = t.Offer.TrackId;
			t.Loading = false;
			Status = "Listening";
			SoundManager i = MonoSingleton<SoundManager>.I;
			if ((Object)(object)i != (Object)null)
			{
				LiveTape.SetName(i, ModConfig.LiveTapeName.Value + ": " + NameOf(_host));
			}
		}

		private static void Follow(SoundManager sm)
		{
			if ((Object)(object)sm == (Object)null || !_haveBeacon || MixtapeBridge.Which(sm) != MixtapeBridge.Tape.Live || _playingTrack == 0 || _playingTrack != _beacon.TrackId)
			{
				return;
			}
			AudioSource val = Refl.MixtapeMusic.Invoke(sm);
			AudioClip val2 = (((Object)(object)val != (Object)null) ? val.clip : null);
			if ((Object)(object)val2 == (Object)null || MixtapeBridge.IsSilence(val2) || val2.frequency <= 0)
			{
				return;
			}
			if ((_beacon.Flags & BeaconFlags.Playing) == 0)
			{
				if (!Mathf.Approximately(val.pitch, 0f))
				{
					val.pitch = 0f;
				}
				return;
			}
			double num = SyncMath.TargetSeconds(_beacon.PosMs, _beacon.SentUs, Clock.NowUs(), Offsets.Best(), (double)Mathf.Max(0, ModConfig.ListenLatencyMs.Value) / 1000.0);
			double num2 = (double)val.timeSamples / (double)val2.frequency;
			double num3 = ((SyncMath.Decide(num - num2) == SyncAction.Seek) ? (num - num2) : ErrorSmoother.Push(num - num2));
			switch (SyncMath.Decide(num3))
			{
			case SyncAction.Hold:
				if (!Mathf.Approximately(val.pitch, 1f))
				{
					val.pitch = 1f;
				}
				break;
			case SyncAction.Nudge:
				val.pitch = SyncMath.PitchFor(num3);
				break;
			case SyncAction.Seek:
			{
				int num4 = Mathf.Max(1, val2.frequency / 4);
				int timeSamples = Mathf.Clamp((int)(num * (double)val2.frequency), 0, Mathf.Max(0, val2.samples - num4));
				val.timeSamples = timeSamples;
				val.pitch = 1f;
				ErrorSmoother.Reset();
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Re-synced by " + num3.ToString("0.00") + " s."));
				}
				break;
			}
			}
		}

		private static void Send(Func<byte[], int> encode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			P2PTransport.SendControl(_host, encode);
		}

		private static string CachePath(uint trackId, string ext)
		{
			return Path.Combine(CacheDir, trackId.ToString("x8") + ext);
		}

		private static string Extension(WireFormat f)
		{
			return f switch
			{
				WireFormat.Mp3 => ".mp3", 
				WireFormat.Ogg => ".ogg", 
				WireFormat.Wav => ".wav", 
				WireFormat.Aiff => ".aiff", 
				_ => ".bin", 
			};
		}

		private static AudioType AudioTypeOf(WireFormat f)
		{
			return (AudioType)(f switch
			{
				WireFormat.Mp3 => 13, 
				WireFormat.Ogg => 14, 
				WireFormat.Wav => 20, 
				WireFormat.Aiff => 2, 
				_ => 0, 
			});
		}

		private static void SafeDelete(string path)
		{
			try
			{
				if (!string.IsNullOrEmpty(path) && File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch (Exception)
			{
			}
		}

		private static string NameOf(CSteamID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!Discovery.TryGetPeer(id, out var peer))
			{
				return id.m_SteamID.ToString();
			}
			return peer.Name;
		}

		public static void ClearCache()
		{
			try
			{
				if (Directory.Exists(CacheDir))
				{
					Directory.Delete(CacheDir, recursive: true);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public sealed class FileChunkStore : IChunkStore, IDisposable
	{
		private readonly FileStream _fs;

		public FileChunkStore(FileStream fs)
		{
			_fs = fs;
		}

		public void Write(long offset, byte[] data, int dataOffset, int count)
		{
			_fs.Seek(offset, SeekOrigin.Begin);
			_fs.Write(data, dataOffset, count);
		}

		public void Flush()
		{
			_fs.Flush(flushToDisk: true);
		}

		public void Dispose()
		{
			_fs.Dispose();
		}
	}
	public static class LiveTape
	{
		public static readonly List<Song> Songs = new List<Song>
		{
			new Song
			{
				Title = "Nobody is sharing",
				Artist = "",
				Music = null,
				Volume = 1f
			}
		};

		private static Song Slot => Songs[0];

		public static bool Injected { get; private set; }

		public static int MixtapeIndex { get; private set; } = -1;

		public static AudioClip Clip { get; private set; }

		public static uint TrackId { get; private set; }

		public static bool HasClip => (Object)(object)Clip != (Object)null;

		public static void EnsureInjected(SoundManager sm)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (Injected || (Object)(object)sm == (Object)null || !ModConfig.SharingEnabled.Value)
			{
				return;
			}
			MusicMixtapes mixtapes = sm.Mixtapes;
			if ((Object)(object)mixtapes == (Object)null || mixtapes.MixTapes == null)
			{
				return;
			}
			for (int i = 0; i < mixtapes.MixTapes.Count; i++)
			{
				if (mixtapes.MixTapes[i].Songs == Songs)
				{
					MixtapeIndex = i;
					Injected = true;
					return;
				}
			}
			Sprite val = BorrowCover(mixtapes);
			mixtapes.MixTapes.Add(new Mixtape
			{
				MixtapeName = ModConfig.LiveTapeName.Value,
				Songs = Songs,
				IsSummerDLC = false,
				MixtapeCover = val,
				MixtapeStreamerCover = val
			});
			MixtapeIndex = mixtapes.MixTapes.Count - 1;
			Injected = true;
			Plugin.Log.LogInfo((object)("Injected the shared-listening tape at index " + MixtapeIndex + "."));
		}

		private static Sprite BorrowCover(MusicMixtapes asset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < asset.MixTapes.Count; i++)
			{
				Sprite mixtapeCover = asset.MixTapes[i].MixtapeCover;
				if ((Object)(object)mixtapeCover != (Object)null)
				{
					return mixtapeCover;
				}
			}
			return null;
		}

		public static void SetName(SoundManager sm, string name)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (!Injected || (Object)(object)sm == (Object)null)
			{
				return;
			}
			MusicMixtapes mixtapes = sm.Mixtapes;
			if (!((Object)(object)mixtapes == (Object)null) && MixtapeIndex >= 0 && MixtapeIndex < mixtapes.MixTapes.Count)
			{
				Mixtape val = mixtapes.MixTapes[MixtapeIndex];
				if (!(val.MixtapeName == name))
				{
					val.MixtapeName = name;
					mixtapes.MixTapes[MixtapeIndex] = val;
				}
			}
		}

		public static void ShowStatus(string title, string artist)
		{
			Slot.Title = title ?? "";
			Slot.Artist = artist ?? "";
		}

		public static void SetTrack(uint trackId, string title, string artist, AudioClip clip)
		{
			ReleaseClip();
			TrackId = trackId;
			Clip = clip;
			Slot.Title = title ?? "";
			Slot.Artist = artist ?? "";
			Slot.Music = clip;
			Slot.Volume = 1f;
		}

		public static void Clear()
		{
			ReleaseClip();
			TrackId = 0u;
			Slot.Title = "Nobody is sharing";
			Slot.Artist = "";
		}

		private static void ReleaseClip()
		{
			Slot.Music = null;
			if (!((Object)(object)Clip == (Object)null))
			{
				try
				{
					Object.Destroy((Object)(object)Clip);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Releasing the shared clip failed: " + ex));
				}
				Clip = null;
			}
		}

		public static void Neutralise(AudioClip filler)
		{
			if ((Object)(object)Slot.Music == (Object)null)
			{
				Slot.Music = filler;
			}
		}
	}
	public enum ShareMode
	{
		Off,
		Broadcasting,
		Listening
	}
	public static class ShareController
	{
		private static bool _initialised;

		public static ShareMode Mode
		{
			get
			{
				if (Listener.Active)
				{
					return ShareMode.Listening;
				}
				if (Broadcaster.Active)
				{
					return ShareMode.Broadcasting;
				}
				return ShareMode.Off;
			}
		}

		public static bool CanBroadcast
		{
			get
			{
				CSteamID lobby;
				if (_initialised && PlaylistLibrary.Tracks.Count > 0)
				{
					return Discovery.TryGetLobby(out lobby);
				}
				return false;
			}
		}

		public static bool AnyoneBroadcasting
		{
			get
			{
				foreach (Peer peer in Discovery.Peers)
				{
					if (peer.Broadcasting)
					{
						return true;
					}
				}
				return false;
			}
		}

		public static string StatusLine
		{
			get
			{
				if (!_initialised)
				{
					return "";
				}
				switch (Mode)
				{
				case ShareMode.Listening:
					if (!string.IsNullOrEmpty(Listener.Status))
					{
						return Listener.Status;
					}
					return "Listening";
				case ShareMode.Broadcasting:
				{
					int listenerCount = Broadcaster.ListenerCount;
					if (listenerCount != 0)
					{
						return "Sharing to " + listenerCount + ((listenerCount == 1) ? " person" : " people");
					}
					return "Sharing - nobody yet";
				}
				default:
				{
					int num = 0;
					foreach (Peer peer in Discovery.Peers)
					{
						if (peer.Broadcasting)
						{
							num++;
						}
					}
					if (num <= 0)
					{
						return "";
					}
					return num + " sharing nearby";
				}
				}
			}
		}

		public static string ShareButtonLabel
		{
			get
			{
				if (!Broadcaster.Active)
				{
					return "Share";
				}
				return "Stop";
			}
		}

		public static string ListenButtonLabel
		{
			get
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (!Listener.Active)
				{
					return "Listen";
				}
				if (!(NextBroadcaster(Listener.Host) == CSteamID.Nil))
				{
					return "Next";
				}
				return "Leave";
			}
		}

		public static void Init()
		{
			if (!_initialised && ModConfig.SharingEnabled.Value)
			{
				_initialised = true;
				P2PTransport.PeerFilter = Discovery.IsAllowed;
				P2PTransport.OnMessage += Route;
				P2PTransport.OnPeerUnreachable += OnUnreachable;
				P2PTransport.Start();
				Plugin.Log.LogInfo((object)("Sharing ready (channels " + 2 + "/" + 3 + "/" + 4 + ")."));
			}
		}

		public static void Shutdown()
		{
			if (_initialised)
			{
				_initialised = false;
				Listener.Leave();
				Broadcaster.Stop();
				Discovery.Advertise(present: false, broadcasting: false);
				P2PTransport.OnMessage -= Route;
				P2PTransport.OnPeerUnreachable -= OnUnreachable;
				P2PTransport.Stop(PeerIds());
				Discovery.Reset();
				Listener.ClearCache();
			}
		}

		private static IEnumerable<CSteamID> PeerIds()
		{
			foreach (Peer peer in Discovery.Peers)
			{
				yield return peer.Id;
			}
		}

		public static void ToggleBroadcast()
		{
			if (_initialised)
			{
				if (Broadcaster.Active)
				{
					Broadcaster.Stop();
					Discovery.Advertise(present: true, broadcasting: false);
				}
				else if (!CanBroadcast)
				{
					Plugin.Log.LogInfo((object)"Nothing to broadcast: no lobby, or no local tracks.");
				}
				else
				{
					Listener.Leave();
					Broadcaster.Start();
					Discovery.Advertise(present: true, broadcasting: true);
				}
			}
		}

		public static void ToggleListen()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialised)
			{
				return;
			}
			CSteamID val = NextBroadcaster(Listener.Active ? Listener.Host : CSteamID.Nil);
			if (val == CSteamID.Nil || (Listener.Active && val == Listener.Host))
			{
				if (Listener.Active)
				{
					Listener.Leave();
				}
				else
				{
					Plugin.Log.LogInfo((object)"Nobody in this lobby is sharing.");
				}
			}
			else
			{
				Broadcaster.Stop();
				Discovery.Advertise(present: true, broadcasting: false);
				Listener.Join(val);
			}
		}

		private static CSteamID NextBroadcaster(CSteamID after)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = after == CSteamID.Nil;
			foreach (Peer peer in Discovery.Peers)
			{
				if (peer.Broadcasting)
				{
					if (flag)
					{
						return peer.Id;
					}
					if (peer.Id == after)
					{
						flag = true;
					}
				}
			}
			return CSteamID.Nil;
		}

		public static void Tick()
		{
			if (_initialised)
			{
				SoundManager sm = SoundManagerOrNull();
				Discovery.Advertise(present: true, Broadcaster.Active);
				Discovery.Tick();
				P2PTransport.Pump();
				Broadcaster.Tick(sm);
				Listener.Tick(sm);
			}
		}

		public static void OnLeaveLobby()
		{
			if (_initialised)
			{
				Listener.Leave();
				Broadcaster.Stop();
				Discovery.Advertise(present: false, broadcasting: false);
				Discovery.Reset();
			}
		}

		private static void Route(CSteamID from, MsgType type, byte[] buf, int off, int len)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Broadcaster.Active)
			{
				Broadcaster.OnMessage(from, type, buf, off, len);
			}
			if (Listener.Active)
			{
				Listener.OnMessage(from, type, buf, off, len);
			}
		}

		private static void OnUnreachable(CSteamID peer, EP2PSessionError error)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Broadcaster.OnPeerUnreachable(peer);
		}

		private static SoundManager SoundManagerOrNull()
		{
			try
			{
				return MonoSingleton<SoundManager>.I;
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.Playlist
{
	public static class ClipCache
	{
		private struct LoadResult
		{
			public bool ok;

			public string error;
		}

		private const int Window = 1;

		private const int MaxPrefetchLoads = 2;

		private static readonly Dictionary<LocalTrack, Coroutine> InFlight = new Dictionary<LocalTrack, Coroutine>();

		public static void EnsureResidency(int currentIndex)
		{
			List<LocalTrack> tracks = PlaylistLibrary.Tracks;
			if (tracks.Count == 0)
			{
				return;
			}
			Request(PlaylistLibrary.TrackAt(currentIndex), priority: true);
			for (int i = 1; i <= 1; i++)
			{
				Request(PlaylistLibrary.TrackAt(Wrap(currentIndex + i, tracks.Count)), priority: false);
				Request(PlaylistLibrary.TrackAt(Wrap(currentIndex - i, tracks.Count)), priority: false);
			}
			for (int j = 0; j < tracks.Count; j++)
			{
				if (Distance(j, currentIndex, tracks.Count) <= 1)
				{
					continue;
				}
				LocalTrack localTrack = tracks[j];
				if (!((Object)(object)localTrack.Clip == (Object)null) && !InFlight.ContainsKey(localTrack))
				{
					if (ModConfig.VerboseLogging.Value)
					{
						Plugin.Log.LogInfo((object)("Evicting clip: " + localTrack.Song.Title));
					}
					localTrack.Unload();
				}
			}
		}

		public static void Request(LocalTrack track, bool priority)
		{
			if (track != null && track.State != TrackState.Ready && track.State != TrackState.Failed && !InFlight.ContainsKey(track) && (priority || InFlight.Count < 2))
			{
				track.State = TrackState.Loading;
				Coroutine val = ModRoot.Run(LoadRoutine(track));
				if (val == null)
				{
					track.State = TrackState.Idle;
				}
				else
				{
					InFlight[track] = val;
				}
			}
		}

		private static IEnumerator LoadRoutine(LocalTrack track)
		{
			bool ok = false;
			string error = null;
			yield return TryLoad(track, FileUrl.ForRequest(track.Path), delegate(LoadResult r)
			{
				ok = r.ok;
				error = r.error;
			});
			if (!ok)
			{
				string text = FileUrl.FallbackUri(track.Path);
				if (text != null)
				{
					if (ModConfig.VerboseLogging.Value)
					{
						Plugin.Log.LogInfo((object)("Raw path failed for " + track.Path + " (" + error + "), retrying as URI."));
					}
					yield return TryLoad(track, text, delegate(LoadResult r)
					{
						ok = r.ok;
						error = r.error;
					});
				}
			}
			InFlight.Remove(track);
			if (!ok)
			{
				track.MarkFailed(error ?? "load failed");
				Plugin.Log.LogWarning((object)("Could not load " + track.Path + ": " + error));
				MixtapeBridge.OnTrackFailed(track);
			}
			else
			{
				track.State = TrackState.Ready;
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Loaded " + track.Song.Title + " (" + track.Clip.length.ToString("0.0") + "s)"));
				}
				MixtapeBridge.OnTrackReady(track);
			}
			MixtapeBridge.ReArmResidency();
		}

		private static IEnumerator TryLoad(LocalTrack track, string url, Action<LoadResult> done)
		{
			UnityWebRequest uwr = null;
			LoadResult result = default(LoadResult);
			try
			{
				uwr = UnityWebRequestMultimedia.GetAudioClip(url, track.AudioType);
				DownloadHandler downloadHandler = uwr.downloadHandler;
				DownloadHandlerAudioClip val = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val != null)
				{
					val.streamAudio = true;
				}
				track.PendingRequest = uwr;
			}
			catch (Exception ex)
			{
				result.error = ex.Message;
				if (uwr != null)
				{
					uwr.Dispose();
				}
				track.PendingRequest = null;
				uwr = null;
			}
			if (uwr == null)
			{
				done(result);
				yield break;
			}
			yield return uwr.SendWebRequest();
			if ((int)uwr.result != 1)
			{
				result.error = uwr.error ?? ((object)uwr.result/*cast due to .constrained prefix*/).ToString();
				track.PendingRequest = null;
				uwr.Dispose();
				done(result);
				yield break;
			}
			AudioClip val2 = null;
			try
			{
				val2 = DownloadHandlerAudioClip.GetContent(uwr);
			}
			catch (Exception ex2)
			{
				result.error = ex2.Message;
			}
			if ((Object)(object)val2 == (Object)null || val2.samples <= 0 || val2.channels <= 0)
			{
				result.error = result.error ?? "decoder produced no audio";
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
				track.PendingRequest = null;
				uwr.Dispose();
				done(result);
			}
			else
			{
				((Object)val2).name = track.Song.Title;
				track.Clip = val2;
				track.Request = uwr;
				track.PendingRequest = null;
				track.Song.Music = val2;
				result.ok = true;
				done(result);
			}
		}

		public static void CancelInFlight()
		{
			foreach (KeyValuePair<LocalTrack, Coroutine> item in InFlight)
			{
				ModRoot.Stop(item.Value);
				item.Key.DisposePending();
				if (item.Key.State == TrackState.Loading)
				{
					item.Key.State = TrackState.Idle;
				}
			}
			InFlight.Clear();
		}

		private static int Wrap(int i, int count)
		{
			return (i % count + count) % count;
		}

		private static int Distance(int a, int b, int count)
		{
			int num = Math.Abs(a - b);
			return Math.Min(num, count - num);
		}
	}
	public static class FileUrl
	{
		public static string ForRequest(string fullPath)
		{
			return fullPath;
		}

		public static string FallbackUri(string fullPath)
		{
			try
			{
				return new Uri(fullPath).AbsoluteUri;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static bool IsUnc(string path)
		{
			if (string.IsNullOrEmpty(path) || path.Length < 2)
			{
				return false;
			}
			char c = path[0];
			char c2 = path[1];
			if (c == '\\' || c == '/')
			{
				if (c2 != '\\')
				{
					return c2 == '/';
				}
				return true;
			}
			return false;
		}
	}
	public static class FolderWatcher
	{
		private const float CeilingSeconds = 20f;

		private static FileSystemWatcher _fsw;

		private static string _watching;

		private static volatile bool _dirty;

		private static bool _pending;

		private static float _quietUntil;

		private static float _ceilingAt;

		private static int _eventsSeen;

		public static bool IsWatching => _fsw != null;

		public static void Sync()
		{
			string text = (ModConfig.MusicFolder.Value ?? "").Trim().Trim('"');
			if (!ModConfig.WatchFolder.Value || text.Length <= 0 || FileUrl.IsUnc(text) || !SafeExists(text))
			{
				Disarm();
			}
			else if (_fsw == null || !string.Equals(_watching, text, StringComparison.OrdinalIgnoreCase))
			{
				Disarm();
				Arm(text);
			}
		}

		private static bool SafeExists(string folder)
		{
			try
			{
				return Directory.Exists(folder);
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void Arm(string folder)
		{
			try
			{
				_fsw = new FileSystemWatcher(folder)
				{
					InternalBufferSize = 65536,
					IncludeSubdirectories = ModConfig.IncludeSubfolders.Value,
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size | NotifyFilters.LastWrite)
				};
				_fsw.Created += OnChanged;
				_fsw.Deleted += OnChanged;
				_fsw.Changed += OnChanged;
				_fsw.Renamed += OnRenamed;
				_fsw.Error += OnError;
				_fsw.EnableRaisingEvents = true;
				_watching = folder;
				Plugin.Log.LogInfo((object)("Watching " + folder + " for changes."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not watch " + folder + " (" + ex.Message + "). Use the Reload button instead."));
				Disarm();
			}
		}

		public static void Disarm()
		{
			if (_fsw != null)
			{
				try
				{
					_fsw.EnableRaisingEvents = false;
					_fsw.Created -= OnChanged;
					_fsw.Deleted -= OnChanged;
					_fsw.Changed -= OnChanged;
					_fsw.Renamed -= OnRenamed;
					_fsw.Error -= OnError;
					_fsw.Dispose();
				}
				catch (Exception)
				{
				}
				_fsw = null;
				_watching = null;
				_pending = false;
				_dirty = false;
			}
		}

		private static void OnChanged(object sender, FileSystemEventArgs e)
		{
			_dirty = true;
		}

		private static void OnRenamed(object sender, RenamedEventArgs e)
		{
			_dirty = true;
		}

		private static void OnError(object sender, ErrorEventArgs e)
		{
			_dirty = true;
		}

		public static void Tick()
		{
			if (_fsw == null)
			{
				return;
			}
			if (_dirty)
			{
				_dirty = false;
				_eventsSeen++;
				float num = Mathf.Max(0.1f, (float)ModConfig.WatchDebounceMs.Value / 1000f);
				_quietUntil = Time.unscaledTime + num;
				if (!_pending)
				{
					_pending = true;
					_ceilingAt = Time.unscaledTime + 20f;
				}
			}
			if (_pending && (!(Time.unscaledTime < _quietUntil) || !(Time.unscaledTime < _ceilingAt)))
			{
				bool flag = Time.unscaledTime >= _ceilingAt && Time.unscaledTime < _quietUntil;
				_pending = false;
				Plugin.Log.LogInfo((object)("Music folder settled after " + _eventsSeen + " event(s)" + (flag ? " (still busy, reloading anyway)" : "") + "."));
				_eventsSeen = 0;
				ReloadCoordinator.Request(ReloadReason.Watcher);
			}
		}
	}
	public static class Formats
	{
		public static bool TryGetAudioType(string path, out AudioType type, out string skipReason)
		{
			type = (AudioType)0;
			skipReason = null;
			string extension;
			try
			{
				extension = Path.GetExtension(path);
			}
			catch (ArgumentException)
			{
				skipReason = "unreadable filename";
				return false;
			}
			if (string.IsNullOrEmpty(extension))
			{
				skipReason = "no extension";
				return false;
			}
			extension = extension.ToLowerInvariant();
			switch (extension)
			{
			case ".mp3":
				type = (AudioType)13;
				return true;
			case ".ogg":
				type = (AudioType)14;
				return true;
			case ".wav":
			case ".wave":
				type = (AudioType)20;
				return true;
			case ".aif":
			case ".aiff":
				type = (AudioType)2;
				return true;
			case ".it":
				type = (AudioType)10;
				break;
			case ".mod":
				type = (AudioType)12;
				break;
			case ".s3m":
				type = (AudioType)17;
				break;
			case ".xm":
				type = (AudioType)21;
				break;
			case ".mp4":
			case ".ape":
			case ".aac":
			case ".m4a":
			case ".wma":
			case ".dsf":
			case ".dff":
			case ".mka":
			case ".opus":
			case ".alac":
			case ".flac":
			case ".wv":
				skipReason = extension.Substring(1) + " is not decodable by Unity on Windows";
				return false;
			default:
				return false;
			}
			if (!ModConfig.AllowTrackerFormats.Value)
			{
				type = (AudioType)0;
				skipReason = "tracker format (enable AllowTrackerFormats to include)";
				return false;
			}
			return true;
		}
	}
	public enum TrackState
	{
		Idle,
		Loading,
		Ready,
		Failed
	}
	public sealed class LocalTrack
	{
		public const string FailurePrefix = "! ";

		public readonly string Path;

		public readonly AudioType AudioType;

		public readonly Song Song;

		public TrackState State;

		public AudioClip Clip;

		public UnityWebRequest Request;

		public UnityWebRequest PendingRequest;

		public string FailureReason;

		public double Duration;

		private string _cleanTitle;

		public bool IsResident
		{
			get
			{
				if ((Object)(object)Clip != (Object)null)
				{
					return State == TrackState.Ready;
				}
				return false;
			}
		}

		public LocalTrack(string path, AudioType audioType, TrackTags tags)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			Path = path;
			AudioType = audioType;
			_cleanTitle = tags.Title ?? "";
			Song = new Song
			{
				Title = _cleanTitle,
				Artist = (tags.Artist ?? ""),
				Music = null,
				Volume = 1f
			};
		}

		public void ApplyTags(TrackTags tags)
		{
			if (!string.IsNullOrEmpty(tags.Title))
			{
				_cleanTitle = tags.Title;
			}
			if (!string.IsNullOrEmpty(tags.Artist))
			{
				Song.Artist = tags.Artist;
			}
			Song.Title = ((State == TrackState.Failed) ? ("! " + _cleanTitle) : _cleanTitle);
		}

		public void MarkFailed(string reason)
		{
			State = TrackState.Failed;
			FailureReason = reason;
			Song.Title = "! " + _cleanTitle;
		}

		public void DisposePending()
		{
			if (PendingRequest == null)
			{
				return;
			}
			UnityWebRequest pendingRequest = PendingRequest;
			PendingRequest = null;
			if (pendingRequest != Request)
			{
				try
				{
					pendingRequest.Abort();
				}
				catch (Exception)
				{
				}
				pendingRequest.Dispose();
			}
		}

		public void Unload()
		{
			DisposePending();
			if ((Object)(object)Clip != (Object)null)
			{
				Object.Destroy((Object)(object)Clip);
				Clip = null;
			}
			if (Request != null)
			{
				Request.Dispose();
				Request = null;
			}
			Song.Music = null;
			if (State == TrackState.Ready || State == TrackState.Loading)
			{
				State = TrackState.Idle;
			}
		}
	}
	public static class MixtapeBridge
	{
		public enum Tape
		{
			None,
			Local,
			Live
		}

		private static bool _disabled;

		private static bool _injected;

		private static AudioClip _silence;

		private static AudioClip _longSilence;

		private static float _nextRepairCheck;

		public static bool LocalInjected
		{
			get
			{
				if (_injected)
				{
					return ModConfig.PlaylistEnabled.Value;
				}
				return false;
			}
		}

		public static bool Active
		{
			get
			{
				if (!_disabled && Refl.PlaylistReady)
				{
					if (!LocalInjected)
					{
						return LiveTape.Injected;
					}
					return true;
				}
				return false;
			}
		}

		public static void Disable()
		{
			if (_disabled)
			{
				return;
			}
			_disabled = true;
			try
			{
				ClipCache.CancelInFlight();
				AudioClip val = LongSilence();
				if (_injected)
				{
					foreach (Song song in PlaylistLibrary.Songs)
					{
						if ((Object)(object)song.Music == (Object)null)
						{
							song.Music = val;
						}
					}
				}
				if (LiveTape.Injected)
				{
					LiveTape.Neutralise(val);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Neutralising the local mixtape failed: " + ex));
			}
			Plugin.Log.LogError((object)"Local playlist disabled. Set Playlist/Enabled = false in the config and restart to remove the 'Local' mixtape entirely.");
		}

		public static void EnsureMixtape(SoundManager sm)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (_disabled || (Object)(object)sm == (Object)null)
			{
				return;
			}
			if (!Refl.PlaylistReady)
			{
				Plugin.Log.LogWarning((object)"Local playlist not injected: the game's audio internals could not be resolved (see the handle list above).");
				return;
			}
			MusicMixtapes mixtapes = sm.Mixtapes;
			if ((Object)(object)mixtapes == (Object)null || mixtapes.MixTapes == null)
			{
				Plugin.Log.LogWarning((object)"SoundManager.Mixtapes is null; local playlist disabled.");
				_disabled = true;
				return;
			}
			LiveTape.EnsureInjected(sm);
			if (!ModConfig.PlaylistEnabled.Value)
			{
				return;
			}
			for (int i = 0; i < mixtapes.MixTapes.Count; i++)
			{
				if (mixtapes.MixTapes[i].Songs == PlaylistLibrary.Songs)
				{
					_injected = true;
					PlaylistLibrary.Rescan();
					return;
				}
			}
			PlaylistLibrary.Rescan();
			if (PlaylistLibrary.Tracks.Count == 0)
			{
				Plugin.Log.LogInfo((object)"No local tracks, so no 'Local' mixtape was added. Set a music folder in the config, or with the Folder... button.");
				FolderWatcher.Sync();
				return;
			}
			string text = (string.IsNullOrEmpty(ModConfig.MixtapeName.Value) ? "Local" : ModConfig.MixtapeName.Value);
			Sprite val = BorrowCover(mixtapes);
			Mixtape item = new Mixtape
			{
				MixtapeName = text,
				Songs = PlaylistLibrary.Songs,
				IsSummerDLC = false,
				MixtapeCover = val,
				MixtapeStreamerCover = val
			};
			mixtapes.MixTapes.Add(item);
			_injected = true;
			Plugin.Log.LogInfo((object)("Injected mixtape '" + text + "' with " + PlaylistLibrary.Songs.Count + " track(s)."));
			FolderWatcher.Sync();
		}

		private static Sprite BorrowCover(MusicMixtapes asset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < asset.MixTapes.Count; i++)
			{
				Sprite mixtapeCover = asset.MixTapes[i].MixtapeCover;
				if ((Object)(object)mixtapeCover != (Object)null)
				{
					return mixtapeCover;
				}
			}
			return null;
		}

		public static Tape Which(SoundManager sm)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || (Object)(object)sm == (Object)null)
			{
				return Tape.None;
			}
			MusicMixtapes mixtapes = sm.Mixtapes;
			if ((Object)(object)mixtapes == (Object)null || mixtapes.MixTapes == null)
			{
				return Tape.None;
			}
			int num = Refl.MixtapeIndex.Invoke(sm);
			if (num < 0 || num >= mixtapes.MixTapes.Count)
			{
				return Tape.None;
			}
			List<Song> songs = mixtapes.MixTapes[num].Songs;
			if (songs == PlaylistLibrary.Songs)
			{
				return Tape.Local;
			}
			if (songs == LiveTape.Songs)
			{
				return Tape.Live;
			}
			return Tape.None;
		}

		public static bool IsOurs(SoundManager sm)
		{
			return Which(sm) == Tape.Local;
		}

		public static List<Song> SongsFor(Tape tape)
		{
			if (tape != Tape.Live)
			{
				return PlaylistLibrary.Songs;
			}
			return LiveTape.Songs;
		}

		public static void BeforePlayMixtape(SoundManager sm)
		{
			Tape tape = Which(sm);
			if (tape == Tape.None)
			{
				return;
			}
			AudioSource val = Refl.MixtapeMusic.Invoke(sm);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int num = ClampSongIndex(sm);
			AudioClip val2 = ((tape == Tape.Live) ? LiveTape.Clip : ResidentClipAt(num));
			if ((Object)(object)val2 != (Object)null)
			{
				val.loop = false;
				if (val.clip != val2)
				{
					val.clip = val2;
				}
			}
			else
			{
				val.loop = true;
				val.clip = Silence();
			}
			if (tape == Tape.Local)
			{
				ClipCache.EnsureResidency(num);
			}
		}

		private static AudioClip ResidentClipAt(int index)
		{
			LocalTrack localTrack = PlaylistLibrary.TrackAt(index);
			if (localTrack == null || !localTrack.IsResident)
			{
				return null;
			}
			return localTrack.Clip;
		}

		public static void OnTrackReady(LocalTrack track)
		{
			SoundManager val = SoundManagerOrNull();
			if ((Object)(object)val == (Object)null || !IsOurs(val))
			{
				return;
			}
			int num = Refl.SongIndex.Invoke(val);
			if (PlaylistLibrary.IndexOf(track) != num)
			{
				return;
			}
			AudioSource val2 = Refl.MixtapeMusic.Invoke(val);
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.loop = false;
				val2.clip = track.Clip;
				val2.time = 0f;
				if (Refl.IsPlayingFlag.Invoke(val) && val.IsInGame)
				{
					val2.Play();
				}
				RefreshNowPlaying(val);
			}
		}

		public static void OnTrackFailed(LocalTrack track)
		{
			SoundManager val = SoundManagerOrNull();
			if ((Object)(object)val == (Object)null || !IsOurs(val))
			{
				return;
			}
			int num = Refl.SongIndex.Invoke(val);
			if (PlaylistLibrary.IndexOf(track) == num)
			{
				if (val.IsInGame && PlaylistLibrary.Tracks.Count > 1 && HasLoadableTrack())
				{
					val.ChangeSong(true);
				}
				else
				{
					RefreshNowPlaying(val);
				}
			}
		}

		private static bool HasLoadableTrack()
		{
			foreach (LocalTrack track in PlaylistLibrary.Tracks)
			{
				if (track.State != TrackState.Failed)
				{
					return true;
				}
			}
			return false;
		}

		public static void ReArmResidency()
		{
			SoundManager val = SoundManagerOrNull();
			if (!((Object)(object)val == (Object)null) && IsOurs(val))
			{
				ClipCache.EnsureResidency(ClampSongIndex(val));
			}
		}

		public static void OnSongChanged(SoundManager sm)
		{
			if (IsOurs(sm))
			{
				ClipCache.EnsureResidency(ClampSongIndex(sm));
			}
		}

		public static void OnMixtapeChanged(SoundManager sm)
		{
			if (!Active || (Object)(object)sm == (Object)null)
			{
				return;
			}
			AudioSource val = Refl.MixtapeMusic.Invoke(sm);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			switch (Which(sm))
			{
			case Tape.None:
				val.loop = false;
				if ((Object)(object)val.clip == (Object)(object)_silence)
				{
					val.clip = null;
				}
				break;
			case Tape.Local:
				ClipCache.EnsureResidency(ClampSongIndex(sm));
				break;
			}
		}

		public static void OnTagsComplete()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			SoundManager val = SoundManagerOrNull();
			if (!((Object)(object)val == (Object)null) && IsOurs(val))
			{
				UIManager i = MonoSingleton<UIManager>.I;
				if (!((Object)(object)i == (Object)null))
				{
					i.LoadMixtape(val.GetMixtape());
				}
			}
		}

		public static void RefreshNowPlaying(SoundManager sm)
		{
			if ((Object)(object)sm == (Object)null)
			{
				return;
			}
			UIManager i = MonoSingleton<UIManager>.I;
			if ((Object)(object)i == (Object)null)
			{
				return;
			}
			ClampSongIndex(sm);
			try
			{
				i.UpdateSongInfo(sm.GetSong());
			}
			catch (Exception)
			{
			}
		}

		public static void Tick()
		{
			if (!Active || Time.unscaledTime < _nextRepairCheck)
			{
				return;
			}
			_nextRepairCheck = Time.unscaledTime + 1f;
			SoundManager val = SoundManagerOrNull();
			Tape tape = Which(val);
			if (tape == Tape.None || !val.IsInGame || !Refl.IsPlayingFlag.Invoke(val))
			{
				return;
			}
			AudioSource val2 = Refl.MixtapeMusic.Invoke(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			int num = ClampSongIndex(val);
			if (!val2.isPlaying && ((Object)(object)val2.clip == (Object)null || (Object)(object)val2.clip == (Object)(object)_silence))
			{
				val2.loop = true;
				val2.clip = Silence();
				val2.Play();
				if (tape == Tape.Local)
				{
					ClipCache.EnsureResidency(num);
				}
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Repaired stalled mixtape source.");
				}
			}
			else if ((Object)(object)val2.clip == (Object)(object)_silence && tape == Tape.Local)
			{
				LocalTrack localTrack = PlaylistLibrary.TrackAt(num);
				if (localTrack != null && localTrack.State == TrackState.Idle)
				{
					ClipCache.EnsureResidency(num);
				}
			}
		}

		public static int ClampSongIndex(SoundManager sm)
		{
			int count = SongsFor(Which(sm)).Count;
			int num = Refl.SongIndex.Invoke(sm);
			if (count <= 0)
			{
				return 0;
			}
			if (num < 0 || num >= count)
			{
				num = Mathf.Clamp(num, 0, count - 1);
				Refl.SongIndex.Invoke(sm) = num;
			}
			return num;
		}

		public static bool IsSilence(AudioClip clip)
		{
			if ((Object)(object)clip != (Object)null)
			{
				if (clip != _silence)
				{
					return clip == _longSilence;
				}
				return true;
			}
			return false;
		}

		public static LocalTrack CurrentTrack(SoundManager sm)
		{
			if (!IsOurs(sm))
			{
				return null;
			}
			return PlaylistLibrary.TrackAt(Refl.SongIndex.Invoke(sm));
		}

		private static AudioClip Silence()
		{
			if ((Object)(object)_silence == (Object)null)
			{
				_silence = AudioClip.Create("OTLP_Silence", 4410, 1, 44100, false);
			}
			return _silence;
		}

		private static AudioClip LongSilence()
		{
			if ((Object)(object)_longSilence == (Object)null)
			{
				_longSilence = AudioClip.Create("OTLP_LongSilence", 220500, 1, 44100, false);
			}
			return _longSilence;
		}

		private static SoundManager SoundManagerOrNull()
		{
			try
			{
				return MonoSingleton<SoundManager>.I;
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
	public static class Mp3Duration
	{
		private static readonly int[,] BitrateV1L3 = new int[2, 16]
		{
			{
				0, 32, 40, 48, 56, 64, 80, 96, 112, 128,
				160, 192, 224, 256, 320, 0
			},
			{
				0, 8, 16, 24, 32, 40, 48, 56, 64, 80,
				96, 112, 128, 144, 160, 0
			}
		};

		private static readonly int[,] SampleRates = new int[4, 4]
		{
			{ 11025, 12000, 8000, 0 },
			{ 0, 0, 0, 0 },
			{ 22050, 24000, 16000, 0 },
			{ 44100, 48000, 32000, 0 }
		};

		public static double TryRead(string path)
		{
			try
			{
				using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 8192);
				long length = fileStream.Length;
				long num = SkipId3v2(fileStream);
				if (num < 0 || num >= length)
				{
					return 0.0;
				}
				long num2 = FindFrameHeader(fileStream, num, Math.Min(length, num + 65536));
				if (num2 < 0)
				{
					return 0.0;
				}
				fileStream.Seek(num2, SeekOrigin.Begin);
				byte[] array = new byte[4];
				if (fileStream.Read(array, 0, 4) != 4)
				{
					return 0.0;
				}
				int num3 = (array[1] >> 3) & 3;
				int num4 = (array[1] >> 1) & 3;
				int num5 = (array[2] >> 4) & 0xF;
				int num6 = (array[2] >> 2) & 3;
				int num7 = (array[3] >> 6) & 3;
				int num8 = SampleRates[num3, num6];
				if (num8 == 0)
				{
					return 0.0;
				}
				bool flag = num3 == 3;
				int num9 = SamplesPerFrame(num4, flag);
				if (num9 == 0)
				{
					return 0.0;
				}
				int num10 = ((!flag) ? ((num7 == 3) ? 9 : 17) : ((num7 == 3) ? 17 : 32));
				long num11 = ReadXingFrames(fileStream, num2 + 4 + num10);
				if (num11 <= 0)
				{
					num11 = ReadVbriFrames(fileStream, num2 + 4 + 32);
				}
				if (num11 > 0)
				{
					return (double)num11 * (double)num9 / (double)num8;
				}
				int num12 = BitrateV1L3[(!flag) ? 1u : 0u, num5];
				if (num12 <= 0 || num4 != 1)
				{
					return 0.0;
				}
				long num13 = length - num2 - Id3v1Size(fileStream, length);
				if (num13 <= 0)
				{
					return 0.0;
				}
				return (double)num13 * 8.0 / ((double)num12 * 1000.0);
			}
			catch (Exception)
			{
				return 0.0;
			}
		}

		private static int SamplesPerFrame(int layer, bool mpeg1)
		{
			switch (layer)
			{
			case 3:
				return 384;
			case 2:
				return 1152;
			case 1:
				if (!mpeg1)
				{
					return 576;
				}
				return 1152;
			default:
				return 0;
			}
		}

		private static long SkipId3v2(FileStream fs)
		{
			fs.Seek(0L, SeekOrigin.Begin);
			byte[] array = new byte[10];
			if (fs.Read(array, 0, 10) != 10)
			{
				return -1L;
			}
			if (array[0] != 73 || array[1] != 68 || array[2] != 51)
			{
				return 0L;
			}
			int num = ((array[6] & 0x7F) << 21) | ((array[7] & 0x7F) << 14) | ((array[8] & 0x7F) << 7) | (array[9] & 0x7F);
			if (num < 0)
			{
				return -1L;
			}
			long num2 = 10 + num;
			if ((array[5] & 0x10) != 0)
			{
				num2 += 10;
			}
			return num2;
		}

		private static long Id3v1Size(FileStream fs, long length)
		{
			if (length < 128)
			{
				return 0L;
			}
			try
			{
				fs.Seek(length - 128, SeekOrigin.Begin);
				byte[] array = new byte[3];
				if (fs.Read(array, 0, 3) != 3)
				{
					return 0L;
				}
				return (array[0] == 84 && array[1] == 65 && array[2] == 71) ? 128 : 0;
			}
			catch (Exception)
			{
				return 0L;
			}
		}

		private static long FindFrameHeader(FileStream fs, long from, long to)
		{
			fs.Seek(from, SeekOrigin.Begin);
			byte[] array = new byte[4096];
			long num = from;
			while (num < to)
			{
				int count = (int)Math.Min(array.Length, to - num);
				int num2 = fs.Read(array, 0, count);
				if (num2 <= 0)
				{
					return -1L;
				}
				for (int i = 0; i + 1 < num2; i++)
				{
					if (array[i] == byte.MaxValue && (array[i + 1] & 0xE0) == 224)
					{
						int num3 = (array[i + 1] >> 3) & 3;
						int num4 = (array[i + 1] >> 1) & 3;
						if (num3 != 1 && num4 != 0)
						{
							return num + i;
						}
					}
				}
				num += num2 - 1;
				fs.Seek(num, SeekOrigin.Begin);
			}
			return -1L;
		}

		private static long ReadXingFrames(FileStream fs, long at)
		{
			try
			{
				fs.Seek(at, SeekOrigin.Begin);
				byte[] array = new byte[12];
				if (fs.Read(array, 0, 12) != 12)
				{
					return 0L;
				}
				bool num = array[0] == 88 && array[1] == 105 && array[2] == 110 && array[3] == 103;
				bool flag = array[0] == 73 && array[1] == 110 && array[2] == 102 && array[3] == 111;
				if (!num && !flag)
				{
					return 0L;
				}
				if ((Be32(array, 4) & 1) == 0)
				{
					return 0L;
				}
				return Be32(array, 8);
			}
			catch (Exception)
			{
				return 0L;
			}
		}

		private static long ReadVbriFrames(FileStream fs, long at)
		{
			try
			{
				fs.Seek(at, SeekOrigin.Begin);
				byte[] array = new byte[20];
				if (fs.Read(array, 0, 20) != 20)
				{
					return 0L;
				}
				if (array[0] != 86 || array[1] != 66 || array[2] != 82 || array[3] != 73)
				{
					return 0L;
				}
				return Be32(array, 14);
			}
			catch (Exception)
			{
				return 0L;
			}
		}

		private static int Be32(byte[] b, int at)
		{
			return (b[at] << 24) | (b[at + 1] << 16) | (b[at + 2] << 8) | b[at + 3];
		}
	}
	public sealed class NaturalSort : IComparer<string>
	{
		public static readonly NaturalSort Instance = new NaturalSort();

		private static bool _nativeUnavailable;

		[DllImport("shlwapi.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
		private static extern int StrCmpLogicalW(string x, string y);

		public int Compare(string x, string y)
		{
			if ((object)x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			if (!_nativeUnavailable)
			{
				try
				{
					return StrCmpLogicalW(x, y);
				}
				catch (DllNotFoundException)
				{
					_nativeUnavailable = true;
				}
				catch (EntryPointNotFoundException)
				{
					_nativeUnavailable = true;
				}
			}
			return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
		}
	}
	public struct ScanResult
	{
		public int Total;

		public int Added;

		public int Removed;

		public int Skipped;

		public string SkipExample;

		public string Error;

		public long ElapsedMs;

		public bool Ok => Error == null;
	}
	public static class PlaylistLibrary
	{
		private const int MaxDirectories = 5000;

		public static readonly List<LocalTrack> Tracks = new List<LocalTrack>();

		public static readonly List<Song> Songs = new List<Song>();

		private static int _scanGeneration;

		public static int TagsPending { get; private set; }

		public static string ScannedFolder { get; private set; }

		public static LocalTrack TrackAt(int songIndex)
		{
			if (songIndex < 0 || songIndex >= Tracks.Count)
			{
				return null;
			}
			return Tracks[songIndex];
		}

		public static int IndexOf(LocalTrack track)
		{
			if (track != null)
			{
				return Tracks.IndexOf(track);
			}
			return -1;
		}

		public static int IndexOfPath(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return -1;
			}
			for (int i = 0; i < Tracks.Count; i++)
			{
				if (string.Equals(Tracks[i].Path, path, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			return -1;
		}

		public static ScanResult Rescan()
		{
			ScanResult result = RescanCore();
			try
			{
				SoundManager i = MonoSingleton<SoundManager>.I;
				if ((Object)(object)i != (Object)null && MixtapeBridge.IsOurs(i))
				{
					MixtapeBridge.ClampSongIndex(i);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Post-rescan clamp: " + ex));
			}
			return result;
		}

		private static ScanResult RescanCore()
		{
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			ScanResult result = default(ScanResult);
			int generation = ++_scanGeneration;
			string text = (ScannedFolder = (ModConfig.MusicFolder.Value ?? "").Trim().Trim('"'));
			if (text.Length == 0)
			{
				DropAll();
				Publish("Set a music folder", "");
				result.Error = "no folder set";
				return result;
			}
			if (FileUrl.IsUnc(text))
			{
				DropAll();
				Publish("! Network paths are not supported", "");
				Plugin.Log.LogWarning((object)("MusicFolder is a network path (" + text + "). Unity's audio loader cannot resolve those - map it to a drive letter instead."));
				result.Error = "network path";
				return result;
			}
			if (!Directory.Exists(text))
			{
				DropAll();
				Publish("! Folder not found", text);
				Plugin.Log.LogWarning((object)("MusicFolder does not exist: " + text));
				result.Error = "folder not found";
				return result;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			List<KeyValuePair<string, AudioType>> list = EnumerateAudioFiles(text, out result.Skipped, out result.SkipExample);
			list.Sort((KeyValuePair<string, AudioType> a, KeyValuePair<string, AudioType> b) => NaturalSort.Instance.Compare(a.Key, b.Key));
			int num = Mathf.Max(1, ModConfig.MaxTracks.Value);
			int num2 = 0;
			if (list.Count > num)
			{
				num2 = list.Count - num;
				list.RemoveRange(num, num2);
			}
			Dictionary<string, LocalTrack> dictionary = new Dictionary<string, LocalTrack>(StringComparer.OrdinalIgnoreCase);
			foreach (LocalTrack track in Tracks)
			{
				dictionary[track.Path] = track;
			}
			List<LocalTrack> list2 = new List<LocalTrack>(list.Count);
			List<LocalTrack> list3 = new List<LocalTrack>();
			foreach (KeyValuePair<string, AudioType> item2 in list)
			{
				if (dictionary.TryGetValue(item2.Key, out var value))
				{
					dictionary.Remove(item2.Key);
					list2.Add(value);
					continue;
				}
				LocalTrack item = new LocalTrack(item2.Key, item2.Value, TagReader.FromFileName(item2.Key));
				list2.Add(item);
				list3.Add(item);
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("  new: " + item2.Key));
				}
			}
			foreach (LocalTrack value2 in dictionary.Values)
			{
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("  gone: " + value2.Path));
				}
				value2.Unload();
			}
			result.Added = list3.Count;
			result.Removed = dictionary.Count;
			result.Total = list2.Count;
			Tracks.Clear();
			Tracks.AddRange(list2);
			stopwatch.Stop();
			result.ElapsedMs = stopwatch.ElapsedMilliseconds;
			if (result.Skipped > 0)
			{
				Plugin.Log.LogInfo((object)("Skipped " + result.Skipped + " unplayable file(s), e.g. " + result.SkipExample));
			}
			if (num2 > 0)
			{
				Plugin.Log.LogWarning((object)("Folder holds " + (result.Total + num2) + " playable files; kept the first " + num + ". Raise Playlist/MaxTracks to include more - note the game instantiates one button per track when the list is shown."));
			}
			if (Tracks.Count == 0)
			{
				Publish("No playable audio here", text);
				Plugin.Log.LogWarning((object)("No playable audio found under " + text + ". Supported: .mp3 .ogg .wav .aif .aiff"));
				result.Error = "nothing playable";
				return result;
			}
			RebuildSongs();
			if (result.ElapsedMs > 750)
			{
				Plugin.Log.LogWarning((object)("That scan took " + result.ElapsedMs + " ms and will have stuttered. Consider a smaller folder, or turn off Playlist/IncludeSubfolders."));
			}
			if (list3.Count > 0)
			{
				StartTagPass(generation, list3);
			}
			return result;
		}

		private static void DropAll()
		{
			ClipCache.CancelInFlight();
			foreach (LocalTrack track in Tracks)
			{
				track.Unload();
			}
			Tracks.Clear();
			TagsPending = 0;
		}

		private static List<KeyValuePair<string, AudioType>> EnumerateAudioFiles(string root, out int skipped, out string skipExample)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			List<KeyValuePair<string, AudioType>> list = new List<KeyValuePair<string, AudioType>>();
			skipped = 0;
			skipExample = null;
			Stack<string> stack = new Stack<string>();
			stack.Push(root);
			int num = 0;
			while (stack.Count > 0)
			{
				if (++num > 5000)
				{
					Plugin.Log.LogWarning((object)("Stopped scanning after " + 5000 + " folders."));
					break;
				}
				string text = stack.Pop();
				string[] directories;
				if (ModConfig.IncludeSubfolders.Value)
				{
					try
					{
						directories = Directory.GetDirectories(text);
						foreach (string item in directories)
						{
							stack.Push(item);
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Cannot list subfolders of " + text + ": " + ex.Message));
					}
				}
				string[] files;
				try
				{
					files = Directory.GetFiles(text);
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)("Cannot list files in " + text + ": " + ex2.Message));
					continue;
				}
				directories = files;
				foreach (string text2 in directories)
				{
					if (Formats.TryGetAudioType(text2, out var type, out var skipReason))
					{
						list.Add(new KeyValuePair<string, AudioType>(text2, type));
					}
					else if (skipReason != null)
					{
						skipped++;
						if (skipExample == null)
						{
							skipExample = Path.GetFileName(text2) + " (" + skipReason + ")";
						}
					}
				}
			}
			return list;
		}

		private static void RebuildSongs()
		{
			Songs.Clear();
			foreach (LocalTrack track in Tracks)
			{
				Songs.Add(track.Song);
			}
		}

		private static void Publish(string title, string artist)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			Songs.Clear();
			Songs.Add(new Song
			{
				Title = title,
				Artist = artist,
				Music = null,
				Volume = 1f
			});
		}

		private static void StartTagPass(int generation, List<LocalTrack> todo)
		{
			LocalTrack[] snapshot = todo.ToArray();
			TagsPending = snapshot.Length;
			ThreadPool.QueueUserWorkItem(delegate
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Invalid comparison between Unknown and I4
				LocalTrack[] array = snapshot;
				foreach (LocalTrack localTrack in array)
				{
					if (generation != _scanGeneration)
					{
						break;
					}
					TrackTags tags;
					try
					{
						tags = TagReader.Read(localTrack.Path);
					}
					catch (Exception)
					{
						tags = default(TrackTags);
					}
					double duration = 0.0;
					try
					{
						if ((int)localTrack.AudioType == 13)
						{
							duration = Mp3Duration.TryRead(localTrack.Path);
						}
					}
					catch (Exception)
					{
						duration = 0.0;
					}
					LocalTrack captured = localTrack;
					MainThread.Post(delegate
					{
						if (generation == _scanGeneration)
						{
							captured.Duration = duration;
							captured.ApplyTags(tags);
							TagsPending--;
							if (TagsPending <= 0)
							{
								MixtapeBridge.OnTagsComplete();
							}
						}
					});
				}
			});
		}
	}
	public enum ReloadReason
	{
		Startup,
		Manual,
		FolderChanged,
		Watcher
	}
	public static class ReloadCoordinator
	{
		public static bool Busy { get; private set; }

		public static string Status { get; private set; } = "";

		public static void Request(ReloadReason reason)
		{
			if (Busy)
			{
				Plugin.Log.LogInfo((object)("Reload already in progress, ignoring " + reason.ToString() + "."));
				return;
			}
			Busy = true;
			try
			{
				Run(reason);
			}
			catch (Exception ex)
			{
				Status = "Reload failed";
				Plugin.Log.LogError((object)("Reload (" + reason.ToString() + ") failed: " + ex));
			}
			finally
			{
				Busy = false;
			}
		}

		private static void Run(ReloadReason reason)
		{
			SoundManager i = MonoSingleton<SoundManager>.I;
			bool flag = (Object)(object)i != (Object)null && MixtapeBridge.IsOurs(i);
			string text = null;
			bool flag2 = false;
			if (flag)
			{
				LocalTrack localTrack = MixtapeBridge.CurrentTrack(i);
				if (localTrack != null)
				{
					text = localTrack.Path;
				}
				flag2 = Refl.IsPlayingFlag.Invoke(i);
			}
			ScanResult r = PlaylistLibrary.Rescan();
			if (!r.Ok)
			{
				Status = Describe(r);
				Plugin.Log.LogWarning((object)("Reload (" + reason.ToString() + "): " + r.Error));
				RefreshUi(i, flag);
				return;
			}
			if (flag && (Object)(object)i != (Object)null)
			{
				int num = PlaylistLibrary.IndexOfPath(text);
				if (num >= 0)
				{
					Refl.SongIndex.Invoke(i) = num;
				}
				MixtapeBridge.ClampSongIndex(i);
				RefreshUi(i, ours: true);
				MixtapeBridge.OnSongChanged(i);
				if (num < 0 && text != null)
				{
					Plugin.Log.LogInfo((object)"The track that was playing is no longer in the folder.");
					if (flag2 && PlaylistLibrary.Tracks.Count > 0 && Refl.PlayMixtape != null)
					{
						Refl.PlayMixtape.Invoke(i, null);
					}
				}
			}
			else
			{
				RefreshUi(i, ours: false);
			}
			Status = Describe(r);
			Plugin.Log.LogInfo((object)("Reload (" + reason.ToString() + "): " + r.Total + " track(s), +" + r.Added + " -" + r.Removed + ", " + r.ElapsedMs + " ms."));
		}

		private static void RefreshUi(SoundManager sm, bool ours)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sm == (Object)null || !ours)
			{
				return;
			}
			UIManager i = MonoSingleton<UIManager>.I;
			if ((Object)(object)i == (Object)null)
			{
				return;
			}
			try
			{
				i.LoadMixtape(sm.GetMixtape());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Rebuilding the song list after a reload failed: " + ex));
			}
		}

		private static string Describe(ScanResult r)
		{
			if (!r.Ok)
			{
				return r.Error;
			}
			if (r.Added == 0 && r.Removed == 0)
			{
				return r.Total + " tracks";
			}
			return r.Total + " tracks (+" + r.Added + " -" + r.Removed + ")";
		}
	}
	public struct TrackTags
	{
		public string Title;

		public string Artist;
	}
	public static class TagReader
	{
		private const int MaxTagBytes = 2097152;

		private const int OggScanBytes = 65536;

		private static readonly Regex LeadingTrackNumber = new Regex("^\\s*(?:\\d{1,3}\\s*[\\.\\-_)\\]]\\s*|0\\d{1,2}\\s+)", RegexOptions.CultureInvariant);

		private static readonly char[] DashSeparators = new char[3] { '-', '–', '—' };

		public static TrackTags Read(string path)
		{
			TrackTags trackTags = default(TrackTags);
			try
			{
				string text = Path.GetExtension(path)?.ToLowerInvariant();
				if (text == ".mp3")
				{
					trackTags = ReadId3v2(path);
					if (IsBlank(trackTags))
					{
						trackTags = ReadId3v1(path);
					}
				}
				else if (text == ".ogg")
				{
					trackTags = ReadVorbisComment(path);
				}
			}
			catch (Exception)
			{
				trackTags = default(TrackTags);
			}
			TrackTags trackTags2 = FromFileName(path);
			if (string.IsNullOrEmpty(trackTags.Title))
			{
				trackTags.Title = trackTags2.Title;
			}
			if (string.IsNullOrEmpty(trackTags.Artist))
			{
				trackTags.Artist = trackTags2.Artist;
			}
			return trackTags;
		}

		private static bool IsBlank(TrackTags t)
		{
			if (string.IsNullOrEmpty(t.Title))
			{
				return string.IsNullOrEmpty(t.Artist);
			}
			return false;
		}

		private static TrackTags ReadId3v2(string path)
		{
			TrackTags result = default(TrackTags);
			using (FileStream s = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 8192))
			{
				byte[] array = new byte[10];
				if (ReadFully(s, array, 10) != 10)
				{
					return result;
				}
				if (array[0] != 73 || array[1] != 68 || array[2] != 51)
				{
					return result;
				}
				int num = array[3];
				if (num < 2 || num > 4)
				{
					return result;
				}
				byte b = array[5];
				if ((b & 0x80) != 0)
				{
					return result;
				}
				int num2 = SyncSafe(array, 6);
				if (num2 <= 0 || num2 > 2097152)
				{
					return result;
				}
				byte[] array2 = new byte[num2];
				int num3 = ReadFully(s, array2, num2);
				if (num3 <= 0)
				{
					return result;
				}
				int num4 = 0;
				if ((b & 0x40) != 0 && num >= 3 && num3 >= 4)
				{
					if (num == 3)
					{
						int num5 = BigEndian32(array2, 0);
						if (num5 < 0)
						{
							return result;
						}
						num4 = 4 + num5;
					}
					else
					{
						int val = SyncSafe(array2, 0);
						num4 = Math.Max(4, val);
					}
					if (num4 >= num3)
					{
						return result;
					}
				}
				int num6 = ((num == 2) ? 3 : 4);
				int num7 = ((num == 2) ? 3 : 4);
				int num8 = ((num != 2) ? 2 : 0);
				int num9 = num6 + num7 + num8;
				while (num4 + num9 <= num3 && array2[num4] != 0)
				{
					string text = Encoding.ASCII.GetString(array2, num4, num6);
					int num10 = num switch
					{
						2 => (array2[num4 + 3] << 16) | (array2[num4 + 4] << 8) | array2[num4 + 5], 
						3 => BigEndian32(array2, num4 + 4), 
						_ => SyncSafe(array2, num4 + 4), 
					};
					int num11 = num4 + num9;
					if (num10 <= 0 || num11 + num10 > num3)
					{
						break;
					}
					bool flag = text == "TIT2" || text == "TT2";
					bool flag2 = text == "TPE1" || text == "TP1";
					if (flag || flag2)
					{
						string text2 = DecodeTextFrame(array2, num11, num10);
						if (!string.IsNullOrEmpty(text2))
						{
							if (flag && string.IsNullOrEmpty(result.Title))
							{
								result.Title = text2;
							}
							else if (flag2 && string.IsNullOrEmpty(result.Artist))
							{
								result.Artist = text2;
							}
						}
					}
					num4 = num11 + num10;
					if (!string.IsNullOrEmpty(result.Title) && !string.IsNullOrEmpty(result.Artist))
					{
						break;
					}
				}
			}
			return result;
		}

		private static string DecodeTextFrame(byte[] buf, int offset, int length)
		{
			if (length < 1)
			{
				return null;
			}
			byte b = buf[offset];
			int num = offset + 1;
			int num2 = length - 1;
			if (num2 <= 0)
			{
				return null;
			}
			return Clean(b switch
			{
				1 => (num2 >= 2 && buf[num] == byte.MaxValue && buf[num + 1] == 254) ? Encoding.Unicode.GetString(buf, num + 2, num2 - 2) : ((num2 < 2 || buf[num] != 254 || buf[num + 1] != byte.MaxValue) ? Encoding.Unicode.GetString(buf, num, num2) : Encoding.BigEndianUnicode.GetString(buf, num + 2, num2 - 2)), 
				2 => Encoding.BigEndianUnicode.GetString(buf, num, num2), 
				3 => Encoding.UTF8.GetString(buf, num, num2), 
				_ => Latin1(buf, num, num2), 
			});
		}

		private static TrackTags ReadId3v1(string path)
		{
			TrackTags result = default(TrackTags);
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 256);
			if (fileStream.Length < 128)
			{
				return result;
			}
			fileStream.Seek(-128L, SeekOrigin.End);
			byte[] array = new byte[128];
			if (ReadFully(fileStream, array, 128) != 128)
			{
				return result;
			}
			if (array[0] != 84 || array[1] != 65 || array[2] != 71)
			{
				return result;
			}
			result.Title = Clean(Latin1(array, 3, 30));
			result.Artist = Clean(Latin1(array, 33, 30));
			return result;
		}

		private static TrackTags ReadVorbisComment(string path)
		{
			TrackTags result = default(TrackTags);
			byte[] array;
			using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 8192))
			{
				int num = (int)Math.Min(65536L, fileStream.Length);
				if (num <= 0)
				{
					return result;
				}
				array = new byte[num];
				int num2 = ReadFully(fileStream, array, num);
				if (num2 <= 0)
				{
					return result;
				}
				if (num2 < array.Length)
				{
					Array.Resize(ref array, num2);
				}
			}
			int num3 = IndexOfVorbisHeader(array, 3);
			if (num3 < 0)
			{
				return result;
			}
			int num4 = num3 + 7;
			if (num4 + 4 > array.Length)
			{
				return result;
			}
			int num5 = LittleEndian32(array, num4);
			num4 += 4;
			if (num5 < 0 || num4 + num5 + 4 > array.Length)
			{
				return result;
			}
			num4 += num5;
			int num6 = LittleEndian32(array, num4);
			num4 += 4;
			if (num6 < 0 || num6 > 512)
			{
				return result;
			}
			for (int i = 0; i < num6; i++)
			{
				if (num4 + 4 > array.Length)
				{
					break;
				}
				int num7 = LittleEndian32(array, num4);
				num4 += 4;
				if (num7 < 0 || num4 + num7 > array.Length)
				{
					break;
				}
				string text = Encoding.UTF8.GetString(array, num4, num7);
				num4 += num7;
				int num8 = text.IndexOf('=');
				if (num8 <= 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num8).ToUpperInvariant();
				string text3 = Clean(text.Substring(num8 + 1));
				if (!string.IsNullOrEmpty(text3))
				{
					if (text2 == "TITLE" && string.IsNullOrEmpty(result.Title))
					{
						result.Title = text3;
					}
					else if (text2 == "ARTIST" && string.IsNullOrEmpty(result.Artist))
					{
						result.Artist = text3;
					}
				}
			}
			return result;
		}

		private static int IndexOfVorbisHeader(byte[] buf, byte packetType)
		{
			for (int i = 0; i + 7 <= buf.Length; i++)
			{
				if (buf[i] == packetType && buf[i + 1] == 118 && buf[i + 2] == 111 && buf[i + 3] == 114 && buf[i + 4] == 98 && buf[i + 5] == 105 && buf[i + 6] == 115)
				{
					return i;
				}
			}
			return -1;
		}

		public static TrackTags FromFileName(string path)
		{
			TrackTags result = default(TrackTags);
			string text = null;
			string text2;
			try
			{
				text2 = Path.GetFileNameWithoutExtension(path);
				if (string.IsNullOrEmpty(text2))
				{
					text2 = path;
				}
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrEmpty(directoryName))
				{
					text = Path.GetFileName(directoryName);
				}
			}
			catch (Exception)
			{
				text2 = path;
			}
			string text3 = LeadingTrackNumber.Replace(text2, "");
			if (text3.Trim().Length == 0)
			{
				text3 = text2;
			}
			char[] dashSeparators = DashSeparators;
			foreach (char c in dashSeparators)
			{
				string text4 = " " + c + " ";
				int num = text3.IndexOf(text4, StringComparison.Ordinal);
				if (num > 0)
				{
					string text5 = text3.Substring(0, num).Trim();
					string text6 = text3.Substring(num + text4.Length).Trim();
					if (text5.Length > 0 && text6.Length > 0)
					{
						result.Artist = text5;
						result.Title = text6;
						return result;
					}
				}
			}
			result.Title = text3.Trim();
			result.Artist = (string.IsNullOrEmpty(text) ? "" : text);
			return result;
		}

		private static string Latin1(byte[] buf, int offset, int length)
		{
			StringBuilder stringBuilder = new StringBuilder(length);
			for (int i = 0; i < length; i++)
			{
				stringBuilder.Append((char)buf[offset + i]);
			}
			return stringBuilder.ToString();
		}

		private static string Clean(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return null;
			}
			int num = s.IndexOf('\0');
			if (num >= 0)
			{
				s = s.Substring(0, num);
			}
			s = s.Trim();
			if (s.Length != 0)
			{
				return s;
			}
			return null;
		}

		private static int SyncSafe(byte[] b, int at)
		{
			return ((b[at] & 0x7F) << 21) | ((b[at + 1] & 0x7F) << 14) | ((b[at + 2] & 0x7F) << 7) | (b[at + 3] & 0x7F);
		}

		private static int BigEndian32(byte[] b, int at)
		{
			return (b[at] << 24) | (b[at + 1] << 16) | (b[at + 2] << 8) | b[at + 3];
		}

		private static int LittleEndian32(byte[] b, int at)
		{
			return b[at] | (b[at + 1] << 8) | (b[at + 2] << 16) | (b[at + 3] << 24);
		}

		private static int ReadFully(Stream s, byte[] buf, int count)
		{
			int i;
			int num;
			for (i = 0; i < count; i += num)
			{
				num = s.Read(buf, i, count - i);
				if (num <= 0)
				{
					break;
				}
			}
			return i;
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.Platform
{
	public static class FolderPicker
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DRelease(IntPtr self);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DShow(IntPtr self, IntPtr hwndOwner);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DGetOptions(IntPtr self, out uint fos);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DSetOptions(IntPtr self, uint fos);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DSetTitle(IntPtr self, [MarshalAs(UnmanagedType.LPWStr)] string t);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DSetOkLabel(IntPtr self, [MarshalAs(UnmanagedType.LPWStr)] string t);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DSetFolder(IntPtr self, IntPtr psi);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DGetResult(IntPtr self, out IntPtr ppsi);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int DGetDisplayName(IntPtr self, uint sigdn, out IntPtr ppsz);

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		private struct BROWSEINFO
		{
			public IntPtr hwndOwner;

			public IntPtr pidlRoot;

			public IntPtr pszDisplayName;

			public IntPtr lpszTitle;

			public uint ulFlags;

			public IntPtr lpfn;

			public IntPtr lParam;

			public int iImage;
		}

		private struct UiState
		{
			private CursorLockMode _lock;

			private bool _cursorVisible;

			private bool _runInBackground;

			private bool _topmostWas;

			private bool _topmostValid;

			public static UiState CaptureAndNeutralise()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				UiState result = new UiState
				{
					_lock = Cursor.lockState,
					_cursorVisible = Cursor.visible,
					_runInBackground = Application.runInBackground
				};
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				Application.runInBackground = true;
				result._topmostValid = TrySetTopmost(value: false, out result._topmostWas);
				return result;
			}

			public void Restore()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (_topmostValid)
				{
					TrySetTopmost(_topmostWas, out var _);
				}
				Cursor.lockState = _lock;
				Cursor.visible = _cursorVisible;
				Application.runInBackground = _runInBackground;
				Input.ResetInputAxes();
			}
		}

		private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

		private static int _busy;

		private static readonly Guid CLSID_FileOpenDialog = new Guid("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7");

		private static readonly Guid IID_IFileOpenDialog = new Guid("D57C7288-D4AD-4768-BE02-9D969532D960");

		private static readonly Guid IID_IShellItem = new Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE");

		private const int V_RELEASE = 2;

		private const int V_SHOW = 3;

		private const int V_SETOPTIONS = 9;

		private const int V_GETOPTIONS = 10;

		private const int V_SETFOLDER = 12;

		private const int V_SETTITLE = 17;

		private const int V_SETOKBUTTONLABEL = 18;

		private const int V_GETRESULT = 20;

		private const int V_SI_GETDISPLAYNAME = 5;

		private const uint FOS_NOCHANGEDIR = 8u;

		private const uint FOS_PICKFOLDERS = 32u;

		private const uint FOS_FORCEFILESYSTEM = 64u;

		private const uint FOS_PATHMUSTEXIST = 2048u;

		private const uint FOS_FILEMUSTEXIST = 4096u;

		private const uint SIGDN_FILESYSPATH = 2147844096u;

		private const int HR_CANCELLED = -2147023673;

		private const uint BIF_RETURNONLYFSDIRS = 1u;

		private const uint BIF_NEWDIALOGSTYLE = 64u;

		private const int MAX_PATH = 260;

		private static IntPtr _hwnd;

		private const uint GW_OWNER = 4u;

		private const uint COINIT_APARTMENTTHREADED = 2u;

		private const uint COINIT_DISABLE_OLE1DDE = 4u;

		private const uint CLSCTX_INPROC_SERVER = 1u;

		private const int RPC_E_CHANGED_MODE = -2147417850;

		public static bool IsOpen => Volatile.Read(in _busy) != 0;

		public static void Pick(string title, string initialFolder, bool byFile, Action<string> onPicked)
		{
			if (onPicked == null)
			{
				return;
			}
			if (Interlocked.CompareExchange(ref _busy, 1, 0) != 0)
			{
				Plugin.Log.LogInfo((object)"Folder picker: a dialog is already open.");
				return;
			}
			IntPtr owner = GetGameWindow();
			UiState saved = UiState.CaptureAndNeutralise();
			Thread thread = new Thread((ThreadStart)delegate
			{
				string text = null;
				try
				{
					text = ShowBlocking(owner, title, initialFolder, byFile);
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)("Folder picker thread failed: " + ex2));
				}
				finally
				{
					string result = text;
					MainThread.Post(delegate
					{
						try
						{
							saved.Restore();
						}
						catch (Exception ex3)
						{
							Plugin.Log.LogError((object)("Folder picker restore failed: " + ex3));
						}
						Volatile.Write(ref _busy, 0);
						try
						{
							onPicked(result);
						}
						catch (Exception ex4)
						{
							Plugin.Log.LogError((object)("Folder picker callback threw: " + ex4));
						}
					});
				}
			})
			{
				Name = "OTLP-FolderPicker",
				IsBackground = true
			};
			try
			{
				thread.SetApartmentState(ApartmentState.STA);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Folder picker: SetApartmentState(STA) failed, relying on CoInitializeEx: " + ex.Message));
			}
			thread.Start();
		}

		private static string ShowBlocking(IntPtr owner, string title, string initialFolder, bool byFile)
		{
			int num = CoInitializeEx(IntPtr.Zero, 6u);
			bool flag = num >= 0;
			if (!flag)
			{
				Plugin.Log.LogWarning((object)("Folder picker: CoInitializeEx(STA) -> 0x" + num.ToString("X8") + ((num == -2147417850) ? " (thread is MTA)" : "")));
			}
			try
			{
				if (flag)
				{
					bool cancelled;
					string text = TryFileOpenDialog(owner, title, initialFolder, byFile, out cancelled);
					if (text != null || cancelled)
					{
						return text;
					}
					Plugin.Log.LogInfo((object)"Folder picker: IFileOpenDialog unavailable, using SHBrowseForFolder.");
				}
				return TryShBrowseForFolder(owner, title, flag);
			}
			finally
			{
				if (flag)
				{
					CoUninitialize();
				}
			}
		}

		private static T Vt<T>(IntPtr obj, int slot) where T : Delegate
		{
			return Marshal.GetDelegateForFunctionPointer<T>(Marshal.ReadIntPtr(Marshal.ReadIntPtr(obj), slot * IntPtr.Size));
		}

		private static string TryFileOpenDialog(IntPtr owner, string title, string initialFolder, bool byFile, out bool cancelled)
		{
			cancelled = false;
			IntPtr ppv = IntPtr.Zero;
			IntPtr ppsi = IntPtr.Zero;
			IntPtr ppv2 = IntPtr.Zero;
			IntPtr ppsz = IntPtr.Zero;
			Guid rclsid = CLSID_FileOpenDialog;
			Guid riid = IID_IFileOpenDialog;
			try
			{
				if (CoCreateInstance(ref rclsid, IntPtr.Zero, 1u, ref riid, out ppv) < 0 || ppv == IntPtr.Zero)
				{
					return null;
				}
				uint num = (uint)(0x848 | (byFile ? 4096 : 32));
				if (Vt<DGetOptions>(ppv, 10)(ppv, out var fos) >= 0)
				{
					num |= fos;
				}
				if (Vt<DSetOptions>(ppv, 9)(ppv, num) < 0)
				{
					return null;
				}
				if (!string.IsNullOrEmpty(title))
				{
					Vt<DSetTitle>(ppv, 17)(ppv, title);
				}
				if (!byFile)
				{
					Vt<DSetOkLabel>(ppv, 18)(ppv, "Use this folder");
				}
				if (!string.IsNullOrEmpty(initialFolder) && Directory.Exists(initialFolder))
				{
					Guid riid2 = IID_IShellItem;
					if (SHCreateItemFromParsingName(initialFolder, IntPtr.Zero, ref riid2, out ppv2) >= 0 && ppv2 != IntPtr.Zero)
					{
						Vt<DSetFolder>(ppv, 12)(ppv, ppv2);
					}
				}
				int num2 = Vt<DShow>(ppv, 3)(ppv, owner);
				if (num2 == -2147023673)
				{
					cancelled = true;
					return null;
				}
				if (num2 < 0)
				{
					return null;
				}
				if (Vt<DGetResult>(ppv, 20)(ppv, out ppsi) < 0 || ppsi == IntPtr.Zero)
				{
					return null;
				}
				if (Vt<DGetDisplayName>(ppsi, 5)(ppsi, 2147844096u, out ppsz) < 0 || ppsz == IntPtr.Zero)
				{
					return null;
				}
				string text = Marshal.PtrToStringUni(ppsz);
				return byFile ? DirectoryOf(text) : text;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("IFileOpenDialog path failed: " + ex.Message));
				return null;
			}
			finally
			{
				if (ppsz != IntPtr.Zero)
				{
					Marshal.FreeCoTaskMem(ppsz);
				}
				if (ppsi != IntPtr.Zero)
				{
					Vt<DRelease>(ppsi, 2)(ppsi);
				}
				if (ppv2 != IntPtr.Zero)
				{
					Vt<DRelease>(ppv2, 2)(ppv2);
				}
				if (ppv != IntPtr.Zero)
				{
					Vt<DRelease>(ppv, 2)(ppv);
				}
			}
		}

		private static string DirectoryOf(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return null;
			}
			try
			{
				if (Directory.Exists(path))
				{
					return path;
				}
				string directoryName = Path.GetDirectoryName(path);
				return string.IsNullOrEmpty(directoryName) ? path : directoryName;
			}
			catch (Exception)
			{
				return path;
			}
		}

		private static string TryShBrowseForFolder(IntPtr owner, string title, bool sta)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(520);
			IntPtr intPtr2 = Marshal.AllocHGlobal(520);
			IntPtr intPtr3 = (string.IsNullOrEmpty(title) ? IntPtr.Zero : Marshal.StringToCoTaskMemUni(title));
			IntPtr intPtr4 = IntPtr.Zero;
			try
			{
				BROWSEINFO bi = new BROWSEINFO
				{
					hwndOwner = owner,
					pszDisplayName = intPtr,
					lpszTitle = intPtr3,
					ulFlags = (uint)(1 | (sta ? 64 : 0))
				};
				intPtr4 = SHBrowseForFolderW(ref bi);
				if (intPtr4 == IntPtr.Zero)
				{
					return null;
				}
				return SHGetPathFromIDListW(intPtr4, intPtr2) ? Marshal.PtrToStringUni(intPtr2) : null;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("SHBrowseForFolder failed: " + ex.Message));
				return null;
			}
			finally
			{
				if (intPtr4 != IntPtr.Zero)
				{
					Marshal.FreeCoTaskMem(intPtr4);
				}
				Marshal.FreeHGlobal(intPtr2);
				Marshal.FreeHGlobal(intPtr);
				if (intPtr3 != IntPtr.Zero)
				{
					Marshal.FreeCoTaskMem(intPtr3);
				}
			}
		}

		private static IntPtr GetGameWindow()
		{
			if (_hwnd != IntPtr.Zero && IsWindow(_hwnd))
			{
				return _hwnd;
			}
			IntPtr exact = IntPtr.Zero;
			IntPtr loose = IntPtr.Zero;
			uint self = (uint)Process.GetCurrentProcess().Id;
			EnumWindowsProc obj = delegate(IntPtr h, IntPtr l)
			{
				GetWindowThreadProcessId(h, out var pid);
				if (pid != self || !IsWindowVisible(h))
				{
					return true;
				}
				if (GetWindow(h, 4u) != IntPtr.Zero)
				{
					return true;
				}
				StringBuilder stringBuilder = new StringBuilder(256);
				GetClassNameW(h, stringBuilder, stringBuilder.Capacity);
				string text = stringBuilder.ToString();
				if (text == "ConsoleWindowClass")
				{
					return true;
				}
				if (text == "UnityWndClass")
				{
					exact = h;
					return false;
				}
				if (loose == IntPtr.Zero)
				{
					loose = h;
				}
				return true;
			};
			EnumWindows(obj, IntPtr.Zero);
			GC.KeepAlive(obj);
			_hwnd = ((exact != IntPtr.Zero) ? exact : loose);
			if (_hwnd == IntPtr.Zero)
			{
				_hwnd = GetActiveWindow();
			}
			return _hwnd;
		}

		private static bool TrySetTopmost(bool value, out bool previous)
		{
			previous = false;
			try
			{
				Type type = Type.GetType("Kirurobo.UniWindowController, Unity.UniWindowController", throwOnError: false);
				if (type == null)
				{
					return false;
				}
				Object[] array = Object.FindObjectsByType(type, (FindObjectsInactive)1, (FindObjectsSortMode)0);
				if (array == null || array.Length == 0)
				{
					return false;
				}
				PropertyInfo property = type.GetProperty("isTopmost", BindingFlags.Instance | BindingFlags.Public);
				if (property == null)
				{
					return false;
				}
				previous = (bool)property.GetValue(array[0]);
				if (previous != value)
				{
					property.SetValue(array[0], value);
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Folder picker: could not adjust the always-on-top flag: " + ex.Message));
				return false;
			}
		}

		[DllImport("ole32.dll")]
		private static extern int CoInitializeEx(IntPtr reserved, uint coInit);

		[DllImport("ole32.dll")]
		private static extern void CoUninitialize();

		[DllImport("ole32.dll")]
		private static extern int CoCreateInstance(ref Guid rclsid, IntPtr outer, uint clsCtx, ref Guid riid, out IntPtr ppv);

		[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
		private static extern int SHCreateItemFromParsingName([MarshalAs(UnmanagedType.LPWStr)] string path, IntPtr bc, ref Guid riid, out IntPtr ppv);

		[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
		private static extern IntPtr SHBrowseForFolderW(ref BROWSEINFO bi);

		[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool SHGetPathFromIDListW(IntPtr pidl, IntPtr pszPath);

		[DllImport("user32.dll")]
		private static extern bool EnumWindows(EnumWindowsProc cb, IntPtr lParam);

		[DllImport("user32.dll")]
		private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);

		[DllImport("user32.dll")]
		private static extern bool IsWindowVisible(IntPtr hWnd);

		[DllImport("user32.dll")]
		private static extern bool IsWindow(IntPtr hWnd);

		[DllImport("user32.dll")]
		private static extern IntPtr GetWindow(IntPtr hWnd, uint cmd);

		[DllImport("user32.dll")]
		private static extern IntPtr GetActiveWindow();

		[DllImport("user32.dll", CharSet = CharSet.Unicode)]
		private static extern int GetClassNameW(IntPtr hWnd, StringBuilder buf, int max);
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.Patches
{
	[HarmonyPatch]
	public static class LifecyclePatches
	{
		[HarmonyPatch(typeof(MainSceneManager), "ReturnMenu")]
		[HarmonyPrefix]
		private static void ReturnMenu_Prefix()
		{
			try
			{
				ClipCache.CancelInFlight();
				ShareController.OnLeaveLobby();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("ReturnMenu prefix: " + ex));
			}
		}
	}
	[HarmonyPatch]
	public static class SoundManagerPatches
	{
		[HarmonyPatch(typeof(SoundManager), "Start")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Start_Prefix(SoundManager __instance)
		{
			try
			{
				MixtapeBridge.EnsureMixtape(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("EnsureMixtape failed, local playlist off: " + ex));
				MixtapeBridge.Disable();
			}
		}

		[HarmonyPatch(typeof(SoundManager), "PlayMixtape")]
		[HarmonyPrefix]
		private static void PlayMixtape_Prefix(SoundManager __instance)
		{
			try
			{
				MixtapeBridge.BeforePlayMixtape(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("BeforePlayMixtape failed, local playlist off: " + ex));
				MixtapeBridge.Disable();
			}
		}

		[HarmonyPatch(typeof(SoundManager), "ChangeMixtape")]
		[HarmonyPostfix]
		private static void ChangeMixtape_Postfix(SoundManager __instance)
		{
			try
			{
				MixtapeBridge.OnMixtapeChanged(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("OnMixtapeChanged: " + ex));
			}
		}

		[HarmonyPatch(typeof(SoundManager), "SetupInGameMusic")]
		[HarmonyPostfix]
		private static void SetupInGameMusic_Postfix(SoundManager __instance)
		{
			try
			{
				MixtapeBridge.OnSongChanged(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("SetupInGameMusic postfix: " + ex));
			}
		}
	}
	[HarmonyPatch]
	public static class UiBuildPatches
	{
		[HarmonyPatch(typeof(UIManager), "Awake")]
		[HarmonyPostfix]
		private static void UIManager_Awake_Postfix(UIManager __instance)
		{
			try
			{
				UiBuilder.BuildMusicUi(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("BuildMusicUi: " + ex));
			}
		}

		[HarmonyPatch(typeof(UIManager), "UpdateStreamerModeUI")]
		[HarmonyPostfix]
		private static void UpdateStreamerModeUI_Postfix(bool value)
		{
			try
			{
				SeekBar.SetInteractable(!value);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("UpdateStreamerModeUI postfix: " + ex));
			}
		}
	}
	[HarmonyPatch]
	public static class UIManagerPatches
	{
		[HarmonyPatch(typeof(UIManager), "LoadMixtape")]
		[HarmonyPostfix]
		private static void LoadMixtape_Postfix()
		{
			try
			{
				SoundManager i = MonoSingleton<SoundManager>.I;
				if ((Object)(object)i != (Object)null && MixtapeBridge.IsOurs(i))
				{
					MixtapeBridge.RefreshNowPlaying(i);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("LoadMixtape postfix: " + ex));
			}
		}

		[HarmonyPatch(typeof(UIManager), "SetupMixtapeSongs")]
		[HarmonyPostfix]
		private static void SetupMixtapeSongs_Postfix(UIManager __instance)
		{
			try
			{
				if (MixtapeBridge.Active)
				{
					object? obj = AccessTools.Field(typeof(UIManager), "_mixTapeNext")?.GetValue(__instance);
					GameObject val = (GameObject)((obj is GameObject) ? obj : null);
					object? obj2 = AccessTools.Field(typeof(UIManager), "_mixTapePrevious")?.GetValue(__instance);
					GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
					if ((Object)(object)val != (Object)null && !val.activeSelf)
					{
						val.SetActive(true);
					}
					if ((Object)(object)val2 != (Object)null && !val2.activeSelf)
					{
						val2.SetActive(true);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("SetupMixtapeSongs postfix: " + ex));
			}
		}
	}
}
namespace SleepeyDev.OnTogetherLocalPlaylist.Net
{
	public struct Peer
	{
		public CSteamID Id;

		public string Name;

		public int ProtocolVersion;

		public bool Broadcasting;
	}
	public static class Discovery
	{
		private const string Key = "otlp";

		private const float MinWriteInterval = 5f;

		private const float RefreshInterval = 2f;

		private static string _lastWritten;

		private static float _lastWriteAt = -999f;

		private static string _pending;

		private static float _lastRefresh = -999f;

		private static readonly List<Peer> Cached = new List<Peer>();

		private static readonly HashSet<ulong> Allowed = new HashSet<ulong>();

		public static IReadOnlyList<Peer> Peers => Cached;

		public static bool TryGetLobby(out CSteamID lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				string text = (((Object)(object)i != (Object)null) ? i.LobbyCode : null);
				if (string.IsNullOrEmpty(text))
				{
					return false;
				}
				if (!ulong.TryParse(text, out var result) || result == 0L)
				{
					return false;
				}
				lobby = new CSteamID(result);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static void Advertise(bool present, bool broadcasting)
		{
			_pending = (present ? ((byte)1 + "|" + (broadcasting ? "B" : "-")) : null);
		}

		public static void Tick()
		{
			FlushAdvertisement();
			RefreshPeers();
		}

		private static void FlushAdvertisement()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (_pending == _lastWritten || Time.unscaledTime - _lastWriteAt < 5f || !TryGetLobby(out var lobby))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "otlp", _pending ?? "");
				_lastWritten = _pending;
				_lastWriteAt = Time.unscaledTime;
				if (ModConfig.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Advertised presence as '" + _pending + "'."));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not publish presence: " + ex.Message));
			}
		}

		private static void RefreshPeers()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime - _lastRefresh < 2f)
			{
				return;
			}
			_lastRefresh = Time.unscaledTime;
			Cached.Clear();
			Allowed.Clear();
			if (!TryGetLobby(out var lobby))
			{
				return;
			}
			CSteamID val = CSteamID.Nil;
			try
			{
				val = SteamUser.GetSteamID();
			}
			catch (Exception)
			{
			}
			try
			{
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
				for (int i = 0; i < numLobbyMembers; i++)
				{
					CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
					if (!(lobbyMemberByIndex == val))
					{
						string lobbyMemberData = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "otlp");
						if (!string.IsNullOrEmpty(lobbyMemberData) && TryParse(lobbyMemberData, out var version, out var broadcasting))
						{
							Allowed.Add(lobbyMemberByIndex.m_SteamID);
							Cached.Add(new Peer
							{
								Id = lobbyMemberByIndex,
								Name = SafeName(lobbyMemberByIndex),
								ProtocolVersion = version,
								Broadcasting = broadcasting
							});
						}
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("Enumerating lobby members failed: " + ex2.Message));
			}
		}

		private static bool TryParse(string data, out int version, out bool broadcasting)
		{
			version = 0;
			broadcasting = false;
			int num = data.IndexOf('|');
			if (!int.TryParse((num < 0) ? data : data.Substring(0, num), out version))
			{
				return false;
			}
			broadcasting = num >= 0 && data.IndexOf('B', num) >= 0;
			return true;
		}

		private static string SafeName(CSteamID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string friendPersonaName = SteamFriends.GetFriendPersonaName(id);
				return string.IsNullOrEmpty(friendPersonaName) ? id.m_SteamID.ToString() : friendPersonaName;
			}
			catch (Exception)
			{
				return id.m_SteamID.ToString();
			}
		}

		public static bool IsAllowed(CSteamID peer)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Allowed.Contains(peer.m_SteamID);
		}

		public static bool TryGetPeer(CSteamID id, out Peer peer)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			foreach (Peer item in Cached)
			{
				if (!(item.Id != id))
				{
					peer = item;
					return true;
				}
			}
			peer = default(Peer);
			return false;
		}

		public static void Reset()
		{
			Cached.Clear();
			Allowed.Clear();
			_pending = null;
			_lastWritten = null;
			_lastWriteAt = -999f;
			_lastRefresh = -999f;
		}
	}
	public enum WireFormat : byte
	{
		Unknown,
		Mp3,
		Ogg,
		Wav,
		Aiff
	}
	[Flags]
	public enum BeaconFlags : byte
	{
		None = 0,
		Playing = 1,
		Paused = 2,
		Buffering = 4,
		TrackEnded = 8
	}
	public enum SubReason : byte
	{
		Ok,
		Full,
		NotAllowed,
		NotBroadcasting,
		VersionMismatch
	}
	public struct Offer
	{
		public uint SessionId;

		public byte Slot;

		public uint TrackId;

		public uint Bytes;

		public uint DurationMs;

		public WireFormat Format;

		public uint Crc32;

		public string Title;

		public string Artist;

		public int ChunkCount
		{
			get
			{
				if (Bytes != 0)
				{
					return (int)((Bytes + 32768 - 1) / 32768);
				}
				return 0;
			}
		}
	}
	public struct Want
	{
		public uint SessionId;

		public uint TrackId;

		public uint FromChunk;

		public ushort Window;
	}
	public struct Beacon
	{
		public uint SessionId;

		public uint TrackId;

		public uint Seq;

		public long SentUs;

		public uint PosMs;

		public BeaconFlags Flags;

		public uint NextTrackId;
	}
	public static class Messages
	{
		public const int MaxTitle = 96;

		public const int MaxArtist = 64;

		public const int MaxName = 64;

		public const int NackBitmapBytes = 32;

		public static int Hello(byte[] buf, byte caps, string name)
		{
			Wire.Writer writer = new Wire.Writer(buf);
			writer.Reset();
			Wire.Writer writer2 = new Wire.Writer(new byte[66]);
			writer2.U8(caps);
			writer2.Str(name, 64);
			return Frame(writer, MsgType.Hello, writer2);
		}

		public static int Bye(byte[] buf, byte reason)
		{
			Wire.Writer writer = new Wire.Writer(new byte[1]);
			writer.U8(reason);
			return Frame(new Wire.Writer(buf), MsgType.Bye, writer);
		}

		public static int Sub(byte[] buf, bool subscribe)
		{
			Wire.Writer writer = new Wire.Writer(new byte[1]);
			writer.U8(subscribe ? ((byte)1) : ((byte)0));
			return Frame(new Wire.Writer(buf), MsgType.Sub, writer);
		}

		public static int SubAck(byte[] buf, bool accepted, SubReason reason, uint sessionId)
		{
			Wire.Writer writer = new Wire.Writer(new byte[6]);
			writer.U8(accepted ? ((byte)1) : ((byte)0));
			writer.U8((byte)reason);
			writer.U32(sessionId);
			return Frame(new Wire.Writer(buf), MsgType.SubAck, writer);
		}

		public static int Ping(byte[] buf, long t0Us)
		{
			Wire.Writer writer = new Wire.Writer(new byte[8]);
			writer.I64(t0Us);
			return Frame(new Wire.Writer(buf), MsgType.Ping, writer);
		}

		public static int Pong(byte[] buf, long t0Us, long t1Us)
		{
			Wire.Writer writer = new Wire.Writer(new byte[16]);
			writer.I64(t0Us);
			writer.I64(t1Us);
			return Frame(new Wire.Writer(buf), MsgType.Pong, writer);
		}

		public static int EncodeOffer(byte[] buf, in Offer o)
		{
			Wire.Writer writer = new Wire.Writer(new byte[196]);
			writer.U32(o.SessionId);
			writer.U8(o.Slot);
			writer.U32(o.TrackId);
			writer.U32(o.Bytes);
			writer.U32(o.DurationMs);
			writer.U8((byte)o.Format);
			writer.U32(o.Crc32);
			writer.Str(o.Title, 96);
			writer.Str(o.Artist, 64);
			return Frame(new Wire.Writer(buf), MsgType.Offer, writer);
		}

		public static int EncodeWant(byte[] buf, in Want v)
		{
			Wire.Writer writer = new Wire.Writer(new byte[14]);
			writer.U32(v.SessionId);
			writer.U32(v.TrackId);
			writer.U32(v.FromChunk);
			writer.U16(v.Window);
			return Frame(new Wire.Writer(buf), MsgType.Want, writer);
		}

		public static int Have(byte[] buf, uint sessionId, uint trackId)
		{
			Wire.Writer writer = new Wire.Writer(new byte[8]);
			writer.U32(sessionId);
			writer.U32(trackId);
			return Frame(new Wire.Writer(buf), MsgType.Have, writer);
		}

		public static int Cancel(byte[] buf, uint sessionId, uint trackId, byte reason)
		{
			Wire.Writer writer = new Wire.Writer(new byte[9]);
			writer.U32(sessionId);
			writer.U32(trackId);
			writer.U8(reason);
			return Frame(new Wire.Writer(buf), MsgType.Cancel, writer);
		}

		public static int Nack(byte[] buf, uint sessionId, uint trackId, uint firstMissing, byte[] bitmap)
		{
			Wire.Writer writer = new Wire.Writer(new byte[44]);
			writer.U32(sessionId);
			writer.U32(trackId);
			writer.U32(firstMissing);
			for (int i = 0; i < 32; i++)
			{
				writer.U8((byte)((bitmap != null && i < bitmap.Length) ? bitmap[i] : 0));
			}
			return Frame(new Wire.Writer(buf), MsgType.Nack, writer);
		}

		public static int EncodeData(byte[] buf, uint sessionId, uint trackId, uint chunkIdx, byte[] payload, int offset, int count)
		{
			if (count < 0 || count > 32768)
			{
				return 0;
			}
			Wire.Writer writer = new Wire.Writer(buf);
			writer.Reset();
			Wire.WriteHeader(writer, MsgType.Data, 14 + count);
			writer.U32(sessionId);
			writer.U32(trackId);
			writer.U32(chunkIdx);
			writer.U16((ushort)count);
			writer.Bytes(payload, offset, count);
			if (!writer.Overflowed)
			{
				return writer.Length;
			}
			return 0;
		}

		public static int EncodeBeacon(byte[] buf, in Beacon b)
		{
			Wire.Writer writer = new Wire.Writer(new byte[29]);
			writer.U32(b.SessionId);
			writer.U32(b.TrackId);
			writer.U32(b.Seq);
			writer.I64(b.SentUs);
			writer.U32(b.PosMs);
			writer.U8((byte)b.Flags);
			writer.U32(b.NextTrackId);
			return Frame(new Wire.Writer(buf), MsgType.Beacon, writer);
		}

		private static int Frame(Wire.Writer w, MsgType type, Wire.Writer body)
		{
			if (body.Overflowed)
			{
				return 0;
			}
			w.Reset();
			Wire.WriteHeader(w, type, body.Length);
			w.Bytes(body.Buffer, 0, body.Length);
			if (!w.Overflowed)
			{
				return w.Length;
			}
			return 0;
		}

		public static bool DecodeOffer(Wire.Reader r, out Offer o)
		{
			o = default(Offer);
			o.SessionId = r.U32();
			o.Slot = r.U8();
			o.TrackId = r.U32();
			o.Bytes = r.U32();
			o.DurationMs = r.U32();
			o.Format = (WireFormat)r.U8();
			o.Crc32 = r.U32();
			o.Title = r.Str(96);
			o.Artist = r.Str(64);
			return !r.Failed;
		}

		public static bool DecodeWant(Wire.Reader r, out Want v)
		{
			v = default(Want);
			v.SessionId = r.U32();
			v.TrackId = r.U32();
			v.FromChunk = r.U32();
			v.Window = r.U16();
			return !r.Failed;
		}

		public static bool DecodeBeacon(Wire.Reader r, out Beacon b)
		{
			b = default(Beacon);
			b.SessionId = r.U32();
			b.TrackId = r.U32();
			b.Seq = r.U32();
			b.SentUs = r.I64();
			b.PosMs = r.U32();
			b.Flags = (BeaconFlags)r.U8();
			b.NextTrackId = r.U32();
			return !r.Failed;
		}

		public static bool DecodeData(Wire.Reader r, byte[] dest, out uint sessionId, out uint trackId, out uint chunkIdx, out int count)
		{
			sessionId = r.U32();
			trackId = r.U32();
			chunkIdx = r.U32();
			count = r.U16();
			if (r.Failed || count > 32768 || count > dest.Length)
			{
				count = 0;
				return false;
			}
			count = r.BytesInto(dest, 0, count);
			return !r.Failed;
		}
	}
	public static class P2PTransport
	{
		private sealed class Meter
		{
			public float WindowStart;

			public int Bytes;

			public int Dropped;
		}

		public const int ChannelControl = 2;

		public const int ChannelBulk = 3;

		public const int ChannelBeacon = 4;

		private static readonly int[] Channels = new int[3] { 2, 3, 4 };

		private const int ScratchSize = 32854;

		private const int MaxPacketsPerChannelPerFrame = 64;

		private const int PerPeerBytesPerSecond = 524288;

		private static readonly byte[] Scratch = new byte[32854];

		private static readonly byte[] SendBuf = new byte[32854];

		private static Callback<P2PSessionConnectFail_t> _connectFail;

		private static readonly Dictionary<ulong, Meter> Meters = new Dictionary<ulong, Meter>();

		private static bool _started;

		private static int _consecutiveReadFailures;

		public static Func<CSteamID, bool> PeerFilter;

		private static readonly HashSet<ulong> Warned = new HashSet<ulong>();

		public static event Action<CSteamID, MsgType, byte[], int, int> OnMessage;

		public static event Action<CSteamID, EP2PSessionError> OnPeerUnreachable;

		public static void Start()
		{
			if (_started)
			{
				return;
			}
			_started = true;
			if (!Wire.IsLittleEndianHost)
			{
				Plugin.Log.LogError((object)"Big-endian host: the sharing protocol assumes little-endian. Disabled.");
				_started = false;
				return;
			}
			try
			{
				_connectFail = Callback<P2PSessionConnectFail_t>.Create((DispatchDelegate<P2PSessionConnectFail_t>)OnConnectFail);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not register the P2P failure callback: " + ex.Message));
			}
		}

		public static void Stop(IEnumerable<CSteamID> peers)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (peers != null)
			{
				foreach (CSteamID peer in peers)
				{
					CloseChannels(peer);
				}
			}
			try
			{
				_connectFail?.Dispose();
			}
			catch (Exception)
			{
			}
			_connectFail = null;
			_started = false;
			Meters.Clear();
		}

		public static void CloseChannels(CSteamID peer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			int[] channels = Channels;
			foreach (int num in channels)
			{
				try
				{
					SteamNetworking.CloseP2PChannelWithUser(peer, num);
				}
				catch (Exception)
				{
				}
			}
		}

		public static bool Send(CSteamID peer, byte[] data, int length, int channel, bool reliable = true)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (data == null || length <= 0 || length > 32854)
			{
				return false;
			}
			try
			{
				EP2PSend val = (EP2PSend)((!reliable) ? 1 : 2);
				return SteamNetworking.SendP2PPacket(peer, data, (uint)length, val, channel);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("P2P send failed: " + ex.Message));
				return false;
			}
		}

		public static bool SendControl(CSteamID peer, Func<byte[], int> encode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return SendEncoded(peer, encode, 2, reliable: true);
		}

		public static bool SendBulk(CSteamID peer, Func<byte[], int> encode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return SendEncoded(peer, encode, 3, reliable: true);
		}

		public static bool SendBeacon(CSteamID peer, Func<byte[], int> encode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return SendEncoded(peer, encode, 4, reliable: false);
		}

		private static bool SendEncoded(CSteamID peer, Func<byte[], int> encode, int channel, bool reliable)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			int num;
			try
			{
				num = encode(SendBuf);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Encoding a message failed: " + ex));
				return false;
			}
			if (num > 0)
			{
				return Send(peer, SendBuf, num, channel, reliable);
			}
			return false;
		}

		public static int QueuedBytes(CSteamID peer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				P2PSessionState_t val = default(P2PSessionState_t);
				if (SteamNetworking.GetP2PSessionState(peer, ref val))
				{
					return val.m_nBytesQueuedForSend;
				}
			}
			catch (Exception)
			{
			}
			return -1;
		}

		public static void Pump()
		{
			if (_started)
			{
				int[] channels = Channels;
				for (int i = 0; i < channels.Length; i++)
				{
					PumpChannel(channels[i]);
				}
			}
		}

		private static void PumpChannel(int channel)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			uint num = default(uint);
			uint length = default(uint);
			CSteamID val = default(CSteamID);
			for (int i = 0; i < 64; i++)
			{
				try
				{
					if (!SteamNetworking.IsP2PPacketAvailable(ref num, channel))
					{
						break;
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("P2P poll failed on channel " + channel + ": " + ex.Message));
					break;
				}
				if (num == 0 || num > 32854)
				{
					ReadAndDiscard(channel);
					continue;
				}
				bool flag;
				try
				{
					flag = SteamNetworking.ReadP2PPacket(Scratch, (uint)Scratch.Length, ref length, ref val, channel);
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)("P2P read failed on channel " + channel + ": " + ex2.Message));
					break;
				}
				if (!flag)
				{
					if (++_consecutiveReadFailures > 8)
					{
						_consecutiveReadFailures = 0;
						Plugin.Log.LogWarning((object)("Giving up on channel " + channel + " for this frame."));
						break;
					}
				}
				else
				{
					_consecutiveReadFailures = 0;
					Handle(val, (int)length);
				}
			}
		}

		private static void ReadAndDiscard(int channel)
		{
			try
			{
				uint num = default(uint);
				CSteamID val = default(CSteamID);
				SteamNetworking.ReadP2PPacket(Scratch, (uint)Scratch.Length, ref num, ref val, channel);
			}
			catch (Exception)
			{
			}
		}

		private static void Handle(CSteamID from, int length)
		{
			//IL_0000: 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)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!Allowed(from, length) || !Wire.TryReadHeader(Scratch, length, out var version, out var type, out var payloadOffset, out var payloadLength))
			{
				return;
			}
			if (version != 1)
			{
				LogOncePerPeer(from, "speaks protocol v" + version + ", we speak v" + (byte)1);
				return;
			}
			try
			{
				P2PTransport.OnMessage?.Invoke(from, type, Scratch, payloadOffset, payloadLength);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Handling a " + type.ToString() + " from " + from.m_SteamID + " threw: " + ex));
			}
		}

		private static bool Allowed(CSteamID from, int length)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Func<CSteamID, bool> peerFilter = PeerFilter;
			if (peerFilter != null)
			{
				bool flag;
				try
				{
					flag = peerFilter(from);
				}
				catch (Exception)
				{
					flag = false;
				}
				if (!flag)
				{
					return false;
				}
			}
			if (!Meters.TryGetValue(from.m_SteamID, out var value))
			{
				value = new Meter
				{
					WindowStart = Time.unscaledTime
				};
				Meters[from.m_SteamID] = value;
			}
			if (Time.unscaledTime - value.WindowStart >= 1f)
			{
				if (value.Dropped > 0)
				{
					Plugin.Log.LogWarning((object)("Rate-limited " + value.Dropped + " packet(s) from " + from.m_SteamID + "."));
				}
				value.WindowStart = Time.unscaledTime;
				value.Bytes = 0;
				value.Dropped = 0;
			}
			if (value.Bytes + length > 524288)
			{
				value.Dropped++;
				return false;
			}
			value.Bytes += length;
			return true;
		}

		private static void LogOncePerPeer(CSteamID peer, string message)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (Warned.Add(peer.m_SteamID))
			{
				Plugin.Log.LogWarning((object)("Peer " + peer.m_SteamID + " " + message + "."));
			}
		}

		private static void OnConnectFail(P2PSessionConnectFail_t e)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			CSteamID arg = default(CSteamID);
			((CSteamID)(ref arg))..ctor(e.m_steamIDRemote.m_SteamID);
			Plugin.Log.LogInfo((object)("P2P session with " + arg.m_SteamID + " failed: " + ((object)(EP2PSessionError)e.m_eP2PSessionError/*cast due to .constrained prefix*/).ToString() + " (retryable)."));
			try
			{
				P2PTransport.OnPeerUnreachable?.Invoke(arg, (EP2PSessionError)e.m_eP2PSessionError);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("OnPeerUnreachable handler threw: " + ex));
			}
		}
	}
	public interface IChunkStore : IDisposable
	{
		void Write(long offset, byte[] data, int dataOffset, int count);

		void Flush();
	}
	public sealed class Spool : IDisposable
	{
		private readonly bool[] _have;

		private readonly IChunkStore _store;

		private int _firstMissing;

		public uint TrackId { get; }

		public uint SessionId { get; set; }

		public long TotalBytes { get; }

		public int ChunkCount { get; }

		public int HaveCount { get; private set; }

		public uint ExpectedCrc32 { get; }

		public bool Complete => HaveCount >= ChunkCount;

		public float Progress
		{
			get
			{
				if (ChunkCount != 0)
				{
					return (float)HaveCount / (float)ChunkCount;
				}
				return 1f;
			}
		}

		public int FirstMissing
		{
			get
			{
				while (_firstMissing < ChunkCount && _have[_firstMissing])
				{
					_firstMissing++;
				}
				return _firstMissing;
			}
		}

		public Spool(uint trackId, uint sessionId, long totalBytes, uint crc32, IChunkStore store)
		{
			if (totalBytes < 0)
			{
				throw new ArgumentOutOfRangeException("totalBytes");
			}
			TrackId = trackId;
			SessionId = sessionId;
			TotalBytes = totalBytes;
			ExpectedCrc32 = crc32;
			_store = store;
			ChunkCount = (int)((totalBytes + 32768 - 1) / 32768);
			_have = new bool[Math.Max(1, ChunkCount)];
		}

		public int ExpectedChunkSize(int index)
		{
			if (index < 0 || index >= ChunkCount)
			{
				return -1;
			}
			long num = (long)index * 32768L;
			long val = TotalBytes - num;
			return (int)Math.Min(32768L, val);
		}

		public bool HasChunk(int index)
		{
			if (index >= 0 && index < ChunkCount)
			{
				return _have[index];
			}
			return false;
		}

		public bool Accept(uint chunkIdx, byte[] data, int count)
		{
			if (data == null)
			{
				return false;
			}
			if (chunkIdx >= (uint)ChunkCount)
			{
				return false;
			}
			if (_have[chunkIdx])
			{
				return false;
			}
			if (count != ExpectedChunkSize((int)chunkIdx))
			{
				return false;
			}
			if (count > data.Length)
			{
				return false;
			}
			try
			{
				_store.Write((long)(int)chunkIdx * 32768L, data, 0, count);
			}
			catch (Exception)
			{
				return false;
			}
			_have[chunkIdx] = true;
			HaveCount++;
			return true;
		}

		public byte[] MissingBitmap(out uint firstMissing)
		{
			int num = (int)(firstMissing = (uint)FirstMissing);
			byte[] array = new byte[32];
			for (int i = 0; i < 256; i++)
			{
				int num2 = num + i;
				if (num2 >= ChunkCount)
				{
					break;
				}
				if (_have[num2])
				{
					array[i >> 3] |= (byte)(1 << (i & 7));
				}
			}
			return array;
		}

		public void Flush()
		{
			try
			{
				_store.Flush();
			}
			catch (Exception)
			{
			}
		}

		public void Dispose()
		{
			try
			{
				_store?.Dispose();
			}
			catch (Exception)
			{
			}
		}
	}
	public static class Crc32
	{
		private static readonly uint[] Table = Build();

		private static uint[] Build()
		{
			uint[] array = new uint[256];
			for (uint num = 0u; num < 256; num++)
			{
				uint num2 = num;
				for (int i = 0; i < 8; i++)
				{
					num2 = (((num2 & 1) != 0) ? (0xEDB88320u ^ (num2 >> 1)) : (num2 >> 1));
				}
				array[num] = num2;
			}
			return array;
		}

		public static uint Update(uint crc, byte[] data, int offset, int count)
		{
			uint num = crc ^ 0xFFFFFFFFu;
			for (int i = 0; i < count; i++)
			{
				num = Table[(num ^ data[offset + i]) & 0xFF] ^ (num >> 8);
			}
			return num ^ 0xFFFFFFFFu;
		}

		public static uint Compute(byte[] data, int offset, int count)
		{
			return Update(0u, data, offset, count);
		}
	}
	public enum SyncAction
	{
		Hold,
		Nudge,
		Seek
	}
	public static class SyncMath
	{
		public sealed class Smoother
		{
			private readonly double _alpha;

			private bool _seeded;

			public double Value { get; private set; }

			public Smoother(double alpha = 0.35)
			{
				_alpha = alpha;
			}

			public double Push(double sample)
			{
				Value = (_seeded ? (Value + _alpha * (sample - Value)) : sample);
				_seeded = true;
				return Value;
			}

			public void Reset()
			{
				_seeded = false;
				Value = 0.0;
			}
		}

		public sealed class OffsetEstimator
		{
			private readonly long[] _samples;

			private readonly long[] _rtts;

			private int _count;

			private int _next;

			public bool HasEstimate => _count > 0;

			public OffsetEstimator(int window = 5)
			{
				_samples = new long[Math.Max(1, window)];
				_rtts = new long[_samples.Length];
			}

			public void Push(long offsetUs, long rttUs)
			{
				_samples[_next] = offsetUs;
				_rtts[_next] = rttUs;
				_next = (_next + 1) % _samples.Length;
				if (_count < _samples.Length)
				{
					_count++;
				}
			}

			public long Best()
			{
				if (_count == 0)
				{
					return 0L;
				}
				int num = 0;
				for (int i = 1; i < _count; i++)
				{
					if (_rtts[i] < _rtts[num])
					{
						num = i;
					}
				}
				return _samples[num];
			}

			public void Reset()
			{
				_count = 0;
				_next = 0;
			}
		}

		public const double DeadbandSeconds = 0.06;

		public const double SeekThresholdSeconds = 0.3;

		public const double MaxPitchDelta = 0.04;

		private const double PitchGain = 0.25;

		public static long Offset(long t0Us, long t1Us, long t3Us)
		{
			return t1Us - (t0Us + t3Us) / 2;
		}

		public static long RoundTrip(long t0Us, long t3Us)
		{
			return Math.Max(0L, t3Us - t0Us);
		}

		public static double TargetSeconds(uint beaconPosMs, long beaconSentUs, long nowUs, long clockOffsetUs, double latencySeconds)
		{
			double num = (double)(nowUs - (beaconSentUs - clockOffsetUs)) / 1000000.0;
			if (num < 0.0)
			{
				num = 0.0;
			}
			if (num > 5.0)
			{
				num = 5.0;
			}
			return (double)beaconPosMs / 1000.0 + num - latencySeconds;
		}

		public static SyncAction Decide(double errorSeconds)
		{
			double num = Math.Abs(errorSeconds);
			if (num < 0.06)
			{
				return SyncAction.Hold;
			}
			if (num < 0.3)
			{
				return SyncAction.Nudge;
			}
			return SyncAction.Seek;
		}

		public static float PitchFor(double smoothedErrorSeconds)
		{
			double num = smoothedErrorSeconds * 0.25;
			if (num > 0.04)
			{
				num = 0.04;
			}
			if (num < -0.04)
			{
				num = -0.04;
			}
			return (float)(1.0 + num);
		}
	}
	public enum MsgType : byte
	{
		Hello = 1,
		Bye = 2,
		Offer = 16,
		Want = 17,
		Have = 18,
		Nack = 19,
		Cancel = 20,
		Data = 32,
		Beacon = 48,
		Ping = 49,
		Pong = 50,
		Sub = 64,
		SubAck = 65
	}
	public static class Wire
	{
		public sealed class Writer
		{
			private readonly byte[] _buf;

			private int _pos;

			public int Length => _pos;

			public byte[] Buffer => _buf;

			public bool Overflowed { get; private set; }

			public Writer(byte[] buffer)
			{
				_buf = buffer;
			}

			public void Reset()
			{
				_pos = 0;
				Overflowed = false;
			}

			private bool Room(int n)
			{
				if (_pos + n <= _buf.Length)
				{
					return true;
				}
				Overflowed = true;
				return false;
			}

			public void U8(byte v)
			{
				if (Room(1))
				{
					_buf[_pos++] = v;
				}
			}

			public void U16(ushort v)
			{
				if (Room(2))
				{
					_buf[_pos++] = (byte)v;
					_buf[_pos++] = (byte)(v >> 8);
				}
			}

			public void U32(uint v)
			{
				if (Room(4))
				{
					_buf[_pos++] = (byte)v;
					_buf[_pos++] = (byte)(v >> 8);
					_buf[_pos++] = (byte)(v >> 16);
					_buf[_pos++] = (byte)(v >> 24);
				}
			}

			public void I64(long v)
			{
				if (Room(8))
				{
					for (int i = 0; i < 8; i++)
					{
						_buf[_pos++] = (byte)(v >> i * 8);
					}
				}
			}

			public void Bytes(byte[] src)
			{
				Bytes(src, 0, (src != null) ? src.Length : 0);
			}

			public void Bytes(byte[] src, int offset, int count)
			{
				if (src != null && count > 0 && Room(count))
				{
					Array.Copy(src, offset, _buf, _pos, count);
					_pos += count;
				}
			}

			public void Str(string s, int maxBytes)
			{
				byte[] bytes = Encoding.UTF8.GetBytes(s ?? "");
				int num = Math.Min(bytes.Length, Math.Min(maxBytes, 255));
				while (num > 0 && num < bytes.Length && (bytes[num] & 0xC0) == 128)
				{
					num--;
				}
				U8((byte)num);
				Bytes(bytes, 0, num);
			}
		}

		public sealed class Reader
		{
			private readonly byte[] _buf;

			private int _pos;

			private readonly int _end;

			public bool Failed { get; private set; }

			public int Remaining => Math.Max(0, _end - _pos);

			public Reader(byte[] buffer, int offset, int count)
			{
				_buf = buffer;
				_pos = offset;
				_end = offset + count;
			}

			private bool Take(int n)
			{
				if (!Failed && _pos + n <= _end)
				{
					return true;
				}
				Failed = true;
				return false;
			}

			public byte U8()
			{
				if (!Take(1))
				{
					return 0;
				}
				return _buf[_pos++];
			}

			public ushort U16()
			{
				if (!Take(2))
				{
					return 0;
				}
				ushort result = (ushort)(_buf[_pos] | (_buf[_pos + 1] << 8));
				_pos += 2;
				return result;
			}

			public uint U32()
			{
				if (!Take(4))
				{
					return 0u;
				}
				int result = _buf[_pos] | (_buf[_pos + 1] << 8) | (_buf[_pos + 2] << 16) | (_buf[_pos + 3] << 24);
				_pos += 4;
				return (uint)result;
			}

			public long I64()
			{
				if (!Take(8))
				{
					return 0L;
				}
				long num = 0L;
				for (int i = 0; i < 8; i++)
				{
					num |= (long)((ulong)_buf[_pos + i] << i * 8);
				}
				_pos += 8;
				return num;
			}

			public byte[] Bytes(int count)
			{
				if (count < 0 || !Take(count))
				{
					return Array.Empty<byte>();
				}
				byte[] array = new byte[count];
				Array.Copy(_buf, _pos, array, 0, count);
				_pos += count;
				return array;
			}

			public int BytesInto(byte[] dest, int destOffset, int count)
			{
				if (count < 0 || dest == null || !Take(count))
				{
					return 0;
				}
				if (destOffset < 0 || destOffset + count > dest.Length)
				{
					Failed = true;
					return 0;
				}
				Array.Copy(_buf, _pos, dest, destOffset, count);
				_pos += count;
				return count;
			}

			public string Str(int maxBytes)
			{
				int num = U8();
				if (num > maxBytes)
				{
					Failed = true;
					return "";
				}
				byte[] bytes = Bytes(num);
				if (Failed)
				{
					return "";
				}
				try
				{
					return Encoding.UTF8.GetString(bytes);
				}
				catch (Exception)
				{
					Failed = true;
					return "";
				}
			}
		}

		public const byte Version = 1;

		public const int HeaderSize = 8;

		public const int MaxPayload = 32782;

		public const int ChunkSize = 32768;

		private static readonly byte[] Magic = new byte[4] { 79, 84, 76, 80 };

		public static bool IsLittleEndianHost => BitConverter.IsLittleEndian;

		public static void WriteHeader(Writer w, MsgType type, int payloadLength)
		{
			w.Bytes(Magic);
			w.U8(1);
			w.U8((byte)type);
			w.U16((ushort)payloadLength);
		}

		public static bool TryReadHeader(byte[] buf, int length, out byte version, out MsgType type, out int payloadOffset, out int payloadLength)
		{
			version = 0;
			type = (MsgType)0;
			payloadOffset = 8;
			payloadLength = 0;
			if (buf == null || length < 8)
			{
				return false;
			}
			if (buf[0] != Magic[0] || buf[1] != Magic[1] || buf[2] != Magic[2] || buf[3] != Magic[3])
			{
				return false;
			}
			version = buf[4];
			type = (MsgType)buf[5];
			payloadLength = buf[6] | (buf[7] << 8);
			if (payloadLength >= 0 && payloadLength <= 32782)
			{
				return 8 + payloadLength == length;
			}
			return false;
		}
	}
}