using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using JazzRadio.Core.Playback;
using Microsoft.CodeAnalysis;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("JazzRadio.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.0.3.0")]
[assembly: AssemblyInformationalVersion("0.0.3+94a9cfb389a71d045c1fd5d5778451dda5527f99")]
[assembly: AssemblyProduct("JazzRadio.Core")]
[assembly: AssemblyTitle("JazzRadio.Core")]
[assembly: InternalsVisibleTo("JazzRadio.Core.Tests")]
[assembly: AssemblyVersion("0.0.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 JazzRadio.Core.Text
{
	public static class DisplayText
	{
		public const string MarqueeGap = "   ·   ";

		public static string Marquee(string text, int maxChars, double seconds, double charsPerSecond)
		{
			if (string.IsNullOrEmpty(text) || maxChars <= 0 || text.Length <= maxChars)
			{
				return text ?? string.Empty;
			}
			string text2 = text + "   ·   ";
			int startIndex = (int)(Math.Max(0.0, seconds) * Math.Max(0.0, charsPerSecond)) % text2.Length;
			return (text2 + text2).Substring(startIndex, maxChars);
		}

		public static string Elapsed(TimeSpan span)
		{
			if (span < TimeSpan.Zero)
			{
				span = TimeSpan.Zero;
			}
			if (!(span.TotalHours >= 1.0))
			{
				return string.Format(CultureInfo.InvariantCulture, "{0}:{1:00}", span.Minutes, span.Seconds);
			}
			return string.Format(CultureInfo.InvariantCulture, "{0}:{1:00}:{2:00}", (int)span.TotalHours, span.Minutes, span.Seconds);
		}

		public static string Percent(float volume)
		{
			return string.Format(CultureInfo.InvariantCulture, "{0}%", (int)Math.Round(VolumeCurve.Clamp(volume) * 100f));
		}

		public static string StateLabel(PlayerStatus status)
		{
			switch (status.State)
			{
			case PlayerState.Stopped:
				return "OFF";
			case PlayerState.Resolving:
				return "TUNING IN...";
			case PlayerState.Buffering:
				return "BUFFERING...";
			case PlayerState.Playing:
			{
				StreamInfo? stream = status.Stream;
				return ((object)stream != null && stream.IsLive) ? "LIVE" : "PLAYING";
			}
			case PlayerState.Reconnecting:
				return "RECONNECTING...";
			case PlayerState.Error:
				return "ERROR";
			default:
				return string.Empty;
			}
		}

		public static string Subtitle(PlayerStatus status, DateTimeOffset now)
		{
			if (status.State == PlayerState.Error || (status.State == PlayerState.Reconnecting && status.LastError != null))
			{
				return status.LastError ?? string.Empty;
			}
			string text = status.Stream?.Channel ?? string.Empty;
			if (status.State != PlayerState.Playing || !status.PlayingSince.HasValue)
			{
				return text;
			}
			string text2 = Elapsed(now - status.PlayingSince.Value);
			if (text.Length != 0)
			{
				return text + "  ·  " + text2;
			}
			return text2;
		}

		public static string Title(PlayerStatus status)
		{
			if (status.State == PlayerState.Stopped)
			{
				return "Radio is off";
			}
			return status.Stream?.Title ?? "Searching for signal...";
		}
	}
}
namespace JazzRadio.Core.Streaming
{
	public sealed class FfmpegPcmSourceFactory : IPcmSourceFactory
	{
		private readonly string? ffmpegPath;

		private readonly Action<string> log;

		public FfmpegPcmSourceFactory(string? ffmpegPath, Action<string> log)
		{
			this.ffmpegPath = ffmpegPath;
			this.log = log ?? throw new ArgumentNullException("log");
		}

		public static IReadOnlyList<string> BuildArguments(string mediaUrl, PcmFormat format)
		{
			return new string[24]
			{
				"-hide_banner",
				"-nostdin",
				"-loglevel",
				"error",
				"-reconnect",
				"1",
				"-reconnect_streamed",
				"1",
				"-reconnect_delay_max",
				"5",
				"-protocol_whitelist",
				"https,http,tls,tcp,crypto,hls",
				"-i",
				mediaUrl,
				"-vn",
				"-f",
				"s16le",
				"-acodec",
				"pcm_s16le",
				"-ac",
				format.Channels.ToString(CultureInfo.InvariantCulture),
				"-ar",
				format.SampleRate.ToString(CultureInfo.InvariantCulture),
				"pipe:1"
			};
		}

		public IPcmSource Open(string mediaUrl, PcmFormat format)
		{
			if (ffmpegPath == null)
			{
				throw new MissingToolException("ffmpeg");
			}
			if (!UrlPolicy.IsHttpUrl(mediaUrl))
			{
				throw new ArgumentException("Media URL must be an http(s) URL", "mediaUrl");
			}
			return new FfmpegPcmSource(ffmpegPath, BuildArguments(mediaUrl, format), log);
		}
	}
	internal sealed class FfmpegPcmSource : IPcmSource, IDisposable
	{
		private readonly Process process;

		private readonly Stream output;

		private readonly Action<string> log;

		private int disposed;

		public FfmpegPcmSource(string ffmpegPath, IEnumerable<string> args, Action<string> log)
		{
			this.log = log;
			process = new Process
			{
				StartInfo = ToolProcess.CreateStartInfo(ffmpegPath, args)
			};
			process.ErrorDataReceived += OnStderr;
			try
			{
				if (!process.Start())
				{
					throw new InvalidOperationException("Failed to start ffmpeg");
				}
				process.BeginErrorReadLine();
				output = process.StandardOutput.BaseStream;
			}
			catch
			{
				process.ErrorDataReceived -= OnStderr;
				ToolProcess.KillQuietly(process);
				process.Dispose();
				throw;
			}
		}

		public int Read(byte[] buffer, int offset, int count)
		{
			if (Volatile.Read(in disposed) != 0)
			{
				return 0;
			}
			try
			{
				return output.Read(buffer, offset, count);
			}
			catch (IOException)
			{
				return 0;
			}
			catch (ObjectDisposedException)
			{
				return 0;
			}
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref disposed, 1) == 0)
			{
				process.ErrorDataReceived -= OnStderr;
				ToolProcess.KillQuietly(process);
				process.Dispose();
			}
		}

		private void OnStderr(object sender, DataReceivedEventArgs e)
		{
			if (!string.IsNullOrWhiteSpace(e.Data))
			{
				log("ffmpeg: " + e.Data);
			}
		}
	}
	public static class ToolLocator
	{
		public static string? Find(string? configuredPath, string toolName, IEnumerable<string> searchDirs, string? pathEnv, bool isWindows)
		{
			if (!string.IsNullOrWhiteSpace(configuredPath))
			{
				string path = configuredPath.Trim().Trim('"');
				if (!File.Exists(path))
				{
					return null;
				}
				return Path.GetFullPath(path);
			}
			string fileName = (isWindows ? (toolName + ".exe") : toolName);
			string[] second = (pathEnv ?? string.Empty).Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
			return (from dir in searchDirs.Concat(second)
				where !string.IsNullOrWhiteSpace(dir)
				select SafeCombine(dir, fileName)).FirstOrDefault((string candidate) => candidate != null && File.Exists(candidate));
		}

		private static string? SafeCombine(string dir, string fileName)
		{
			try
			{
				return Path.Combine(dir.Trim('"'), fileName);
			}
			catch (ArgumentException)
			{
				return null;
			}
		}
	}
	internal static class ToolProcess
	{
		public static ProcessStartInfo CreateStartInfo(string exePath, IEnumerable<string> args, bool redirectStdin = false)
		{
			ProcessStartInfo processStartInfo = new ProcessStartInfo(exePath)
			{
				UseShellExecute = false,
				CreateNoWindow = true,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				RedirectStandardInput = redirectStdin,
				WindowStyle = ProcessWindowStyle.Hidden
			};
			foreach (string arg in args)
			{
				processStartInfo.ArgumentList.Add(arg);
			}
			string directoryName = Path.GetDirectoryName(exePath);
			if (!string.IsNullOrEmpty(directoryName))
			{
				processStartInfo.Environment.TryGetValue("PATH", out string value);
				processStartInfo.Environment["PATH"] = (string.IsNullOrEmpty(value) ? directoryName : (directoryName + Path.PathSeparator + value));
			}
			return processStartInfo;
		}

		public static void KillQuietly(Process process)
		{
			try
			{
				if (!process.HasExited)
				{
					process.Kill(entireProcessTree: true);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public static class UrlPolicy
	{
		public static bool IsHttpUrl(string? value)
		{
			if (Uri.TryCreate(value?.Trim(), UriKind.Absolute, out Uri result) && (result.Scheme == Uri.UriSchemeHttps || result.Scheme == Uri.UriSchemeHttp))
			{
				return !string.IsNullOrEmpty(result.Host);
			}
			return false;
		}
	}
	public static class YtDlpOutput
	{
		public static readonly string[] PrintTemplates = new string[4] { "%(title)s", "%(channel)s", "%(is_live)s", "%(url)s" };

		private static readonly Regex LiveTimestampSuffix = new Regex("\\s+\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$", RegexOptions.Compiled);

		public static StreamInfo Parse(string stdout)
		{
			string[] array = (from l in (stdout ?? string.Empty).Replace("\r", string.Empty).Split('\n')
				select l.Trim() into l
				where l.Length > 0
				select l).ToArray();
			if (array.Length < PrintTemplates.Length)
			{
				throw new FormatException($"Unexpected yt-dlp output ({array.Length} lines)");
			}
			string[] array2 = array.Skip(array.Length - PrintTemplates.Length).ToArray();
			string text = array2[3];
			if (!UrlPolicy.IsHttpUrl(text))
			{
				throw new FormatException("yt-dlp did not return a media URL");
			}
			return new StreamInfo(CleanTitle(NullIfNa(array2[0]) ?? "Unknown stream"), NullIfNa(array2[1]) ?? string.Empty, text, string.Equals(array2[2], "True", StringComparison.OrdinalIgnoreCase));
		}

		public static string CleanTitle(string title)
		{
			return LiveTimestampSuffix.Replace(title.Trim(), string.Empty);
		}

		private static string? NullIfNa(string value)
		{
			if (!(value == "NA"))
			{
				return value;
			}
			return null;
		}
	}
	public sealed class YtDlpResolver : IStreamResolver
	{
		private readonly string? ytDlpPath;

		private readonly TimeSpan timeout;

		public YtDlpResolver(string? ytDlpPath, TimeSpan timeout)
		{
			this.ytDlpPath = ytDlpPath;
			this.timeout = timeout;
		}

		public static IReadOnlyList<string> BuildArguments(string pageUrl)
		{
			List<string> list = new List<string> { "--ignore-config", "--no-exec", "--no-warnings", "--no-playlist", "--skip-download", "--format", "bestaudio/best" };
			string[] printTemplates = YtDlpOutput.PrintTemplates;
			foreach (string item in printTemplates)
			{
				list.Add("--print");
				list.Add(item);
			}
			list.Add("--");
			list.Add(pageUrl);
			return list;
		}

		public async Task<StreamInfo> ResolveAsync(string pageUrl, CancellationToken ct)
		{
			if (ytDlpPath == null)
			{
				throw new MissingToolException("yt-dlp");
			}
			if (!UrlPolicy.IsHttpUrl(pageUrl))
			{
				throw new ArgumentException("Stream URL must be an http(s) URL", "pageUrl");
			}
			using CancellationTokenSource timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
			timeoutCts.CancelAfter(timeout);
			using Process process = new Process
			{
				StartInfo = ToolProcess.CreateStartInfo(ytDlpPath, BuildArguments(pageUrl))
			};
			if (!process.Start())
			{
				throw new InvalidOperationException("Failed to start yt-dlp");
			}
			Task<string> stdoutTask = process.StandardOutput.ReadToEndAsync();
			Task<string> stderrTask = process.StandardError.ReadToEndAsync();
			try
			{
				await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (OperationCanceledException)
			{
				ToolProcess.KillQuietly(process);
				Observe(stdoutTask);
				Observe(stderrTask);
				ct.ThrowIfCancellationRequested();
				throw new TimeoutException("yt-dlp timed out");
			}
			string stdout = await stdoutTask.ConfigureAwait(continueOnCapturedContext: false);
			string text = await stderrTask.ConfigureAwait(continueOnCapturedContext: false);
			if (process.ExitCode != 0)
			{
				throw new InvalidOperationException("yt-dlp failed: " + LastLine(text));
			}
			return YtDlpOutput.Parse(stdout);
		}

		private static void Observe(Task task)
		{
			task.ContinueWith((Task t) => t.Exception, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
		}

		private static string LastLine(string text)
		{
			return (from l in text.Split('\n')
				select l.Trim()).LastOrDefault((string l) => l.Length > 0) ?? "unknown error";
		}
	}
}
namespace JazzRadio.Core.Playback
{
	public sealed record PcmFormat(int SampleRate, int Channels)
	{
		public static PcmFormat Default { get; } = new PcmFormat(48000, 2);

		public int BytesPerSecond => SampleRate * Channels * 2;

		[CompilerGenerated]
		private PcmFormat(PcmFormat original)
		{
			SampleRate = original.SampleRate;
			Channels = original.Channels;
		}
	}
	public interface IStreamResolver
	{
		Task<StreamInfo> ResolveAsync(string pageUrl, CancellationToken ct);
	}
	public interface IPcmSource : IDisposable
	{
		int Read(byte[] buffer, int offset, int count);
	}
	public interface IPcmSourceFactory
	{
		IPcmSource Open(string mediaUrl, PcmFormat format);
	}
	public interface IAudioSink : IDisposable
	{
		TimeSpan Buffered { get; }

		void SetVolume(float volume);

		void Write(byte[] buffer, int offset, int count);

		void Play();
	}
	public interface IAudioSinkFactory
	{
		IAudioSink Create(PcmFormat format);
	}
	public sealed class MissingToolException : Exception
	{
		public string ToolName { get; }

		public MissingToolException(string toolName)
			: base(toolName + " not found")
		{
			ToolName = toolName;
		}
	}
	public sealed class NAudioSinkFactory : IAudioSinkFactory
	{
		public IAudioSink Create(PcmFormat format)
		{
			return new NAudioSink(format);
		}
	}
	internal sealed class NAudioSink : IAudioSink, IDisposable
	{
		private readonly BufferedWaveProvider buffer;

		private readonly VolumeSampleProvider volumeProvider;

		private readonly WaveOutEvent output;

		public TimeSpan Buffered => buffer.BufferedDuration;

		public NAudioSink(PcmFormat format)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			buffer = new BufferedWaveProvider(new WaveFormat(format.SampleRate, 16, format.Channels))
			{
				BufferDuration = TimeSpan.FromSeconds(15.0),
				DiscardOnBufferOverflow = true,
				ReadFully = true
			};
			volumeProvider = new VolumeSampleProvider(WaveExtensionMethods.ToSampleProvider((IWaveProvider)(object)buffer));
			output = new WaveOutEvent
			{
				DesiredLatency = 200,
				NumberOfBuffers = 3
			};
			WaveExtensionMethods.Init((IWavePlayer)(object)output, (ISampleProvider)(object)volumeProvider, false);
		}

		public void SetVolume(float volume)
		{
			volumeProvider.Volume = volume;
		}

		public void Write(byte[] data, int offset, int count)
		{
			buffer.AddSamples(data, offset, count);
		}

		public void Play()
		{
			output.Play();
		}

		public void Dispose()
		{
			output.Stop();
			output.Dispose();
		}
	}
	public enum PlayerState
	{
		Stopped,
		Resolving,
		Buffering,
		Playing,
		Reconnecting,
		Error
	}
	public sealed record StreamInfo(string Title, string Channel, string MediaUrl, bool IsLive);
	public sealed record PlayerStatus(PlayerState State, StreamInfo? Stream, DateTimeOffset? PlayingSince, string? LastError)
	{
		public static PlayerStatus Stopped { get; } = new PlayerStatus(PlayerState.Stopped, null, null, null);

		public bool IsActive
		{
			get
			{
				if (State != PlayerState.Stopped)
				{
					return State != PlayerState.Error;
				}
				return false;
			}
		}

		[CompilerGenerated]
		private PlayerStatus(PlayerStatus original)
		{
			State = original.State;
			Stream = original.Stream;
			PlayingSince = original.PlayingSince;
			LastError = original.LastError;
		}
	}
	public sealed class RadioPlayer : IDisposable
	{
		private readonly object gate = new object();

		private readonly string pageUrl;

		private readonly IStreamResolver resolver;

		private readonly IPcmSourceFactory sourceFactory;

		private readonly IAudioSinkFactory sinkFactory;

		private readonly RadioPlayerOptions options;

		private readonly PcmFormat format;

		private readonly Action<string> log;

		private CancellationTokenSource? session;

		private Task? worker;

		private PlayerStatus status = PlayerStatus.Stopped;

		private IAudioSink? activeSink;

		private float volume;

		public PlayerStatus Status
		{
			get
			{
				lock (gate)
				{
					return status;
				}
			}
		}

		public float Volume
		{
			get
			{
				lock (gate)
				{
					return volume;
				}
			}
		}

		public bool IsRunning
		{
			get
			{
				lock (gate)
				{
					return session != null;
				}
			}
		}

		internal Task? CurrentWorker
		{
			get
			{
				lock (gate)
				{
					return worker;
				}
			}
		}

		public RadioPlayer(string pageUrl, IStreamResolver resolver, IPcmSourceFactory sourceFactory, IAudioSinkFactory sinkFactory, RadioPlayerOptions options, PcmFormat format, float initialVolume, Action<string> log)
		{
			this.pageUrl = pageUrl ?? throw new ArgumentNullException("pageUrl");
			this.resolver = resolver ?? throw new ArgumentNullException("resolver");
			this.sourceFactory = sourceFactory ?? throw new ArgumentNullException("sourceFactory");
			this.sinkFactory = sinkFactory ?? throw new ArgumentNullException("sinkFactory");
			this.options = options ?? throw new ArgumentNullException("options");
			this.format = format ?? throw new ArgumentNullException("format");
			this.log = log ?? throw new ArgumentNullException("log");
			volume = VolumeCurve.Clamp(initialVolume);
		}

		public void Start()
		{
			lock (gate)
			{
				if (session == null)
				{
					CancellationTokenSource cts = new CancellationTokenSource();
					session = cts;
					status = new PlayerStatus(PlayerState.Resolving, null, null, null);
					worker = Task.Factory.StartNew(() => RunAsync(cts), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Unwrap();
				}
			}
		}

		public void Stop()
		{
			CancellationTokenSource cancelled;
			lock (gate)
			{
				cancelled = session;
				if (cancelled == null)
				{
					return;
				}
				session = null;
				worker = null;
				status = PlayerStatus.Stopped;
			}
			ThreadPool.QueueUserWorkItem(delegate
			{
				CancelQuietly(cancelled);
			});
		}

		public void Toggle()
		{
			if (IsRunning)
			{
				Stop();
			}
			else
			{
				Start();
			}
		}

		public void SetVolume(float value)
		{
			float num = VolumeCurve.Clamp(value);
			IAudioSink audioSink;
			lock (gate)
			{
				volume = num;
				audioSink = activeSink;
			}
			audioSink?.SetVolume(VolumeCurve.ToGain(num));
		}

		public void Dispose()
		{
			Task task;
			lock (gate)
			{
				task = worker;
			}
			Stop();
			try
			{
				task?.Wait(TimeSpan.FromMilliseconds(500.0));
			}
			catch (AggregateException ex)
			{
				log("Player shutdown error: " + ex.InnerException?.Message);
			}
		}

		private void CancelQuietly(CancellationTokenSource cts)
		{
			try
			{
				cts.Cancel();
			}
			catch (ObjectDisposedException)
			{
			}
			catch (AggregateException ex2)
			{
				log("Player stop error: " + ex2.InnerException?.Message);
			}
		}

		private async Task RunAsync(CancellationTokenSource cts)
		{
			CancellationToken ct = cts.Token;
			int attempt = 0;
			StreamInfo lastInfo = null;
			string lastError = null;
			try
			{
				while (!ct.IsCancellationRequested)
				{
					PlayerState state = ((attempt == 0) ? PlayerState.Resolving : PlayerState.Reconnecting);
					Publish(cts, new PlayerStatus(state, lastInfo, null, lastError));
					try
					{
						StreamInfo info = await resolver.ResolveAsync(pageUrl, ct).ConfigureAwait(continueOnCapturedContext: false);
						lastInfo = info;
						if (await Task.Factory.StartNew(() => Pump(cts, info), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(continueOnCapturedContext: false))
						{
							attempt = 0;
						}
						lastError = "Stream ended";
					}
					catch (OperationCanceledException) when (ct.IsCancellationRequested)
					{
						break;
					}
					catch (MissingToolException ex2)
					{
						log("Cannot play: " + ex2.Message);
						Fail(cts, new PlayerStatus(PlayerState.Error, lastInfo, null, ex2.Message));
						break;
					}
					catch (Exception ex3)
					{
						lastError = ex3.Message;
						log("Stream error: " + ex3.Message);
					}
					if (ct.IsCancellationRequested)
					{
						break;
					}
					attempt++;
					TimeSpan delay = Backoff.Delay(attempt, options.RetryBaseDelay, options.RetryMaxDelay);
					Publish(cts, new PlayerStatus(PlayerState.Reconnecting, lastInfo, null, lastError));
					await Task.Delay(delay, ct).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (OperationCanceledException) when (ct.IsCancellationRequested)
			{
			}
			finally
			{
				cts.Dispose();
			}
		}

		private bool Pump(CancellationTokenSource cts, StreamInfo info)
		{
			CancellationToken token = cts.Token;
			using IPcmSource pcmSource = sourceFactory.Open(info.MediaUrl, format);
			using (token.Register(pcmSource.Dispose))
			{
				using IAudioSink audioSink = sinkFactory.Create(format);
				lock (gate)
				{
					if (token.IsCancellationRequested)
					{
						return false;
					}
					activeSink = audioSink;
					audioSink.SetVolume(VolumeCurve.ToGain(volume));
				}
				try
				{
					Publish(cts, new PlayerStatus(PlayerState.Buffering, info, null, null));
					byte[] array = new byte[AlignToFrame(format.BytesPerSecond / 10)];
					bool flag = false;
					while (!token.IsCancellationRequested)
					{
						int num = pcmSource.Read(array, 0, array.Length);
						if (num <= 0 || !WaitForRoom(audioSink, token))
						{
							break;
						}
						audioSink.Write(array, 0, num);
						if (!flag && audioSink.Buffered >= options.Prebuffer)
						{
							audioSink.Play();
							flag = true;
							Publish(cts, new PlayerStatus(PlayerState.Playing, info, DateTimeOffset.UtcNow, null));
						}
					}
					return flag;
				}
				finally
				{
					lock (gate)
					{
						if (activeSink == audioSink)
						{
							activeSink = null;
						}
					}
				}
			}
		}

		private bool WaitForRoom(IAudioSink sink, CancellationToken ct)
		{
			TimeSpan timeSpan = sink.Buffered;
			DateTime utcNow = DateTime.UtcNow;
			while (timeSpan > options.MaxBuffer)
			{
				if (ct.WaitHandle.WaitOne(50))
				{
					return false;
				}
				TimeSpan buffered = sink.Buffered;
				if (buffered < timeSpan)
				{
					utcNow = DateTime.UtcNow;
				}
				else if (DateTime.UtcNow - utcNow > options.StallTimeout)
				{
					throw new TimeoutException("Audio output stalled");
				}
				timeSpan = buffered;
			}
			return !ct.IsCancellationRequested;
		}

		private int AlignToFrame(int bytes)
		{
			int num = format.Channels * 2;
			return Math.Max(num, bytes - bytes % num);
		}

		private void Publish(CancellationTokenSource owner, PlayerStatus next)
		{
			lock (gate)
			{
				if (session == owner && !owner.IsCancellationRequested)
				{
					status = next;
				}
			}
		}

		private void Fail(CancellationTokenSource owner, PlayerStatus next)
		{
			lock (gate)
			{
				if (session == owner && !owner.IsCancellationRequested)
				{
					status = next;
					session = null;
					worker = null;
				}
			}
		}
	}
	public sealed record RadioPlayerOptions(TimeSpan Prebuffer, TimeSpan MaxBuffer, TimeSpan RetryBaseDelay, TimeSpan RetryMaxDelay, TimeSpan StallTimeout)
	{
		public static RadioPlayerOptions Default { get; } = new RadioPlayerOptions(TimeSpan.FromSeconds(1.5), TimeSpan.FromSeconds(5.0), TimeSpan.FromSeconds(2.0), TimeSpan.FromSeconds(60.0), TimeSpan.FromSeconds(10.0));

		[CompilerGenerated]
		private RadioPlayerOptions(RadioPlayerOptions original)
		{
			Prebuffer = original.Prebuffer;
			MaxBuffer = original.MaxBuffer;
			RetryBaseDelay = original.RetryBaseDelay;
			RetryMaxDelay = original.RetryMaxDelay;
			StallTimeout = original.StallTimeout;
		}
	}
	public static class Backoff
	{
		public static TimeSpan Delay(int attempt, TimeSpan baseDelay, TimeSpan maxDelay)
		{
			if (attempt <= 1)
			{
				return baseDelay;
			}
			int num = Math.Min(attempt - 1, 16);
			long num2 = baseDelay.Ticks * (1L << num);
			if (num2 < maxDelay.Ticks)
			{
				return TimeSpan.FromTicks(num2);
			}
			return maxDelay;
		}
	}
	public static class VolumeCurve
	{
		public static float Clamp(float volume)
		{
			if (!float.IsNaN(volume))
			{
				return Math.Clamp(volume, 0f, 1f);
			}
			return 0f;
		}

		public static float ToGain(float volume)
		{
			float num = Clamp(volume);
			return num * num;
		}

		public static float Step(float volume, float delta)
		{
			return Clamp((float)Math.Round(volume + delta, 2));
		}
	}
}
namespace JazzRadio.Core.Layout
{
	public static class PanelArt
	{
		private const float IdleLevel = 0.15f;

		public static int LitSegments(float volume, int count)
		{
			if (count > 0)
			{
				return (int)Math.Round(VolumeCurve.Clamp(volume) * (float)count);
			}
			return 0;
		}

		public static float[] SignalLevels(double seconds, int bars, bool active)
		{
			float[] array = new float[Math.Max(0, bars)];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (active ? Wave(seconds, i) : 0.15f);
			}
			return array;
		}

		public static bool Blink(double seconds, double period)
		{
			if (!(period <= 0.0))
			{
				return Math.Max(0.0, seconds) % period < period / 2.0;
			}
			return true;
		}

		private static float Wave(double seconds, int bar)
		{
			return (float)Math.Clamp(0.5 + 0.3 * Math.Sin(seconds * 5.1 + (double)bar * 1.7) + 0.2 * Math.Sin(seconds * 8.3 + (double)bar * 2.9), 0.15000000596046448, 1.0);
		}
	}
	public enum PanelAnchor
	{
		TopLeft,
		TopRight,
		BottomLeft,
		BottomRight
	}
	public readonly record struct PanelRect(float X, float Y, float Width, float Height);
	public static class PanelLayout
	{
		public const float BaseWidth = 340f;

		public const float BaseHeight = 104f;

		public static PanelRect Compute(PanelAnchor anchor, int screenWidth, int screenHeight, float margin, float scale)
		{
			float num = Math.Clamp(scale, 0.5f, 3f);
			float num2 = 340f * num;
			float num3 = 104f * num;
			float num4 = Math.Max(0f, margin);
			bool flag = ((anchor == PanelAnchor.TopLeft || anchor == PanelAnchor.BottomLeft) ? true : false);
			float val = (flag ? num4 : ((float)screenWidth - num2 - num4));
			flag = (uint)anchor <= 1u;
			float val2 = (flag ? num4 : ((float)screenHeight - num3 - num4));
			return new PanelRect(Math.Max(0f, val), Math.Max(0f, val2), num2, num3);
		}

		public static PanelRect Inner(PanelRect panel, float scale, float x, float y, float w, float h)
		{
			float num = Math.Clamp(scale, 0.5f, 3f);
			return new PanelRect(panel.X + x * num, panel.Y + y * num, w * num, h * num);
		}
	}
}
namespace JazzRadio.Core.Input
{
	public enum RadioAction
	{
		TogglePlay,
		TogglePanel,
		VolumeUp,
		VolumeDown
	}
	public sealed class HotkeyDispatcher
	{
		private readonly IReadOnlyList<KeyValuePair<RadioAction, int>> bindings;

		private readonly HashSet<int> held = new HashSet<int>();

		public HotkeyDispatcher(IReadOnlyDictionary<RadioAction, int> bindings)
		{
			this.bindings = (bindings ?? throw new ArgumentNullException("bindings")).Where((KeyValuePair<RadioAction, int> b) => b.Value != 0).ToList();
		}

		public IReadOnlyList<RadioAction> Poll(Func<int, bool> isDown, bool enabled)
		{
			if (!enabled)
			{
				held.Clear();
				return Array.Empty<RadioAction>();
			}
			List<RadioAction> list = new List<RadioAction>();
			foreach (int key in bindings.Select((KeyValuePair<RadioAction, int> b) => b.Value).Distinct())
			{
				bool flag = isDown(key);
				if (flag && held.Add(key))
				{
					list.AddRange(from b in bindings
						where b.Value == key
						select b.Key);
				}
				else if (!flag)
				{
					held.Remove(key);
				}
			}
			return list;
		}
	}
	public static class KeyMap
	{
		public const int None = 0;

		private static readonly IReadOnlyDictionary<string, int> Named = BuildNamed();

		public static bool TryParse(string? name, out int virtualKey)
		{
			virtualKey = 0;
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			return Named.TryGetValue(name.Trim(), out virtualKey);
		}

		private static Dictionary<string, int> BuildNamed()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)
			{
				["None"] = 0,
				["PageUp"] = 33,
				["PageDown"] = 34,
				["End"] = 35,
				["Home"] = 36,
				["Left"] = 37,
				["Up"] = 38,
				["Right"] = 39,
				["Down"] = 40,
				["Insert"] = 45,
				["Delete"] = 46,
				["Pause"] = 19,
				["ScrollLock"] = 145,
				["Multiply"] = 106,
				["Add"] = 107,
				["Subtract"] = 109,
				["Divide"] = 111,
				["Equals"] = 187,
				["Minus"] = 189,
				["LeftBracket"] = 219,
				["RightBracket"] = 221
			};
			for (int i = 1; i <= 24; i++)
			{
				dictionary["F" + i] = 112 + i - 1;
			}
			for (char c = 'A'; c <= 'Z'; c = (char)(c + 1))
			{
				dictionary[c.ToString()] = c;
			}
			for (int j = 0; j <= 9; j++)
			{
				dictionary[j.ToString(CultureInfo.InvariantCulture)] = 48 + j;
				dictionary["Alpha" + j] = 48 + j;
				dictionary["Keypad" + j] = 96 + j;
				dictionary["NumPad" + j] = 96 + j;
			}
			return dictionary;
		}
	}
}