using System;
using System.Collections.Generic;
using System.Diagnostics;
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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using VoiceVolumeSaver.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("voice_volume_saver")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+dd56b358e4b1c85dec5aef2d74e9e383eaf8e957")]
[assembly: AssemblyProduct("voice_volume_saver")]
[assembly: AssemblyTitle("VoiceVolumeSaver")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace VoiceVolumeSaver
{
	public class ConfigurationHandler
	{
		private ConfigFile _config;

		private static ConfigEntry<string> _configDictionary;

		public static Dictionary<string, float> VoiceVolumes { get; private set; } = new Dictionary<string, float>();


		public ConfigurationHandler(ConfigFile configFile)
		{
			_config = configFile;
			Plugin.Logger.LogInfo((object)"ConfigurationHandler initialising");
			_configDictionary = _config.Bind<string>("General", "SavedData", "", "Serialized key=value pairs");
			if (_configDictionary.Value != "")
			{
				LoadDictionaryFromConfig();
			}
			Plugin.Logger.LogInfo((object)"ConfigurationHandler initialised");
		}

		private void LoadDictionaryFromConfig()
		{
			VoiceVolumes = DeserializeDictionary(_configDictionary.Value);
		}

		public static Dictionary<string, float> DeserializeDictionary(string data)
		{
			Plugin.Logger.LogInfo((object)"Plugin voice_volume_saver is deserializing data!");
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			if (string.IsNullOrWhiteSpace(data))
			{
				return dictionary;
			}
			string[] array = data.Split(';');
			string[] array2 = array;
			foreach (string text in array2)
			{
				string[] array3 = text.Split('=');
				if (array3.Length == 2)
				{
					string key = array3[0];
					if (float.TryParse(array3[1], out var result))
					{
						dictionary[key] = result;
					}
				}
			}
			return dictionary;
		}

		public string SerializeDictionary()
		{
			Plugin.Logger.LogInfo((object)"Plugin voice_volume_saver is serializing data!");
			return string.Join(";", VoiceVolumes.Select<KeyValuePair<string, float>, string>((KeyValuePair<string, float> kvp) => $"{kvp.Key}={kvp.Value}"));
		}

		public void SaveDictionaryToConfig()
		{
			Plugin.Logger.LogInfo((object)"Plugin voice_volume_saver is pre serializing data!");
			_configDictionary.Value = SerializeDictionary();
			_config.Save();
		}
	}
	[BepInPlugin("voice_volume_saver", "VoiceVolumeSaver", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private readonly Harmony _harmony = new Harmony("voice_volume_saver");

		public static ConfigurationHandler ConfigurationHandler;

		public const string Id = "voice_volume_saver";

		public static string Name => "VoiceVolumeSaver";

		public static string Version => "1.0.0";

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			ConfigurationHandler = new ConfigurationHandler(((BaseUnityPlugin)this).Config);
			Logger.LogInfo((object)"Plugin voice_volume_saver is patching Init!");
			Logger.LogInfo((object)"Plugin voice_volume_saver is patching OnSliderChanged!");
			_harmony.PatchAll(typeof(AudioLevelSliderPatches));
			_harmony.PatchAll(typeof(OnPlayerEnteredRoomPatch));
			Logger.LogInfo((object)"Plugin voice_volume_saver has finished loading!");
		}
	}
}
namespace VoiceVolumeSaver.Patches
{
	[HarmonyPatch]
	public class AudioLevelSliderPatches
	{
		[HarmonyPatch(typeof(AudioLevelSlider), "Init")]
		[HarmonyPostfix]
		private static void InitPostfix(AudioLevelSlider __instance)
		{
			if (__instance.player != null)
			{
				Plugin.Logger.LogInfo((object)("Player Joined: " + __instance.player.NickName));
				if (__instance.player != null && !__instance.player.IsLocal && ConfigurationHandler.VoiceVolumes.TryGetValue(__instance.player.NickName, out var value))
				{
					Plugin.Logger.LogInfo((object)$"Player Volume: {value}");
					AudioLevels.SetPlayerLevel(__instance.player.UserId, value);
					__instance.slider.SetValueWithoutNotify(AudioLevels.GetPlayerLevel(__instance.player.UserId));
					((TMP_Text)__instance.percent).text = Mathf.RoundToInt(__instance.slider.value * 200f) + "%";
				}
			}
		}

		[HarmonyPatch(typeof(AudioLevelSlider), "OnSliderChanged")]
		[HarmonyPostfix]
		private static void OnSliderChangedPostfix(float newValue, AudioLevelSlider __instance)
		{
			if (__instance.player != null)
			{
				Plugin.Logger.LogInfo((object)$"Player saving: {__instance.player.NickName} {newValue}");
				ConfigurationHandler.VoiceVolumes[__instance.player.NickName] = newValue;
				Plugin.ConfigurationHandler.SaveDictionaryToConfig();
			}
		}
	}
	public class OnPlayerEnteredRoomPatch
	{
		[HarmonyPatch(typeof(PlayerConnectionLog), "OnPlayerEnteredRoom")]
		[HarmonyPostfix]
		private static void Postfix()
		{
			bool activeSelf = GUIManager.instance.pauseMenu.activeSelf;
			GUIManager.instance.pauseMenu.SetActive(false);
			GUIManager.instance.pauseMenu.SetActive(true);
			GUIManager.instance.pauseMenu.SetActive(activeSelf);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}