using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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("FishingRadioExpansion")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("FishingRadioExpansion")]
[assembly: AssemblyTitle("FishingRadioExpansion")]
[assembly: AssemblyVersion("0.1.0.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 FishingRadioExpansion
{
	[BepInPlugin("collinj.fishingradioexpansion", "Fishing Radio Expansion", "0.1.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "collinj.fishingradioexpansion";

		public const string PluginName = "Fishing Radio Expansion";

		public const string PluginVersion = "0.1.0";

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			_harmony = new Harmony("collinj.fishingradioexpansion");
			_harmony.PatchAll();
			RadioReflection.Resolve();
			RadioPatches.VerifyTargets();
			((MonoBehaviour)this).StartCoroutine(AudioLibrary.LoadBundledTracks());
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Fishing Radio Expansion 0.1.0 loaded.");
		}

		internal void RunCoroutine(IEnumerator routine)
		{
			((MonoBehaviour)this).StartCoroutine(routine);
		}

		private void OnDestroy()
		{
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
		}
	}
	internal static class AudioLibrary
	{
		internal sealed class Track
		{
			public string Name = "";

			public string FileName = "";

			public AudioClip? Clip;
		}

		internal static readonly Track[] Tracks = new Track[6]
		{
			new Track
			{
				Name = "Dockside",
				FileName = "Dockside.ogg"
			},
			new Track
			{
				Name = "Fishing 3",
				FileName = "Fishing3.ogg"
			},
			new Track
			{
				Name = "Lock In",
				FileName = "LockIn.ogg"
			},
			new Track
			{
				Name = "Casino Royale",
				FileName = "CasinoRoyale.ogg"
			},
			new Track
			{
				Name = "Let it Ride!",
				FileName = "LetItRide.ogg"
			},
			new Track
			{
				Name = "Tropicalada",
				FileName = "Tropicalada.ogg"
			}
		};

		internal static bool Ready { get; private set; }

		internal static IEnumerator LoadBundledTracks()
		{
			Ready = false;
			string directoryName = Path.GetDirectoryName(typeof(Plugin).Assembly.Location);
			string musicDir = Path.Combine(directoryName, "music");
			for (int i = 0; i < Tracks.Length; i++)
			{
				Track track = Tracks[i];
				string text = Path.Combine(musicDir, track.FileName);
				if (!File.Exists(text))
				{
					Plugin.Log.LogError((object)("Missing radio track: " + text));
					continue;
				}
				string absoluteUri = new Uri(text).AbsoluteUri;
				UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(absoluteUri, (AudioType)14);
				try
				{
					yield return req.SendWebRequest();
					if ((int)req.result != 1)
					{
						Plugin.Log.LogError((object)("Could not load " + track.FileName + ": " + req.error));
						continue;
					}
					AudioClip content = DownloadHandlerAudioClip.GetContent(req);
					((Object)content).name = "FishingRadioExpansion - " + track.Name;
					track.Clip = content;
					Plugin.Log.LogInfo((object)$"Loaded radio track: {track.Name} ({content.length:0.0}s)");
				}
				finally
				{
					((IDisposable)req)?.Dispose();
				}
			}
			Ready = true;
			RadioInjector.PatchTrackedRadios();
		}
	}
	internal static class RadioInjector
	{
		private sealed class InjectionState
		{
			public int OriginalCount;

			public float WidthFactor = 1f;

			public float[] CustomFrequencies = Array.Empty<float>();
		}

		private static readonly List<WeakReference> Tracked = new List<WeakReference>();

		private static readonly Dictionary<int, InjectionState> States = new Dictionary<int, InjectionState>();

		internal static void Track(object radio)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (radio == null)
			{
				return;
			}
			int instanceID = ((Object)radio).GetInstanceID();
			for (int num = Tracked.Count - 1; num >= 0; num--)
			{
				object target = Tracked[num].Target;
				if (target == null)
				{
					Tracked.RemoveAt(num);
				}
				else if (((Object)target).GetInstanceID() == instanceID)
				{
					return;
				}
			}
			Tracked.Add(new WeakReference(radio));
		}

		internal static void PatchTrackedRadios()
		{
			for (int num = Tracked.Count - 1; num >= 0; num--)
			{
				object target = Tracked[num].Target;
				if (target == null)
				{
					Tracked.RemoveAt(num);
				}
				else
				{
					TryInject(target);
				}
			}
		}

		internal static void TryInject(object radio)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if (!AudioLibrary.Ready || RadioReflection.RadioChannelType == null)
			{
				return;
			}
			Array channels = RadioReflection.GetChannels(radio);
			if (channels == null || channels.Length == 0)
			{
				return;
			}
			int instanceID = ((Object)radio).GetInstanceID();
			if (States.ContainsKey(instanceID))
			{
				return;
			}
			AudioSource source = RadioReflection.GetSource(channels.GetValue(0));
			if (!Object.op_Implicit((Object)(object)source))
			{
				Plugin.Log.LogWarning((object)"Radio channel has no AudioSource; custom stations were not added.");
				return;
			}
			List<object> list = new List<object>();
			List<float> list2 = new List<float>();
			for (int i = 0; i < channels.Length; i++)
			{
				object value = channels.GetValue(i);
				if (value != null)
				{
					list.Add(value);
					list2.Add(RadioReflection.GetFrequency(value));
				}
			}
			Vector2 band = RadioReflection.GetBand(radio);
			float[] array = ChooseFrequencies(list2, band.x, band.y, AudioLibrary.Tracks.Length);
			for (int j = 0; j < AudioLibrary.Tracks.Length; j++)
			{
				AudioClip clip = AudioLibrary.Tracks[j].Clip;
				if (Object.op_Implicit((Object)(object)clip))
				{
					AudioSource val = CloneAudioSource(source, radio, j);
					val.clip = clip;
					val.loop = true;
					val.playOnAwake = false;
					val.volume = 0f;
					object obj = Activator.CreateInstance(RadioReflection.RadioChannelType);
					RadioReflection.ChannelSourceField.SetValue(obj, val);
					RadioReflection.SetFrequency(obj, array[j]);
					RadioReflection.SetMuted(obj, muted: true);
					list.Add(obj);
				}
			}
			Array array2 = Array.CreateInstance(RadioReflection.RadioChannelType, list.Count);
			for (int k = 0; k < list.Count; k++)
			{
				array2.SetValue(list[k], k);
			}
			RadioReflection.ChannelsField.SetValue(radio, array2);
			List<float> list3 = (from v in list.Select(RadioReflection.GetFrequency)
				orderby v
				select v).ToList();
			float num = float.MaxValue;
			for (int num2 = 1; num2 < list3.Count; num2++)
			{
				num = Mathf.Min(num, list3[num2] - list3[num2 - 1]);
			}
			float num3 = Mathf.Clamp(num / 3f, 0.12f, 1f);
			States[instanceID] = new InjectionState
			{
				OriginalCount = channels.Length,
				WidthFactor = num3,
				CustomFrequencies = array
			};
			Plugin.Log.LogInfo((object)($"Added {AudioLibrary.Tracks.Length} radio stations. " + "Frequencies: " + string.Join(", ", array.Select((float f) => f.ToString("0.00"))) + ". " + $"Width factor: {num3:0.00}"));
		}

		internal static bool TryGetState(object radio, out float widthFactor)
		{
			widthFactor = 1f;
			Object val = (Object)((radio is Object) ? radio : null);
			if (val == null)
			{
				return false;
			}
			if (!States.TryGetValue(val.GetInstanceID(), out InjectionState value))
			{
				return false;
			}
			widthFactor = value.WidthFactor;
			return true;
		}

		private static float[] ChooseFrequencies(List<float> existing, float min, float max, int count)
		{
			List<float> list = (from f in existing
				where f >= min && f <= max
				orderby f
				select f).ToList();
			List<float> list2 = new List<float>();
			for (int num = 0; num < count; num++)
			{
				float num2 = min;
				float num3 = -1f;
				for (float num4 = min + 0.15f; num4 <= max - 0.15f; num4 += 0.05f)
				{
					float num5 = float.MaxValue;
					foreach (float item in list)
					{
						num5 = Mathf.Min(num5, Mathf.Abs(num4 - item));
					}
					foreach (float item2 in list2)
					{
						num5 = Mathf.Min(num5, Mathf.Abs(num4 - item2));
					}
					num5 = Mathf.Min(num5, (num4 - min) * 1.35f);
					num5 = Mathf.Min(num5, (max - num4) * 1.35f);
					if (num5 > num3)
					{
						num3 = num5;
						num2 = num4;
					}
				}
				num2 = Mathf.Round(num2 * 20f) / 20f;
				list2.Add(num2);
			}
			return list2.OrderBy((float f) => f).ToArray();
		}

		private static AudioSource CloneAudioSource(AudioSource template, object radio, int index)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)template).gameObject;
			GameObject val;
			if (!Object.op_Implicit((Object)(object)gameObject.GetComponentInChildren(RadioReflection.RadioType, true)))
			{
				val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
				val.transform.localPosition = gameObject.transform.localPosition;
				val.transform.localRotation = gameObject.transform.localRotation;
				val.transform.localScale = gameObject.transform.localScale;
			}
			else
			{
				val = new GameObject($"Fishing Radio Custom Channel {index + 1}");
				val.transform.SetParent(gameObject.transform, false);
				AudioSource to = val.AddComponent<AudioSource>();
				CopyAudioSettings(template, to);
			}
			((Object)val).name = $"Fishing Radio Custom Channel {index + 1}";
			AudioSource component = val.GetComponent<AudioSource>();
			component.volume = 0f;
			return component;
		}

		private static void CopyAudioSettings(AudioSource from, AudioSource to)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			to.outputAudioMixerGroup = from.outputAudioMixerGroup;
			to.mute = false;
			to.bypassEffects = from.bypassEffects;
			to.bypassListenerEffects = from.bypassListenerEffects;
			to.bypassReverbZones = from.bypassReverbZones;
			to.priority = from.priority;
			to.pitch = from.pitch;
			to.panStereo = from.panStereo;
			to.spatialBlend = from.spatialBlend;
			to.reverbZoneMix = from.reverbZoneMix;
			to.dopplerLevel = from.dopplerLevel;
			to.spread = from.spread;
			to.rolloffMode = from.rolloffMode;
			to.minDistance = from.minDistance;
			to.maxDistance = from.maxDistance;
			to.ignoreListenerVolume = from.ignoreListenerVolume;
			to.ignoreListenerPause = from.ignoreListenerPause;
		}

		internal static void RecomputeVolumes(object radio)
		{
			if (!TryGetState(radio, out var widthFactor))
			{
				return;
			}
			Array channels = RadioReflection.GetChannels(radio);
			if (channels == null)
			{
				return;
			}
			float tunedFrequency = RadioReflection.GetTunedFrequency(radio);
			float radioVolume = RadioReflection.GetRadioVolume(radio);
			float num = 0f;
			for (int i = 0; i < channels.Length; i++)
			{
				object value = channels.GetValue(i);
				if (value != null)
				{
					float frequency = RadioReflection.GetFrequency(value);
					float num2 = Mathf.Abs(tunedFrequency - frequency) / Mathf.Max(0.01f, widthFactor) - 0.5f;
					num2 = Mathf.Clamp01(1f - num2);
					float num3 = num2 * radioVolume;
					RadioReflection.SetChannelVolume(value, num3);
					RadioReflection.SetMuted(value, num3 < 0.015f);
					if (num2 > num)
					{
						num = num2;
					}
				}
			}
			try
			{
				object? obj = RadioReflection.NoiseSourceField?.GetValue(radio);
				AudioSource val = (AudioSource)((obj is AudioSource) ? obj : null);
				if (val != null)
				{
					val.volume = (1f - num) * 0.075f;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class RadioStartPatch
	{
		private static MethodBase? TargetMethod()
		{
			RadioReflection.Resolve();
			return RadioReflection.OnStartClientMethod;
		}

		private static void Postfix(object __instance)
		{
			try
			{
				RadioInjector.Track(__instance);
				RadioInjector.TryInject(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Radio startup patch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch]
	internal static class RadioVolumePatch
	{
		private static MethodBase? TargetMethod()
		{
			RadioReflection.Resolve();
			return RadioReflection.ApplyVolumeMethod;
		}

		private static void Postfix(object __instance)
		{
			try
			{
				RadioInjector.RecomputeVolumes(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Radio volume patch failed: " + ex.Message));
			}
		}
	}
	internal static class RadioPatches
	{
		internal static void VerifyTargets()
		{
			if (RadioReflection.RadioType == null)
			{
				Plugin.Log.LogError((object)"Radio type was not found.");
			}
			if (RadioReflection.OnStartClientMethod == null)
			{
				Plugin.Log.LogError((object)"Radio.OnStartClient was not found.");
			}
			if (RadioReflection.ApplyVolumeMethod == null)
			{
				Plugin.Log.LogError((object)"Radio.ApplyVolume was not found.");
			}
		}
	}
	internal static class RadioReflection
	{
		internal static Type? RadioType;

		internal static Type? RadioChannelType;

		internal static FieldInfo? ChannelsField;

		internal static FieldInfo? ChannelSourceField;

		internal static FieldInfo? ChannelFrequencyField;

		internal static FieldInfo? FrequencyRangeField;

		internal static FieldInfo? LocalFrequencyField;

		internal static FieldInfo? NetworkFrequencyField;

		internal static FieldInfo? RadioVolumeField;

		internal static FieldInfo? NoiseSourceField;

		internal static MethodInfo? ApplyVolumeMethod;

		internal static MethodInfo? OnStartClientMethod;

		internal static MethodInfo? ToggleMuteMethod;

		internal static MethodInfo? SetVolMethod;

		internal static PropertyInfo? IsMutedProperty;

		internal static bool Resolved { get; private set; }

		internal static void Resolve()
		{
			if (Resolved)
			{
				return;
			}
			Resolved = true;
			RadioType = AccessTools.TypeByName("Radio");
			RadioChannelType = AccessTools.TypeByName("RadioChannel");
			if (RadioType == null || RadioChannelType == null)
			{
				Plugin.Log.LogError((object)"Could not find Radio/RadioChannel. The game may have updated.");
				return;
			}
			ChannelsField = AccessTools.Field(RadioType, "_channels");
			ChannelSourceField = AccessTools.Field(RadioChannelType, "_channelSource");
			ChannelFrequencyField = AccessTools.Field(RadioChannelType, "_frequency");
			FrequencyRangeField = AccessTools.Field(RadioType, "FreqMinMax");
			LocalFrequencyField = AccessTools.Field(RadioType, "_localFrequency");
			NetworkFrequencyField = AccessTools.Field(RadioType, "_frequency");
			RadioVolumeField = AccessTools.Field(RadioType, "_radioVol");
			NoiseSourceField = AccessTools.Field(RadioType, "_noiseSource");
			ApplyVolumeMethod = AccessTools.Method(RadioType, "ApplyVolume", (Type[])null, (Type[])null);
			OnStartClientMethod = AccessTools.Method(RadioType, "OnStartClient", (Type[])null, (Type[])null);
			ToggleMuteMethod = AccessTools.Method(RadioChannelType, "ToggleMute", (Type[])null, (Type[])null);
			SetVolMethod = AccessTools.Method(RadioChannelType, "SetVol", (Type[])null, (Type[])null);
			IsMutedProperty = AccessTools.Property(RadioChannelType, "IsMuted");
			if (ChannelsField == null || ChannelSourceField == null || ChannelFrequencyField == null)
			{
				Plugin.Log.LogError((object)"Could not find Radio/RadioChannel. The game may have updated.");
			}
		}

		internal static Array? GetChannels(object radio)
		{
			try
			{
				return ChannelsField?.GetValue(radio) as Array;
			}
			catch
			{
				return null;
			}
		}

		internal static AudioSource? GetSource(object channel)
		{
			try
			{
				object? obj = ChannelSourceField?.GetValue(channel);
				return (AudioSource?)((obj is AudioSource) ? obj : null);
			}
			catch
			{
				return null;
			}
		}

		internal static float GetFrequency(object channel)
		{
			try
			{
				return (ChannelFrequencyField?.GetValue(channel) is float num) ? num : 0f;
			}
			catch
			{
				return 0f;
			}
		}

		internal static void SetFrequency(object channel, float frequency)
		{
			ChannelFrequencyField?.SetValue(channel, frequency);
		}

		internal static Vector2 GetBand(object radio)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object obj = FrequencyRangeField?.GetValue(radio);
				if (obj is Vector2)
				{
					return (Vector2)obj;
				}
			}
			catch
			{
			}
			return new Vector2(88f, 108f);
		}

		internal static float GetTunedFrequency(object radio)
		{
			try
			{
				if (LocalFrequencyField?.GetValue(radio) is float num && num >= 70f && num <= 130f)
				{
					return num;
				}
			}
			catch
			{
			}
			try
			{
				object obj2 = NetworkFrequencyField?.GetValue(radio);
				if (obj2 != null && obj2.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) is float result)
				{
					return result;
				}
			}
			catch
			{
			}
			return 98f;
		}

		internal static float GetRadioVolume(object radio)
		{
			try
			{
				object obj = RadioVolumeField?.GetValue(radio);
				if (obj is float)
				{
					return (float)obj;
				}
			}
			catch
			{
			}
			return 0.3f;
		}

		internal static void SetChannelVolume(object channel, float volume)
		{
			try
			{
				if (SetVolMethod != null)
				{
					SetVolMethod.Invoke(channel, new object[1] { volume });
					return;
				}
			}
			catch
			{
			}
			AudioSource source = GetSource(channel);
			if (Object.op_Implicit((Object)(object)source))
			{
				source.volume = volume;
			}
		}

		internal static void SetMuted(object channel, bool muted)
		{
			try
			{
				bool flag = false;
				if (IsMutedProperty?.GetValue(channel) is bool flag2)
				{
					flag = flag2;
				}
				if (flag != muted)
				{
					ToggleMuteMethod?.Invoke(channel, new object[2] { muted, 0f });
				}
			}
			catch
			{
			}
		}
	}
}