using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using JetBrains.Annotations;
using JukeboxCore;
using JukeboxCore.Events;
using JukeboxCore.Exceptions;
using JukeboxCore.Models.Downloader;
using JukeboxCore.Utils;
using JukeboxDownloader.Events;
using JukeboxDownloader.Exceptions;
using JukeboxDownloader.Models;
using JukeboxDownloader.Service;
using JukeboxDownloader.Service.YouTube;
using JukeboxDownloader.UI;
using JukeboxDownloader.Utils;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YoutubeDLSharp;
using YoutubeDLSharp.Metadata;
using YoutubeDLSharp.Options;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("JukeboxDownloader")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("JukeboxDownloader")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5C0415F4-8665-489A-A19E-094051311242")]
[assembly: AssemblyFileVersion("2.1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.1.0.0")]
namespace JukeboxDownloader
{
	[BepInProcess("ULTRAKILL.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("dev.flazhik.jukebox.downloader", "JukeboxDownloader", "2.1.0")]
	public class JukeboxDownloaderPlugin : BaseUnityPlugin
	{
	}
	public class QueueManager : IDisposable
	{
		private readonly Channel<Func<CancellationToken, Task>> channel;

		private readonly List<Task> workers;

		private CancellationTokenSource token;

		private readonly object @lock = new object();

		private bool disposed;

		public QueueManager(int workersCount)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			channel = Channel.CreateUnbounded<Func<CancellationToken, Task>>(new UnboundedChannelOptions
			{
				SingleReader = false,
				SingleWriter = false
			});
			token = new CancellationTokenSource();
			workers = (from _ in Enumerable.Range(0, workersCount)
				select Task.Run((Func<Task?>)WorkerLoop)).ToList();
		}

		public void Enqueue(Func<CancellationToken, Task> taskFactory)
		{
			if (!((Channel<Func<CancellationToken, Task>, Func<CancellationToken, Task>>)(object)channel).Writer.TryWrite(taskFactory))
			{
				throw new InvalidOperationException("Queue is closed.");
			}
		}

		public void CancelAll()
		{
			lock (@lock)
			{
				token.Cancel();
				token.Dispose();
				token = new CancellationTokenSource();
				Func<CancellationToken, Task> func = default(Func<CancellationToken, Task>);
				while (((Channel<Func<CancellationToken, Task>, Func<CancellationToken, Task>>)(object)channel).Reader.TryRead(ref func))
				{
				}
			}
		}

		private async Task WorkerLoop()
		{
			Func<CancellationToken, Task> func = default(Func<CancellationToken, Task>);
			while (await ((Channel<Func<CancellationToken, Task>, Func<CancellationToken, Task>>)(object)channel).Reader.WaitToReadAsync(default(CancellationToken)))
			{
				if (((Channel<Func<CancellationToken, Task>, Func<CancellationToken, Task>>)(object)channel).Reader.TryRead(ref func))
				{
					CancellationToken ct;
					lock (@lock)
					{
						ct = token.Token;
					}
					try
					{
						await func(ct);
					}
					catch (OperationCanceledException) when (ct.IsCancellationRequested)
					{
					}
					ct = default(CancellationToken);
				}
			}
		}

		public void Dispose()
		{
			if (!disposed)
			{
				disposed = true;
				((Channel<Func<CancellationToken, Task>, Func<CancellationToken, Task>>)(object)channel).Writer.TryComplete((Exception)null);
				try
				{
					Task.WhenAll(workers).GetAwaiter().GetResult();
				}
				catch
				{
				}
				token.Cancel();
				token.Dispose();
			}
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "dev.flazhik.jukebox.downloader";

		public const string NAME = "JukeboxDownloader";

		public const string VERSION = "2.1.0";
	}
}
namespace JukeboxDownloader.Utils
{
	public static class ThirdPartySoftwareUtils
	{
		internal class FfmpegApi
		{
			public class Root
			{
				[JsonProperty("version")]
				public string Version { get; set; }

				[JsonProperty("permalink")]
				public string Permalink { get; set; }

				[JsonProperty("bin")]
				public Bin Bin { get; set; }
			}

			public class Bin
			{
				[JsonProperty("windows-64")]
				public OsBinVersion Windows64 { get; set; }
			}

			public class OsBinVersion
			{
				[JsonProperty("ffmpeg")]
				public string Ffmpeg { get; set; }

				[JsonProperty("ffprobe")]
				public string Ffprobe { get; set; }
			}
		}

		private const string FfmpegApiUrl = "https://ffbinaries.com/api/v1/version/6.1";

		private const string YtDlpUrl = "https://github.com/yt-dlp/yt-dlp/releases/download/2025.07.21/yt-dlp.exe";

		private static readonly List<string> BinariesNames = new List<string>
		{
			Utils.YtDlpBinaryName,
			Utils.FfmpegBinaryName,
			Utils.FfprobeBinaryName
		};

		private static readonly Dictionary<string, string> BinariesHashes = new Dictionary<string, string>
		{
			{ "ffmpeg.exe", "7afdd1037ac16bce65a7bb721818cc9fa0857059" },
			{ "ffprobe.exe", "678fcc1327c5d86c33e1f2e463bcb592f6c1643f" },
			{ "yt-dlp.exe", "66e4550d420a940fe75a6029439afb30665b73b8" }
		};

		private static readonly SHA1CryptoServiceProvider SHA1Provider = new SHA1CryptoServiceProvider();

		public static bool AllRequiredSoftwarePresent()
		{
			return BinariesNames.All(ThirdPartySoftwarePresent);
		}

		public static bool ValidateThirdPartySoftwareIntegrity()
		{
			return BinariesNames.All(ValidateBinaryIntegrity);
		}

		public static bool ThirdPartySoftwarePresent(string binary)
		{
			if (new FileInfo(Path.Combine(PathsUtils.AssemblyPath, binary)).Exists)
			{
				return BinariesHashes.ContainsKey(binary);
			}
			return false;
		}

		public static bool ValidateBinaryIntegrity(string binary)
		{
			FileInfo fileInfo = new FileInfo(Path.Combine(PathsUtils.AssemblyPath, binary));
			if (fileInfo.Exists)
			{
				return GetFileHash(fileInfo.FullName).Equals(BinariesHashes[binary]);
			}
			return false;
		}

		public static async Task DownloadYtDlp(WebClient client)
		{
			string text = Path.Combine(PathsUtils.AssemblyPath, Utils.YtDlpBinaryName);
			if (File.Exists(text))
			{
				File.Delete(text);
			}
			await client.DownloadFileTaskAsync(new Uri("https://github.com/yt-dlp/yt-dlp/releases/download/2025.07.21/yt-dlp.exe"), text);
		}

		public static async Task DownloadFfmpeg(WebClient client)
		{
			await DownloadFf(client, (FfmpegApi.OsBinVersion downloader) => downloader.Ffmpeg, "ffmpeg.exe");
		}

		public static async Task DownloadFfprobe(WebClient client)
		{
			await DownloadFf(client, (FfmpegApi.OsBinVersion downloader) => downloader.Ffprobe, "ffprobe.exe");
		}

		private static async Task DownloadFf(WebClient client, Func<FfmpegApi.OsBinVersion, string> url, string fileName)
		{
			string zipPath = Path.Combine(PathsUtils.AssemblyPath, fileName);
			FfmpegApi.OsBinVersion arg = await FfDownloader();
			if (File.Exists(zipPath))
			{
				File.Delete(zipPath);
			}
			await client.DownloadFileTaskAsync(new Uri(url(arg)), zipPath);
			await Task.Run(delegate
			{
				Unzip(zipPath);
			});
		}

		public static void CleanUp()
		{
			foreach (FileInfo item in from file in new DirectoryInfo(PathsUtils.AssemblyPath).EnumerateFiles()
				where file.Extension.ToLower().Equals(".zip")
				select file)
			{
				item.Delete();
			}
		}

		private static async Task<FfmpegApi.OsBinVersion> FfDownloader()
		{
			return JsonConvert.DeserializeObject<FfmpegApi.Root>(await NetworkUtils.GetRaw("https://ffbinaries.com/api/v1/version/6.1"))?.Bin.Windows64;
		}

		private static void Unzip(string path)
		{
			using MemoryStream stream = new MemoryStream(File.ReadAllBytes(path));
			using ZipArchive zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
			if (zipArchive.Entries.Count > 0)
			{
				string path2 = Path.Combine(PathsUtils.AssemblyPath, zipArchive.Entries[0].FullName);
				if (File.Exists(path2))
				{
					File.Delete(path2);
				}
				zipArchive.Entries[0].ExtractToFile(Path.Combine(PathsUtils.AssemblyPath, zipArchive.Entries[0].FullName), overwrite: true);
			}
		}

		private static string GetFileHash(string path)
		{
			using FileStream inputStream = File.OpenRead(path);
			byte[] array = SHA1Provider.ComputeHash(inputStream);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
}
namespace JukeboxDownloader.UI
{
	public class DownloadableTrackElement : MonoBehaviour
	{
		private static readonly Color DefaultColor = new Color(0f, 0f, 0f, 0.851f);

		private static readonly Color SuccessColor = new Color(0f, 0.2f, 0f, 0.851f);

		private static readonly Color FailColor = new Color(0.4f, 0f, 0f, 0.851f);

		[HideInInspector]
		public string id;

		[SerializeField]
		public TMP_Text titleText;

		[SerializeField]
		public TMP_Text artistText;

		[SerializeField]
		public TMP_Text progressPercentage;

		[SerializeField]
		public TMP_Text downloadEta;

		[SerializeField]
		public Image thumbnail;

		[SerializeField]
		public GradualProgressBar progressBar;

		[SerializeField]
		public Button downloadButton;

		[SerializeField]
		public Button retryButton;

		[SerializeField]
		public GameObject thumbnailPlaceholder;

		[SerializeField]
		public GameObject downloadProgressSection;

		[SerializeField]
		public GameObject enqueuedGo;

		[SerializeField]
		public GameObject preprocessingGo;

		[SerializeField]
		public GameObject postprocessingGo;

		private DownloaderUIEventManager uiEventManager;

		private MainThreadDispatcher mainThread;

		private void Awake()
		{
			uiEventManager = MonoSingleton<JukeboxDownloaderService>.Instance.UIEventManager;
			mainThread = MonoSingleton<MainThreadDispatcher>.Instance;
		}

		private void OnEnable()
		{
			DownloadableEntityState val = ((EventManager<DownloadableEntityState>)uiEventManager).StateOf(id);
			if (val != null)
			{
				SetTrackState(val);
			}
			((EventManager<DownloadableEntityState>)uiEventManager).Subscribe(id, (Action<JukeboxEvent<DownloadableEntityState>>)OnUpdated);
		}

		private void OnDisable()
		{
			((EventManager<DownloadableEntityState>)uiEventManager).Unsubscribe(id, (Action<JukeboxEvent<DownloadableEntityState>>)OnUpdated);
		}

		private void SetTrackState(DownloadableEntityState state)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			HandleState(state.state.Value);
			SetThumbnail(state.thumbnail);
			SetProgressBar(state);
			if (state.progress.HasValue)
			{
				progressPercentage.text = $"{(int)(state.progress.Value * 100f)}%";
			}
			if (state.eta != null)
			{
				progressPercentage.text = state.eta;
			}
		}

		private void SetThumbnail(Sprite texture)
		{
			thumbnailPlaceholder.SetActive((Object)(object)texture == (Object)null);
			((Component)thumbnail).gameObject.SetActive((Object)(object)texture != (Object)null);
			thumbnail.sprite = texture;
		}

		private void SetProgressBar(DownloadableEntityState state)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (state.state != (TrackDownloadingState?)3 || !state.progress.HasValue)
			{
				((Component)progressBar).gameObject.SetActive(false);
			}
			else
			{
				progressBar.ForceSetProgress(state.progress.Value);
			}
		}

		private void UpdateProgress(float progress)
		{
			progressBar.UpdateProgress(progress);
			progressPercentage.text = $"{(int)(progress * 100f)}%";
		}

		private void OnUpdated(JukeboxEvent<DownloadableEntityState> e)
		{
			mainThread.Enqueue((Action)delegate
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (e.newState.state.HasValue)
				{
					HandleState(e.newState.state.Value);
				}
				if ((Object)(object)e.newState.thumbnail != (Object)null)
				{
					SetThumbnail(e.newState.thumbnail);
				}
				if (e.newState.progress.HasValue)
				{
					UpdateProgress(e.newState.progress.Value);
				}
				if (e.newState.eta != null)
				{
					downloadEta.text = e.newState.eta;
				}
			});
		}

		private void HandleState(TrackDownloadingState state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_00a0: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			((Component)progressBar).gameObject.SetActive((int)state == 3);
			((Component)downloadButton).gameObject.SetActive((int)state == 0);
			((Component)retryButton).gameObject.SetActive((int)state == 6);
			downloadProgressSection.SetActive((int)state == 3);
			enqueuedGo.SetActive((int)state == 1);
			preprocessingGo.SetActive((int)state == 2);
			postprocessingGo.SetActive((int)state == 4);
			Image component = ((Component)this).GetComponent<Image>();
			Color color = (((int)state == 5) ? SuccessColor : (((int)state != 6) ? DefaultColor : FailColor));
			((Graphic)component).color = color;
		}
	}
	public class DownloaderErrorDialogue : MonoBehaviour
	{
		[SerializeField]
		public TMP_Text messageText;
	}
	public class GradualProgressBar : MonoBehaviour
	{
		private const float Epsilon = 0.001f;

		[SerializeField]
		public Slider progressBar;

		[SerializeField]
		public float smoothTime;

		private float progressBarTargetValue;

		private float progressBarVelocity;

		private void Update()
		{
			float num = progressBarTargetValue - progressBar.value;
			if (!(Math.Abs(num) < 0.001f))
			{
				if (num > 0f)
				{
					progressBar.value = Mathf.SmoothDamp(progressBar.value, progressBarTargetValue, ref progressBarVelocity, smoothTime, float.PositiveInfinity, Time.unscaledDeltaTime);
				}
				else
				{
					progressBar.value = progressBarTargetValue;
				}
			}
		}

		public void UpdateProgress(float progress)
		{
			progressBarTargetValue = progress;
		}

		public void ForceSetProgress(float progress)
		{
			progressBarTargetValue = progress;
			progressBar.value = progressBarTargetValue;
		}
	}
	public class TotalDownloadProgress : MonoBehaviour
	{
		[SerializeField]
		public TMP_Text downloadedText;

		[SerializeField]
		public TMP_Text failedText;

		[SerializeField]
		public TMP_Text enqueuedText;

		private int mDownloaded;

		private int mFailed;

		private int mEnqueued;

		public int Downloaded
		{
			set
			{
				mDownloaded = value;
				downloadedText.text = mDownloaded.ToString();
			}
		}

		public int Failed
		{
			set
			{
				mFailed = value;
				failedText.text = mFailed.ToString();
			}
		}

		public int Enqueued
		{
			set
			{
				mEnqueued = value;
				enqueuedText.text = mEnqueued.ToString();
			}
		}
	}
}
namespace JukeboxDownloader.Service
{
	public abstract class AbstractDownloaderClient
	{
		public abstract bool SupportsUrl(string url);

		public abstract Task<List<DownloadableSongMetadata>> GetMetadata(string url, CancellationToken token);

		public abstract Task Download(string url, string playlist, IProgress<DownloadProgress> progress, CancellationToken token);
	}
	public class DownloaderUIEventManager : EventManager<DownloadableEntityState>
	{
		private static readonly Dictionary<string, Sprite> ThumbnailCache = new Dictionary<string, Sprite>();

		public async Task<Sprite> DownloadThumbnail(string id, string thumbnailUrl)
		{
			if (ThumbnailCache.TryGetValue(id, out var value))
			{
				return value;
			}
			value = await DownloadSprite(thumbnailUrl);
			ThumbnailCache.Add(id, value);
			base.Invoke(id, (JukeboxEvent<DownloadableEntityState>)new ThumbnailLoadedEvent(value));
			return value;
		}

		private static async Task<Sprite> DownloadSprite(string url)
		{
			Texture2D val = await NetworkUtils.DownloadImage(url);
			int num = Mathf.Min(((Texture)val).width, ((Texture)val).height);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor((float)(((Texture)val).width - num) / 2f, (float)(((Texture)val).height - num) / 2f, (float)num, (float)num);
			return Sprite.Create(val, val2, new Vector2(0.5f, 0.5f));
		}

		protected override DownloadableEntityState DefaultState(string id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Sprite value;
			return new DownloadableEntityState
			{
				state = (TrackDownloadingState)0,
				thumbnail = (ThumbnailCache.TryGetValue(id, out value) ? value : null)
			};
		}
	}
	public class JukeboxDownloaderService : MonoSingleton<JukeboxDownloaderService>
	{
		private readonly ConfigEntry<int> queueSize = ConfigUtils.BepInExConfig.Bind<int>("Concurrency", "DownloaderQueueSize", 3, "The size of the downloader queue");

		private static readonly List<AbstractDownloaderClient> Clients = new List<AbstractDownloaderClient>
		{
			new YoutubeClient()
		};

		private QueueManager queue;

		private CancellationTokenSource tokenSource = new CancellationTokenSource();

		private ThirdPartyExecsState thirdPartySoftwareState = new ThirdPartyExecsState();

		private MainThreadDispatcher mainThread;

		private int mTotalDownloaded;

		private int mTotalFailed;

		private int mTotalEnqueued;

		private JukeboxDownloaderState state;

		public int TotalDownloaded
		{
			get
			{
				return mTotalDownloaded;
			}
			private set
			{
				mTotalDownloaded = value;
			}
		}

		public int TotalFailed
		{
			get
			{
				return mTotalFailed;
			}
			private set
			{
				mTotalFailed = value;
			}
		}

		public int TotalEnqueued
		{
			get
			{
				return mTotalEnqueued;
			}
			private set
			{
				mTotalEnqueued = value;
			}
		}

		public JukeboxDownloaderState State
		{
			get
			{
				return state;
			}
			set
			{
				state = value;
				mainThread.Enqueue((Action)delegate
				{
					this.OnStateChanged?.Invoke(value);
				});
			}
		}

		public ThirdPartyExecsState ThirdPartySoftwareState
		{
			get
			{
				return thirdPartySoftwareState;
			}
			set
			{
				thirdPartySoftwareState = value;
				mainThread.Enqueue((Action)delegate
				{
					this.OnThirdPartySoftwareChanged?.Invoke(value);
				});
			}
		}

		public DownloaderUIEventManager UIEventManager { get; } = new DownloaderUIEventManager();


		public List<DownloadableSongMetadata> Metadata { get; private set; } = new List<DownloadableSongMetadata>();


		public event Action<ThirdPartyExecsState> OnThirdPartySoftwareChanged;

		public event Action<JukeboxDownloaderState> OnStateChanged;

		public event Action<List<DownloadableSongMetadata>> OnMetadataChanged;

		protected override void Awake()
		{
			base.Awake();
			queue = new QueueManager(queueSize.Value);
			mainThread = MonoSingleton<MainThreadDispatcher>.Instance;
		}

		public static bool SupportsUrl(string url)
		{
			return Clients.Any((AbstractDownloaderClient client) => client.SupportsUrl(url));
		}

		public void Clear()
		{
			((EventManager<DownloadableEntityState>)UIEventManager).Clear();
		}

		public void CancelEverything()
		{
			tokenSource.Cancel();
			queue.CancelAll();
			ResetCounters();
			((EventManager<DownloadableEntityState>)UIEventManager).Map((Action<KeyValuePair<string, DownloadableEntityState>>)delegate(KeyValuePair<string, DownloadableEntityState> kv)
			{
				TrackDownloadingState? val = kv.Value.state;
				if (val.HasValue && !ObjectExtensions.IsOneOf((object)val, new object[2]
				{
					(object)(TrackDownloadingState)6,
					(object)(TrackDownloadingState)5
				}))
				{
					((EventManager<DownloadableEntityState>)UIEventManager).Invoke(kv.Key, (JukeboxEvent<DownloadableEntityState>)new DownloadCanceledEvent());
				}
			});
		}

		public async Task LoadMetadata(string url)
		{
			try
			{
				queue.CancelAll();
				State = JukeboxDownloaderState.LoadingMetadata;
				Metadata = await GetClientFor(url).GetMetadata(url, RegenerateTokenSource().Token);
				foreach (DownloadableSongMetadata metadatum in Metadata)
				{
					((EventManager<DownloadableEntityState>)UIEventManager).Register(metadatum.Id);
				}
				mainThread.Enqueue((Action)delegate
				{
					this.OnMetadataChanged?.Invoke(Metadata);
				});
			}
			catch (JukeboxException val)
			{
				JukeboxException val2 = val;
				JukeboxException e = val2;
				mainThread.Enqueue((Action)delegate
				{
					Debug.LogError((object)("Unable to retrieve metadata: " + ((Exception)(object)e).Message));
				});
				throw;
			}
			finally
			{
				State = JukeboxDownloaderState.Idle;
			}
		}

		public void EnqueueDownload(string id, string url, string playlist, bool decrementFailed = false)
		{
			Interlocked.Increment(ref mTotalEnqueued);
			if (decrementFailed)
			{
				Interlocked.Decrement(ref mTotalFailed);
			}
			((EventManager<DownloadableEntityState>)UIEventManager).Invoke(id, (JukeboxEvent<DownloadableEntityState>)new TrackEnqueuedEvent());
			queue.Enqueue(delegate(CancellationToken token)
			{
				Progress<DownloadProgress> progress = new Progress<DownloadProgress>(delegate(DownloadProgress p)
				{
					//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_0015: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Invalid comparison between Unknown and I4
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Invalid comparison between Unknown and I4
					//IL_0095: Unknown result type (might be due to invalid IL or missing references)
					if (!token.IsCancellationRequested)
					{
						TrackDownloadingState val = p.State;
						if ((int)val != 5)
						{
							if ((int)val == 6)
							{
								Interlocked.Decrement(ref mTotalEnqueued);
								Interlocked.Increment(ref mTotalFailed);
							}
						}
						else
						{
							Interlocked.Decrement(ref mTotalEnqueued);
							Interlocked.Increment(ref mTotalDownloaded);
						}
						((EventManager<DownloadableEntityState>)UIEventManager).Invoke(id, (JukeboxEvent<DownloadableEntityState>)new ProgressUpdatedEvent(p.State, p.Progress, p.Eta));
					}
				});
				return GetClientFor(url).Download(url, playlist, progress, token);
			});
		}

		public async Task DownloadThirdPartySoftware()
		{
			_ = 2;
			try
			{
				await DownloadSoftwarePiece("ffmpeg", Utils.FfmpegBinaryName, ThirdPartySoftwareUtils.DownloadFfmpeg);
				await DownloadSoftwarePiece("ffprobe", Utils.FfprobeBinaryName, ThirdPartySoftwareUtils.DownloadFfprobe);
				await DownloadSoftwarePiece("yt-dlp", Utils.YtDlpBinaryName, ThirdPartySoftwareUtils.DownloadYtDlp);
				ThirdPartySoftwareUtils.CleanUp();
				ThirdPartySoftwareState = ThirdPartyExecsState.Present();
			}
			catch (Exception)
			{
				ThirdPartySoftwareState = ThirdPartyExecsState.Failed();
			}
			async Task DownloadSoftwarePiece(string softwareTitle, string filename, Func<WebClient, Task> downloadRoutine)
			{
				try
				{
					if (!ThirdPartySoftwareUtils.ThirdPartySoftwarePresent(filename) || !ThirdPartySoftwareUtils.ValidateBinaryIntegrity(filename))
					{
						ThirdPartySoftwareState = ThirdPartyExecsState.DownloadingStarted();
						using WebClient client = new WebClient();
						client.DownloadProgressChanged += delegate(object _, DownloadProgressChangedEventArgs e)
						{
							ThirdPartySoftwareState = ThirdPartyExecsState.DownloadingProgress(softwareTitle, (float)e.ProgressPercentage / 100f);
						};
						await downloadRoutine(client);
					}
				}
				catch (Exception ex2)
				{
					Exception ex3 = ex2;
					Exception e2 = ex3;
					mainThread.Enqueue((Action)delegate
					{
						Debug.LogError((object)("An error has occured while downloading 3rd-party software: " + e2.Message));
					});
					ThirdPartySoftwareState = ThirdPartyExecsState.Failed();
					throw;
				}
			}
		}

		private void ResetCounters()
		{
			TotalDownloaded = 0;
			TotalFailed = 0;
			TotalEnqueued = 0;
		}

		private CancellationTokenSource RegenerateTokenSource()
		{
			tokenSource.Cancel();
			tokenSource = new CancellationTokenSource();
			return tokenSource;
		}

		private static AbstractDownloaderClient GetClientFor(string url)
		{
			return Clients.FirstOrDefault((AbstractDownloaderClient client) => client.SupportsUrl(url)) ?? throw new UrlIsNotSupported();
		}

		protected override void OnDestroy()
		{
			CancelEverything();
			base.OnDestroy();
		}
	}
	public enum JukeboxDownloaderState
	{
		Idle,
		LoadingMetadata
	}
}
namespace JukeboxDownloader.Service.YouTube
{
	public class YoutubeClient : AbstractDownloaderClient
	{
		private const string YouTubeVideoRegex = "^(?:https:\\/\\/)?(?:(?:www|m)\\.)?(?:youtube\\.com|youtu.be)(?:\\/(?:[\\w\\-]+\\?v=|embed\\/|v\\/)?)([\\w\\-]+)(\\S+)?$";

		private const string YouTubePlaylistRegex = "^(?:https:\\/\\/)?(?:(?:www|m)\\.)?(?:youtube\\.com|youtu.be).*?list=([a-zA-Z0-9\\-_]*).*(?:&|$)$";

		private readonly YtDlpClient client;

		public YoutubeClient()
		{
			client = new YtDlpClient();
		}

		public override bool SupportsUrl(string url)
		{
			if (!UrlIsSingleTrack(url))
			{
				return UrlIsPlaylist(url);
			}
			return true;
		}

		public override async Task<List<DownloadableSongMetadata>> GetMetadata(string url, CancellationToken token)
		{
			string targetUrl = url;
			if (UrlIsPlaylist(url))
			{
				targetUrl = ConstructPlaylistUrl(GetPlaylistId(url));
			}
			RunResult<VideoData> data = await client.GetMetadata(targetUrl, token);
			if (!data.Success || data.Data == null)
			{
				throw HandleErrorOutput(data.ErrorOutput);
			}
			bool isPlaylist = data.Data.Entries != null && data.Data.Entries.Length != 0;
			return ((IEnumerable<VideoData>)(isPlaylist ? ((Array)data.Data.Entries) : ((Array)new VideoData[1] { data.Data }))).Select((Func<VideoData, DownloadableSongMetadata>)((VideoData entry) => new DownloadableSongMetadata(entry.ID, isPlaylist ? entry.Url : targetUrl, "https://i.ytimg.com/vi/" + entry.ID + "/hqdefault.jpg", entry.Title, entry.Uploader, isPlaylist ? data.Data.Title : null))).ToList();
		}

		public override async Task Download(string url, string playlist, IProgress<DownloadProgress> progress, CancellationToken token)
		{
			IProgress<DownloadProgress> progress2 = new Progress<DownloadProgress>(delegate(DownloadProgress p)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected I4, but got Unknown
				//IL_0028: 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_0030: 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)
				//IL_003c: 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_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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)
				DownloadState state = p.State;
				progress.Report(new DownloadProgress((TrackDownloadingState)((int)state switch
				{
					0 => 0, 
					1 => 2, 
					2 => 3, 
					3 => 4, 
					5 => 5, 
					4 => 2, 
					_ => 0, 
				}), p.Progress, p.ETA));
			});
			RunResult<string> val = await client.Download(url, playlist, progress2, token);
			progress.Report(val.Success ? new DownloadProgress((TrackDownloadingState)5, 1f, string.Empty) : new DownloadProgress((TrackDownloadingState)6, 0f, string.Empty));
		}

		private static bool UrlIsSingleTrack(string url)
		{
			return Regex.IsMatch(url, "^(?:https:\\/\\/)?(?:(?:www|m)\\.)?(?:youtube\\.com|youtu.be)(?:\\/(?:[\\w\\-]+\\?v=|embed\\/|v\\/)?)([\\w\\-]+)(\\S+)?$", RegexOptions.IgnoreCase);
		}

		private static bool UrlIsPlaylist(string url)
		{
			return Regex.IsMatch(url, "^(?:https:\\/\\/)?(?:(?:www|m)\\.)?(?:youtube\\.com|youtu.be).*?list=([a-zA-Z0-9\\-_]*).*(?:&|$)$", RegexOptions.IgnoreCase);
		}

		private static string GetPlaylistId(string url)
		{
			return Regex.Match(url, "^(?:https:\\/\\/)?(?:(?:www|m)\\.)?(?:youtube\\.com|youtu.be).*?list=([a-zA-Z0-9\\-_]*).*(?:&|$)$").Groups[1].Value;
		}

		private static string ConstructPlaylistUrl(string playlistId)
		{
			return "https://youtube.com/playlist?list=" + playlistId;
		}

		private static Exception HandleErrorOutput(string[] errorOutput)
		{
			string output = string.Join("\n", errorOutput);
			return Handle(output, new(string[], Func<JukeboxException>)[4]
			{
				(new string[1] { "Sign in to confirm you" }, () => (JukeboxException)new CookiesRequiredException()),
				(new string[2] { "Incomplete YouTube ID", "Video unavailable" }, () => (JukeboxException)new InvalidVideoUrlException()),
				(new string[1] { "skipping cookie file entry" }, () => (JukeboxException)new InvalidCookiesFileException()),
				(new string[1] { "This playlist type is unviewable" }, () => (JukeboxException)new PlaylistIsUnviewableException())
			});
			Exception Handle(string o, (string[], Func<JukeboxException>)[] handlers)
			{
				(string[], Func<JukeboxException>) tuple = handlers.FirstOrDefault(((string[], Func<JukeboxException>) handler) => handler.Item1.FirstOrDefault(o.Contains) != null);
				var (array, func) = tuple;
				if (array != null || (Delegate?)func != (Delegate?)null)
				{
					throw tuple.Item2();
				}
				return (Exception)(object)new UnableToFetchMetadata(output);
			}
		}
	}
	public class YtDlpClient
	{
		private readonly ConfigEntry<byte> ytDlpMaxProcesses = ConfigUtils.BepInExConfig.Bind<byte>("Concurrency", "YtDlpMaxProcesses", (byte)3, "Maximum number of yt-dlp processes");

		private readonly string cookiesPath = Path.Combine(PathsUtils.AssemblyPath, "cookies.txt");

		private const string PostProcessing = "EmbedThumbnail+ffmpeg_o:-c:v mjpeg -vf crop=\\\"w='min(iw,ih)':h='min(iw,ih)'\\\"";

		private static readonly string OutputFolder = Path.Combine(PathsUtils.MusicPath, "YouTube");

		private static readonly Progress<string> Logger = new Progress<string>(delegate(string msg)
		{
			MonoSingleton<MainThreadDispatcher>.Instance.Enqueue((Action)delegate
			{
				Debug.Log((object)msg);
			});
		});

		private readonly YoutubeDL client;

		private static bool SaveIntoSeparateFolders => MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.downloader.separateFolderPerPlaylist", false);

		public YtDlpClient()
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			client = new YoutubeDL(ytDlpMaxProcesses.Value)
			{
				YoutubeDLPath = Path.Combine(PathsUtils.AssemblyPath, "yt-dlp.exe"),
				FFmpegPath = "ffmpeg.exe"
			};
		}

		public async Task<RunResult<VideoData>> GetMetadata(string url, CancellationToken token)
		{
			OptionSet val = new OptionSet
			{
				Cookies = cookiesPath
			};
			YoutubeDL obj = client;
			OptionSet val2 = val;
			return await obj.RunVideoDataFetch(url, token, true, false, val2);
		}

		public async Task<RunResult<string>> Download(string url, string playlist, IProgress<DownloadProgress> progress, CancellationToken token)
		{
			string text = ((!string.IsNullOrEmpty(playlist) || !SaveIntoSeparateFolders) ? Path.Combine(OutputFolder, PathsUtils.CoerceValidFileName(playlist)) : OutputFolder);
			OptionSet val = new OptionSet
			{
				ExtractAudio = true,
				EmbedThumbnail = true,
				EmbedMetadata = true,
				AudioFormat = (AudioConversionFormat)3,
				Output = text + "\\%(title)s.%(ext)s",
				Cookies = cookiesPath
			};
			val.AddCustomOption<string>("--ppa", "EmbedThumbnail+ffmpeg_o:-c:v mjpeg -vf crop=\\\"w='min(iw,ih)':h='min(iw,ih)'\\\"");
			return await client.RunWithOptions(url, val, token, progress, (IProgress<string>)Logger, true);
		}
	}
}
namespace JukeboxDownloader.Models
{
	public class DownloadProgress
	{
		public TrackDownloadingState State { get; private set; }

		public float Progress { get; private set; }

		public string Eta { get; private set; }

		public DownloadProgress(TrackDownloadingState state, float progress, string eta)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			State = state;
			Progress = progress;
			Eta = eta;
		}
	}
	public class ThirdPartyExecsState
	{
		public ExecsState state;

		public float? progress;

		[CanBeNull]
		public string currentBinary;

		public ThirdPartyExecsState()
		{
			state = ExecsState.None;
		}

		public static ThirdPartyExecsState DownloadingStarted()
		{
			return new ThirdPartyExecsState
			{
				state = ExecsState.Downloading,
				currentBinary = null,
				progress = null
			};
		}

		public static ThirdPartyExecsState DownloadingProgress(string software, float progress)
		{
			return new ThirdPartyExecsState
			{
				state = ExecsState.Downloading,
				currentBinary = software,
				progress = progress
			};
		}

		public static ThirdPartyExecsState Failed()
		{
			return new ThirdPartyExecsState
			{
				state = ExecsState.Failed,
				currentBinary = null,
				progress = null
			};
		}

		public static ThirdPartyExecsState Present()
		{
			return new ThirdPartyExecsState
			{
				state = ExecsState.Present,
				currentBinary = null,
				progress = null
			};
		}
	}
	public enum ExecsState
	{
		None,
		Missing,
		Present,
		Downloading,
		Failed
	}
}
namespace JukeboxDownloader.Exceptions
{
	public class UnableToFetchMetadata : JukeboxException
	{
		private readonly string message;

		public override string Message => "Unable to fetch metadata: " + message;

		public UnableToFetchMetadata(string message)
		{
			this.message = message;
		}
	}
	public class UrlIsNotSupported : JukeboxException
	{
		public override string Message => "URL is not supported";
	}
}
namespace JukeboxDownloader.Events
{
	public class DownloadCanceledEvent : DownloadableEntityStateEvent
	{
		public DownloadCanceledEvent()
			: base(GetState())
		{
		}

		private static DownloadableEntityState GetState()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new DownloadableEntityState
			{
				state = (TrackDownloadingState)0
			};
		}

		public override void Mutate(DownloadableEntityState state)
		{
			state.state = ((JukeboxEvent<DownloadableEntityState>)this).newState.state;
		}
	}
	public class DownloadFailedEvent : DownloadableEntityStateEvent
	{
		public DownloadFailedEvent()
			: base(GetState())
		{
		}

		private static DownloadableEntityState GetState()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new DownloadableEntityState
			{
				state = (TrackDownloadingState)6
			};
		}

		public override void Mutate(DownloadableEntityState state)
		{
			state.state = ((JukeboxEvent<DownloadableEntityState>)this).newState.state;
		}
	}
	public abstract class DownloadableEntityStateEvent : JukeboxEvent<DownloadableEntityState>
	{
		protected DownloadableEntityStateEvent(DownloadableEntityState newState)
		{
			base.newState = newState;
		}
	}
	public class ProgressUpdatedEvent : DownloadableEntityStateEvent
	{
		public ProgressUpdatedEvent(TrackDownloadingState state, float progress, string eta)
			: base(GetState(state, progress, eta))
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)


		private static DownloadableEntityState GetState(TrackDownloadingState newState, float newProgress, string eta)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			return new DownloadableEntityState
			{
				state = newState,
				progress = newProgress,
				eta = eta
			};
		}

		public override void Mutate(DownloadableEntityState state)
		{
			state.state = ((JukeboxEvent<DownloadableEntityState>)this).newState.state;
			state.progress = ((JukeboxEvent<DownloadableEntityState>)this).newState.progress;
		}
	}
	public class ThumbnailLoadedEvent : DownloadableEntityStateEvent
	{
		public ThumbnailLoadedEvent(Sprite sprite)
			: base(GetState(sprite))
		{
		}

		private static DownloadableEntityState GetState(Sprite sprite)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return new DownloadableEntityState
			{
				thumbnail = sprite
			};
		}

		public override void Mutate(DownloadableEntityState state)
		{
			state.thumbnail = ((JukeboxEvent<DownloadableEntityState>)this).newState.thumbnail;
		}
	}
	public class TrackEnqueuedEvent : DownloadableEntityStateEvent
	{
		public TrackEnqueuedEvent()
			: base(GetState())
		{
		}

		private static DownloadableEntityState GetState()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new DownloadableEntityState
			{
				state = (TrackDownloadingState)1
			};
		}

		public override void Mutate(DownloadableEntityState state)
		{
			state.state = ((JukeboxEvent<DownloadableEntityState>)this).newState.state;
		}
	}
}
namespace JukeboxDownloader.Components
{
	public class JukeboxDownloader : MonoBehaviour
	{
		private const float OnUrlChangedDelay = 1f;

		[SerializeField]
		public JukeboxDownloaderBrowser browser;

		[SerializeField]
		public DownloaderErrorDialogue errorDialogue;

		[SerializeField]
		public TMP_InputField urlInputField;

		[SerializeField]
		public GameObject downloadProgress;

		[SerializeField]
		public GameObject loadingPlaceholder;

		[SerializeField]
		public GameObject bottomPanel;

		[SerializeField]
		public GameObject cookiesRequiredWindow;

		[SerializeField]
		public Button downloadAllButton;

		private JukeboxDownloaderService downloaderService;

		private MainThreadDispatcher mainThread;

		private Coroutine urlChangedRoutine;

		private TotalDownloadProgress downloadProgressComponent;

		private void Awake()
		{
			downloaderService = MonoSingleton<JukeboxDownloaderService>.Instance;
			mainThread = MonoSingleton<MainThreadDispatcher>.Instance;
			downloadProgressComponent = downloadProgress.GetComponent<TotalDownloadProgress>();
		}

		private void Update()
		{
			bool flag = downloaderService.TotalEnqueued == 0 && downloaderService.TotalDownloaded == 0 && downloaderService.TotalFailed == 0;
			downloadProgress.SetActive(!flag);
			if (!flag)
			{
				downloadProgressComponent.Downloaded = downloaderService.TotalDownloaded;
				downloadProgressComponent.Failed = downloaderService.TotalFailed;
				downloadProgressComponent.Enqueued = downloaderService.TotalEnqueued;
			}
		}

		private void OnEnable()
		{
			((UnityEvent<string>)(object)urlInputField.onValueChanged).AddListener((UnityAction<string>)OnURLChanged);
			ReloadBrowserMetadata(downloaderService.Metadata);
			OnDownloaderState(downloaderService.State);
			downloaderService.OnMetadataChanged += ReloadBrowserMetadata;
			downloaderService.OnStateChanged += OnDownloaderState;
		}

		private void OnDisable()
		{
			((UnityEvent<string>)(object)urlInputField.onValueChanged).RemoveListener((UnityAction<string>)OnURLChanged);
			downloaderService.OnMetadataChanged -= ReloadBrowserMetadata;
			downloaderService.OnStateChanged -= OnDownloaderState;
		}

		public void Cancel()
		{
			downloaderService.CancelEverything();
		}

		private void OnURLChanged(string value)
		{
			if (urlChangedRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(urlChangedRoutine);
			}
			urlChangedRoutine = ((MonoBehaviour)this).StartCoroutine(URLChangedRoutine(value));
		}

		private void ReloadBrowserMetadata(List<DownloadableSongMetadata> metadata)
		{
			bool active = metadata == null || metadata.Count != 0;
			bottomPanel.SetActive(active);
			((Component)downloadAllButton).gameObject.SetActive(active);
			browser.ReloadMetadata(metadata);
		}

		public void DownloadAll()
		{
			foreach (DownloadableSongMetadata metadatum in browser.Metadata)
			{
				downloaderService.EnqueueDownload(metadatum.Id, metadatum.Url, metadatum.Playlist);
			}
		}

		private void OnDownloaderState(JukeboxDownloaderState state)
		{
			switch (state)
			{
			case JukeboxDownloaderState.Idle:
				loadingPlaceholder.SetActive(false);
				break;
			case JukeboxDownloaderState.LoadingMetadata:
				browser.Clear();
				bottomPanel.SetActive(false);
				loadingPlaceholder.SetActive(true);
				break;
			}
		}

		private IEnumerator URLChangedRoutine(string value)
		{
			yield return (object)new WaitForSecondsRealtime(1f);
			((Component)errorDialogue).gameObject.SetActive(false);
			if (JukeboxDownloaderService.SupportsUrl(value))
			{
				downloaderService.CancelEverything();
				downloaderService.Clear();
				downloadProgress.SetActive(false);
				Run(() => downloaderService.LoadMetadata(value));
			}
		}

		private void Run(Func<Task> function)
		{
			Task.Run(function).ContinueWith(ErrorHandler());
		}

		private Action<Task> ErrorHandler()
		{
			return delegate(Task t)
			{
				mainThread.Enqueue((Action)delegate
				{
					if (t.IsFaulted)
					{
						RaiseErrorDialogue(t.Exception);
					}
				});
			};
		}

		private void RaiseErrorDialogue(Exception e)
		{
			if (e is AggregateException)
			{
				Exception innerException = e.InnerException;
				if (!(innerException is CookiesRequiredException) && !(innerException is InvalidCookiesFileException))
				{
					JukeboxException val = (JukeboxException)(object)((innerException is JukeboxException) ? innerException : null);
					if (val != null)
					{
						((Component)errorDialogue).gameObject.SetActive(true);
						errorDialogue.messageText.text = ((Exception)(object)val).Message;
					}
				}
				else
				{
					cookiesRequiredWindow.SetActive(true);
				}
			}
			else
			{
				errorDialogue.messageText.text = "Unexpected error " + e.Message;
			}
		}

		public void RevealModLocation()
		{
			Application.OpenURL(PathsUtils.AssemblyPath);
		}

		public void OpenURL(string url)
		{
			Application.OpenURL(url);
		}
	}
	public class JukeboxDownloaderBrowser : DirectoryTreeBrowser<DownloadableSongMetadata>
	{
		private JukeboxDownloaderService downloaderService;

		public List<DownloadableSongMetadata> Metadata { get; private set; } = new List<DownloadableSongMetadata>();


		protected override int maxPageLength => 5;

		protected override IDirectoryTree<DownloadableSongMetadata> baseDirectory => (IDirectoryTree<DownloadableSongMetadata>)(object)new FakeDirectoryTree<DownloadableSongMetadata>("Downloads", Metadata, (List<FakeDirectoryTree<DownloadableSongMetadata>>)null, (IDirectoryTree<DownloadableSongMetadata>)null);

		protected void Awake()
		{
			downloaderService = MonoSingleton<JukeboxDownloaderService>.Instance;
		}

		public void ReloadMetadata(List<DownloadableSongMetadata> newMetadata)
		{
			Metadata = newMetadata;
			((DirectoryTreeBrowser<DownloadableSongMetadata>)this).Rebuild(true);
		}

		public void Clear()
		{
			Metadata.Clear();
			((DirectoryTreeBrowser<DownloadableSongMetadata>)this).Rebuild(true);
		}

		protected override Action BuildLeaf(DownloadableSongMetadata item, int indexInPage)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemParent, false);
			DownloadableTrackElement component = go.GetComponent<DownloadableTrackElement>();
			component.id = item.Id;
			component.titleText.text = item.Title;
			component.artistText.text = item.Artist;
			((UnityEvent)component.downloadButton.onClick).AddListener((UnityAction)delegate
			{
				Download();
			});
			((UnityEvent)component.retryButton.onClick).AddListener((UnityAction)delegate
			{
				Download(decrementFailed: true);
			});
			go.SetActive(true);
			Task.Run(() => downloaderService.UIEventManager.DownloadThumbnail(item.Id, item.ThumbnailUrl));
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
			void Download(bool decrementFailed = false)
			{
				downloaderService.EnqueueDownload(item.Id, item.Url, item.Playlist, decrementFailed);
			}
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			base.currentDirectory = ((DirectoryTreeBrowser<DownloadableSongMetadata>)this).baseDirectory;
			base.Rebuild(setToPageZero);
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
		}
	}
	public class JukeboxDownloaderContainer : MonoBehaviour
	{
		[SerializeField]
		public GameObject loadingScreen;

		[SerializeField]
		public JukeboxDownloader downloader;

		[SerializeField]
		public ThirdPartyExecsDownloader thirdPartyExecsDownloader;

		private JukeboxDownloaderService downloaderService;

		private void Awake()
		{
			downloaderService = MonoSingleton<JukeboxDownloaderService>.Instance;
			Task.Run(delegate
			{
				bool softwareIntact = ThirdPartySoftwareUtils.AllRequiredSoftwarePresent() && ThirdPartySoftwareUtils.ValidateThirdPartySoftwareIntegrity();
				MonoSingleton<MainThreadDispatcher>.Instance.Enqueue((Action)delegate
				{
					downloaderService.ThirdPartySoftwareState = new ThirdPartyExecsState
					{
						state = ((!softwareIntact) ? ExecsState.Missing : ExecsState.Present)
					};
					loadingScreen.SetActive(false);
				});
			});
		}

		private void OnEnable()
		{
			HandleState(downloaderService.ThirdPartySoftwareState);
			downloaderService.OnThirdPartySoftwareChanged += HandleState;
		}

		private void OnDisable()
		{
			downloaderService.OnThirdPartySoftwareChanged -= HandleState;
		}

		private void HandleState(ThirdPartyExecsState state)
		{
			((Component)downloader).gameObject.SetActive(state.state == ExecsState.Present);
			((Component)thirdPartyExecsDownloader).gameObject.SetActive(!ObjectExtensions.IsOneOf((object)state.state, new object[2]
			{
				ExecsState.Present,
				ExecsState.None
			}));
		}
	}
	public class ThirdPartyExecsDownloader : MonoBehaviour
	{
		[SerializeField]
		public Button installButton;

		[SerializeField]
		public GradualProgressBar progressBar;

		[SerializeField]
		public GameObject errorMessage;

		[SerializeField]
		public TMP_Text progressText;

		private JukeboxDownloaderService downloaderService;

		public void RevealModLocation()
		{
			Application.OpenURL(PathsUtils.AssemblyPath);
		}

		public void OpenURL(string url)
		{
			Application.OpenURL(url);
		}

		private void Awake()
		{
			downloaderService = MonoSingleton<JukeboxDownloaderService>.Instance;
		}

		private void OnEnable()
		{
			downloaderService.OnThirdPartySoftwareChanged += SetState;
			SetState(downloaderService.ThirdPartySoftwareState);
		}

		private void OnDisable()
		{
			downloaderService.OnThirdPartySoftwareChanged -= SetState;
		}

		private void SetState(ThirdPartyExecsState state)
		{
			HandleState(state.state);
			SetProgressBar(state);
		}

		private void SetProgressBar(ThirdPartyExecsState state, bool forced = false)
		{
			string arg = state.currentBinary ?? string.Empty;
			if (!state.progress.HasValue)
			{
				progressBar.ForceSetProgress(0f);
				progressText.text = "Downloading...";
				return;
			}
			if (forced)
			{
				progressBar.ForceSetProgress(state.progress.Value);
			}
			else
			{
				progressBar.UpdateProgress(state.progress.Value);
			}
			progressText.text = $"Downloading {arg}: {(int)(state.progress * 100f).Value}%";
		}

		public void Install()
		{
			downloaderService.ThirdPartySoftwareState = ThirdPartyExecsState.DownloadingStarted();
			Task.Run(() => downloaderService.DownloadThirdPartySoftware());
		}

		private void HandleState(ExecsState state)
		{
			if (state == ExecsState.Present)
			{
				((Component)this).gameObject.SetActive(false);
				return;
			}
			((Component)installButton).gameObject.SetActive(state == ExecsState.Missing);
			((Component)progressText).gameObject.SetActive(state == ExecsState.Downloading);
			errorMessage.gameObject.SetActive(state == ExecsState.Failed);
		}
	}
}