using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using AuthoritativeConfig;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Adjust Taming Speed")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Adjust Taming Speed")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b1a20b64-f2c7-4a27-bd87-2be6bf703b0a")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AuthoritativeConfig
{
	public class Config
	{
		private static Config _instance;

		public Dictionary<string, ConfigBaseEntry> _configEntries;

		public BaseUnityPlugin _mod;

		private static ConfigEntry<bool> _ServerIsAuthoritative;

		private static bool _DefaultBindAuthority;

		public static ManualLogSource Logger;

		public static Config Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new Config();
				}
				return _instance;
			}
			set
			{
			}
		}

		public static ZNet ZNet => ZNet.instance;

		public static string GUID => Instance._mod.Info.Metadata.GUID;

		public static string RPC_SYNC_GUID => "AuthoritativeConfig_" + GUID;

		public void init(BaseUnityPlugin mod, bool defaultBindServerAuthority = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			_mod = mod;
			Logger = new ManualLogSource(RPC_SYNC_GUID);
			Logger.Sources.Add((ILogSource)(object)Logger);
			_configEntries = new Dictionary<string, ConfigBaseEntry>();
			_DefaultBindAuthority = defaultBindServerAuthority;
			_ServerIsAuthoritative = _mod.Config.Bind<bool>("ServerAuthoritativeConfig", "ServerIsAuthoritative", true, "<Server Only> Forces Clients to use Server defined configs.");
			Harmony.CreateAndPatchAll(typeof(Config), (string)null);
			Logger.LogInfo((object)"Initialized Server Authoritative Config Manager.");
		}

		[HarmonyPatch(typeof(Game), "Start")]
		[HarmonyPostfix]
		private static void RegisterSyncConfigRPC()
		{
			Logger.LogInfo((object)("Authoritative Config Registered -> " + RPC_SYNC_GUID));
			ZRoutedRpc.instance.Register<ZPackage>(RPC_SYNC_GUID, (Action<long, ZPackage>)RPC_SyncServerConfig);
			foreach (ConfigBaseEntry value in Instance._configEntries.Values)
			{
				value.ClearServerValue();
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPostfix]
		private static void RequestConfigFromServer()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (!ZNet.IsServer() && (int)ZNet.GetConnectionStatus() == 2)
			{
				long? num = AccessTools.Method(typeof(ZRoutedRpc), "GetServerPeerID", (Type[])null, (Type[])null).Invoke(ZRoutedRpc.instance, null) as long?;
				ZRoutedRpc.instance.InvokeRoutedRPC(num.Value, RPC_SYNC_GUID, new object[1] { (object)new ZPackage() });
				Logger.LogInfo((object)("Authoritative Config Registered -> " + RPC_SYNC_GUID));
				Debug.Log((object)(Instance._mod.Info.Metadata.Name + ": Authoritative Config Requested -> " + RPC_SYNC_GUID));
			}
			else if (!ZNet.IsServer())
			{
				Logger.LogWarning((object)"Failed to Request Configs. Bad Peer? Too Early?");
			}
		}

		public ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, ConfigDescription configDescription = null, bool? serverAuthoritative = null)
		{
			ConfigEntry<T> configEntry = new ConfigEntry<T>(_mod.Config.Bind<T>(section, key, defaultValue, configDescription), serverAuthoritative.HasValue ? serverAuthoritative.Value : _DefaultBindAuthority);
			_configEntries[((object)configEntry.BaseEntry.Definition).ToString()] = configEntry;
			return configEntry;
		}

		public ConfigEntry<T> Bind<T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null, bool? serverAuthoritative = null)
		{
			ConfigEntry<T> configEntry = new ConfigEntry<T>(_mod.Config.Bind<T>(configDefinition, defaultValue, configDescription), serverAuthoritative.HasValue ? serverAuthoritative.Value : _DefaultBindAuthority);
			_configEntries[((object)configEntry.BaseEntry.Definition).ToString()] = configEntry;
			return configEntry;
		}

		public ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description, bool? serverAuthoritative = null)
		{
			ConfigEntry<T> configEntry = new ConfigEntry<T>(_mod.Config.Bind<T>(section, key, defaultValue, description), serverAuthoritative.HasValue ? serverAuthoritative.Value : _DefaultBindAuthority);
			_configEntries[((object)configEntry.BaseEntry.Definition).ToString()] = configEntry;
			return configEntry;
		}

		public static void SendConfigToClient(long sender)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (!ZNet.IsServer())
			{
				return;
			}
			ZPackage val = new ZPackage();
			int num = 0;
			foreach (KeyValuePair<string, ConfigBaseEntry> configEntry in Instance._configEntries)
			{
				if (configEntry.Value.ServerAuthoritative)
				{
					val.Write(configEntry.Key);
					val.Write(configEntry.Value.BaseEntry.GetSerializedValue());
					num++;
					Logger.LogInfo((object)("Sending Config " + configEntry.Key + ": " + configEntry.Value.BaseEntry.GetSerializedValue()));
				}
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, RPC_SYNC_GUID, new object[1] { val });
			Logger.LogInfo((object)$"Sent {num} config pairs to client {sender}");
		}

		public static void ReadConfigPkg(ZPackage pkg)
		{
			if (ZNet.IsServer())
			{
				return;
			}
			int num = 0;
			while (pkg.GetPos() != pkg.Size())
			{
				string text = pkg.ReadString();
				string text2 = pkg.ReadString();
				num++;
				if (Instance._configEntries.ContainsKey(text))
				{
					Instance._configEntries[text].SetSerializedValue(text2);
					Logger.LogInfo((object)("Applied Server Authoritative config pair => " + text + ": " + text2));
				}
				else
				{
					Logger.LogError((object)("Recieved config key we dont have locally. Possible Version Mismatch. " + text + ": " + text2));
				}
			}
			Logger.LogInfo((object)$"Applied {num} config pairs");
		}

		public static void RPC_SyncServerConfig(long sender, ZPackage pkg)
		{
			if (ZNet.IsServer() && _ServerIsAuthoritative.Value)
			{
				SendConfigToClient(sender);
			}
			else if (!ZNet.IsServer() && pkg != null && pkg.Size() > 0 && AccessTools.Method(typeof(ZRoutedRpc), "GetServerPeerID", (Type[])null, (Type[])null).Invoke(ZRoutedRpc.instance, null) as long? == sender)
			{
				ReadConfigPkg(pkg);
			}
		}
	}
	public class ConfigBaseEntry
	{
		protected object _serverValue;

		public ConfigEntryBase BaseEntry;

		public bool ServerAuthoritative;

		protected bool _didError;

		internal ConfigBaseEntry(ConfigEntryBase configEntry, bool serverAuthoritative)
		{
			BaseEntry = configEntry;
			ServerAuthoritative = serverAuthoritative;
		}

		public void SetSerializedValue(string value)
		{
			try
			{
				_serverValue = TomlTypeConverter.ConvertToValue(value, BaseEntry.SettingType);
				_didError = false;
			}
			catch (Exception ex)
			{
				Config.Logger.LogWarning((object)$"Config value of setting \"{BaseEntry.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
			}
		}

		public void ClearServerValue()
		{
			_serverValue = null;
			_didError = false;
		}
	}
	public class ConfigEntry<T> : ConfigBaseEntry
	{
		private ConfigEntry<T> _configEntry;

		public T ServerValue => (T)_serverValue;

		public T Value
		{
			get
			{
				if (ServerAuthoritative && !Config.ZNet.IsServer())
				{
					if (_serverValue != null)
					{
						return ServerValue;
					}
					if (!_didError)
					{
						Config.Logger.LogWarning((object)("No Recieved value for Server Authoritative Config. " + ((object)BaseEntry.Definition).ToString() + ". Falling Back to Client Config."));
						_didError = true;
					}
					return _configEntry.Value;
				}
				return _configEntry.Value;
			}
			set
			{
				_configEntry.Value = value;
			}
		}

		internal ConfigEntry(ConfigEntry<T> configEntry, bool serverAuthoritative)
			: base((ConfigEntryBase)(object)configEntry, serverAuthoritative)
		{
			_configEntry = configEntry;
		}
	}
}
namespace Adjust_Taming_Speed
{
	[BepInPlugin("zukane2.AdjustTamingSpeed", "Adjust Taming Speed", "2.0.0")]
	public class AdjustTamingSpeed : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Tameable), "Awake")]
		private static class Tame_Awake_Patch
		{
			private static void Postfix(ref float ___m_tamingTime)
			{
				___m_tamingTime = tamingTime.Value;
			}
		}

		private readonly Harmony harmony = new Harmony("zukane2.AdjustTamingSpeed");

		private static ConfigEntry<float> tamingTime;

		public Config Config
		{
			get
			{
				return Config.Instance;
			}
			set
			{
			}
		}

		private void Awake()
		{
			Config.init((BaseUnityPlugin)(object)this, defaultBindServerAuthority: true);
			tamingTime = Config.Bind("General", "TamingTime", 1800f, "Taming Time");
			harmony.PatchAll();
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}
	}
}