using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Configs;
using HarmonyLib;
using Jotunn.Utils;
using Logging;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("NetworkTweaks")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NetworkTweaks")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("08a6f7d7-cf93-4931-aecd-abf2ce6ed34c")]
[assembly: AssemblyFileVersion("0.1.4")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.4.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NetworkTweaks
{
	internal static class ModCompat
	{
		internal const string NetworkGUID = "org.bepinex.plugins.network";

		internal const string ReturnToSenderGUID = "redseiko.valheim.returntosender";

		internal static bool IsNetworkInstalled => IsPluginInstalled("org.bepinex.plugins.network");

		internal static bool IsReturnToSenderInstalled => IsPluginInstalled("redseiko.valheim.returntosender");

		internal static bool HasIncompatibleMods()
		{
			bool isNetworkInstalled = IsNetworkInstalled;
			bool isReturnToSenderInstalled = IsReturnToSenderInstalled;
			if (isNetworkInstalled)
			{
				Log.LogWarning("Incompatible mod: org.bepinex.plugins.network is installed!");
			}
			if (isReturnToSenderInstalled)
			{
				Log.LogWarning("Incompatible mod: redseiko.valheim.returntosender is installed!");
			}
			return isNetworkInstalled || isReturnToSenderInstalled;
		}

		private static bool IsPluginInstalled(string pluginGUID)
		{
			return Chainloader.PluginInfos.ContainsKey(pluginGUID);
		}
	}
	[BepInPlugin("Searica.Valheim.NetworkTweaks", "NetworkTweaks", "0.1.4")]
	[BepInDependency("com.jotunn.jotunn", "2.22.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal sealed class NetworkTweaks : BaseUnityPlugin
	{
		public const string PluginName = "NetworkTweaks";

		internal const string Author = "Searica";

		public const string PluginGUID = "Searica.Valheim.NetworkTweaks";

		public const string PluginVersion = "0.1.4";

		internal static NetworkTweaks Instance;

		internal static ConfigFile ConfigFile;

		internal const string GlobalSection = "Global";

		internal ConfigEntry<int> PeersPerUpdate;

		public void Awake()
		{
			Instance = this;
			ConfigFile = ((BaseUnityPlugin)this).Config;
			Log.Init(((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Config.Init("Searica.Valheim.NetworkTweaks");
			SetUpConfigEntries();
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			if (ModCompat.HasIncompatibleMods())
			{
				Log.LogWarning("Incompatible mods detected, NetworkTweaks will not load!");
				return;
			}
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "Searica.Valheim.NetworkTweaks");
			Game.isModded = true;
			((BaseUnityPlugin)this).Config.SetupWatcher();
		}

		internal void SetUpConfigEntries()
		{
			PeersPerUpdate = ((BaseUnityPlugin)this).Config.BindConfigInOrder("Global", "Peers Per Update", 10, "Number of peers to sync data to each update tick. Vanilla default is 1. The higher this is the more data needs to be transferred each update tick.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50));
		}

		public void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}
	}
}
namespace NetworkTweaks.Patches
{
	[HarmonyPatch]
	internal static class SteamDataTransferPatches
	{
		private const int VanillaTransferRate = 153600;

		private const int MaxTransferRate = 50000000;

		private const int BufferSize = 100000000;

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ZSteamSocket), "RegisterGlobalCallbacks")]
		private static IEnumerable<CodeInstruction> ChangeSendingLimitTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4, (object)153600, (string)null)
			};
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, array).ThrowIfInvalid("Could not patch ZSteamSocket.RegisterGlobalCallbacks()!").SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldc_I4, (object)50000000))
				.InstructionEnumeration();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZSteamSocket), "RegisterGlobalCallbacks")]
		private static void IncreaseSendBufferSize()
		{
			if (!(CSteamAPIContext.GetSteamClient() == IntPtr.Zero))
			{
				GCHandle gCHandle = GCHandle.Alloc(100000000, GCHandleType.Pinned);
				SteamNetworkingUtils.SetConfigValue((ESteamNetworkingConfigValue)9, (ESteamNetworkingConfigScope)1, IntPtr.Zero, (ESteamNetworkingConfigDataType)1, gCHandle.AddrOfPinnedObject());
				gCHandle.Free();
			}
		}
	}
	[HarmonyPatch]
	internal static class ZDOToPeersPatches
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ZDOMan), "Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			CodeMatch val = new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ZDOMan), "SendZDOToPeers2", (Type[])null, (Type[])null), (string)null);
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[1] { val }).ThrowIfInvalid("Could not patch ZDOMan.Update()! (send-zdo-to-peers)")
				.SetOperandAndAdvance((object)AccessTools.Method(typeof(ZDOToPeersPatches), "SendZDOToPeers", (Type[])null, (Type[])null))
				.InstructionEnumeration();
		}

		private static void SendZDOToPeers(ZDOMan zdoManager, float dt)
		{
			int count = zdoManager.m_peers.Count;
			if (count <= 0)
			{
				return;
			}
			zdoManager.m_sendTimer += dt;
			if (!(zdoManager.m_sendTimer < 0.05f))
			{
				zdoManager.m_sendTimer = 0f;
				List<ZDOPeer> peers = zdoManager.m_peers;
				int num = Math.Max(zdoManager.m_nextSendPeer, 0);
				int num2 = Math.Min(num + NetworkTweaks.Instance.PeersPerUpdate.Value, count);
				for (int i = num; i < num2; i++)
				{
					zdoManager.SendZDOs(peers[i], false);
				}
				zdoManager.m_nextSendPeer = ((num2 < count) ? num2 : 0);
			}
		}
	}
	[HarmonyPatch]
	internal static class ZPkgBufferPatches
	{
		private static readonly List<ZPackage> zpkgBuffer = new List<ZPackage>();

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static void StartBuffering(ZNet __instance, ZNetPeer peer)
		{
			if (Object.op_Implicit((Object)(object)__instance) && !__instance.IsServer())
			{
				peer.m_rpc.Register<ZPackage>("ZDOData", (Action<ZRpc, ZPackage>)delegate(ZRpc _, ZPackage package)
				{
					zpkgBuffer.Add(package);
				});
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private static void ClearBufferOnShutdown()
		{
			zpkgBuffer.Clear();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZDOMan), "AddPeer")]
		private static void ParseBufferedZPackages(ZDOMan __instance, ZNetPeer netPeer)
		{
			foreach (ZPackage item in zpkgBuffer)
			{
				__instance.RPC_ZDOData(netPeer.m_rpc, item);
			}
			zpkgBuffer.Clear();
		}
	}
}
namespace Logging
{
	internal static class Log
	{
		internal enum InfoLevel
		{
			Low,
			Medium,
			High
		}

		private static ManualLogSource logSource;

		internal static ConfigEntry<InfoLevel> Verbosity { get; set; }

		internal static InfoLevel VerbosityLevel => Verbosity.Value;

		internal static bool IsVerbosityLow => Verbosity.Value >= InfoLevel.Low;

		internal static bool IsVerbosityMedium => Verbosity.Value >= InfoLevel.Medium;

		internal static bool IsVerbosityHigh => Verbosity.Value >= InfoLevel.High;

		internal static void Init(ManualLogSource logSource)
		{
			Log.logSource = logSource;
		}

		internal static void LogDebug(object data)
		{
			logSource.LogDebug(data);
		}

		internal static void LogError(object data)
		{
			logSource.LogError(data);
		}

		internal static void LogFatal(object data)
		{
			logSource.LogFatal(data);
		}

		internal static void LogMessage(object data)
		{
			logSource.LogMessage(data);
		}

		internal static void LogWarning(object data)
		{
			logSource.LogWarning(data);
		}

		internal static void LogInfo(object data, InfoLevel level = InfoLevel.Low)
		{
			if (Verbosity == null || VerbosityLevel >= level)
			{
				logSource.LogInfo(data);
			}
		}

		internal static void LogGameObject(GameObject prefab, bool includeChildren = false)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			LogInfo("***** " + ((Object)prefab).name + " *****");
			Component[] components = prefab.GetComponents<Component>();
			for (int i = 0; i < components.Length; i++)
			{
				LogComponent(components[i]);
			}
			if (!includeChildren)
			{
				return;
			}
			LogInfo("***** " + ((Object)prefab).name + " (children) *****");
			foreach (Transform item in prefab.transform)
			{
				Transform val = item;
				if (Object.op_Implicit((Object)(object)val))
				{
					LogInfo(" - " + ((Object)val).name);
					components = ((Component)val).GetComponents<Component>();
					for (int i = 0; i < components.Length; i++)
					{
						LogComponent(components[i]);
					}
				}
			}
		}

		internal static void LogComponent(Component compo)
		{
			if (!Object.op_Implicit((Object)(object)compo))
			{
				return;
			}
			try
			{
				LogInfo("--- " + ((object)compo).GetType().Name + ": " + ((Object)compo).name + " ---");
			}
			catch (Exception ex)
			{
				LogError(ex.ToString());
				LogWarning("Could not get type name for component!");
				return;
			}
			try
			{
				foreach (PropertyInfo declaredProperty in AccessTools.GetDeclaredProperties(((object)compo).GetType()))
				{
					try
					{
						LogInfo($" - {declaredProperty.Name} = {declaredProperty.GetValue(compo)}");
					}
					catch (Exception ex2)
					{
						LogError(ex2.ToString());
						LogWarning("Could not get property: " + declaredProperty.Name + " for component!");
					}
				}
			}
			catch (Exception ex3)
			{
				LogError(ex3.ToString());
				LogWarning("Could not get properties for component!");
			}
			try
			{
				foreach (FieldInfo declaredField in AccessTools.GetDeclaredFields(((object)compo).GetType()))
				{
					try
					{
						LogInfo($" - {declaredField.Name} = {declaredField.GetValue(compo)}");
					}
					catch (Exception ex4)
					{
						LogError(ex4.ToString());
						LogWarning("Could not get field: " + declaredField.Name + " for component!");
					}
				}
			}
			catch (Exception ex5)
			{
				LogError(ex5.ToString());
				LogWarning("Could not get fields for component!");
			}
		}
	}
}
namespace Configs
{
	public static class ConfigFileManager
	{
		internal static string ConfigFileName;

		internal static string ConfigFileFullPath;

		internal static DateTime lastRead = DateTime.MinValue;

		private static readonly Dictionary<string, int> _sectionToSectionNumber = new Dictionary<string, int>();

		private static readonly Dictionary<string, int> _sectionToSettingOrder = new Dictionary<string, int>();

		private static readonly List<string> ConfigManagerGUIDs = new List<string> { "_shudnal.ConfigurationManager", "com.bepis.bepinex.configurationmanager" };

		private static BaseUnityPlugin _configManager = null;

		private const string WindowChangedEventName = "DisplayingWindowChanged";

		private const string DisplayingWindowName = "DisplayingWindow";

		private static PropertyInfo _dispWindowInfo = null;

		private static BaseUnityPlugin ConfigManager
		{
			get
			{
				if ((Object)(object)_configManager == (Object)null)
				{
					foreach (string configManagerGUID in ConfigManagerGUIDs)
					{
						if (Chainloader.PluginInfos.TryGetValue(configManagerGUID, out var value) && Object.op_Implicit((Object)(object)value.Instance))
						{
							_configManager = value.Instance;
							break;
						}
					}
				}
				return _configManager;
			}
		}

		private static PropertyInfo DisplayWindowInfo
		{
			get
			{
				if ((object)_dispWindowInfo == null)
				{
					_dispWindowInfo = ((object)ConfigManager).GetType().GetProperty("DisplayingWindow");
				}
				return _dispWindowInfo;
			}
		}

		internal static event Action OnConfigFileReloaded;

		internal static event Action OnConfigWindowClosed;

		private static string GetOrderedSectionName(string section)
		{
			if (!_sectionToSectionNumber.TryGetValue(section, out var value))
			{
				value = _sectionToSectionNumber.Count + 1;
				_sectionToSectionNumber[section] = value;
			}
			return $"{value} - {section}";
		}

		private static int GetSettingOrder(string section)
		{
			if (!_sectionToSettingOrder.TryGetValue(section, out var value))
			{
				value = 0;
			}
			_sectionToSettingOrder[section] = value - 1;
			return value;
		}

		private static void InvokeOnConfigFileReloaded()
		{
			Action onConfigFileReloaded = ConfigFileManager.OnConfigFileReloaded;
			if (onConfigFileReloaded != null)
			{
				onConfigFileReloaded.SafeInvoke();
			}
		}

		private static void InvokeOnConfigWindowClosed()
		{
			Action onConfigWindowClosed = ConfigFileManager.OnConfigWindowClosed;
			if (onConfigWindowClosed != null)
			{
				onConfigWindowClosed.SafeInvoke();
			}
		}

		public static void Init(this ConfigFile configFile, string GUID, bool saveOnConfigSet = false)
		{
			configFile.SaveOnConfigSet = saveOnConfigSet;
			ConfigFileName = GUID + ".cfg";
			ConfigFileFullPath = Path.Combine(Paths.ConfigPath, ConfigFileName);
		}

		public static bool DisableSaveOnConfigSet(this ConfigFile configFile)
		{
			bool saveOnConfigSet = configFile.SaveOnConfigSet;
			configFile.SaveOnConfigSet = false;
			return saveOnConfigSet;
		}

		public static ConfigEntry<T> BindConfigInOrder<T>(this ConfigFile configFile, string section, string name, T value, string description, AcceptableValueBase acceptVals = null, bool synced = true, bool sectionOrder = true, bool settingOrder = true, Action<ConfigEntryBase> drawer = null, ConfigurationManagerAttributes configAttributes = null)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			section = (sectionOrder ? GetOrderedSectionName(section) : section);
			int value2 = (settingOrder ? GetSettingOrder(section) : 0);
			if (configAttributes == null)
			{
				configAttributes = new ConfigurationManagerAttributes();
			}
			configAttributes.Order = value2;
			return configFile.BindConfig(section, name, value, description, acceptVals, synced, drawer, configAttributes);
		}

		public static ConfigEntry<T> BindConfig<T>(this ConfigFile configFile, string section, string name, T value, string description, AcceptableValueBase acceptVals = null, bool synced = true, Action<ConfigEntryBase> drawer = null, ConfigurationManagerAttributes configAttributes = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			string extendedDescription = GetExtendedDescription(description, synced);
			if (configAttributes == null)
			{
				configAttributes = new ConfigurationManagerAttributes();
			}
			configAttributes.IsAdminOnly = synced;
			if (drawer != null)
			{
				configAttributes.CustomDrawer = drawer;
			}
			return configFile.Bind<T>(section, name, value, new ConfigDescription(extendedDescription, acceptVals, new object[1] { configAttributes }));
		}

		internal static string GetExtendedDescription(string description, bool synchronizedSetting)
		{
			return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]");
		}

		internal static void SetupWatcher(this ConfigFile configFile)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += configFile.ReloadConfigFile;
			fileSystemWatcher.Created += configFile.ReloadConfigFile;
			fileSystemWatcher.Renamed += configFile.ReloadConfigFile;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		internal static void ReloadConfigFile(this ConfigFile configFile, object sender, FileSystemEventArgs eventArgs)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				DateTime lastWriteTime = File.GetLastWriteTime(eventArgs.FullPath);
				if (lastRead != lastWriteTime)
				{
					Log.LogInfo("Reloading config file");
					bool saveOnConfigSet = configFile.DisableSaveOnConfigSet();
					configFile.Reload();
					configFile.SaveOnConfigSet = saveOnConfigSet;
					InvokeOnConfigFileReloaded();
					lastRead = lastWriteTime;
				}
			}
			catch
			{
				Log.LogError("There was an issue loading your " + ConfigFileName);
				Log.LogError("Please check your config entries for spelling and format!");
			}
		}

		internal static void CheckForConfigManager(this ConfigFile config)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType != 4 && !((Object)(object)ConfigManager == (Object)null))
			{
				Log.LogDebug("Configuration manager found, hooking DisplayingWindowChanged");
				EventInfo @event = ((object)ConfigManager).GetType().GetEvent("DisplayingWindowChanged");
				if (!(@event == null))
				{
					Action<object, object> action = OnConfigManagerDisplayingWindowChanged;
					Delegate handler = Delegate.CreateDelegate(@event.EventHandlerType, action.Target, action.Method);
					@event.AddEventHandler(ConfigManager, handler);
				}
			}
		}

		private static void OnConfigManagerDisplayingWindowChanged(object sender, object e)
		{
			if (!(DisplayWindowInfo == null) && !(bool)DisplayWindowInfo.GetValue(ConfigManager, null))
			{
				InvokeOnConfigWindowClosed();
			}
		}

		private static void SafeInvoke(this Action events)
		{
			if (events == null)
			{
				return;
			}
			Delegate[] invocationList = events.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception arg)
				{
					Log.LogWarning("Exception thrown at event " + new StackFrame(1).GetMethod().Name + $" in {action.Method.DeclaringType.Name}.{action.Method.Name}:\n{arg}");
				}
			}
		}
	}
}