using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using NLayer;
using UnityEngine;
using UnityEngine.Networking;

[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("ShipMusic")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.7.0.0")]
[assembly: AssemblyInformationalVersion("0.7.0+b765a0fab82a3212197c9c122cd45f491c6782a4")]
[assembly: AssemblyProduct("ShipMusic")]
[assembly: AssemblyTitle("ShipMusic")]
[assembly: AssemblyVersion("0.7.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 ShipMusic
{
	[DataContract]
	internal sealed class RadioStation
	{
		[DataMember]
		public string stationuuid { get; set; }

		[DataMember]
		public string name { get; set; }

		[DataMember]
		public string url_resolved { get; set; }

		[DataMember]
		public string tags { get; set; }

		[DataMember]
		public string codec { get; set; }

		[DataMember]
		public int hls { get; set; }

		[DataMember]
		public int lastcheckok { get; set; }

		public bool Playable
		{
			get
			{
				if (Guid.TryParse(stationuuid, out var _) && lastcheckok == 1 && hls == 0 && string.Equals(codec, "MP3", StringComparison.OrdinalIgnoreCase))
				{
					return RadioHttp.IsPublicUrl(url_resolved);
				}
				return false;
			}
		}
	}
	internal static class RadioHttp
	{
		public static bool IsPublicUrl(string value)
		{
			if (value != null && value.Length <= 2048 && Uri.TryCreate(value, UriKind.Absolute, out Uri result) && (result.Scheme == "https" || result.Scheme == "http") && result.UserInfo.Length == 0 && !result.IsLoopback && result.Host.Contains("."))
			{
				if (IPAddress.TryParse(result.Host, out IPAddress address))
				{
					return PublicAddress(address);
				}
				return true;
			}
			return false;
		}

		private static bool PublicAddress(IPAddress address)
		{
			if (IPAddress.IsLoopback(address))
			{
				return false;
			}
			if (address.IsIPv4MappedToIPv6)
			{
				address = address.MapToIPv4();
			}
			byte[] addressBytes = address.GetAddressBytes();
			if (addressBytes.Length == 16)
			{
				if (!address.IsIPv6LinkLocal && !address.IsIPv6SiteLocal && addressBytes[0] != byte.MaxValue && (addressBytes[0] & 0xFE) != 252)
				{
					return !address.Equals(IPAddress.IPv6Any);
				}
				return false;
			}
			if (addressBytes[0] != 0 && addressBytes[0] != 10 && addressBytes[0] != 127 && addressBytes[0] < 224 && (addressBytes[0] != 169 || addressBytes[1] != 254) && (addressBytes[0] != 172 || addressBytes[1] < 16 || addressBytes[1] > 31) && (addressBytes[0] != 192 || addressBytes[1] != 168))
			{
				if (addressBytes[0] == 100 && addressBytes[1] >= 64)
				{
					return addressBytes[1] > 127;
				}
				return true;
			}
			return false;
		}

		public static HttpWebResponse Open(string url, CancellationToken token)
		{
			for (int i = 0; i < 6; i++)
			{
				token.ThrowIfCancellationRequested();
				if (!IsPublicUrl(url))
				{
					throw new IOException("Unsupported radio address.");
				}
				Uri uri = new Uri(url);
				IPAddress[] hostAddresses = Dns.GetHostAddresses(uri.DnsSafeHost);
				for (int j = 0; j < hostAddresses.Length; j++)
				{
					if (!PublicAddress(hostAddresses[j]))
					{
						throw new IOException("Radio address must be public.");
					}
				}
				HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
				httpWebRequest.UserAgent = "ShipMusic/0.7.0";
				httpWebRequest.Timeout = 8000;
				httpWebRequest.ReadWriteTimeout = 8000;
				httpWebRequest.AllowAutoRedirect = false;
				httpWebRequest.Headers["Icy-MetaData"] = "0";
				HttpWebResponse httpWebResponse;
				using (token.Register(httpWebRequest.Abort))
				{
					httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
				}
				if (httpWebResponse.StatusCode >= HttpStatusCode.MultipleChoices && httpWebResponse.StatusCode < HttpStatusCode.BadRequest)
				{
					string text = httpWebResponse.Headers["Location"];
					httpWebResponse.Dispose();
					if (string.IsNullOrEmpty(text))
					{
						throw new IOException("Missing radio redirect.");
					}
					url = new Uri(uri, text).AbsoluteUri;
					continue;
				}
				return httpWebResponse;
			}
			throw new IOException("Too many radio redirects.");
		}
	}
	internal sealed class RadioCatalog
	{
		private string[] _servers;

		public static RadioStation[] Parse(byte[] json)
		{
			if (json == null || json.Length > 1048576)
			{
				throw new IOException("Radio catalog response too large.");
			}
			using MemoryStream stream = new MemoryStream(json);
			return (RadioStation[])new DataContractJsonSerializer(typeof(RadioStation[])).ReadObject(stream);
		}

		private string[] Servers()
		{
			if (_servers != null)
			{
				return _servers;
			}
			List<string> list = new List<string>();
			try
			{
				IPAddress[] hostAddresses = Dns.GetHostAddresses("all.api.radio-browser.info");
				for (int i = 0; i < hostAddresses.Length; i++)
				{
					string hostName = Dns.GetHostEntry(hostAddresses[i]).HostName;
					if (hostName.EndsWith(".api.radio-browser.info", StringComparison.OrdinalIgnoreCase) && !list.Contains(hostName))
					{
						list.Add(hostName);
					}
					if (list.Count == 3)
					{
						break;
					}
				}
			}
			catch
			{
			}
			if (list.Count == 0)
			{
				list.Add("de1.api.radio-browser.info");
				list.Add("nl1.api.radio-browser.info");
			}
			int index = new Random().Next(list.Count);
			string item = list[index];
			list.RemoveAt(index);
			list.Insert(0, item);
			return _servers = list.ToArray();
		}

		private RadioStation[] Get(string path, CancellationToken token)
		{
			Exception innerException = null;
			string[] array = Servers();
			foreach (string text in array)
			{
				token.ThrowIfCancellationRequested();
				try
				{
					using HttpWebResponse httpWebResponse = RadioHttp.Open("https://" + text + path, token);
					using (token.Register(httpWebResponse.Close))
					{
						using Stream stream = httpWebResponse.GetResponseStream();
						using MemoryStream memoryStream = new MemoryStream();
						byte[] array2 = new byte[8192];
						int num;
						while ((num = stream.Read(array2, 0, array2.Length)) > 0)
						{
							token.ThrowIfCancellationRequested();
							if (memoryStream.Length + num > 1048576)
							{
								throw new IOException("Radio catalog response too large.");
							}
							memoryStream.Write(array2, 0, num);
						}
						return Parse(memoryStream.ToArray());
					}
				}
				catch (Exception ex)
				{
					token.ThrowIfCancellationRequested();
					innerException = ex;
				}
			}
			throw new IOException("Radio Browser unavailable.", innerException);
		}

		public RadioStation[] Search(string tags, CancellationToken token)
		{
			List<RadioStation> list = new List<RadioStation>();
			HashSet<string> hashSet = new HashSet<string>();
			string[] array = tags.Split(',');
			for (int i = 0; i < array.Length && i < 8; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0 || text.Length > 60)
				{
					continue;
				}
				RadioStation[] array2 = Get("/json/stations/search?tag=" + Uri.EscapeDataString(text) + "&tagExact=true&codec=MP3&hidebroken=true&limit=20&order=random", token);
				foreach (RadioStation radioStation in array2)
				{
					if (radioStation != null && radioStation.Playable && MatchesTag(radioStation.tags, text) && hashSet.Add(radioStation.stationuuid))
					{
						list.Add(radioStation);
					}
				}
			}
			if (list.Count == 0)
			{
				throw new IOException("No playable MP3 stations for the configured radio tags.");
			}
			return list.ToArray();
		}

		internal static bool MatchesTag(string tags, string term)
		{
			string[] array = (tags ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				if (string.Equals(array[i].Trim(), term.Trim(), StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public RadioStation Lookup(string id, CancellationToken token)
		{
			if (!Guid.TryParseExact(id, "D", out var _))
			{
				throw new IOException("Invalid station ID.");
			}
			RadioStation[] array = Get("/json/stations/byuuid/" + id, token);
			foreach (RadioStation radioStation in array)
			{
				if (radioStation != null && radioStation.Playable && string.Equals(radioStation.stationuuid, id, StringComparison.OrdinalIgnoreCase))
				{
					return radioStation;
				}
			}
			throw new IOException("Radio station is unavailable or not an MP3 stream.");
		}
	}
	internal sealed class RadioPcmBuffer
	{
		private readonly float[] _samples;

		private readonly object _gate = new object();

		private int _read;

		private int _write;

		private int _count;

		public int Count
		{
			get
			{
				lock (_gate)
				{
					return _count;
				}
			}
		}

		public RadioPcmBuffer(int capacity)
		{
			_samples = new float[capacity];
		}

		public int Write(float[] data, int offset, int count)
		{
			lock (_gate)
			{
				count = Math.Min(count, _samples.Length - _count);
				int num = Math.Min(count, _samples.Length - _write);
				Array.Copy(data, offset, _samples, _write, num);
				Array.Copy(data, offset + num, _samples, 0, count - num);
				_write = (_write + count) % _samples.Length;
				_count += count;
				return count;
			}
		}

		public void Read(float[] data)
		{
			lock (_gate)
			{
				int num = Math.Min(data.Length, _count);
				int num2 = Math.Min(num, _samples.Length - _read);
				Array.Copy(_samples, _read, data, 0, num2);
				Array.Copy(_samples, 0, data, num2, num - num2);
				Array.Clear(data, num, data.Length - num);
				_read = (_read + num) % _samples.Length;
				_count -= num;
			}
		}
	}
	internal sealed class IcyAudioStream : Stream
	{
		private readonly Stream _inner;

		private readonly int _interval;

		private int _remaining;

		private long _position;

		public override bool CanRead => true;

		public override bool CanSeek => false;

		public override bool CanWrite => false;

		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override long Position
		{
			get
			{
				return _position;
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public IcyAudioStream(Stream inner, int interval)
		{
			_inner = inner;
			_interval = Math.Max(0, interval);
			_remaining = _interval;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (count == 0)
			{
				return 0;
			}
			if (_interval == 0)
			{
				int num = _inner.Read(buffer, offset, count);
				_position += num;
				return num;
			}
			if (_remaining == 0)
			{
				int num2 = _inner.ReadByte();
				if (num2 < 0)
				{
					return 0;
				}
				for (int i = 0; i < num2 * 16; i++)
				{
					if (_inner.ReadByte() < 0)
					{
						throw new EndOfStreamException("Truncated radio metadata.");
					}
				}
				_remaining = _interval;
			}
			int num3 = _inner.Read(buffer, offset, Math.Min(count, _remaining));
			_remaining -= num3;
			_position += num3;
			return num3;
		}

		public override void Flush()
		{
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException();
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException();
		}
	}
	internal interface IRadioStream : IDisposable
	{
		RadioPcmBuffer Buffer { get; }

		int SampleRate { get; }

		bool Finished { get; }

		string Error { get; }
	}
	internal sealed class RadioStream : IRadioStream, IDisposable
	{
		private readonly CancellationTokenSource _stop = new CancellationTokenSource();

		private volatile RadioPcmBuffer _buffer;

		private volatile int _sampleRate;

		private volatile bool _finished;

		private volatile string _error;

		private int _disposed;

		private readonly Task _worker;

		public RadioPcmBuffer Buffer => _buffer;

		public int SampleRate => _sampleRate;

		public bool Finished => _finished;

		public string Error => _error;

		public RadioStream(string url)
		{
			RadioStream radioStream = this;
			_worker = Task.Run(delegate
			{
				radioStream.Run(url);
			});
		}

		private void Run(string url)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			try
			{
				using HttpWebResponse httpWebResponse = RadioHttp.Open(url, _stop.Token);
				using (_stop.Token.Register(httpWebResponse.Close))
				{
					using Stream inner = httpWebResponse.GetResponseStream();
					int.TryParse(httpWebResponse.Headers["icy-metaint"], out var result);
					using IcyAudioStream icyAudioStream = new IcyAudioStream(inner, result);
					MpegFile val = new MpegFile((Stream)icyAudioStream);
					try
					{
						val.StereoMode = (StereoMode)3;
						int sampleRate = val.SampleRate;
						if (sampleRate < 8000 || sampleRate > 48000)
						{
							throw new IOException("Unsupported radio sample rate.");
						}
						_sampleRate = sampleRate;
						_buffer = new RadioPcmBuffer(sampleRate * 8);
						float[] array = new float[4096];
						while (!_stop.IsCancellationRequested)
						{
							int num = val.ReadSamples(array, 0, array.Length);
							if (num == 0)
							{
								throw new EndOfStreamException("Radio stream ended.");
							}
							int num2 = 0;
							while (num2 < num && !_stop.IsCancellationRequested)
							{
								num2 += _buffer.Write(array, num2, num - num2);
								if (num2 < num)
								{
									_stop.Token.WaitHandle.WaitOne(20);
								}
							}
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
			}
			catch (Exception ex)
			{
				if (!_stop.IsCancellationRequested)
				{
					_error = ex.GetType().Name + ": radio connection or decoding failed.";
				}
			}
			finally
			{
				_finished = true;
			}
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref _disposed, 1) == 0)
			{
				_stop.Cancel();
				_worker.ContinueWith(delegate
				{
					_stop.Dispose();
				}, TaskScheduler.Default);
			}
		}
	}
	internal sealed class SharedMusic : IDisposable
	{
		private sealed class Wanted
		{
			public SharedTrackOffer Offer;

			public long Peer;

			public bool Seen;
		}

		private sealed class Loaded
		{
			public AudioClip Clip;

			public UnityWebRequest Request;
		}

		private sealed class Upload
		{
			public long Peer;

			public int Offset;
		}

		private sealed class PendingChunk
		{
			public float Sent;
		}

		private sealed class Download
		{
			public Wanted Want;

			public SharedTrackBuffer Buffer;

			public int NextOffset;

			public float LastProgress;

			public readonly Dictionary<int, PendingChunk> Pending = new Dictionary<int, PendingChunk>();
		}

		internal const string OfferKey = "fenikonir.shipmusic.offer.v1";

		private const string RequestRpc = "fenikonir.shipmusic.request.v1";

		private const string ChunkRpc = "fenikonir.shipmusic.chunk.v1";

		private readonly ConfigEntry<bool> _share;

		private readonly ConfigEntry<bool> _receive;

		private readonly ConfigEntry<int> _maxSize;

		private readonly ConfigEntry<int> _cacheSize;

		private readonly ConfigEntry<int> _uploadLimit;

		private readonly ManualLogSource _log;

		private readonly string _cache;

		private readonly Dictionary<string, Wanted> _wanted = new Dictionary<string, Wanted>();

		private readonly Dictionary<string, Loaded> _loaded = new Dictionary<string, Loaded>();

		private readonly Dictionary<string, float> _failed = new Dictionary<string, float>();

		private readonly List<string> _remove = new List<string>();

		private const int WindowSize = 16;

		private readonly List<Upload> _uploads = new List<Upload>();

		private long _lastRecipient;

		private ZRoutedRpc _router;

		private SharedTrackOffer _localOffer;

		private byte[] _localBytes;

		private string _localIdentity;

		private Player _localPlayer;

		private Download _download;

		private float _sendBudget;

		private float _lastTick;

		private bool _disposed;

		private bool _cacheDirty = true;

		private int MaxBytes => Math.Min(_maxSize.Value, _cacheSize.Value) * 1024 * 1024;

		public static double Now
		{
			get
			{
				if (!((Object)(object)ZNet.instance != (Object)null))
				{
					return 0.0;
				}
				return ZNet.instance.GetTimeSeconds();
			}
		}

		public SharedMusic(ConfigFile config, ManualLogSource log)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			_log = log;
			_share = config.Bind<bool>("Sharing", "ShareMyTracks", false, "Send your selected OGG recording to nearby listeners while at the helm.");
			_receive = config.Bind<bool>("Sharing", "ReceiveSharedTracks", false, "Download and play the helmsman's recording. Off uses your local songs.");
			_maxSize = config.Bind<int>("Sharing", "MaxTrackSizeMB", 15, new ConfigDescription("Maximum compressed OGG size to send or receive.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			_cacheSize = config.Bind<int>("Sharing", "CacheSizeMB", 200, new ConfigDescription("Disk cache budget. Old cached tracks are removed first.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(15, 1000), Array.Empty<object>()));
			_cacheSize.SettingChanged += CacheChanged;
			_uploadLimit = config.Bind<int>("Sharing", "UploadLimitKBps", 1024, new ConfigDescription("Total OGG upload limit in KiB/s, shared by all listeners. Lower this on slow connections.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 4096), Array.Empty<object>()));
			_cache = Path.Combine(Paths.CachePath, "ShipMusic", "shared-v1");
		}

		private void CacheChanged(object sender, EventArgs args)
		{
			_cacheDirty = true;
		}

		public static ZDO Data(Component component)
		{
			ZNetView val = (((Object)(object)component != (Object)null) ? component.GetComponent<ZNetView>() : null);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return val.GetZDO();
		}

		public unsafe void SetLocal(Player player, Ship ship, string key, string path)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			ZDO val = Data((Component)(object)player);
			ZDO val2 = Data((Component)(object)ship);
			bool flag = _share.Value && val2 != null && val != null && val.IsOwner() && path != null;
			object obj;
			if (!flag)
			{
				obj = "";
			}
			else
			{
				string[] array = new string[5];
				ZDOID uid = val2.m_uid;
				array[0] = ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString();
				array[1] = "|";
				array[2] = key;
				array[3] = "|";
				array[4] = MaxBytes.ToString();
				obj = string.Concat(array);
			}
			string text = (string)obj;
			if ((Object)(object)_localPlayer == (Object)(object)player && text == _localIdentity)
			{
				return;
			}
			ClearLocal();
			_localPlayer = player;
			_localIdentity = text;
			if (!flag)
			{
				return;
			}
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				if (!fileInfo.Exists || fileInfo.Length < 64 || fileInfo.Length > MaxBytes)
				{
					throw new IOException("Track exceeds the configured size limit or is unavailable.");
				}
				byte[] array2 = File.ReadAllBytes(path);
				if (array2.Length > MaxBytes || !SharedTrackOffer.IsVorbis(array2))
				{
					throw new IOException("Expected OGG Vorbis.");
				}
				_localBytes = array2;
				_localOffer = new SharedTrackOffer
				{
					Ship = ((object)Unsafe.As<ZDOID, ZDOID>(ref val2.m_uid)/*cast due to .constrained prefix*/).ToString(),
					Hash = SharedTrackOffer.Digest(array2),
					Length = array2.Length,
					Started = Now,
					Session = Guid.NewGuid().ToString("N")
				};
				val.Set("fenikonir.shipmusic.offer.v1", _localOffer.Encode());
				_log.LogInfo((object)$"Sharing selected recording: {Path.GetFileName(path)} ({array2.Length / 1024} KiB)");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Could not share track: " + ex.Message));
			}
		}

		private void ClearLocal()
		{
			ZDO val = Data((Component)(object)_localPlayer);
			if (val != null && val.IsOwner())
			{
				val.Set("fenikonir.shipmusic.offer.v1", "");
			}
			_localOffer = null;
			_localBytes = null;
			_uploads.Clear();
		}

		public void BeginFrame()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (_router != instance)
			{
				ResetTransfers();
				_router = instance;
				if (_router != null)
				{
					_router.Register<ZPackage>("fenikonir.shipmusic.request.v1", (Action<long, ZPackage>)OnRequest);
					_router.Register<ZPackage>("fenikonir.shipmusic.chunk.v1", (Action<long, ZPackage>)OnChunk);
				}
			}
			foreach (Wanted value in _wanted.Values)
			{
				value.Seen = false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			_sendBudget = Math.Min(98304f, _sendBudget + Math.Max(0f, realtimeSinceStartup - _lastTick) * (float)_uploadLimit.Value * 1024f);
			_lastTick = realtimeSinceStartup;
		}

		public AudioClip Resolve(Ship ship, Player captain, AudioClip fallback, out double started, out string session)
		{
			//IL_0070: 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)
			started = -1.0;
			session = "";
			if ((Object)(object)captain == (Object)null)
			{
				return fallback;
			}
			SharedTrackOffer localOffer;
			if ((Object)(object)captain == (Object)(object)Player.m_localPlayer)
			{
				localOffer = _localOffer;
				if (localOffer == null)
				{
					return fallback;
				}
				started = localOffer.Started;
				session = localOffer.Session;
				return fallback;
			}
			if (!_receive.Value || (Object)(object)Player.m_localPlayer == (Object)null || Vector3.Distance(((Component)Player.m_localPlayer).transform.position, ((Component)ship).transform.position) > 50f)
			{
				return fallback;
			}
			ZDO val = Data((Component)(object)captain);
			ZDO val2 = Data((Component)(object)ship);
			if (val == null || val2 == null)
			{
				return fallback;
			}
			localOffer = SharedTrackOffer.Parse(val.GetString("fenikonir.shipmusic.offer.v1", ""), MaxBytes);
			if (localOffer == null || localOffer.Ship != ((object)Unsafe.As<ZDOID, ZDOID>(ref val2.m_uid)/*cast due to .constrained prefix*/).ToString() || localOffer.Started > Now + 10.0)
			{
				return fallback;
			}
			if (!_wanted.TryGetValue(localOffer.Hash, out var value))
			{
				if (_wanted.Count >= 4)
				{
					return fallback;
				}
				value = new Wanted();
				_wanted.Add(localOffer.Hash, value);
			}
			value.Offer = localOffer;
			value.Peer = val.GetOwner();
			value.Seen = true;
			if (_loaded.TryGetValue(localOffer.Hash, out var value2) && (Object)(object)value2.Clip != (Object)null)
			{
				started = localOffer.Started;
				session = localOffer.Session;
				return value2.Clip;
			}
			return fallback;
		}

		public void EndFrame()
		{
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Invalid comparison between Unknown and I4
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Invalid comparison between Unknown and I4
			_remove.Clear();
			foreach (KeyValuePair<string, Wanted> item in _wanted)
			{
				if (!item.Value.Seen || !_receive.Value)
				{
					_remove.Add(item.Key);
				}
			}
			foreach (string item2 in _remove)
			{
				_wanted.Remove(item2);
			}
			_remove.Clear();
			foreach (KeyValuePair<string, Loaded> item3 in _loaded)
			{
				if (!_wanted.ContainsKey(item3.Key))
				{
					_remove.Add(item3.Key);
				}
			}
			foreach (string item4 in _remove)
			{
				Release(_loaded[item4]);
				_loaded.Remove(item4);
				_cacheDirty = true;
			}
			if (_download != null && (!_wanted.TryGetValue(_download.Want.Offer.Hash, out var value) || value.Peer != _download.Want.Peer || value.Offer.Session != _download.Want.Offer.Session || value.Offer.Length > MaxBytes))
			{
				_download = null;
			}
			foreach (KeyValuePair<string, Loaded> item5 in _loaded)
			{
				Loaded value2 = item5.Value;
				if (value2.Request == null || !value2.Request.isDone)
				{
					continue;
				}
				try
				{
					if ((int)value2.Request.result != 1)
					{
						throw new IOException(value2.Request.error);
					}
					value2.Clip = DownloadHandlerAudioClip.GetContent(value2.Request);
					if ((Object)(object)value2.Clip == (Object)null || (int)value2.Clip.loadState == 3)
					{
						throw new IOException("OGG decoding failed.");
					}
				}
				catch (Exception ex)
				{
					Fail(item5.Key, ex.Message);
				}
				finally
				{
					value2.Request.Dispose();
					value2.Request = null;
				}
			}
			if (_cacheDirty)
			{
				TrimCache(0);
				_cacheDirty = false;
			}
			if (_router == null)
			{
				return;
			}
			SendQueuedChunks();
			if (_download == null)
			{
				foreach (KeyValuePair<string, Wanted> item6 in _wanted)
				{
					if (!_loaded.ContainsKey(item6.Key) && (!_failed.TryGetValue(item6.Key, out var value3) || !(Time.realtimeSinceStartup < value3)) && !TryCached(item6.Value.Offer))
					{
						_download = new Download
						{
							Want = new Wanted
							{
								Offer = item6.Value.Offer,
								Peer = item6.Value.Peer
							},
							Buffer = new SharedTrackBuffer(item6.Value.Offer.Length, MaxBytes),
							LastProgress = Time.realtimeSinceStartup
						};
						_log.LogInfo((object)$"Receiving shared track ({item6.Value.Offer.Length / 1024} KiB)");
						break;
					}
				}
			}
			if (_download == null)
			{
				return;
			}
			if (Time.realtimeSinceStartup - _download.LastProgress > 22f)
			{
				Fail(_download.Want.Offer.Hash, "Transfer timed out; using local music.");
				_download = null;
				return;
			}
			foreach (KeyValuePair<int, PendingChunk> item7 in _download.Pending)
			{
				if (!(Time.realtimeSinceStartup - item7.Value.Sent < 1f))
				{
					RequestChunk(item7.Key, item7.Value);
				}
			}
			while (_download.Pending.Count < 16 && _download.NextOffset < _download.Buffer.Bytes.Length)
			{
				int nextOffset = _download.NextOffset;
				_download.NextOffset += 24576;
				PendingChunk pendingChunk = new PendingChunk();
				_download.Pending.Add(nextOffset, pendingChunk);
				RequestChunk(nextOffset, pendingChunk);
			}
		}

		private void RequestChunk(int offset, PendingChunk pending)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(_download.Want.Offer.Session);
			val.Write(_download.Want.Offer.Hash);
			val.Write(offset);
			pending.Sent = Time.realtimeSinceStartup;
			_router.InvokeRoutedRPC(_download.Want.Peer, "fenikonir.shipmusic.request.v1", new object[1] { val });
		}

		private void OnRequest(long sender, ZPackage package)
		{
			if (_disposed || !_share.Value || _localOffer == null || _localBytes == null || _router == null)
			{
				return;
			}
			try
			{
				if (package.Size() > 256)
				{
					return;
				}
				string text = package.ReadString();
				string text2 = package.ReadString();
				int num = package.ReadInt();
				if (text != _localOffer.Session || text2 != _localOffer.Hash || num < 0 || num >= _localBytes.Length || num % 24576 != 0 || _localBytes.Length > MaxBytes || !CanSendTo(sender))
				{
					return;
				}
				int num2 = 0;
				foreach (Upload upload in _uploads)
				{
					if (upload.Peer == sender)
					{
						if (upload.Offset == num)
						{
							return;
						}
						num2++;
					}
				}
				if (num2 < 16 && _uploads.Count < 128)
				{
					_uploads.Add(new Upload
					{
						Peer = sender,
						Offset = num
					});
				}
			}
			catch (Exception ex)
			{
				_log.LogDebug((object)("Rejected track request: " + ex.Message));
			}
		}

		private bool CanSendTo(long peer)
		{
			//IL_008d: 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)
			Player localPlayer = Player.m_localPlayer;
			Ship val = (((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead()) ? localPlayer.GetControlledShip() : null);
			if ((Object)(object)val == (Object)null || ((object)Unsafe.As<ZDOID, ZDOID>(ref Data((Component)(object)val)?.m_uid)/*cast due to .constrained prefix*/).ToString() != _localOffer.Ship)
			{
				return false;
			}
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				ZDO obj = Data((Component)(object)allPlayer);
				if (obj != null && obj.GetOwner() == peer && Vector3.Distance(((Component)allPlayer).transform.position, ((Component)val).transform.position) <= 60f)
				{
					return true;
				}
			}
			return false;
		}

		private void SendQueuedChunks()
		{
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			if (!_share.Value || _localOffer == null || _localBytes == null || _localBytes.Length > MaxBytes)
			{
				_uploads.Clear();
				return;
			}
			for (int i = 0; i < 8; i++)
			{
				if (_uploads.Count <= 0)
				{
					break;
				}
				int num = _uploads.FindIndex((Upload upload2) => upload2.Peer != _lastRecipient);
				if (num < 0)
				{
					num = 0;
				}
				Upload upload = _uploads[num];
				if (!CanSendTo(upload.Peer))
				{
					_uploads.RemoveAt(num);
					continue;
				}
				int num2 = Math.Min(24576, _localBytes.Length - upload.Offset);
				if (_sendBudget < (float)num2)
				{
					break;
				}
				_uploads.RemoveAt(num);
				_sendBudget -= num2;
				_lastRecipient = upload.Peer;
				int num3 = _uploads.Count;
				int num4 = 0;
				while (num4 < num3)
				{
					if (_uploads[num4].Peer != upload.Peer)
					{
						num4++;
						continue;
					}
					Upload item = _uploads[num4];
					_uploads.RemoveAt(num4);
					_uploads.Add(item);
					num3--;
				}
				byte[] array = new byte[num2];
				Buffer.BlockCopy(_localBytes, upload.Offset, array, 0, num2);
				ZPackage val = new ZPackage();
				val.Write(_localOffer.Session);
				val.Write(_localOffer.Hash);
				val.Write(upload.Offset);
				val.Write(array);
				_router.InvokeRoutedRPC(upload.Peer, "fenikonir.shipmusic.chunk.v1", new object[1] { val });
			}
		}

		private void OnChunk(long sender, ZPackage package)
		{
			if (_disposed || !_receive.Value || _download == null)
			{
				return;
			}
			try
			{
				if (package.Size() > 24832 || sender != _download.Want.Peer)
				{
					return;
				}
				string text = package.ReadString();
				string text2 = package.ReadString();
				int num = package.ReadInt();
				int num2 = package.ReadInt();
				if (text != _download.Want.Offer.Session || text2 != _download.Want.Offer.Hash || num2 < 1 || num2 > 24576 || _download.Buffer.Bytes.Length > MaxBytes || !_download.Pending.ContainsKey(num))
				{
					return;
				}
				byte[] chunk = package.ReadByteArray(num2);
				if (!_download.Buffer.Append(num, chunk))
				{
					return;
				}
				_download.Pending.Remove(num);
				_download.LastProgress = Time.realtimeSinceStartup;
				if (_download.Buffer.Complete)
				{
					byte[] bytes = _download.Buffer.Bytes;
					if (SharedTrackOffer.Digest(bytes) != text2 || !SharedTrackOffer.IsVorbis(bytes))
					{
						throw new IOException("Track integrity/format check failed.");
					}
					Directory.CreateDirectory(_cache);
					TrimCache(bytes.Length);
					string path = CachePath(text2);
					File.WriteAllBytes(path, bytes);
					BeginDecode(text2, path);
					_download = null;
					_log.LogInfo((object)"Shared track received and verified; preparing playback.");
				}
			}
			catch (Exception ex)
			{
				if (_download != null)
				{
					Fail(_download.Want.Offer.Hash, ex.Message);
				}
				_download = null;
			}
		}

		private string CachePath(string hash)
		{
			return Path.Combine(_cache, hash + ".ogg");
		}

		private bool TryCached(SharedTrackOffer offer)
		{
			try
			{
				string text = CachePath(offer.Hash);
				FileInfo fileInfo = new FileInfo(text);
				if (!fileInfo.Exists || fileInfo.Length != offer.Length)
				{
					return false;
				}
				byte[] bytes = File.ReadAllBytes(text);
				if (SharedTrackOffer.Digest(bytes) != offer.Hash || !SharedTrackOffer.IsVorbis(bytes))
				{
					File.Delete(text);
					return false;
				}
				File.SetLastWriteTimeUtc(text, DateTime.UtcNow);
				BeginDecode(offer.Hash, text);
				return true;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Cache read failed: " + ex.Message));
				return false;
			}
		}

		private void BeginDecode(string hash, string path)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(new Uri(path).AbsoluteUri, (AudioType)14);
			((DownloadHandlerAudioClip)audioClip.downloadHandler).streamAudio = true;
			audioClip.SendWebRequest();
			_loaded[hash] = new Loaded
			{
				Request = audioClip
			};
		}

		private void TrimCache(int incoming)
		{
			try
			{
				if (!Directory.Exists(_cache))
				{
					return;
				}
				FileInfo[] files = new DirectoryInfo(_cache).GetFiles("*.ogg");
				Array.Sort(files, (FileInfo a, FileInfo b) => a.LastWriteTimeUtc.CompareTo(b.LastWriteTimeUtc));
				long num = incoming;
				FileInfo[] array = files;
				foreach (FileInfo fileInfo in array)
				{
					num += fileInfo.Length;
				}
				array = files;
				foreach (FileInfo fileInfo2 in array)
				{
					if (num <= (long)_cacheSize.Value * 1024L * 1024)
					{
						break;
					}
					if (!_loaded.ContainsKey(Path.GetFileNameWithoutExtension(fileInfo2.Name)))
					{
						long length = fileInfo2.Length;
						fileInfo2.Delete();
						num -= length;
					}
				}
				if (incoming <= 0 || num <= (long)_cacheSize.Value * 1024L * 1024)
				{
					return;
				}
				throw new IOException("Cache budget exhausted.");
			}
			catch (Exception ex)
			{
				if (incoming > 0)
				{
					throw;
				}
				_log.LogWarning((object)("Cache cleanup failed: " + ex.Message));
			}
		}

		private void Fail(string hash, string reason)
		{
			if (_failed.Count >= 128)
			{
				_failed.Clear();
			}
			_failed[hash] = Time.realtimeSinceStartup + 60f;
			_log.LogWarning((object)("Shared track unavailable: " + reason));
		}

		private static void Release(Loaded loaded)
		{
			if ((Object)(object)loaded.Clip != (Object)null)
			{
				Object.Destroy((Object)(object)loaded.Clip);
			}
			UnityWebRequest request = loaded.Request;
			if (request != null)
			{
				request.Abort();
			}
			UnityWebRequest request2 = loaded.Request;
			if (request2 != null)
			{
				request2.Dispose();
			}
		}

		private void ResetTransfers()
		{
			_download = null;
			foreach (Loaded value in _loaded.Values)
			{
				Release(value);
			}
			_loaded.Clear();
			_wanted.Clear();
			_failed.Clear();
			_uploads.Clear();
			_sendBudget = 0f;
			_lastTick = Time.realtimeSinceStartup;
			_localIdentity = null;
		}

		public void Dispose()
		{
			_disposed = true;
			ClearLocal();
			ResetTransfers();
			_cacheSize.SettingChanged -= CacheChanged;
		}
	}
	internal sealed class SharedTrackOffer
	{
		public string Ship;

		public string Hash;

		public string Session;

		public int Length;

		public double Started;

		public string Encode()
		{
			return string.Join("|", Ship, Hash, Length.ToString(CultureInfo.InvariantCulture), Started.ToString("R", CultureInfo.InvariantCulture), Session);
		}

		public static SharedTrackOffer Parse(string value, int maxBytes)
		{
			if (string.IsNullOrEmpty(value) || value.Length > 256)
			{
				return null;
			}
			string[] array = value.Split('|');
			if (array.Length != 5 || array[0].Length == 0 || !IsHash(array[1]) || !int.TryParse(array[2], out var result) || result < 64 || result > maxBytes || !double.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || double.IsNaN(result2) || double.IsInfinity(result2) || result2 < 0.0 || !Guid.TryParseExact(array[4], "N", out var _))
			{
				return null;
			}
			return new SharedTrackOffer
			{
				Ship = array[0],
				Hash = array[1],
				Length = result,
				Started = result2,
				Session = array[4]
			};
		}

		public static bool IsHash(string hash)
		{
			if (hash == null || hash.Length != 64)
			{
				return false;
			}
			foreach (char c in hash)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}

		public static string Digest(byte[] bytes)
		{
			using SHA256 sHA = SHA256.Create();
			return BitConverter.ToString(sHA.ComputeHash(bytes)).Replace("-", "").ToLowerInvariant();
		}

		public static bool IsVorbis(byte[] bytes)
		{
			if (bytes == null || bytes.Length < 64 || bytes[0] != 79 || bytes[1] != 103 || bytes[2] != 103 || bytes[3] != 83 || bytes[4] != 0)
			{
				return false;
			}
			int num = 27 + bytes[26];
			if (num + 7 <= bytes.Length && bytes[num] == 1 && bytes[num + 1] == 118 && bytes[num + 2] == 111 && bytes[num + 3] == 114 && bytes[num + 4] == 98 && bytes[num + 5] == 105)
			{
				return bytes[num + 6] == 115;
			}
			return false;
		}
	}
	internal sealed class SharedTrackBuffer
	{
		public const int ChunkSize = 24576;

		public readonly byte[] Bytes;

		private readonly bool[] _received;

		public int ReceivedBytes { get; private set; }

		public bool Complete => ReceivedBytes == Bytes.Length;

		public SharedTrackBuffer(int length, int maxBytes)
		{
			if (length < 64 || length > maxBytes)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			Bytes = new byte[length];
			_received = new bool[(length + 24576 - 1) / 24576];
		}

		public bool Append(int offset, byte[] chunk)
		{
			if (chunk == null || offset < 0 || offset >= Bytes.Length || offset % 24576 != 0 || _received[offset / 24576] || chunk.Length != Math.Min(24576, Bytes.Length - offset))
			{
				return false;
			}
			Buffer.BlockCopy(chunk, 0, Bytes, offset, chunk.Length);
			_received[offset / 24576] = true;
			ReceivedBytes += chunk.Length;
			return true;
		}
	}
	[BepInPlugin("fenikonir.shipmusic", "Ship Music", "0.7.0")]
	public sealed class ShipMusicPlugin : BaseUnityPlugin
	{
		private readonly Dictionary<Ship, AudioSource> _shipSources = new Dictionary<Ship, AudioSource>();

		private readonly List<Ship> _removedShips = new List<Ship>();

		private readonly Dictionary<string, AudioClip> _musicClips = new Dictionary<string, AudioClip>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> TrackFiles = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			{ "Raft", "raft.ogg" },
			{ "Karve", "karve.ogg" },
			{ "VikingShip", "longship.ogg" },
			{ "VikingShip_Ashlands", "drakkar.ogg" }
		};

		private UnityWebRequest _loadRequest;

		private ConfigEntry<int> _volume;

		private FileSystemWatcher _configWatcher;

		private long _reloadAfterTicks;

		private int _reloadAttempts;

		private int _watcherError;

		private readonly List<string> _extraTracks = new List<string>();

		private Ship _localHelm;

		private Player _selectionPlayer;

		private int _trackIndex = -1;

		private bool _tracksLoaded;

		private const string SelectionKey = "fenikonir.shipmusic.selection";

		private SharedMusic _sharing;

		private ShipRadio _radio;

		private readonly Dictionary<string, string> _trackPaths = new Dictionary<string, string>(StringComparer.Ordinal);

		private readonly Dictionary<Ship, string> _playSessions = new Dictionary<Ship, string>();

		private double _selectedStart;

		private string _selectedSession;

		private void Awake()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Ship Music loaded");
			_volume = ((BaseUnityPlugin)this).Config.Bind<int>("Audio", "Volume", 50, new ConfigDescription("Music volume in percent. 0 = muted, 100 = maximum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			_volume.SettingChanged += OnVolumeChanged;
			_sharing = new SharedMusic(((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Logger);
			_radio = new ShipRadio(((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Logger, delegate(string message)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null, false);
				}
			});
			StartConfigWatcher();
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			((MonoBehaviour)this).StartCoroutine(LoadTracks(directoryName));
		}

		private IEnumerator LoadTracks(string directory)
		{
			foreach (KeyValuePair<string, string> trackFile in TrackFiles)
			{
				yield return LoadMusic(trackFile.Key, Path.Combine(directory, trackFile.Value));
			}
			string path = Path.Combine(directory, "tracks");
			Directory.CreateDirectory(path);
			string[] files = Directory.GetFiles(path);
			Array.Sort(files, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
			string[] array = files;
			foreach (string path2 in array)
			{
				if (!string.Equals(Path.GetExtension(path2), ".ogg", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string key = "tracks/" + Path.GetFileName(path2).ToLowerInvariant();
				if (!_musicClips.ContainsKey(key))
				{
					yield return LoadMusic(key, path2);
					if (_musicClips.ContainsKey(key))
					{
						_extraTracks.Add(key);
					}
				}
			}
			_tracksLoaded = true;
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Extra tracks ready: {_extraTracks.Count}. F8 cycles tracks at the helm.");
		}

		private IEnumerator LoadMusic(string prefab, string path)
		{
			if (!File.Exists(path))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Music file not found: " + path + ". Place it beside ShipMusic.dll and restart the game."));
				yield break;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Loading music: " + path));
			_loadRequest = UnityWebRequestMultimedia.GetAudioClip(new Uri(path).AbsoluteUri, (AudioType)14);
			try
			{
				yield return _loadRequest.SendWebRequest();
				if ((int)_loadRequest.result != 1)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failed to load " + path + ": " + _loadRequest.error));
					yield break;
				}
				AudioClip content = DownloadHandlerAudioClip.GetContent(_loadRequest);
				if ((Object)(object)content == (Object)null || (int)content.loadState == 3)
				{
					if ((Object)(object)content != (Object)null)
					{
						Object.Destroy((Object)(object)content);
					}
					((BaseUnityPlugin)this).Logger.LogError((object)("Could not decode " + path + ". Use an OGG Vorbis audio file."));
				}
				else
				{
					_musicClips.Add(prefab, content);
					_trackPaths[prefab] = path;
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"Music loaded: {prefab} -> {Path.GetFileName(path)}, {content.length:F1} seconds.");
				}
			}
			finally
			{
				ShipMusicPlugin shipMusicPlugin = this;
				UnityWebRequest loadRequest = shipMusicPlugin._loadRequest;
				if (loadRequest != null)
				{
					loadRequest.Dispose();
				}
				shipMusicPlugin._loadRequest = null;
			}
		}

		private void Update()
		{
			ReloadChangedConfig();
			_sharing.BeginFrame();
			UpdateTrackSelection();
			UpdateRadio();
			UpdateShipAudio();
			_sharing.EndFrame();
		}

		private void PublishSelection(Player player, Ship ship, string track)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)player).GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsOwner())
			{
				ZDO zDO = component.GetZDO();
				if (zDO != null)
				{
					ZNetView val = (((Object)(object)ship != (Object)null) ? ((Component)ship).GetComponent<ZNetView>() : null);
					ZDO val2 = (((Object)(object)val != (Object)null) ? val.GetZDO() : null);
					zDO.Set("fenikonir.shipmusic.selection", (val2 != null && track.Length > 0) ? (((object)Unsafe.As<ZDOID, ZDOID>(ref val2.m_uid)/*cast due to .constrained prefix*/).ToString() + "\n" + track) : "");
				}
			}
		}

		private void UpdateTrackSelection()
		{
			Player localPlayer = Player.m_localPlayer;
			Ship val = (((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead()) ? localPlayer.GetControlledShip() : null);
			if ((Object)(object)localPlayer != (Object)(object)_selectionPlayer || (Object)(object)val != (Object)(object)_localHelm)
			{
				PublishSelection(_selectionPlayer, null, "");
				_selectionPlayer = localPlayer;
				_localHelm = val;
				_trackIndex = -1;
				PublishSelection(localPlayer, null, "");
			}
			bool flag = (Object)(object)val != (Object)null && Input.GetKeyDown((KeyCode)289);
			_radio.UpdateLocal(localPlayer, val, flag);
			UpdateSharedSelection(localPlayer, val);
			if (_radio.Enabled || !flag)
			{
				return;
			}
			if (!_tracksLoaded)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Tracks are still loading.");
				return;
			}
			if (_extraTracks.Count == 0)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"No extra tracks. Add OGG Vorbis files to tracks beside the DLL and restart.");
				return;
			}
			_trackIndex++;
			if (_trackIndex >= _extraTracks.Count)
			{
				_trackIndex = -1;
			}
			string text = ((_trackIndex < 0) ? "" : _extraTracks[_trackIndex]);
			PublishSelection(localPlayer, val, text);
			UpdateSharedSelection(localPlayer, val);
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Selected music: " + ((text.Length == 0) ? "boat default" : text)));
		}

		private void UpdateSharedSelection(Player player, Ship helm)
		{
			if (_radio.Enabled)
			{
				_sharing.SetLocal(player, null, "", null);
				return;
			}
			string text = ((_trackIndex < 0 || _trackIndex >= _extraTracks.Count) ? "" : _extraTracks[_trackIndex]);
			if (text.Length == 0 && (Object)(object)helm != (Object)null)
			{
				text = ((Object)((Component)helm).gameObject).name;
				if (text.EndsWith("(Clone)", StringComparison.Ordinal))
				{
					text = text.Substring(0, text.Length - 7);
				}
			}
			_trackPaths.TryGetValue(text, out var value);
			_sharing.SetLocal(player, helm, text, value);
		}

		private void UpdateRadio()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			Ship ship = null;
			Player captain = null;
			Player localPlayer = Player.m_localPlayer;
			float num = 50f;
			if (_radio.Enabled && (Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead())
			{
				foreach (IMonoUpdater instance in Ship.Instances)
				{
					Ship val = (Ship)(object)((instance is Ship) ? instance : null);
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled || (Object)(object)val.m_shipControlls == (Object)null || !val.m_shipControlls.HaveValidUser())
					{
						continue;
					}
					float num2 = Vector3.Distance(((Component)localPlayer).transform.position, ((Component)val).transform.position);
					if (!(num2 > num))
					{
						Player player = Player.GetPlayer(val.m_shipControlls.GetUser());
						ZDO obj = SharedMusic.Data((Component)(object)player);
						RadioSelection radioSelection = RadioSelection.Parse((obj != null) ? obj.GetString("fenikonir.shipmusic.radio.v1", "") : null);
						if (radioSelection != null && !(radioSelection.Ship != ((object)Unsafe.As<ZDOID, ZDOID>(ref SharedMusic.Data((Component)(object)val)?.m_uid)/*cast due to .constrained prefix*/).ToString()))
						{
							ship = val;
							captain = player;
							num = num2;
						}
					}
				}
			}
			_radio.Listen(ship, captain);
		}

		private AudioClip GetShipClip(Ship ship, ShipControlls controls)
		{
			_selectedStart = -1.0;
			_selectedSession = "";
			string text = ((Object)((Component)ship).gameObject).name;
			if (text.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length);
			}
			if (!TrackFiles.ContainsKey(text))
			{
				return null;
			}
			_musicClips.TryGetValue(text, out var value);
			Player val = (((Object)(object)controls != (Object)null) ? Player.GetPlayer(controls.GetUser()) : null);
			if (_radio.WantsShip(ship))
			{
				return _radio.Clip ?? value;
			}
			if (_radio.Enabled)
			{
				ZDO obj = SharedMusic.Data((Component)(object)val);
				if (RadioSelection.Parse((obj != null) ? obj.GetString("fenikonir.shipmusic.radio.v1", "") : null) != null)
				{
					return null;
				}
			}
			ZNetView val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<ZNetView>() : null);
			ZNetView component = ((Component)ship).GetComponent<ZNetView>();
			ZDO val3 = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			ZDO val4 = (((Object)(object)val2 != (Object)null) ? val2.GetZDO() : null);
			if (val4 != null && val3 != null)
			{
				string text2 = val4.GetString("fenikonir.shipmusic.selection", "");
				string text3 = ((object)Unsafe.As<ZDOID, ZDOID>(ref val3.m_uid)/*cast due to .constrained prefix*/).ToString() + "\n";
				if (text2.StartsWith(text3, StringComparison.Ordinal))
				{
					string text4 = text2.Substring(text3.Length);
					if (text4.StartsWith("tracks/", StringComparison.Ordinal) && _musicClips.TryGetValue(text4, out var value2))
					{
						value = value2;
					}
				}
			}
			return _sharing.Resolve(ship, val, value, out _selectedStart, out _selectedSession);
		}

		private void UpdateShipAudio()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Invalid comparison between Unknown and I4
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)Player.m_localPlayer != (Object)null;
			if (flag)
			{
				foreach (IMonoUpdater instance in Ship.Instances)
				{
					Ship val = (Ship)(object)((instance is Ship) ? instance : null);
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled)
					{
						continue;
					}
					ShipControlls shipControlls = val.m_shipControlls;
					bool flag2 = (Object)(object)shipControlls != (Object)null && shipControlls.HaveValidUser();
					AudioClip val2 = (flag2 ? GetShipClip(val, shipControlls) : null);
					string text = (flag2 ? _selectedSession : "");
					if (!_shipSources.TryGetValue(val, out var value))
					{
						if (!flag2 || (Object)(object)val2 == (Object)null || (int)val2.loadState != 2)
						{
							continue;
						}
						GameObject val3 = new GameObject("ShipMusicAudio");
						val3.transform.SetParent(((Component)val).transform, false);
						value = val3.AddComponent<AudioSource>();
						value.playOnAwake = false;
						value.clip = val2;
						value.loop = true;
						value.spatialBlend = 1f;
						value.dopplerLevel = 0f;
						value.rolloffMode = (AudioRolloffMode)1;
						value.minDistance = 10f;
						value.maxDistance = 40f;
						value.volume = Mathf.Clamp01((float)_volume.Value / 100f);
						_shipSources.Add(val, value);
						((BaseUnityPlugin)this).Logger.LogInfo((object)("Ship audio attached: " + ((Object)((Component)val).gameObject).name));
					}
					if ((Object)(object)value == (Object)null)
					{
						continue;
					}
					_playSessions.TryGetValue(val, out var value2);
					if ((Object)(object)value.clip != (Object)(object)val2 || value2 != text)
					{
						value.Stop();
						value.clip = val2;
						_playSessions[val] = text;
					}
					if (flag2 && (Object)(object)val2 != (Object)null && !value.isPlaying)
					{
						if (_selectedStart >= 0.0 && val2.length > 0f)
						{
							value.time = (float)(Math.Max(0.0, SharedMusic.Now - _selectedStart) % (double)val2.length);
						}
						value.Play();
					}
					else if (!flag2 && value.isPlaying)
					{
						value.Stop();
					}
				}
			}
			_removedShips.Clear();
			foreach (KeyValuePair<Ship, AudioSource> shipSource in _shipSources)
			{
				if (!flag || (Object)(object)shipSource.Key == (Object)null || !((Behaviour)shipSource.Key).isActiveAndEnabled || !Ship.Instances.Contains((IMonoUpdater)(object)shipSource.Key) || (Object)(object)shipSource.Value == (Object)null)
				{
					if ((Object)(object)shipSource.Value != (Object)null)
					{
						shipSource.Value.Stop();
						Object.Destroy((Object)(object)((Component)shipSource.Value).gameObject);
					}
					_removedShips.Add(shipSource.Key);
				}
			}
			foreach (Ship removedShip in _removedShips)
			{
				_shipSources.Remove(removedShip);
				_playSessions.Remove(removedShip);
			}
		}

		private void OnVolumeChanged(object sender, EventArgs args)
		{
			ApplyVolume();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Music volume: {_volume.Value}%");
		}

		private void StartConfigWatcher()
		{
			try
			{
				_configWatcher = new FileSystemWatcher(Path.GetDirectoryName(((BaseUnityPlugin)this).Config.ConfigFilePath), Path.GetFileName(((BaseUnityPlugin)this).Config.ConfigFilePath));
				_configWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite;
				_configWatcher.Changed += OnConfigFileChanged;
				_configWatcher.Created += OnConfigFileChanged;
				_configWatcher.Renamed += OnConfigFileChanged;
				_configWatcher.Error += OnConfigWatcherError;
				_configWatcher.EnableRaisingEvents = true;
			}
			catch (Exception ex)
			{
				_configWatcher?.Dispose();
				_configWatcher = null;
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Config watching unavailable; restart to apply file edits: " + ex.Message));
			}
		}

		private void OnConfigFileChanged(object sender, FileSystemEventArgs args)
		{
			Interlocked.Exchange(ref _reloadAttempts, 0);
			Interlocked.Exchange(ref _reloadAfterTicks, DateTime.UtcNow.AddMilliseconds(250.0).Ticks);
		}

		private void OnConfigWatcherError(object sender, ErrorEventArgs args)
		{
			Interlocked.Exchange(ref _watcherError, 1);
			OnConfigFileChanged(sender, null);
		}

		private void ReloadChangedConfig()
		{
			if (Interlocked.Exchange(ref _watcherError, 0) != 0)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Config watcher reported an error. Reloading config; if later edits are ignored, restart the game.");
			}
			long num = Interlocked.Read(in _reloadAfterTicks);
			if (num == 0L || DateTime.UtcNow.Ticks < num || Interlocked.CompareExchange(ref _reloadAfterTicks, 0L, num) != num)
			{
				return;
			}
			try
			{
				if (!File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
				{
					throw new IOException("Config file is temporarily unavailable.");
				}
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch (Exception ex)
			{
				if (Interlocked.Increment(ref _reloadAttempts) < 3)
				{
					Interlocked.CompareExchange(ref _reloadAfterTicks, DateTime.UtcNow.AddMilliseconds(500.0).Ticks, 0L);
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not reload music config; save it again to retry: " + ex.Message));
				}
			}
		}

		private void ApplyVolume()
		{
			foreach (AudioSource value in _shipSources.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					value.volume = Mathf.Clamp01((float)_volume.Value / 100f);
				}
			}
		}

		private void OnDestroy()
		{
			PublishSelection(_selectionPlayer, null, "");
			_sharing?.Dispose();
			_radio?.Dispose();
			_configWatcher?.Dispose();
			_configWatcher = null;
			if (_volume != null)
			{
				_volume.SettingChanged -= OnVolumeChanged;
			}
			((MonoBehaviour)this).StopAllCoroutines();
			UnityWebRequest loadRequest = _loadRequest;
			if (loadRequest != null)
			{
				loadRequest.Dispose();
			}
			_loadRequest = null;
			foreach (AudioSource value in _shipSources.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					value.Stop();
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			_shipSources.Clear();
			foreach (AudioClip value2 in _musicClips.Values)
			{
				if ((Object)(object)value2 != (Object)null)
				{
					Object.Destroy((Object)(object)value2);
				}
			}
			_musicClips.Clear();
		}
	}
	internal sealed class RadioSelection
	{
		public string Ship;

		public string Station;

		public string Session;

		public string Encode()
		{
			return Ship + "|" + Station + "|" + Session;
		}

		public static RadioSelection Parse(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length > 200)
			{
				return null;
			}
			string[] array = value.Split('|');
			if (array.Length != 3 || array[0].Length == 0 || !Guid.TryParseExact(array[1], "D", out var result) || !Guid.TryParseExact(array[2], "N", out result))
			{
				return null;
			}
			return new RadioSelection
			{
				Ship = array[0],
				Station = array[1],
				Session = array[2]
			};
		}
	}
	internal sealed class ShipRadio : IDisposable
	{
		internal const string SelectionKey = "fenikonir.shipmusic.radio.v1";

		private readonly ConfigEntry<bool> _enabled;

		private readonly ConfigEntry<string> _tags;

		private readonly ManualLogSource _log;

		private readonly Action<string> _notify;

		private readonly Func<string, CancellationToken, RadioStation[]> _search;

		private readonly Func<string, CancellationToken, RadioStation> _lookup;

		private readonly Func<string, IRadioStream> _open;

		private readonly Random _random = new Random();

		private Player _localPlayer;

		private Ship _helm;

		private Ship _target;

		private string _localTags;

		private string _session = "";

		private string _localStation = "";

		private string _localSession = "";

		private RadioStation[] _stations;

		private RadioStation _selectedStation;

		private Task<RadioStation[]> _searchTask;

		private Task<RadioStation> _lookupTask;

		private CancellationTokenSource _searchStop;

		private CancellationTokenSource _lookupStop;

		private IRadioStream _stream;

		private AudioClip _clip;

		private float _searchRetry;

		private float _streamRetry;

		private float _nextSwitch;

		private float _connectingSince;

		private float _catalogExpires;

		private int _failures;

		public bool Enabled => _enabled.Value;

		public AudioClip Clip => _clip;

		public ShipRadio(ConfigFile config, ManualLogSource log, Action<string> notify = null, Func<string, CancellationToken, RadioStation[]> search = null, Func<string, CancellationToken, RadioStation> lookup = null, Func<string, IRadioStream> open = null)
		{
			_log = log;
			_notify = notify;
			RadioCatalog radioCatalog = new RadioCatalog();
			_search = search ?? new Func<string, CancellationToken, RadioStation[]>(radioCatalog.Search);
			_lookup = lookup ?? new Func<string, CancellationToken, RadioStation>(radioCatalog.Lookup);
			_open = open ?? ((Func<string, IRadioStream>)((string url) => new RadioStream(url)));
			_enabled = config.Bind<bool>("Radio", "Enabled", true, "Play live internet radio on occupied ships. F8 at the helm changes station. Disable to use local OGG music and file sharing.");
			_tags = config.Bind<string>("Radio", "Tags", "viking,viking metal,nordic folk,folk metal,pagan metal", "Comma-separated Radio Browser genre tags (up to eight). A random MP3 station is chosen; the station controls its playlist.");
		}

		public void UpdateLocal(Player player, Ship helm, bool next)
		{
			string tags = _tags.Value ?? "";
			if (tags.Length > 512)
			{
				tags = tags.Substring(0, 512);
			}
			if (!Enabled)
			{
				helm = null;
			}
			if ((Object)(object)_localPlayer != (Object)(object)player || (Object)(object)_helm != (Object)(object)helm || _localTags != tags)
			{
				ClearOffer();
				Cancel(ref _searchStop, ref _searchTask);
				if (_localTags != tags)
				{
					_stations = null;
				}
				_localPlayer = player;
				_helm = helm;
				_localTags = tags;
				_localStation = "";
				_localSession = "";
				_selectedStation = null;
				_searchRetry = 0f;
			}
			ZDO val = SharedMusic.Data((Component)(object)helm);
			if ((Object)(object)helm == (Object)null || val == null)
			{
				return;
			}
			ZDO obj = SharedMusic.Data((Component)(object)player);
			if (obj == null || !obj.IsOwner())
			{
				return;
			}
			if (next && Time.realtimeSinceStartup >= _nextSwitch)
			{
				_nextSwitch = Time.realtimeSinceStartup + 1f;
				_localSession = "";
				_searchRetry = 0f;
			}
			if (_searchTask != null && _searchTask.IsCompleted)
			{
				try
				{
					_stations = _searchTask.GetAwaiter().GetResult();
					_catalogExpires = Time.realtimeSinceStartup + 900f;
				}
				catch (Exception)
				{
					_log.LogWarning((object)"Radio Browser search failed; retrying in 30 seconds. Local music continues.");
					_searchRetry = Time.realtimeSinceStartup + 30f;
				}
				Cancel(ref _searchStop, ref _searchTask);
			}
			if (_localSession.Length != 0 || Time.realtimeSinceStartup < _searchRetry)
			{
				return;
			}
			if (Time.realtimeSinceStartup >= _catalogExpires)
			{
				_stations = null;
			}
			if (_stations == null || _stations.Length == 0)
			{
				if (_searchTask == null)
				{
					_searchStop = new CancellationTokenSource();
					CancellationToken token = _searchStop.Token;
					_searchTask = Task.Run(() => _search(tags, token), token);
				}
				return;
			}
			int num = _random.Next(_stations.Length);
			if (_stations.Length > 1 && _stations[num].stationuuid == _localStation)
			{
				num = (num + 1) % _stations.Length;
			}
			_selectedStation = _stations[num];
			_localStation = _selectedStation.stationuuid;
			_localSession = Guid.NewGuid().ToString("N");
			RadioSelection radioSelection = new RadioSelection
			{
				Ship = ((object)Unsafe.As<ZDOID, ZDOID>(ref val.m_uid)/*cast due to .constrained prefix*/).ToString(),
				Station = _localStation,
				Session = _localSession
			};
			SharedMusic.Data((Component)(object)player).Set("fenikonir.shipmusic.radio.v1", radioSelection.Encode());
			string text = SafeName(_selectedStation.name);
			_log.LogInfo((object)("Selected radio: " + text));
			_notify?.Invoke("Radio: " + text);
		}

		internal static string SafeName(string value)
		{
			value = (value ?? "Radio").Replace("\r", " ").Replace("\n", " ").Replace("<", "")
				.Replace(">", "");
			if (value.Length <= 100)
			{
				return value;
			}
			return value.Substring(0, 100);
		}

		public bool WantsShip(Ship ship)
		{
			if (Enabled)
			{
				return (Object)(object)_target == (Object)(object)ship;
			}
			return false;
		}

		public void Listen(Ship ship, Player captain)
		{
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			object obj;
			if (!Enabled || !((Object)(object)ship != (Object)null) || !((Object)(object)captain != (Object)null))
			{
				obj = null;
			}
			else
			{
				ZDO obj2 = SharedMusic.Data((Component)(object)captain);
				obj = RadioSelection.Parse((obj2 != null) ? obj2.GetString("fenikonir.shipmusic.radio.v1", "") : null);
			}
			RadioSelection radioSelection = (RadioSelection)obj;
			if (radioSelection == null || radioSelection.Ship != ((object)Unsafe.As<ZDOID, ZDOID>(ref SharedMusic.Data((Component)(object)ship)?.m_uid)/*cast due to .constrained prefix*/).ToString())
			{
				ship = null;
			}
			string text = (((Object)(object)ship != (Object)null) ? radioSelection.Session : "");
			if ((Object)(object)_target != (Object)(object)ship || _session != text)
			{
				StopPlayback();
				_target = ship;
				_session = text;
				_streamRetry = 0f;
				_failures = 0;
			}
			if ((Object)(object)ship == (Object)null)
			{
				return;
			}
			if (_lookupTask != null && _lookupTask.IsCompleted)
			{
				try
				{
					RadioStation result = _lookupTask.GetAwaiter().GetResult();
					_stream = _open(result.url_resolved);
					_connectingSince = Time.realtimeSinceStartup;
					_log.LogInfo((object)("Connecting to radio: " + SafeName(result.name)));
				}
				catch (Exception)
				{
					Retry("Station lookup failed.");
				}
				Cancel(ref _lookupStop, ref _lookupTask);
			}
			if (_stream != null)
			{
				if (_stream.Finished || ((Object)(object)_clip == (Object)null && Time.realtimeSinceStartup - _connectingSince > 20f))
				{
					Retry(_stream.Error ?? "Radio buffering timed out.");
					return;
				}
				RadioPcmBuffer buffer = _stream.Buffer;
				if ((Object)(object)_clip == (Object)null && buffer != null && _stream.SampleRate > 0 && buffer.Count >= _stream.SampleRate * 2)
				{
					_clip = AudioClip.Create("ShipMusicRadio", _stream.SampleRate, 1, _stream.SampleRate, true, new PCMReaderCallback(buffer.Read));
					_failures = 0;
					_log.LogInfo((object)"Radio buffered; starting live playback.");
				}
			}
			if (_stream == null && _lookupTask == null && Time.realtimeSinceStartup >= _streamRetry)
			{
				_lookupStop = new CancellationTokenSource();
				CancellationToken token = _lookupStop.Token;
				string id = radioSelection.Station;
				_lookupTask = Task.Run(() => _lookup(id, token), token);
			}
		}

		private void Retry(string reason)
		{
			StopPlayback();
			_streamRetry = Time.realtimeSinceStartup + (float)Math.Min(60, 5 * (1 << Math.Min(_failures++, 3)));
			_log.LogWarning((object)("Radio unavailable: " + reason + " Local music continues; reconnect scheduled."));
			if ((Object)(object)_target == (Object)(object)_helm && _failures >= 2 && _stations != null && _stations.Length > 1)
			{
				_localSession = "";
				_searchRetry = _streamRetry;
			}
		}

		private void ClearOffer()
		{
			ZDO val = SharedMusic.Data((Component)(object)_localPlayer);
			if (val != null && val.IsOwner())
			{
				val.Set("fenikonir.shipmusic.radio.v1", "");
			}
		}

		private static void Cancel<T>(ref CancellationTokenSource stop, ref Task<T> task)
		{
			CancellationTokenSource source = stop;
			Task<T> task2 = task;
			stop = null;
			task = null;
			if (source == null)
			{
				return;
			}
			source.Cancel();
			if (task2 == null)
			{
				source.Dispose();
				return;
			}
			task2.ContinueWith(delegate(Task<T> done)
			{
				_ = done.Exception;
				source.Dispose();
			}, TaskScheduler.Default);
		}

		private void StopPlayback()
		{
			Cancel(ref _lookupStop, ref _lookupTask);
			_stream?.Dispose();
			_stream = null;
			if ((Object)(object)_clip != (Object)null)
			{
				Object.Destroy((Object)(object)_clip);
			}
			_clip = null;
		}

		public void Dispose()
		{
			ClearOffer();
			Cancel(ref _searchStop, ref _searchTask);
			StopPlayback();
			_target = null;
			_helm = null;
		}
	}
}