using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BigVoice.Configuration;
using Dissonance.Audio.Playback;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Microsoft.CodeAnalysis;
using Mirror;
using Rewired;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BigVoice")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4e2352a9dc4752c0718672eb17293ce5cb0b7461")]
[assembly: AssemblyProduct("Big Voice")]
[assembly: AssemblyTitle("BigVoice")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 BigVoice
{
	[BepInPlugin("BigVoice", "Big Voice", "1.0.0")]
	public class Plugin : BasePlugin
	{
		internal static Plugin Instance;

		internal static ManualLogSource Log;

		internal static ConfigFile PluginConfig;

		internal static ConfigEntry<float> UnknownPlayerVolume;

		private Harmony _harmony;

		private GameObject _configurationUiObject;

		public ConfigurationHandler ConfigurationHandler { get; private set; }

		public override void Load()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Instance = this;
			Log = ((BasePlugin)this).Log;
			PluginConfig = ((BasePlugin)this).Config;
			UnknownPlayerVolume = ((BasePlugin)this).Config.Bind<float>("General", "UnknownPlayerVolume", 1f, new ConfigDescription("VOIP multiplier for players without a matching entry. 0 = muted, 1 = normal, 15 = max.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			ConfigurationHandler = new ConfigurationHandler(((BasePlugin)this).Config);
			_harmony = new Harmony("BigVoice");
			HarmonyPatches();
			CreateConfigurationUI();
			Log.LogInfo((object)"Big Voice loaded");
		}

		private void CreateConfigurationUI()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			try
			{
				ClassInjector.RegisterTypeInIl2Cpp<ModConfigurationUI>();
			}
			catch (Exception ex)
			{
				Log.LogDebug((object)("ModConfigurationUI type registration skipped or failed: " + ex.Message));
			}
			_configurationUiObject = new GameObject("Big Voice Configuration UI");
			Object.DontDestroyOnLoad((Object)(object)_configurationUiObject);
			((Object)_configurationUiObject).hideFlags = (HideFlags)61;
			_configurationUiObject.AddComponent<ModConfigurationUI>().Init();
		}

		private void HarmonyPatches()
		{
			TryPatch(AccessTools.Method(typeof(PlayerNetworking), "OnStartClient", Type.EmptyTypes, (Type[])null), null, AccessTools.Method(typeof(PlayerNetworkingPatch), "RegisterPostfix", (Type[])null, (Type[])null), "PlayerNetworking.OnStartClient");
			TryPatch(AccessTools.Method(typeof(PlayerNetworking), "Start", Type.EmptyTypes, (Type[])null), null, AccessTools.Method(typeof(PlayerNetworkingPatch), "RegisterPostfix", (Type[])null, (Type[])null), "PlayerNetworking.Start");
			TryPatch(AccessTools.Method(typeof(PlayerVoicePlaybackControl), "Update", Type.EmptyTypes, (Type[])null), null, AccessTools.Method(typeof(PlayerVoicePlaybackControlPatch), "UpdatePostfix", (Type[])null, (Type[])null), "PlayerVoicePlaybackControl.Update");
			TryPatch(AccessTools.Method(typeof(SamplePlaybackComponent), "ProcessSamples", (Type[])null, (Type[])null), null, AccessTools.Method(typeof(SamplePlaybackComponentPatch), "ProcessSamplesPostfix", (Type[])null, (Type[])null), "SamplePlaybackComponent.ProcessSamples");
		}

		private void TryPatch(MethodInfo original, MethodInfo prefix, MethodInfo postfix, string patchName)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (original == null)
			{
				Log.LogError((object)("Failed to find patch target: " + patchName));
				return;
			}
			try
			{
				_harmony.Patch((MethodBase)original, (prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(prefix), (postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(postfix), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Patches patchInfo = Harmony.GetPatchInfo((MethodBase)original);
				int valueOrDefault = (patchInfo?.Prefixes?.Count).GetValueOrDefault();
				int valueOrDefault2 = (patchInfo?.Postfixes?.Count).GetValueOrDefault();
				Log.LogInfo((object)("Installed patch for " + patchName + " prefixes=" + valueOrDefault + " postfixes=" + valueOrDefault2));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Failed to apply the patch for " + patchName + ": " + ex));
			}
		}
	}
	internal static class PlayerNetworkingPatch
	{
		public static void RegisterPostfix(PlayerNetworking __instance)
		{
			PlayerVolumeConfig.Register(__instance);
		}
	}
	internal static class PlayerVoicePlaybackControlPatch
	{
		public static void UpdatePostfix(PlayerVoicePlaybackControl __instance)
		{
			PlayerCharacter val = ((__instance != null) ? __instance.playerCharacter : null);
			if ((Object)(object)((val != null) ? val.playerNetworking : null) != (Object)null)
			{
				PlayerVolumeConfig.Register(val.playerNetworking);
				if ((Object)(object)__instance.dissonanceSampleProvider != (Object)null)
				{
					PlayerVolumeConfig.RegisterSampleProvider(__instance.dissonanceSampleProvider, val.playerNetworking);
				}
			}
		}
	}
	internal static class SamplePlaybackComponentPatch
	{
		public static void ProcessSamplesPostfix(SamplePlaybackComponent __instance, ref Il2CppStructArray<float> data, int channels)
		{
			float volume = PlayerVolumeConfig.GetVolume(__instance);
			ApplyGain(data, volume);
		}

		private static void ApplyGain(Il2CppStructArray<float> data, float volume)
		{
			if (data != null && !Mathf.Approximately(volume, 1f))
			{
				for (int i = 0; i < ((Il2CppArrayBase<float>)(object)data).Length; i++)
				{
					int num = i;
					((Il2CppArrayBase<float>)(object)data)[num] = ((Il2CppArrayBase<float>)(object)data)[num] * volume;
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "BigVoice";

		public const string PLUGIN_NAME = "Big Voice";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace BigVoice.Configuration
{
	public class ConfigurationHandler
	{
		private sealed class ConfigChangeListener<T>
		{
			private readonly ConfigEntry<T> _entry;

			private readonly Action _onChanged;

			private readonly Func<T, T> _clamp;

			public ConfigChangeListener(ConfigEntry<T> entry, Action onChanged, Func<T, T> clamp)
			{
				_entry = entry;
				_onChanged = onChanged;
				_clamp = clamp;
			}

			public void OnSettingChanged(object sender, EventArgs args)
			{
				if (_clamp != null)
				{
					_entry.Value = _clamp(_entry.Value);
				}
				_onChanged();
			}
		}

		private readonly ConfigFile _config;

		public KeyCode MenuKey { get; private set; }

		public ConfigEntry<string> ConfigMenuKey { get; }

		public ConfigEntry<float> ConfigUnknownPlayerVolume => Plugin.UnknownPlayerVolume;

		public ConfigurationHandler(ConfigFile configFile)
		{
			_config = configFile;
			Plugin.Log.LogInfo((object)"ConfigurationHandler initialising");
			ConfigMenuKey = Bind("General", "Config Menu Key", "F10", "Keyboard key for opening the Big Voice configuration menu", SetupInputKey);
			SetupInputKey();
			Plugin.Log.LogInfo((object)"ConfigurationHandler initialised");
		}

		private ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description, Action onChanged = null, Func<T, T> clamp = null)
		{
			ConfigEntry<T> val = _config.Bind<T>(section, key, defaultValue, description);
			if (clamp != null)
			{
				val.Value = clamp(val.Value);
			}
			Plugin.Log.LogInfo((object)(key + " set to " + val.Value));
			if (onChanged != null)
			{
				AddSettingChangedHandler(val, onChanged, clamp);
			}
			return val;
		}

		private static void AddSettingChangedHandler<T>(ConfigEntry<T> entry, Action onChanged, Func<T, T> clamp)
		{
			EventInfo eventInfo = typeof(ConfigEntry<T>).GetEvent("SettingChanged");
			if (eventInfo == null)
			{
				Plugin.Log.LogWarning((object)("Could not subscribe to SettingChanged for " + ((ConfigEntryBase)entry).Definition.Key));
				return;
			}
			ConfigChangeListener<T> firstArgument = new ConfigChangeListener<T>(entry, onChanged, clamp);
			MethodInfo method = typeof(ConfigChangeListener<T>).GetMethod("OnSettingChanged", BindingFlags.Instance | BindingFlags.Public);
			Delegate handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, firstArgument, method);
			eventInfo.AddEventHandler(entry, handler);
		}

		private void SetupInputKey()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<KeyCode>(ConfigMenuKey.Value, out KeyCode result))
			{
				MenuKey = result;
				Plugin.Log.LogInfo((object)("Menu key set to " + ((object)MenuKey/*cast due to .constrained prefix*/).ToString()));
			}
			else
			{
				MenuKey = (KeyCode)291;
				Plugin.Log.LogWarning((object)("Invalid menu key " + ConfigMenuKey.Value + ", using F10"));
			}
		}
	}
	public class ModConfigurationUI : MonoBehaviour
	{
		private const int MouseWheelAxis = 2;

		private List<Option> _options = new List<Option>();

		private bool _visible;

		private int _selectedIndex;

		private int _scrollStartIndex;

		private int _knownPlayerConfigVersion = -1;

		private bool _prevCursorVisible;

		private CursorLockMode _prevCursorLock;

		private bool _waitingForBinding;

		private Option _bindingTarget;

		private Texture2D _whiteTex;

		private GUIStyle _titleStyle;

		private GUIStyle _rowStyle;

		private GUIStyle _hintStyle;

		private string titleText = "Big Voice | v 1.0.0";

		private string hintText = "F11: Open/Close | Tab or Up/Down: Move | Enter/Click: Change | Scroll Wheel or Left/Right: Adjust Volume | +/-: Scale Menu";

		private int RowHeight = 32;

		private int PanelWidth = 460;

		private int Pad = 12;

		private int TitleFontSize = 22;

		private int OptionFontSize = 16;

		private int HintFontSize = 14;

		private Player _player;

		private Keyboard _keyboard;

		private Mouse _mouse;

		public ModConfigurationUI(IntPtr ptr)
			: base(ptr)
		{
		}

		private Color GetColor(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)SystemInfo.graphicsDeviceType == 21)
			{
				return ((Color)(ref c)).linear;
			}
			return c;
		}

		private void CalculatePanelWidth()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			float num = _titleStyle.CalcSize(new GUIContent(titleText)).x;
			foreach (Option option in _options)
			{
				float x = _rowStyle.CalcSize(new GUIContent(option.Label + ": " + option.DisplayValue())).x;
				if (x > num)
				{
					num = x;
				}
			}
			int num2 = CalculateHintWidth();
			num = Mathf.Max(num, (float)num2);
			PanelWidth = Mathf.Clamp((int)num + Pad * 2, 460, Screen.width - Pad * 2);
		}

		private int CalculateHintWidth()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			float num = _hintStyle.CalcHeight(new GUIContent("Test"), 9999f) * 2f;
			for (int i = 200; i < Screen.width - Pad * 2; i += 20)
			{
				if (_hintStyle.CalcHeight(new GUIContent(hintText), (float)i) <= num)
				{
					return i;
				}
			}
			return Screen.width - Pad * 2;
		}

		private void Scale(int scale)
		{
			if (scale >= 0 || HintFontSize >= 2)
			{
				TitleFontSize += scale * 2;
				OptionFontSize += scale * 2;
				HintFontSize += scale * 2;
				RowHeight = OptionFontSize + 16;
				CalculatePanelWidth();
			}
		}

		public void Init()
		{
			RebuildOptions();
			_selectedIndex = 0;
			UpdateHintText();
		}

		private void RebuildOptionsIfNeeded()
		{
			if (_knownPlayerConfigVersion != PlayerVolumeConfig.Version)
			{
				RebuildOptions();
			}
		}

		private void RebuildOptions()
		{
			ConfigurationHandler configurationHandler = Plugin.Instance.ConfigurationHandler;
			string selectedLabel = ((_options.Count > 0 && _selectedIndex >= 0 && _selectedIndex < _options.Count) ? _options[_selectedIndex].Label : null);
			List<Option> list = new List<Option> { Option.Float("Default Player Volume", configurationHandler.ConfigUnknownPlayerVolume, 0f, 15f, 0.25f) };
			foreach (PlayerVolumeOption playerOption in PlayerVolumeConfig.GetPlayerOptions())
			{
				list.Add(Option.Float(playerOption.DisplayName, playerOption.ConfigEntry, 0f, 15f, 0.25f));
			}
			list.Add(Option.InputAction("Menu Key", configurationHandler.ConfigMenuKey));
			_options = list;
			_knownPlayerConfigVersion = PlayerVolumeConfig.Version;
			if (selectedLabel != null)
			{
				int num = _options.FindIndex((Option option) => option.Label == selectedLabel);
				_selectedIndex = ((num >= 0) ? num : Mathf.Clamp(_selectedIndex, 0, _options.Count - 1));
			}
			else
			{
				_selectedIndex = Mathf.Clamp(_selectedIndex, 0, _options.Count - 1);
			}
			UpdateHintText();
		}

		private void UpdateHintText()
		{
			string text = Plugin.Instance.ConfigurationHandler.ConfigMenuKey.Value.Split("/")[^1].ToUpper();
			hintText = text + ": Open/Close | Tab or Up/Down: Move | Enter/Click: Change | Scroll Wheel or Left/Right: Adjust Volume | +/-: Scale Menu";
		}

		private void EnsureStyles()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00a8: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_whiteTex == (Object)null)
			{
				_whiteTex = new Texture2D(1, 1, (TextureFormat)4, false);
				_whiteTex.SetPixel(0, 0, GetColor(Color.white));
				_whiteTex.Apply();
			}
			_titleStyle = new GUIStyle(GUI.skin.label)
			{
				fontSize = TitleFontSize,
				alignment = (TextAnchor)3,
				fontStyle = (FontStyle)1
			};
			_rowStyle = new GUIStyle(GUI.skin.button)
			{
				alignment = (TextAnchor)3,
				fontSize = OptionFontSize,
				padding = new RectOffset(10, 10, 4, 4)
			};
			_hintStyle = new GUIStyle(GUI.skin.label)
			{
				fontSize = HintFontSize,
				alignment = (TextAnchor)3,
				wordWrap = true
			};
		}

		private void Update()
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			if (!ReInput.isReady)
			{
				return;
			}
			if (_player == null)
			{
				_player = ReInput.players.GetPlayer(0);
				_keyboard = ReInput.controllers.Keyboard;
				_mouse = ReInput.controllers.Mouse;
			}
			if (_waitingForBinding)
			{
				bool flag = default(bool);
				foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
				{
					if (_keyboard.GetKeyDown(value))
					{
						string text = ((object)value/*cast due to .constrained prefix*/).ToString();
						_bindingTarget.StringEntry.Value = text;
						ManualLogSource log = Plugin.Log;
						BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(12, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Rebound ");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(_bindingTarget.Label);
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" to ");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
						}
						log.LogInfo(val2);
						_waitingForBinding = false;
						UpdateHintText();
						_bindingTarget = null;
						break;
					}
				}
				return;
			}
			if (_keyboard.GetKeyDown(Plugin.Instance.ConfigurationHandler.MenuKey))
			{
				_visible = !_visible;
				if (_visible)
				{
					OnOpened();
				}
				else
				{
					OnClosed();
				}
			}
			if (_visible && _options.Count != 0)
			{
				RebuildOptionsIfNeeded();
				if (_keyboard.GetKeyDown((KeyCode)9))
				{
					bool flag2 = _keyboard.GetKey((KeyCode)304) || _keyboard.GetKey((KeyCode)303);
					CycleSelection((!flag2) ? 1 : (-1));
				}
				if (_keyboard.GetKeyDown((KeyCode)61) || _keyboard.GetKeyDown((KeyCode)43))
				{
					Scale(1);
				}
				if (_keyboard.GetKeyDown((KeyCode)45))
				{
					Scale(-1);
				}
				if (_keyboard.GetKeyDown((KeyCode)273))
				{
					CycleSelection(-1);
				}
				if (_keyboard.GetKeyDown((KeyCode)274))
				{
					CycleSelection(1);
				}
				if (_keyboard.GetKeyDown((KeyCode)13) || _keyboard.GetKeyDown((KeyCode)271))
				{
					ToggleSelected();
				}
				if (_keyboard.GetKeyDown((KeyCode)276))
				{
					AdjustNumerical(-1);
				}
				if (_keyboard.GetKeyDown((KeyCode)275))
				{
					AdjustNumerical(1);
				}
				float axis = ((ControllerWithAxes)_mouse).GetAxis(2);
				if (axis > 0f)
				{
					AdjustNumerical(1);
				}
				else if (axis < 0f)
				{
					AdjustNumerical(-1);
				}
			}
		}

		private void ToggleSelected()
		{
			Option option = _options[_selectedIndex];
			if (option.IsDisabled())
			{
				return;
			}
			switch (option.Type)
			{
			case Option.OptionType.Bool:
				option.BoolEntry.Value = !option.BoolEntry.Value;
				break;
			case Option.OptionType.Int:
			{
				int num2 = option.IntEntry.Value + option.Step;
				if (num2 > option.MaxInt)
				{
					num2 = option.MinInt;
				}
				option.IntEntry.Value = num2;
				break;
			}
			case Option.OptionType.Float:
			{
				float num = option.FloatEntry.Value + option.FloatStep;
				if (num > option.MaxFloat)
				{
					num = option.MinFloat;
				}
				option.FloatEntry.Value = num;
				break;
			}
			case Option.OptionType.InputAction:
				_waitingForBinding = true;
				_bindingTarget = option;
				break;
			case Option.OptionType.String:
				break;
			}
		}

		private void AdjustNumerical(int delta)
		{
			Option option = _options[_selectedIndex];
			if (!option.IsDisabled())
			{
				if (option.Type == Option.OptionType.Bool)
				{
					option.BoolEntry.Value = delta > 0;
				}
				else if (option.Type == Option.OptionType.Int)
				{
					AdjustInt(option, delta);
				}
				else if (option.Type == Option.OptionType.Float)
				{
					AdjustFloat(option, delta);
				}
			}
		}

		private static void AdjustInt(Option option, int delta)
		{
			int value = option.IntEntry.Value;
			int num = value;
			int num2 = Mathf.Max(1, Mathf.CeilToInt((float)(option.MaxInt - option.MinInt) / (float)option.Step) + 1);
			for (int i = 0; i < num2; i++)
			{
				int num3 = Mathf.Clamp(num + delta * option.Step, option.MinInt, option.MaxInt);
				if (num3 == num)
				{
					break;
				}
				option.IntEntry.Value = num3;
				if (option.IntEntry.Value != value)
				{
					break;
				}
				num = num3;
			}
		}

		private static void AdjustFloat(Option option, int delta)
		{
			float value = option.FloatEntry.Value;
			float num = value;
			int num2 = Mathf.Max(1, Mathf.CeilToInt((option.MaxFloat - option.MinFloat) / option.FloatStep) + 1);
			for (int i = 0; i < num2; i++)
			{
				float num3 = Mathf.Clamp(num + (float)delta * option.FloatStep, option.MinFloat, option.MaxFloat);
				if (Mathf.Approximately(num3, num))
				{
					break;
				}
				option.FloatEntry.Value = num3;
				if (!Mathf.Approximately(option.FloatEntry.Value, value))
				{
					break;
				}
				num = num3;
			}
		}

		private void OnOpened()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			RebuildOptionsIfNeeded();
			_prevCursorVisible = Cursor.visible;
			_prevCursorLock = Cursor.lockState;
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			if (_options.Count > 0 && _options[_selectedIndex].IsDisabled())
			{
				CycleSelection(1);
			}
		}

		private void OnClosed()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Cursor.visible = _prevCursorVisible;
			Cursor.lockState = _prevCursorLock;
		}

		private void CycleSelection(int delta)
		{
			if (_options.Count == 0)
			{
				return;
			}
			int selectedIndex = _selectedIndex;
			do
			{
				_selectedIndex = (_selectedIndex + delta) % _options.Count;
				if (_selectedIndex < 0)
				{
					_selectedIndex += _options.Count;
				}
			}
			while (_options[_selectedIndex].IsDisabled() && _selectedIndex != selectedIndex);
		}

		private void EnsureSelectedVisible(int visibleRows)
		{
			if (visibleRows <= 0)
			{
				_scrollStartIndex = 0;
				return;
			}
			if (_selectedIndex < _scrollStartIndex)
			{
				_scrollStartIndex = _selectedIndex;
			}
			else if (_selectedIndex >= _scrollStartIndex + visibleRows)
			{
				_scrollStartIndex = _selectedIndex - visibleRows + 1;
			}
			_scrollStartIndex = Mathf.Clamp(_scrollStartIndex, 0, Mathf.Max(0, _options.Count - visibleRows));
		}

		private void OnGUI()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			RebuildOptionsIfNeeded();
			EnsureStyles();
			CalculatePanelWidth();
			float num = _titleStyle.CalcHeight(new GUIContent(titleText), (float)(PanelWidth - Pad * 2));
			float num2 = _options.Count * (RowHeight + 4);
			float num3 = _hintStyle.CalcHeight(new GUIContent("Test"), 9999f) * 2f;
			int num4 = Mathf.Max(1, Mathf.Min(_options.Count, Mathf.FloorToInt(((float)(Screen.height - 80) - num - num3 - (float)(Pad * 3)) / (float)(RowHeight + 4))));
			EnsureSelectedVisible(num4);
			num2 = num4 * (RowHeight + 4);
			int num5 = Pad + (int)num + 8 + (int)num2 + Pad + (int)num3;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(20f, 20f, (float)PanelWidth, (float)num5);
			GUI.color = GetColor(new Color(0f, 0f, 0f, 0.75f));
			GUI.DrawTexture(val, (Texture)(object)_whiteTex);
			GUI.color = Color.white;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).x + (float)Pad, ((Rect)(ref val)).y + (float)Pad, ((Rect)(ref val)).width - (float)(Pad * 2), num);
			GUI.Label(val2, titleText, _titleStyle);
			float num6 = ((Rect)(ref val2)).yMax + 8f;
			int num7 = Mathf.Min(_options.Count, _scrollStartIndex + num4);
			Rect val3 = default(Rect);
			for (int i = _scrollStartIndex; i < num7; i++)
			{
				((Rect)(ref val3))..ctor(((Rect)(ref val)).x + (float)Pad, num6, ((Rect)(ref val)).width - (float)(Pad * 2), (float)RowHeight);
				Option option = _options[i];
				if (((Rect)(ref val3)).Contains(Event.current.mousePosition) && !option.IsDisabled())
				{
					_selectedIndex = i;
				}
				if (i == _selectedIndex && !option.IsDisabled())
				{
					GUI.color = GetColor(new Color(1f, 1f, 1f, 0.24f));
					GUI.DrawTexture(val3, (Texture)(object)_whiteTex);
					GUI.color = Color.white;
				}
				GUI.enabled = !option.IsDisabled();
				if (option.Label == "Menu Key" && _waitingForBinding)
				{
					GUI.color = GetColor(new Color(0f, 0f, 0f, 0.6f));
					GUI.DrawTexture(val3, (Texture)(object)_whiteTex);
					GUI.color = Color.white;
					GUI.Button(val3, "Press any key...", _rowStyle);
				}
				else if (GUI.Button(val3, option.Label + ": " + option.DisplayValue(), _rowStyle) && !option.IsDisabled())
				{
					ToggleSelected();
				}
				GUI.enabled = true;
				num6 += (float)(RowHeight + 4);
			}
			GUI.Label(new Rect(((Rect)(ref val)).x + (float)Pad, ((Rect)(ref val)).yMax - (float)Pad - num3, ((Rect)(ref val)).width - (float)(Pad * 2), num3), hintText, _hintStyle);
		}

		private void OnDestroy()
		{
			if ((Object)(object)_whiteTex != (Object)null)
			{
				Object.Destroy((Object)(object)_whiteTex);
				_whiteTex = null;
			}
		}
	}
	public class Option
	{
		public enum OptionType
		{
			Bool,
			Int,
			String,
			InputAction,
			Float
		}

		public string Label { get; set; }

		public OptionType Type { get; set; }

		public ConfigEntry<bool> BoolEntry { get; set; }

		public ConfigEntry<int> IntEntry { get; set; }

		public ConfigEntry<string> StringEntry { get; set; }

		public int MinInt { get; set; }

		public int MaxInt { get; set; }

		public int Step { get; set; }

		public Func<bool> IsDisabled { get; set; } = () => false;

		public Func<string> DisplayValue { get; set; } = () => "";

		public ConfigEntry<float> FloatEntry { get; set; }

		public float MinFloat { get; set; }

		public float MaxFloat { get; set; }

		public float FloatStep { get; set; }

		private Option(string label, OptionType type)
		{
			Label = label;
			Type = type;
		}

		public static Option Float(string label, ConfigEntry<float> entry, float min, float max, float step = 0.05f, Func<bool> isDisabled = null, Func<string> displayValue = null)
		{
			return new Option(label, OptionType.Float)
			{
				FloatEntry = entry,
				MinFloat = min,
				MaxFloat = max,
				FloatStep = step,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = (displayValue ?? ((Func<string>)(() => entry.Value.ToString("F2") + "x")))
			};
		}

		public static Option Bool(string label, ConfigEntry<bool> entry, Func<bool> isDisabled = null)
		{
			return new Option(label, OptionType.Bool)
			{
				BoolEntry = entry,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = () => (!entry.Value) ? "OFF" : "ON"
			};
		}

		public static Option InputAction(string label, ConfigEntry<string> entry, Func<bool> isDisabled = null)
		{
			return new Option(label, OptionType.InputAction)
			{
				StringEntry = entry,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = delegate
				{
					string[] array = entry.Value.Split("/");
					return (array.Length <= 1) ? entry.Value : array[^1].ToUpper();
				}
			};
		}

		public static Option Int(string label, ConfigEntry<int> entry, int min, int max, int step = 1, Func<bool> isDisabled = null, Func<string> displayValue = null)
		{
			return new Option(label, OptionType.Int)
			{
				IntEntry = entry,
				MinInt = min,
				MaxInt = max,
				Step = step,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = (displayValue ?? ((Func<string>)(() => entry.Value.ToString())))
			};
		}
	}
	internal sealed class PlayerRecord(string displayName, ConfigEntry<float> configEntry)
	{
		public string DisplayName { get; set; } = displayName;

		public ConfigEntry<float> ConfigEntry { get; } = configEntry;
	}
	internal static class PlayerVolumeConfig
	{
		private const string PlayerVolumesSection = "Player Volumes";

		public const float MinVolume = 0f;

		public const float MaxVolume = 15f;

		public const float VolumeStep = 0.25f;

		private static readonly List<PlayerRecord> Records = new List<PlayerRecord>();

		private static readonly Dictionary<string, PlayerRecord> RecordsById = new Dictionary<string, PlayerRecord>();

		private static readonly Dictionary<int, PlayerRecord> RecordsBySampleProviderId = new Dictionary<int, PlayerRecord>();

		public static int Version { get; private set; }

		public static void Register(PlayerNetworking networking)
		{
			try
			{
				GetOrCreateRecord(networking);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Failed to register player VOIP volume: " + ex));
			}
		}

		public static void RegisterSampleProvider(SamplePlaybackComponent sampleProvider, PlayerNetworking networking)
		{
			if ((Object)(object)sampleProvider == (Object)null)
			{
				return;
			}
			try
			{
				PlayerRecord orCreateRecord = GetOrCreateRecord(networking);
				if (orCreateRecord != null)
				{
					RecordsBySampleProviderId[((Object)sampleProvider).GetInstanceID()] = orCreateRecord;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Failed to register VOIP sample provider: " + ex));
			}
		}

		public static IReadOnlyList<PlayerVolumeOption> GetPlayerOptions()
		{
			return (from record in Records.OrderBy<PlayerRecord, string>((PlayerRecord record) => record.DisplayName, StringComparer.OrdinalIgnoreCase)
				select new PlayerVolumeOption(record.DisplayName, record.ConfigEntry)).ToArray();
		}

		public static float GetVolume(SamplePlaybackComponent sampleProvider)
		{
			if ((Object)(object)sampleProvider != (Object)null && RecordsBySampleProviderId.TryGetValue(((Object)sampleProvider).GetInstanceID(), out var value))
			{
				return ClampVolume(value.ConfigEntry.Value);
			}
			return ClampVolume(Plugin.UnknownPlayerVolume.Value);
		}

		private static PlayerRecord GetOrCreateRecord(PlayerNetworking networking)
		{
			if ((Object)(object)networking == (Object)null || ((NetworkBehaviour)networking).isLocalPlayer)
			{
				return null;
			}
			string playerId = GetPlayerId(networking);
			if (string.IsNullOrWhiteSpace(playerId))
			{
				return null;
			}
			string playerName = GetPlayerName(networking);
			if (RecordsById.TryGetValue(playerId, out var value))
			{
				UpdateDisplayName(value, playerName);
				return value;
			}
			value = new PlayerRecord(GetDisplayName(playerName, playerId), CreateEntry(playerId, GetDisplayName(playerName, playerId)));
			RecordsById[playerId] = value;
			Records.Add(value);
			Version++;
			return value;
		}

		private static void UpdateDisplayName(PlayerRecord record, string name)
		{
			if (!string.IsNullOrWhiteSpace(name) && !string.Equals(record.DisplayName, name, StringComparison.Ordinal))
			{
				record.DisplayName = name;
				Version++;
			}
		}

		private static ConfigEntry<float> CreateEntry(string id, string displayName)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			ConfigDefinition val = new ConfigDefinition("Player Volumes", id);
			ConfigEntry<float> result = default(ConfigEntry<float>);
			if (Plugin.PluginConfig.TryGetEntry<float>(val, ref result))
			{
				return result;
			}
			ConfigEntry<float> result2 = Plugin.PluginConfig.Bind<float>(val, ClampVolume(Plugin.UnknownPlayerVolume.Value), new ConfigDescription("VOIP volume multiplier for " + displayName + ". Player ID " + id, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			Plugin.PluginConfig.Save();
			Plugin.Log.LogInfo((object)("Created VOIP volume config entry for " + displayName + " as [Player Volumes] " + id));
			return result2;
		}

		private static string GetPlayerId(PlayerNetworking networking)
		{
			if (networking.NetworkuserPlatformId != 0L)
			{
				return networking.NetworkuserPlatformId.ToString(CultureInfo.InvariantCulture);
			}
			return "";
		}

		private static string GetPlayerName(PlayerNetworking networking)
		{
			return networking.NetworkmoderationName;
		}

		private static string GetDisplayName(string name, string id)
		{
			if (!string.IsNullOrWhiteSpace(name))
			{
				return name;
			}
			return id;
		}

		private static float ClampVolume(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Clamp(value, 0f, 15f);
			}
			return 1f;
		}
	}
	public readonly struct PlayerVolumeOption
	{
		public string DisplayName { get; }

		public ConfigEntry<float> ConfigEntry { get; }

		public PlayerVolumeOption(string displayName, ConfigEntry<float> configEntry)
		{
			DisplayName = displayName;
			ConfigEntry = configEntry;
		}
	}
}