using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using AutoMapPins.Common;
using AutoMapPins.Data;
using AutoMapPins.Icons;
using AutoMapPins.Model;
using AutoMapPins.Patches;
using AutoMapPins.Properties;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AutoMapPins")]
[assembly: AssemblyDescription("Github Template for a Valheim mod project")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AutoMapPins")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("F5D7B6C6-C13D-4B48-B472-E7854E5141E0")]
[assembly: AssemblyFileVersion("2.2.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.2.2.0")]
[module: UnverifiableCode]
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;
		}
	}
}
namespace AutoMapPins
{
	[BepInPlugin("FixItFelix.AutoMapPins", "AutoMapPins", "2.2.2")]
	public class AutoMapPinsPlugin : BaseUnityPlugin
	{
		internal const string ModName = "AutoMapPins";

		internal const string ModVersion = "2.2.2";

		private const string ModAuthor = "FixItFelix";

		private const string ModGuid = "FixItFelix.AutoMapPins";

		private const string ConfigFileName = "FixItFelix.AutoMapPins.cfg";

		private static AutoMapPinsPlugin _instance = null;

		private readonly Harmony _harmony = new Harmony("FixItFelix.AutoMapPins");

		public static readonly ManualLogSource Log = Logger.CreateLogSource("FixItFelix.AutoMapPins");

		internal static readonly YamlFileStorage FileIO = new YamlFileStorage("FixItFelix.AutoMapPins");

		private static readonly ConfigSync ConfigSync = new ConfigSync("FixItFelix.AutoMapPins")
		{
			DisplayName = "AutoMapPins",
			CurrentVersion = "2.2.2"
		};

		private static ConfigEntry<bool> _configLocked = null;

		private static CustomSyncedValue<Dictionary<string, string>> _categoryPinsConfigFilesContent = null;

		internal static ConfigEntry<float> GroupingRadius = null;

		internal static ConfigEntry<float> MaxDetectionHeight = null;

		internal static ConfigEntry<bool> PrefabDiscoveryEnabled = null;

		internal static ConfigEntry<bool> SilentDiscoveryEnabled = null;

		private void Awake()
		{
			_instance = this;
			_configLocked = CreateConfig("1 - General", "Lock Configuration", value: true, "If 'true' and playing on a server, config can only be changed on server-side configuration, clients cannot override");
			ConfigSync.AddLockingConfigEntry<bool>(_configLocked);
			PrefabDiscoveryEnabled = CreateConfig("1 - General", "Enable the prefab discovery", value: false, "This option will either enable (true) or disable (false, default) the discovery of new prefabs that have not yet been configured. For smoother gameplay you can simply disable it, the mod will then not print to console that there are new objects that have not been configured, yet. If you want to create new configurations for not configured prefabs, you will need to enable this flag.");
			SilentDiscoveryEnabled = CreateConfig("1 - General", "Prefab discovery silent mode", value: true, "This option will either enable (true, default) or disable (false) the log messages on discovery of new prefabs that have not yet been configured. For smoother gameplay you can simply enable it, the mod will then not print to console that there are new objects that have not been configured, yet. For finding out if there are prefabs missing that were not configured, you will need to disable this flag.");
			MaxDetectionHeight = CreateConfig("1 - General", "Maximum height to map objects", 4000f, "This option will set the height over sea level until where game objects will get the auto map pins logic applied. The usual default is '4000', since over 4000 meters over ground the dungeons are placed in the game scene. BEWARE: if you set this to a lower height, your map has chances to get pins added that point to a location inside a dungeon that is just above the height on ground, you should better not change this.");
			GroupingRadius = CreateConfig("2 - Grouping", "Fallback General Grouping Radius", 15f, "Grouping radius can be set per configured pin, but if it was set to 0 or no config for a pin was provided, this value will be used instead. Radius that will be applied when trying to group pins together that have grouping enabled. Default 15.0");
			_categoryPinsConfigFilesContent = new CustomSyncedValue<Dictionary<string, string>>(ConfigSync, "CategoryPinsConfigFilesContent", new Dictionary<string, string>());
			_categoryPinsConfigFilesContent.ValueChanged += ReloadRegistry;
			ReadYamlFileContent(null, null);
			SetupFileWatcher("FixItFelix.AutoMapPins.cfg");
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			LogUsageMode();
		}

		internal static void ReadYamlFileContent(object? _, FileSystemEventArgs? __)
		{
			Log.LogInfo((object)"loading pin configs from yaml files");
			_categoryPinsConfigFilesContent.Value = FileIO.ReadConfigFiles();
		}

		private static void ReloadRegistry()
		{
			Registry.InitializeRegistry(FileIO.DeserializeAndMergeFileData(_categoryPinsConfigFilesContent.Value));
		}

		private void SetupFileWatcher(string fileName)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, fileName);
			fileSystemWatcher.Changed += ReloadConfig;
			fileSystemWatcher.Created += ReloadConfig;
			fileSystemWatcher.Renamed += ReloadConfig;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReloadConfig(object? _, FileSystemEventArgs? __)
		{
			Log.LogWarning((object)"config file 'FixItFelix.AutoMapPins.cfg' change registered");
			((BaseUnityPlugin)this).Config.Reload();
			LogUsageMode();
		}

		private static void LogUsageMode()
		{
			if (PrefabDiscoveryEnabled.Value)
			{
				Log.LogWarning((object)"loaded mod with game object discovery enabled, deactivate to increase performance");
			}
			if (!SilentDiscoveryEnabled.Value)
			{
				Log.LogWarning((object)"silent discovery mode was deactivated, this will print log each time an object without config will be approached");
			}
		}

		public void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}

		private static ConfigEntry<T> CreateConfig<T>(string group, string parameterName, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)_instance).Config.Bind<T>(group, parameterName, value, description);
			ConfigSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

		private static ConfigEntry<T> CreateConfig<T>(string group, string parameterName, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return CreateConfig(group, parameterName, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}
	}
}
namespace AutoMapPins.Patches
{
	internal static class CommonPatchLogic
	{
		internal static void Patch(GameObject gameObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (gameObject.transform.position.y < AutoMapPinsPlugin.MaxDetectionHeight.Value)
			{
				gameObject.AddComponent<PinComponent>();
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "Start")]
	internal class DestructiblePatch
	{
		[UsedImplicitly]
		private static void Postfix(ref Destructible __instance)
		{
			Pickable val = default(Pickable);
			if (!((Component)__instance).TryGetComponent<Pickable>(ref val))
			{
				CommonPatchLogic.Patch(((Component)__instance).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(MineRock), "Start")]
	internal class MineRockPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref MineRock __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(MineRock5), "Awake")]
	internal class MineRock5Patch
	{
		[UsedImplicitly]
		private static void Postfix(ref MineRock5 __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(Location), "Awake")]
	internal class LocationPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref Location __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(Leviathan), "Awake")]
	internal class LeviathanPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref Leviathan __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Awake")]
	internal class TeleportWorldPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref TeleportWorld __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(PickableItem), "Awake")]
	internal class PickableItemPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref PickableItem __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	internal class ContainerPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref Container __instance)
		{
			CommonPatchLogic.Patch(((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(Console), "Awake")]
	internal class ConsolePatches : HasLogger
	{
		private const string WriteMissingConfigsOption = "write_missing_configs_file";

		private const string PrintEffectiveConfig = "print_effective_config";

		private const string DebugLogPins = "debug_log_pins";

		private const string ClearPins = "clear_pins";

		private const string ClearAllMessage = "cleared all pins from map";

		private const string PrintEffectiveConfigRequiredNameMessage = "for printing the effective config of an object, please provide the object name as argument to the command";

		[UsedImplicitly]
		private static void Postfix(Console __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_003c: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Console __instance2 = __instance;
			new ConsoleCommand("amp", "auto map pins commands", (ConsoleEvent)delegate(ConsoleEventArgs consoleEventArgs)
			{
				if (consoleEventArgs.Length > 1)
				{
					AutoMapPinsPlugin.Log.LogInfo((object)("called amp with args: '" + string.Join(", ", consoleEventArgs.Args.ToList()) + "'"));
					switch (consoleEventArgs.Args[1])
					{
					case "debug_log_pins":
						if (Object.op_Implicit((Object)(object)Minimap.instance))
						{
							HasLogger.Log.LogInfo((object)("vanilla map registered pins:\n" + MinimapPatch.PrintMapPins()));
						}
						break;
					case "clear_pins":
						if (Object.op_Implicit((Object)(object)Minimap.instance))
						{
							Minimap.instance.ClearPins();
							__instance2.Print("cleared all pins from map");
							HasLogger.Log.LogWarning((object)"cleared all pins from map");
						}
						break;
					case "print_effective_config":
						if (consoleEventArgs.Args.Length < 3)
						{
							__instance2.Print("for printing the effective config of an object, please provide the object name as argument to the command");
						}
						else
						{
							string text = consoleEventArgs.Args[2];
							if (!string.IsNullOrEmpty(text) && Registry.ConfiguredPins.TryGetValue(text, out Config.Pin value))
							{
								__instance2.Print(text + ":");
								__instance2.Print("  " + value.ToString().Replace("\n", "\n  "));
							}
							else
							{
								__instance2.Print("no config found for object name '" + text + "'");
							}
						}
						break;
					case "write_missing_configs_file":
						WriteMissingConfigs();
						break;
					default:
						PrintUsage(__instance2);
						break;
					}
				}
				else
				{
					PrintUsage(__instance2);
				}
			}, false, false, false, false, false, new ConsoleOptionsFetcher(OptionFetcher), false, false, false);
		}

		private static void PrintUsage(Console __instance)
		{
			__instance.Print("Auto Map Pins (amp) console commands - use 'amp' followed by one of the following options");
			__instance.Print(" debug_log_pins --> print all active pins to log");
			__instance.Print(" clear_pins --> will remove all pins from map (use this in case the mod went crazy and created too many pins before ;)");
			__instance.Print(" print_effective_config <object name> --> replace '<object name>' with the object to print the effective config for, this can be used to debug config issues and config inheritance");
			__instance.Print(" write_missing_configs_file --> will write all objects without config to a yaml file");
		}

		private static void WriteMissingConfigs()
		{
			Dictionary<string, Config.Category> dictionary = (from config in Registry.MissingConfigs
				select new KeyValuePair<string, string>("category", config) into kv
				group kv by kv.Key).ToDictionary((IGrouping<string, KeyValuePair<string, string>> group) => group.Key, (IGrouping<string, KeyValuePair<string, string>> group) => new Config.Category
			{
				IsActive = false,
				IndividualConfiguredObjects = new Dictionary<string, Config.Pin> { 
				{
					"example",
					new Config.Pin
					{
						Name = "example name",
						IconName = "mine",
						IconColorRGBA = Config.PinColor.White
					}
				} },
				CategoryConfiguredObjects = (from kv in @group
					select kv.Value into x
					orderby x
					select x).ToList()
			});
			if (dictionary.Count > 0)
			{
				AutoMapPinsPlugin.FileIO.WriteFile(AutoMapPinsPlugin.FileIO.GetSingleFile("write_missing_configs_file"), dictionary);
			}
			else
			{
				HasLogger.Log.LogWarning((object)"could not print any configs, since no config was recorded during game play");
			}
		}

		private static List<string> OptionFetcher()
		{
			return new List<string> { "print_effective_config", "write_missing_configs_file", "debug_log_pins", "clear_pins" };
		}
	}
	[HarmonyPatch(typeof(Minimap))]
	internal abstract class MinimapPatch : HasLogger
	{
		private static readonly List<MapPin> MapTableTempStorage = new List<MapPin>();

		[UsedImplicitly]
		[HarmonyPatch("LoadMapData")]
		[HarmonyPostfix]
		internal static void LoadMapDataPostfix(ref Minimap __instance)
		{
			List<PinData> list = new List<PinData>();
			List<MapPin> list2 = new List<MapPin>();
			HasLogger.Log.LogInfo((object)$"loading map data with '{__instance.m_pins.Count}' pins");
			foreach (PinData pin in __instance.m_pins)
			{
				Config.Pin value = Registry.ConfiguredPins.FirstOrDefault<KeyValuePair<string, Config.Pin>>((KeyValuePair<string, Config.Pin> pinConfig) => pinConfig.Value.Name == pin.m_name).Value;
				if (value != null)
				{
					list.Add(pin);
					MapPin item = new MapPin(pin, value);
					list2.Add(item);
				}
			}
			if (list.Count > 0)
			{
				HasLogger.Log.LogInfo((object)($"removing {list.Count} pins due to config updates and/or replacement by loading " + "from player save file"));
				foreach (PinData item2 in list)
				{
					__instance.RemovePin(item2);
				}
			}
			if (list2.Count > 0)
			{
				HasLogger.Log.LogInfo((object)$"adding {list2.Count} AMP pins to replace vanilla stored pins");
				foreach (MapPin item3 in list2)
				{
					__instance.m_pins?.Add((PinData)(object)item3);
				}
			}
			HasLogger.Log.LogInfo((object)$"Loaded map with {__instance.m_pins?.Count} existing pins");
		}

		[UsedImplicitly]
		[HarmonyPatch("UpdatePins")]
		[HarmonyPostfix]
		internal static void UpdatePinsPostfix(ref Minimap __instance)
		{
			foreach (PinData pin in __instance.m_pins)
			{
				if (pin is MapPin mapPin && Object.op_Implicit((Object)(object)((PinData)mapPin).m_iconElement))
				{
					mapPin.UpdatePinColor();
				}
			}
		}

		[UsedImplicitly]
		[HarmonyPatch("GetSharedMapData")]
		[HarmonyPrefix]
		internal static void GetSharedMapDataPrefix(ref Minimap __instance)
		{
			MapTableTempStorage.Clear();
			MapTableTempStorage.AddRange(__instance.m_pins.OfType<MapPin>());
			foreach (MapPin item in MapTableTempStorage)
			{
				__instance.m_pins.Remove((PinData)(object)item);
			}
		}

		[UsedImplicitly]
		[HarmonyPatch("GetSharedMapData")]
		[HarmonyPostfix]
		internal static void GetSharedMapDataPostfix(ref Minimap __instance)
		{
			__instance.m_pins.AddRange(MapTableTempStorage.Select((MapPin pin) => (PinData)(object)pin));
			MapTableTempStorage.Clear();
		}

		internal static void UpsertPin(GameObject objectToPin)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			GameObject objectToPin2 = objectToPin;
			if (Object.op_Implicit((Object)(object)Minimap.instance) || Minimap.instance.m_pins == null)
			{
				string text = AutoMapPins.Common.Constants.ParseInternalName(((Object)objectToPin2).name);
				if (!Registry.ConfiguredPins.TryGetValue(text, out Config.Pin config) || !config.IsActive)
				{
					Registry.AddMissingConfig(text);
				}
				else if (((IEnumerable<PinData>)Minimap.instance.m_pins).FirstOrDefault((Func<PinData, bool>)((PinData pin) => pin.m_pos == objectToPin2.transform.position && pin.m_name == config.Name)) == null)
				{
					CreateAndInsertPin(new PositionedObject(text, objectToPin2.transform.position), config);
				}
			}
		}

		private static void CreateAndInsertPin(PositionedObject positionedObject, Config.Pin config)
		{
			if (!ObjectGroupingAvailable(positionedObject, config))
			{
				Minimap.instance.m_pins.Add((PinData)(object)new MapPin(positionedObject, config));
			}
		}

		private static bool ObjectGroupingAvailable(PositionedObject positionedObject, Config.Pin config)
		{
			if (!config.Groupable)
			{
				return false;
			}
			MapPin mapPin = (from pin in Minimap.instance.m_pins.OfType<MapPin>()
				where pin.Config.Groupable
				select pin).FirstOrDefault((MapPin pin) => pin.AcceptsObject(positionedObject));
			if (mapPin == null)
			{
				return false;
			}
			mapPin.AddObjectToPin(positionedObject);
			return true;
		}

		internal static void UnpinObject(GameObject objectToRemove)
		{
			UnpinObject(PositionedObject.FromGameObject(objectToRemove));
		}

		private static void UnpinObject(PositionedObject positionToRemove)
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance) && Minimap.instance.m_pins != null)
			{
				MapPin mapPin = Minimap.instance.m_pins.OfType<MapPin>().FirstOrDefault((MapPin pin) => pin.RemoveObjectFromPin(positionToRemove));
				if (mapPin != null)
				{
					Minimap.instance.RemovePin((PinData)(object)mapPin);
				}
			}
		}

		internal static void UpdatePins()
		{
			if (!Object.op_Implicit((Object)(object)Minimap.instance) || Minimap.instance.m_pins == null)
			{
				return;
			}
			HasLogger.Log.LogInfo((object)"updating pins");
			List<PositionedObject> list = new List<PositionedObject>();
			foreach (MapPin item in Minimap.instance.m_pins.OfType<MapPin>())
			{
				if (Registry.ConfiguredPins.TryGetValue(item.InternalName, out Config.Pin value))
				{
					item.ApplyConfigUpdate(value);
				}
				else
				{
					list.Add(item.GetPinnedPosition());
				}
			}
			foreach (PositionedObject item2 in list)
			{
				UnpinObject(item2);
			}
		}

		internal static string PrintMapPins()
		{
			string text = "";
			if (!Object.op_Implicit((Object)(object)Minimap.instance))
			{
				return text;
			}
			foreach (KeyValuePair<PositionedObject, PinData> item in from pair in Minimap.instance.m_pins.ToDictionary(delegate(PinData pin)
				{
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					PinNameData namePinData = pin.m_NamePinData;
					return new PositionedObject(((namePinData != null) ? namePinData.PinNameText.text : null) ?? "no name", pin.m_pos);
				}, (PinData pin) => pin)
				orderby pair.Key
				select pair)
			{
				text = ((!(item.Value is MapPin mapPin)) ? (text + $"vanilla pin: {item.Key} of type '{((object)(PinType)(ref item.Value.m_type)).ToString()}'\n") : (text + ((object)mapPin)?.ToString() + "\n"));
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(Pickable), "Awake")]
	internal class PickablePatch
	{
		[UsedImplicitly]
		[HarmonyPriority(600)]
		private static void Postfix(ref Pickable __instance)
		{
			if (!__instance.m_picked)
			{
				CommonPatchLogic.Patch(((Component)__instance).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(Pickable), "SetPicked")]
	public class PickableDropPatch
	{
		[UsedImplicitly]
		private static void Postfix(ref Pickable __instance, bool picked)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)__instance).gameObject;
			PinComponent pinComponent = default(PinComponent);
			if (gameObject.transform.position.y <= AutoMapPinsPlugin.MaxDetectionHeight.Value && picked && gameObject.TryGetComponent<PinComponent>(ref pinComponent))
			{
				pinComponent.OnDestroy();
			}
		}
	}
}
namespace AutoMapPins.Model
{
	public class MapPin : PinData
	{
		internal readonly string InternalName;

		internal Config.Pin Config;

		private readonly List<Vector3> InstancePositions = new List<Vector3>();

		internal MapPin(PositionedObject positionedObject, Config.Pin config)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			InternalName = positionedObject.ObjectName;
			InstancePositions.Add(positionedObject.ObjectPosition);
			base.m_type = (PinType)8;
			base.m_checked = false;
			base.m_ownerID = 0L;
			ApplyConfigUpdate(config);
		}

		internal MapPin(PinData fromVanilla, Config.Pin config)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			InternalName = AutoMapPins.Common.Constants.ParseInternalName(fromVanilla.m_name);
			InstancePositions.Add(fromVanilla.m_pos);
			base.m_type = fromVanilla.m_type;
			base.m_checked = fromVanilla.m_checked;
			base.m_ownerID = fromVanilla.m_ownerID;
			ApplyConfigUpdate(config);
		}

		internal PositionedObject GetPinnedPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new PositionedObject(InternalName, base.m_pos);
		}

		internal void ApplyConfigUpdate(Config.Pin config)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			Config = config;
			base.m_name = Config.Name;
			base.m_save = Config.IsPermanent;
			if (Config.IconName != null)
			{
				base.m_icon = Assets.GetIcon(Config.IconName);
			}
			PinNameData namePinData = base.m_NamePinData;
			if (namePinData != null)
			{
				namePinData.DestroyMapMarker();
			}
			base.m_NamePinData = new PinNameData((PinData)(object)this);
			UpdatePin();
		}

		private void UpdatePin()
		{
			UpdatePosition();
			UpdatePinText();
			UpdatePinColor();
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				Minimap.instance.m_pinUpdateRequired = true;
			}
		}

		private void UpdatePosition()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (InstancePositions.Count > 1)
			{
				Vector3 pos = default(Vector3);
				((Vector3)(ref pos))..ctor(InstancePositions.Average((Vector3 position) => position.x), InstancePositions.Average((Vector3 position) => position.y), InstancePositions.Average((Vector3 position) => position.z));
				base.m_pos = pos;
			}
			else
			{
				base.m_pos = InstancePositions.First();
			}
		}

		private void UpdatePinText()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Invalid comparison between Unknown and I4
			if (InstancePositions.Count > 1)
			{
				string text = InstancePositions.Count.ToString() ?? "";
				base.m_name = (string.IsNullOrEmpty(Config.Name) ? text : ((text == "") ? Config.Name : (text + " " + Config.Name)));
			}
			else
			{
				base.m_name = (string.IsNullOrEmpty(Config.Name) ? " " : Config.Name);
			}
			base.m_NamePinData.DestroyMapMarker();
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				RectTransform val = (((int)Minimap.instance.m_mode == 2) ? Minimap.instance.m_pinNameRootLarge : Minimap.instance.m_pinNameRootSmall);
				Minimap.instance.CreateMapNamePin((PinData)(object)this, val);
			}
		}

		internal void UpdatePinColor()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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 (Object.op_Implicit((Object)(object)base.m_iconElement))
			{
				Color color = Config.IconColorRGBA?.FromConfig() ?? Color.white;
				((Graphic)base.m_iconElement).color = color;
				((Graphic)base.m_NamePinData.PinNameText).color = color;
			}
		}

		internal bool AcceptsObject(PositionedObject objectToGroup)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (Config.Groupable && InternalName == objectToGroup.ObjectName)
			{
				return WithinGroupDistance(objectToGroup.ObjectPosition);
			}
			return false;
		}

		private bool WithinGroupDistance(Vector3 newPosition)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Config.Pin config = Config;
			float num = ((config != null && config.GroupingDistance > 0f) ? Config.GroupingDistance : AutoMapPinsPlugin.GroupingRadius.Value);
			return Utils.DistanceXZ(base.m_pos, newPosition) < num;
		}

		internal void AddObjectToPin(PositionedObject objectToAdd)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!InstancePositions.Contains(objectToAdd.ObjectPosition))
			{
				InstancePositions.Add(objectToAdd.ObjectPosition);
				UpdatePin();
			}
		}

		internal bool RemoveObjectFromPin(PositionedObject positionedObject)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (Config.IsPermanent)
			{
				return false;
			}
			if (!InstancePositions.Remove(positionedObject.ObjectPosition))
			{
				return false;
			}
			if (InstancePositions.Count > 0)
			{
				UpdatePin();
			}
			return true;
		}

		public override string ToString()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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)
			string text = "custom AMP pin: '" + base.m_name + "' (game object name '" + InternalName + "') at position '" + ((object)(Vector3)(ref base.m_pos)).ToString() + "' " + $"with icon '{Config.IconName}', permanent '{Config.IsPermanent}'";
			if (InstancePositions.Count <= 1)
			{
				return text;
			}
			text += "; grouped pin, containing positions:";
			foreach (Vector3 instancePosition in InstancePositions)
			{
				string text2 = text;
				Vector3 val = instancePosition;
				text = text2 + "\n  " + ((object)(Vector3)(ref val)).ToString();
			}
			return text;
		}
	}
	internal class PinComponent : MonoBehaviour
	{
		private Vector3 Position;

		private bool IsVisible;

		private Coroutine Routine;

		private PinComponent()
		{
		}

		internal void Awake()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Position = ((Component)this).gameObject.transform.position;
			IsVisible = Object.op_Implicit((Object)(object)Minimap.instance) && Minimap.instance.IsExplored(((Component)this).transform.position);
			SetVisiblePin();
		}

		internal void OnDestroy()
		{
			if (Routine != null)
			{
				((MonoBehaviour)this).StopCoroutine(Routine);
			}
			MinimapPatch.UnpinObject(((Component)this).gameObject);
		}

		private IEnumerator VisibleCheck()
		{
			while (!IsVisible)
			{
				IsVisible = Object.op_Implicit((Object)(object)Minimap.instance) && Minimap.instance.IsExplored(Position);
				if (IsVisible)
				{
					SetVisiblePin();
					break;
				}
				yield return (object)new WaitForFixedUpdate();
			}
		}

		private void SetVisiblePin()
		{
			if (IsVisible)
			{
				MinimapPatch.UpsertPin(((Component)this).gameObject);
				return;
			}
			if (Routine != null)
			{
				((MonoBehaviour)this).StopCoroutine(Routine);
			}
			Routine = ((MonoBehaviour)this).StartCoroutine(VisibleCheck());
		}
	}
	internal readonly struct PositionedObject : IComparable
	{
		internal readonly string ObjectName;

		internal readonly Vector3 ObjectPosition;

		public PositionedObject(string objectName, Vector3 objectPosition)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ObjectName = objectName;
			ObjectPosition = objectPosition;
		}

		internal static PositionedObject FromGameObject(GameObject pinnedObject)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return new PositionedObject(AutoMapPins.Common.Constants.ParseInternalName(((Object)pinnedObject).name), pinnedObject.transform.position);
		}

		public override bool Equals(object? obj)
		{
			if (obj is PositionedObject other)
			{
				return Equals(other);
			}
			return base.Equals(obj);
		}

		private bool Equals(PositionedObject other)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (ObjectName == other.ObjectName)
			{
				Vector3 objectPosition = ObjectPosition;
				return ((Vector3)(ref objectPosition)).Equals(other.ObjectPosition);
			}
			return false;
		}

		public override int GetHashCode()
		{
			//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)
			int num = ObjectName.GetHashCode() * 397;
			Vector3 objectPosition = ObjectPosition;
			return num ^ ((object)(Vector3)(ref objectPosition)).GetHashCode();
		}

		public int CompareTo(object obj)
		{
			if (obj is PositionedObject other)
			{
				return CompareTo(other);
			}
			throw new NotImplementedException();
		}

		private int CompareTo(PositionedObject other)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			int num = string.Compare(ObjectName, other.ObjectName, StringComparison.Ordinal);
			if (num != 0)
			{
				return num;
			}
			float x = ObjectPosition.x;
			return x.CompareTo(other.ObjectPosition.x);
		}

		public override string ToString()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return $"'{ObjectName}' at '{ObjectPosition}'";
		}
	}
}
namespace AutoMapPins.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("AutoMapPins.Icons.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] AMP => (byte[])ResourceManager.GetObject("AMP", resourceCulture);

		internal static byte[] Axe => (byte[])ResourceManager.GetObject("Axe", resourceCulture);

		internal static byte[] Axe48 => (byte[])ResourceManager.GetObject("Axe48", resourceCulture);

		internal static byte[] Berry => (byte[])ResourceManager.GetObject("Berry", resourceCulture);

		internal static byte[] Berry48 => (byte[])ResourceManager.GetObject("Berry48", resourceCulture);

		internal static byte[] Bones => (byte[])ResourceManager.GetObject("Bones", resourceCulture);

		internal static byte[] Bones48 => (byte[])ResourceManager.GetObject("Bones48", resourceCulture);

		internal static byte[] Dot => (byte[])ResourceManager.GetObject("Dot", resourceCulture);

		internal static byte[] Dot48 => (byte[])ResourceManager.GetObject("Dot48", resourceCulture);

		internal static byte[] Dungeon => (byte[])ResourceManager.GetObject("Dungeon", resourceCulture);

		internal static byte[] Dungeon48 => (byte[])ResourceManager.GetObject("Dungeon48", resourceCulture);

		internal static byte[] Fire => (byte[])ResourceManager.GetObject("Fire", resourceCulture);

		internal static byte[] Fire48 => (byte[])ResourceManager.GetObject("Fire48", resourceCulture);

		internal static byte[] Flower => (byte[])ResourceManager.GetObject("Flower", resourceCulture);

		internal static byte[] Flower48 => (byte[])ResourceManager.GetObject("Flower48", resourceCulture);

		internal static byte[] Hand => (byte[])ResourceManager.GetObject("Hand", resourceCulture);

		internal static byte[] Hand48 => (byte[])ResourceManager.GetObject("Hand48", resourceCulture);

		internal static byte[] Hay => (byte[])ResourceManager.GetObject("Hay", resourceCulture);

		internal static byte[] Hay48 => (byte[])ResourceManager.GetObject("Hay48", resourceCulture);

		internal static byte[] Herb => (byte[])ResourceManager.GetObject("Herb", resourceCulture);

		internal static byte[] Herb48 => (byte[])ResourceManager.GetObject("Herb48", resourceCulture);

		internal static byte[] Island => (byte[])ResourceManager.GetObject("Island", resourceCulture);

		internal static byte[] Island48 => (byte[])ResourceManager.GetObject("Island48", resourceCulture);

		internal static byte[] Mine => (byte[])ResourceManager.GetObject("Mine", resourceCulture);

		internal static byte[] Mine48 => (byte[])ResourceManager.GetObject("Mine48", resourceCulture);

		internal static byte[] Monument => (byte[])ResourceManager.GetObject("Monument", resourceCulture);

		internal static byte[] Monument48 => (byte[])ResourceManager.GetObject("Monument48", resourceCulture);

		internal static byte[] Mushroom => (byte[])ResourceManager.GetObject("Mushroom", resourceCulture);

		internal static byte[] Mushroom48 => (byte[])ResourceManager.GetObject("Mushroom48", resourceCulture);

		internal static byte[] Portal => (byte[])ResourceManager.GetObject("Portal", resourceCulture);

		internal static byte[] Portal48 => (byte[])ResourceManager.GetObject("Portal48", resourceCulture);

		internal static byte[] Rune => (byte[])ResourceManager.GetObject("Rune", resourceCulture);

		internal static byte[] Rune48 => (byte[])ResourceManager.GetObject("Rune48", resourceCulture);

		internal static byte[] Seed => (byte[])ResourceManager.GetObject("Seed", resourceCulture);

		internal static byte[] Seed48 => (byte[])ResourceManager.GetObject("Seed48", resourceCulture);

		internal static byte[] Spawner => (byte[])ResourceManager.GetObject("Spawner", resourceCulture);

		internal static byte[] Spawner48 => (byte[])ResourceManager.GetObject("Spawner48", resourceCulture);

		internal static byte[] Temple => (byte[])ResourceManager.GetObject("Temple", resourceCulture);

		internal static byte[] Temple48 => (byte[])ResourceManager.GetObject("Temple48", resourceCulture);

		internal static byte[] Treasure => (byte[])ResourceManager.GetObject("Treasure", resourceCulture);

		internal static byte[] Treasure48 => (byte[])ResourceManager.GetObject("Treasure48", resourceCulture);

		internal static byte[] Tree => (byte[])ResourceManager.GetObject("Tree", resourceCulture);

		internal static byte[] Tree48 => (byte[])ResourceManager.GetObject("Tree48", resourceCulture);

		internal static byte[] Village => (byte[])ResourceManager.GetObject("Village", resourceCulture);

		internal static byte[] Village48 => (byte[])ResourceManager.GetObject("Village48", resourceCulture);

		internal static byte[] Whale => (byte[])ResourceManager.GetObject("Whale", resourceCulture);

		internal static byte[] Whale48 => (byte[])ResourceManager.GetObject("Whale48", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace AutoMapPins.Icons
{
	internal abstract class Assets
	{
		private static readonly Sprite DefaultIcon = LoadSpriteFromTexture(Resources.Dot);

		private static readonly Dictionary<string, Sprite> Icons = new Dictionary<string, Sprite>
		{
			{
				"amp",
				LoadSpriteFromTexture(Resources.AMP)
			},
			{
				"axe",
				LoadSpriteFromTexture(Resources.Axe)
			},
			{
				"axe48",
				LoadSpriteFromTexture(Resources.Axe48)
			},
			{
				"berry",
				LoadSpriteFromTexture(Resources.Berry)
			},
			{
				"berry48",
				LoadSpriteFromTexture(Resources.Berry48)
			},
			{
				"bones",
				LoadSpriteFromTexture(Resources.Bones)
			},
			{
				"bones48",
				LoadSpriteFromTexture(Resources.Bones48)
			},
			{
				"dot",
				LoadSpriteFromTexture(Resources.Dot)
			},
			{
				"dot48",
				LoadSpriteFromTexture(Resources.Dot48)
			},
			{
				"dungeon",
				LoadSpriteFromTexture(Resources.Dungeon)
			},
			{
				"dungeon48",
				LoadSpriteFromTexture(Resources.Dungeon48)
			},
			{
				"fire",
				LoadSpriteFromTexture(Resources.Fire)
			},
			{
				"fire48",
				LoadSpriteFromTexture(Resources.Fire48)
			},
			{
				"flower",
				LoadSpriteFromTexture(Resources.Flower)
			},
			{
				"flower48",
				LoadSpriteFromTexture(Resources.Flower48)
			},
			{
				"hand",
				LoadSpriteFromTexture(Resources.Hand)
			},
			{
				"hand48",
				LoadSpriteFromTexture(Resources.Hand48)
			},
			{
				"hay",
				LoadSpriteFromTexture(Resources.Hay)
			},
			{
				"hay48",
				LoadSpriteFromTexture(Resources.Hay48)
			},
			{
				"herb",
				LoadSpriteFromTexture(Resources.Herb)
			},
			{
				"herb48",
				LoadSpriteFromTexture(Resources.Herb48)
			},
			{
				"island",
				LoadSpriteFromTexture(Resources.Island)
			},
			{
				"island48",
				LoadSpriteFromTexture(Resources.Island48)
			},
			{
				"mine",
				LoadSpriteFromTexture(Resources.Mine)
			},
			{
				"mine48",
				LoadSpriteFromTexture(Resources.Mine48)
			},
			{
				"monument",
				LoadSpriteFromTexture(Resources.Monument)
			},
			{
				"monument48",
				LoadSpriteFromTexture(Resources.Monument48)
			},
			{
				"mushroom",
				LoadSpriteFromTexture(Resources.Mushroom)
			},
			{
				"mushroom48",
				LoadSpriteFromTexture(Resources.Mushroom48)
			},
			{
				"portal",
				LoadSpriteFromTexture(Resources.Portal)
			},
			{
				"portal48",
				LoadSpriteFromTexture(Resources.Portal48)
			},
			{
				"rune",
				LoadSpriteFromTexture(Resources.Rune)
			},
			{
				"rune48",
				LoadSpriteFromTexture(Resources.Rune48)
			},
			{
				"seed",
				LoadSpriteFromTexture(Resources.Seed)
			},
			{
				"seed48",
				LoadSpriteFromTexture(Resources.Seed48)
			},
			{
				"spawner",
				LoadSpriteFromTexture(Resources.Spawner)
			},
			{
				"spawner48",
				LoadSpriteFromTexture(Resources.Spawner48)
			},
			{
				"temple",
				LoadSpriteFromTexture(Resources.Temple)
			},
			{
				"temple48",
				LoadSpriteFromTexture(Resources.Temple48)
			},
			{
				"treasure",
				LoadSpriteFromTexture(Resources.Treasure)
			},
			{
				"treasure48",
				LoadSpriteFromTexture(Resources.Treasure48)
			},
			{
				"tree",
				LoadSpriteFromTexture(Resources.Tree)
			},
			{
				"tree48",
				LoadSpriteFromTexture(Resources.Tree48)
			},
			{
				"village",
				LoadSpriteFromTexture(Resources.Village)
			},
			{
				"village48",
				LoadSpriteFromTexture(Resources.Village48)
			},
			{
				"whale",
				LoadSpriteFromTexture(Resources.Whale)
			},
			{
				"whale48",
				LoadSpriteFromTexture(Resources.Whale48)
			}
		};

		internal static Sprite GetIcon(string iconName)
		{
			if (Icons.TryGetValue(iconName, out Sprite value))
			{
				return value;
			}
			return DefaultIcon;
		}

		private static Texture2D LoadTextureFromRaw(byte[] bytes)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0010: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, bytes);
			return val;
		}

		private static Sprite LoadSpriteFromTexture(Texture2D spriteTexture, float pixelsPerUnit = 100f)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			AutoMapPinsPlugin.Log.LogDebug((object)$"Making Sprite from Texture {spriteTexture}");
			return Sprite.Create(spriteTexture, new Rect(0f, 0f, (float)((Texture)spriteTexture).width, (float)((Texture)spriteTexture).height), new Vector2(0f, 0f), pixelsPerUnit);
		}

		private static Sprite LoadSpriteFromTexture(byte[] bytes)
		{
			return LoadSpriteFromTexture(LoadTextureFromRaw(bytes));
		}
	}
}
namespace AutoMapPins.Data
{
	public abstract class Config
	{
		public class Category : Pin
		{
			public Dictionary<string, Pin>? IndividualConfiguredObjects;

			public List<string>? CategoryConfiguredObjects;
		}

		public class Pin : SerializedToStrings
		{
			public string? Name;

			public string? IconName;

			public PinColor? IconColorRGBA;

			public bool IsPermanent;

			public bool IsActive;

			public bool Groupable;

			public float GroupingDistance = 30f;
		}

		public class PinColor : SerializedToStrings
		{
			internal static PinColor White = new PinColor
			{
				Red = 255,
				Green = 255,
				Blue = 255,
				Alpha = 255
			};

			private const int RGBMin = 0;

			private const int RGBMax = 255;

			private const float Divider = 255f;

			public int Red;

			public int Green;

			public int Blue;

			public int Alpha;

			internal PinColor ClampColor()
			{
				Red = Clamp(Red, 0, 255);
				Green = Clamp(Green, 0, 255);
				Blue = Clamp(Blue, 0, 255);
				Alpha = Clamp(Alpha, 0, 255);
				return this;
			}

			public Color FromConfig()
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				float num = (float)Clamp(Red, 0, 255) / 255f;
				float num2 = (float)Clamp(Green, 0, 255) / 255f;
				float num3 = (float)Clamp(Blue, 0, 255) / 255f;
				float num4 = (float)Clamp(Alpha, 0, 255) / 255f;
				return new Color(num, num2, num3, num4);
			}

			private static int Clamp(int value, int min, int max)
			{
				if (value >= min)
				{
					if (value <= max)
					{
						return value;
					}
					return max;
				}
				return min;
			}
		}

		public abstract class SerializedToStrings
		{
			public override string ToString()
			{
				return YamlFileStorage.Serializer.Serialize(this);
			}
		}
	}
	public abstract class Registry : HasLogger
	{
		internal static Dictionary<string, Config.Pin> ConfiguredPins = new Dictionary<string, Config.Pin>();

		private static HashSet<string> ConfiguredObjects = new HashSet<string>();

		internal static readonly HashSet<string> MissingConfigs = new HashSet<string>();

		internal static void InitializeRegistry(Dictionary<string, Config.Category> newConfiguredCategories)
		{
			HasLogger.Log.LogDebug((object)"initializing registry");
			MissingConfigs.Clear();
			ConfiguredObjects.Clear();
			ConfiguredPins.Clear();
			ConfiguredPins = LoadActivePinConfigs(newConfiguredCategories);
			ConfiguredObjects = GetConfiguredObjects(newConfiguredCategories);
			MinimapPatch.UpdatePins();
			HasLogger.Log.LogDebug((object)"registry initialization successful");
		}

		private static Dictionary<string, Config.Pin> LoadActivePinConfigs(Dictionary<string, Config.Category> newConfiguredCategories)
		{
			Dictionary<string, Config.Pin> dictionary = new Dictionary<string, Config.Pin>();
			foreach (KeyValuePair<string, Config.Category> newConfiguredCategory in newConfiguredCategories)
			{
				if (!newConfiguredCategory.Value.IsActive)
				{
					continue;
				}
				if (newConfiguredCategory.Value.IndividualConfiguredObjects != null)
				{
					foreach (KeyValuePair<string, Config.Pin> individualConfiguredObject in newConfiguredCategory.Value.IndividualConfiguredObjects)
					{
						Config.Pin value = individualConfiguredObject.Value;
						if (value != null && value.IsActive)
						{
							Config.Pin value2 = individualConfiguredObject.Value;
							value = value2;
							if (value.Name == null)
							{
								value.Name = newConfiguredCategory.Value.Name;
							}
							value = value2;
							if (value.IconName == null)
							{
								value.IconName = newConfiguredCategory.Value.IconName ?? "n_a";
							}
							value2.IconColorRGBA = value2.IconColorRGBA?.ClampColor() ?? newConfiguredCategory.Value.IconColorRGBA?.ClampColor() ?? Config.PinColor.White;
							dictionary.Add(individualConfiguredObject.Key, value2);
						}
					}
				}
				if (newConfiguredCategory.Value.CategoryConfiguredObjects == null)
				{
					continue;
				}
				foreach (string categoryConfiguredObject in newConfiguredCategory.Value.CategoryConfiguredObjects)
				{
					if (!dictionary.ContainsKey(categoryConfiguredObject))
					{
						dictionary.Add(categoryConfiguredObject, new Config.Pin
						{
							Name = newConfiguredCategory.Value.Name,
							IsActive = newConfiguredCategory.Value.IsActive,
							IsPermanent = newConfiguredCategory.Value.IsPermanent,
							Groupable = newConfiguredCategory.Value.Groupable,
							GroupingDistance = newConfiguredCategory.Value.GroupingDistance,
							IconName = newConfiguredCategory.Value.IconName,
							IconColorRGBA = (newConfiguredCategory.Value.IconColorRGBA?.ClampColor() ?? Config.PinColor.White)
						});
					}
					else
					{
						HasLogger.Log.LogWarning((object)("tried to add a by category '" + newConfiguredCategory.Key + "' configured object '" + categoryConfiguredObject + "' that does already exist in individual configured objects list - skipping object"));
					}
				}
			}
			HasLogger.Log.LogInfo((object)$"loaded '{dictionary.Count}' configs for active pins");
			return dictionary;
		}

		private static HashSet<string> GetConfiguredObjects(Dictionary<string, Config.Category> newConfiguredCategories)
		{
			List<string> first = newConfiguredCategories.Where<KeyValuePair<string, Config.Category>>((KeyValuePair<string, Config.Category> cat) => cat.Value.CategoryConfiguredObjects != null).SelectMany((KeyValuePair<string, Config.Category> cat) => cat.Value.CategoryConfiguredObjects).ToList();
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Config.Category> newConfiguredCategory in newConfiguredCategories)
			{
				if (newConfiguredCategory.Value.IndividualConfiguredObjects == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, Config.Pin> individualConfiguredObject in newConfiguredCategory.Value.IndividualConfiguredObjects)
				{
					list.Add(individualConfiguredObject.Key ?? "n_a");
				}
			}
			List<string> source = first.Concat(list).ToList();
			Dictionary<string, int> dictionary = (from kv in (from x in source
					group x by x).ToDictionary((IGrouping<string, string> @group) => @group.Key, (IGrouping<string, string> @group) => @group.Count())
				where kv.Value > 1
				select kv).ToDictionary((KeyValuePair<string, int> kv) => kv.Key, (KeyValuePair<string, int> kv) => kv.Value);
			if (dictionary.Count > 0)
			{
				HasLogger.Log.LogWarning((object)$"found '{dictionary.Count}' duplicates in config:");
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					HasLogger.Log.LogWarning((object)$"object name '{item.Key}' found '{item.Value}' times");
				}
			}
			HashSet<string> hashSet = source.Distinct().ToHashSet();
			HasLogger.Log.LogInfo((object)$"loaded '{hashSet.Count}' configured objects in total (also inactive ones)");
			return hashSet;
		}

		internal static void AddMissingConfig(string internalName)
		{
			if (AutoMapPinsPlugin.PrefabDiscoveryEnabled.Value && !ConfiguredObjects.Contains(internalName) && MissingConfigs.Add(internalName) && !AutoMapPinsPlugin.SilentDiscoveryEnabled.Value)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, "discovered object '" + internalName + "' that was not configured", 0, Assets.GetIcon("amp"));
				}
				HasLogger.Log.LogWarning((object)("discovered new game object named '" + internalName + "' that has no configuration"));
			}
		}
	}
	internal class YamlFileStorage : HasLogger
	{
		private readonly string _modGuid;

		private readonly List<string> _yamlFiles = new List<string>();

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();

		internal static readonly ISerializer Serializer = new SerializerBuilder().DisableAliases().WithNamingConvention(CamelCaseNamingConvention.Instance).Build();

		internal YamlFileStorage(string modGuid)
		{
			_modGuid = modGuid;
			FindConfigFiles();
		}

		private string GetModFilePattern(string fileInfix = "categories")
		{
			return _modGuid + "." + fileInfix + ".*.yaml";
		}

		internal string GetSingleFile(string fileInfix)
		{
			return Path.Combine(Paths.ConfigPath, _modGuid + "." + fileInfix + ".yaml");
		}

		internal void WriteFile(string file, Dictionary<string, Config.Category> objects)
		{
			string contents = Serializer.Serialize(objects);
			File.WriteAllText(file, contents);
			HasLogger.Log.LogInfo((object)("wrote yaml content to file '" + file + "'"));
		}

		private Dictionary<string, Config.Category> DeserializeFile(string fileName, string fileContent)
		{
			try
			{
				return Deserializer.Deserialize<Dictionary<string, Config.Category>>(fileContent);
			}
			catch (Exception ex)
			{
				HasLogger.Log.LogWarning((object)("Unable to parse config file '" + fileName + "' due to '" + ex.Message + "' because of '" + ex.GetBaseException().Message + "', \n" + ex.StackTrace));
			}
			return new Dictionary<string, Config.Category>();
		}

		internal Dictionary<string, string> ReadConfigFiles()
		{
			return _yamlFiles.ToDictionary((string fileName) => fileName, File.ReadAllText);
		}

		private void FindConfigFiles(string fileInfix = "categories")
		{
			string[] files = Directory.GetFiles(Paths.ConfigPath, GetModFilePattern(fileInfix), SearchOption.AllDirectories);
			foreach (string text in files)
			{
				HasLogger.Log.LogInfo((object)("found category and pin config file '" + text + "'"));
				_yamlFiles.Add(text);
				FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Path.GetDirectoryName(text), Path.GetFileName(text));
				fileSystemWatcher.Changed += AutoMapPinsPlugin.ReadYamlFileContent;
				fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
				fileSystemWatcher.EnableRaisingEvents = true;
			}
		}

		internal Dictionary<string, Config.Category> DeserializeAndMergeFileData(Dictionary<string, string> configFileContents)
		{
			return (from kv in (from kv in configFileContents
					where !string.IsNullOrEmpty(kv.Value) || !string.IsNullOrWhiteSpace(kv.Value)
					select DeserializeFile(kv.Key, kv.Value)).SelectMany((Dictionary<string, Config.Category> x) => x)
				group kv by kv.Key).ToDictionary((IGrouping<string, KeyValuePair<string, Config.Category>> group) => group.Key, delegate(IGrouping<string, KeyValuePair<string, Config.Category>> group)
			{
				bool isActive = group.All((KeyValuePair<string, Config.Category> cat) => cat.Value.IsActive);
				bool isPermanent = group.All((KeyValuePair<string, Config.Category> cat) => cat.Value.IsPermanent);
				bool groupable = group.All((KeyValuePair<string, Config.Category> cat) => cat.Value.Groupable);
				float groupingDistance = group.Min((KeyValuePair<string, Config.Category> cat) => cat.Value.GroupingDistance);
				string iconName = group.First().Value.IconName;
				string name = group.First().Value.Name;
				Config.PinColor iconColorRGBA = group.First().Value.IconColorRGBA;
				Dictionary<string, Config.Pin> dictionary = new Dictionary<string, Config.Pin>();
				List<string> list = new List<string>();
				foreach (Config.Category item in group.Select((KeyValuePair<string, Config.Category> category) => category.Value))
				{
					if (item.IndividualConfiguredObjects != null)
					{
						dictionary = (from pin in dictionary.Concat<KeyValuePair<string, Config.Pin>>(item.IndividualConfiguredObjects)
							group pin by pin.Key).ToDictionary((IGrouping<string, KeyValuePair<string, Config.Pin>> pinGroup) => pinGroup.Key, (IGrouping<string, KeyValuePair<string, Config.Pin>> pinGroup) => pinGroup.First().Value);
					}
					if (item.CategoryConfiguredObjects != null)
					{
						list = list.Concat(item.CategoryConfiguredObjects).ToList();
					}
				}
				return new Config.Category
				{
					Name = name,
					IsActive = isActive,
					IsPermanent = isPermanent,
					Groupable = groupable,
					GroupingDistance = groupingDistance,
					IconName = iconName,
					IconColorRGBA = iconColorRGBA,
					IndividualConfiguredObjects = dictionary,
					CategoryConfiguredObjects = list
				};
			});
		}
	}
}
namespace AutoMapPins.Common
{
	internal static class Constants
	{
		internal const float DefaultGroupingDistance = 30f;

		internal const string NoConfig = "n_a";

		private static readonly Regex CloneRegex = new Regex("\\(Clone\\)");

		private static readonly Regex DuplicateRegex = new Regex("[ ]*\\([\\d]*\\)");

		internal static string ParseInternalName(string instanceName)
		{
			string input = CloneRegex.Replace(instanceName, "");
			return DuplicateRegex.Replace(input, "");
		}
	}
	public abstract class HasLogger
	{
		protected static ManualLogSource Log => AutoMapPinsPlugin.Log;
	}
}
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 ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (__instance.IsServer())
				{
					BufferingSocket value = new BufferingSocket(rpc.GetSocket());
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
					object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (val != null && (int)ZNet.m_onlineBackend > 0)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
					}
					if (__state == null)
					{
						__state = new Dictionary<Assembly, BufferingSocket>();
					}
					__state[Assembly.GetExecutingAssembly()] = value;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void Chec