using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ArgusMagnus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("ArgusMagnus")]
[assembly: AssemblyDescription("Automatically update map tables with icons for portals and ships")]
[assembly: AssemblyFileVersion("1.99.8.0")]
[assembly: AssemblyInformationalVersion("1.99.8-beta+328851184cc278c858ffbc70e717af9f9d7b6973")]
[assembly: AssemblyProduct("ServersideQoL.AutoMapTables")]
[assembly: AssemblyTitle("ServersideQoL.AutoMapTables")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ArgusMagnus/ValheimServersideQoL")]
[assembly: AssemblyVersion("1.99.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 ServersideQoL.AutoMapTables
{
	[BepInPlugin("ArgusMagnus.ServersideQoL.AutoMapTables", "ServersideQoL.AutoMapTables", "1.99.8")]
	public sealed class AutoMapTablesPlugin : ServersideQoLPluginBase<AutoMapTablesPlugin, Config>
	{
		public static readonly int PluginGuidHash = StringExtensionMethods.GetStableHashCode("ArgusMagnus.ServersideQoL.AutoMapTables", true);

		public const string Author = "ArgusMagnus";

		public const string PluginName = "ServersideQoL.AutoMapTables";

		public const string PluginGuid = "ArgusMagnus.ServersideQoL.AutoMapTables";

		public const string PluginVersion = "1.99.8";

		public const string PluginInformationalVersion = "1.99.8-beta";

		private DateTimeOffset BuildTimestamp { get; } = new DateTimeOffset(639215507820137804L, default(TimeSpan));

		protected override Config CreateConfigSingleton(ConfigFile configFile, Logger logger)
		{
			return new Config(configFile, logger);
		}

		protected override void RegisterProcessors(IProcessorCollection processors)
		{
			processors.Add<MapTableProcessor>().Add<ShipProcessor>();
		}

		private void Awake()
		{
			ServersideQoLPluginBase<AutoMapTablesPlugin, Config>.Logger.LogWarning((object)string.Format("You are running a pre-release version: {0} ({1})", "1.99.8-beta", BuildTimestamp.LocalDateTime));
		}
	}
	public sealed class Config : ConfigBase<Config>
	{
		public sealed class LocalizationConfig
		{
			public string Updated { get; init; } = "$msg_mapsaved";
		}

		public sealed class AdvancedConfig
		{
			public float MapTableUpdateInterval { get; init; } = 5f;
		}

		private const string Section = "AutoMapTables";

		public override ConfigEntry<bool> Enabled { get; } = ConfigBase<Config>.BindEx<bool>(cfg, "AutoMapTables", true, "Enables/disables the entire mod", (AcceptableValueBase)null, (Deprecated<Config>)null, "Enabled");

		public ConfigEntry<bool> AutoUpdatePortals { get; } = ConfigBase<Config>.BindEx<bool>(cfg, "AutoMapTables", true, "True to update map tables with portal pins", (AcceptableValueBase)null, (Deprecated<Config>)null, "AutoUpdatePortals");

		public ConfigEntry<string> AutoUpdatePortalsExclude { get; } = ConfigBase<Config>.BindEx<string>(cfg, "AutoMapTables", "", "Portals with a tag that matches this filter are not added to map tables", (AcceptableValueBase)null, (Deprecated<Config>)null, "AutoUpdatePortalsExclude");

		public ConfigEntry<string> AutoUpdatePortalsInclude { get; } = ConfigBase<Config>.BindEx<string>(cfg, "AutoMapTables", "*", "Only portals with a tag that matches this filter are added to map tables", (AcceptableValueBase)null, (Deprecated<Config>)null, "AutoUpdatePortalsInclude");

		public ConfigEntry<bool> AutoUpdateShips { get; } = ConfigBase<Config>.BindEx<bool>(cfg, "AutoMapTables", true, "True to update map tables with ship pins", (AcceptableValueBase)null, (Deprecated<Config>)null, "AutoUpdateShips");

		public ConfigEntry<MessageTypes> UpdatedMessageType { get; } = ConfigBase<Config>.BindEx<MessageTypes>(cfg, "AutoMapTables", (MessageTypes)0, "Type of message to show when a map table is updated", (AcceptableValueBase)(object)AcceptableEnum<MessageTypes>.Default, (Deprecated<Config>)null, "UpdatedMessageType");

		public YamlConfigEntry<LocalizationConfig> Localization { get; } = ConfigBase<Config>.BindYaml<LocalizationConfig>(cfg, "Localization");

		public YamlConfigEntry<AdvancedConfig> Advanced { get; } = ConfigBase<Config>.BindYaml<AdvancedConfig>(cfg, "Advanced");

		public Config(ConfigFile cfg, Logger logger)
			: base(cfg, logger)
		{
		}
	}
	[Processor("05450dd6-13bd-42cc-9bd3-b1eed5e501af")]
	public sealed class MapTableProcessor : Processor<ProcessorPrefabInfo<MapTable>>
	{
		private record Pin(long OwnerId, string Tag, Vector3 Pos, PinType Type, bool IsChecked, string Author)
		{
			[CompilerGenerated]
			public void Deconstruct(out long OwnerId, out string Tag, out Vector3 Pos, out PinType Type, out bool IsChecked, out string Author)
			{
				//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)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected I4, but got Unknown
				OwnerId = this.OwnerId;
				Tag = this.Tag;
				Pos = this.Pos;
				Type = (PinType)(int)this.Type;
				IsChecked = this.IsChecked;
				Author = this.Author;
			}
		}

		private readonly List<Pin> _pins = new List<Pin>();

		private readonly List<Pin> _existingPins = new List<Pin>();

		private byte[]? _emptyExplored;

		private int _pinsHash;

		private int _oldPinsHash;

		private Regex? _includePortalRegex;

		private Regex? _excludePortalRegex;

		private DateTimeOffset _pinsValidUntil;

		protected override void Initialize()
		{
			if (((ConfigBase<Config>)(object)ConfigBase<Config>.Instance).Enabled.Value)
			{
				string text = ConfigBase<Config>.Instance.AutoUpdatePortalsInclude.Value.Trim();
				_includePortalRegex = (string.IsNullOrEmpty(text.Trim(new char[1] { '*' })) ? null : new Regex(Processor.ConvertToRegexPattern(text)));
				text = ConfigBase<Config>.Instance.AutoUpdatePortalsExclude.Value.Trim();
				_excludePortalRegex = (string.IsNullOrEmpty(text) ? null : new Regex(Processor.ConvertToRegexPattern(text)));
			}
			else
			{
				_includePortalRegex = null;
				_excludePortalRegex = null;
			}
			_pins.Clear();
			_existingPins.Clear();
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, ProcessorPrefabInfo<MapTable> prefabInfo)
		{
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Expected O, but got Unknown
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Invalid comparison between Unknown and I4
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Expected I4, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			DateTimeOffset utcNow = DateTimeOffset.UtcNow;
			if (_pinsValidUntil < utcNow)
			{
				_pins.Clear();
				_pinsHash = 0;
				_pinsValidUntil = utcNow.AddSeconds(ConfigBase<Config>.Instance.Advanced.Value.MapTableUpdateInterval);
			}
			zdo.DelaySchedulingFor(ConfigBase<Config>.Instance.Advanced.Value.MapTableUpdateInterval);
			List<Pin> pins = _pins;
			ZDOVars vars;
			if (pins != null && pins.Count == 0)
			{
				if (ConfigBase<Config>.Instance.AutoUpdatePortals.Value)
				{
					foreach (ServersideQoLZDO item in ZDOMan.instance.GetPortals().Values.SelectMany((List<ZDO> x) => x.Select((ZDO val3) => val3.ServersideQoLZDO)))
					{
						if (!item.IsModCreator())
						{
							vars = item.Vars;
							string tag = ((ZDOVars)(ref vars)).GetTag("");
							if ((_includePortalRegex?.IsMatch(tag) ?? true) && ((!(_excludePortalRegex?.IsMatch(tag))) ?? true))
							{
								Pin pin = new Pin(AutoMapTablesPlugin.PluginGuidHash, tag, item.ZDO.GetPosition(), (PinType)6, IsChecked: false, "ArgusMagnus.ServersideQoL.AutoMapTables");
								_pins.Add(pin);
								_oldPinsHash = (_oldPinsHash, pin).GetHashCode();
							}
						}
					}
				}
				if (ConfigBase<Config>.Instance.AutoUpdateShips.Value)
				{
					foreach (ServersideQoLZDO ship in Processor.Instance<ShipProcessor>().Ships)
					{
						Vector3 position = ship.ZDO.GetPosition();
						((Vector3)(ref position))..ctor(RoundToMultipleOf(position.x), RoundToMultipleOf(position.y), RoundToMultipleOf(position.z));
						ShipProcessor.PrefabInfo processorPrefabInfo = ship.GetProcessorPrefabInfo<ShipProcessor.PrefabInfo>();
						Pin pin2 = new Pin(AutoMapTablesPlugin.PluginGuidHash, processorPrefabInfo.Piece.m_name ?? "", position, (PinType)10, IsChecked: false, "ArgusMagnus.ServersideQoL.AutoMapTables");
						_pins.Add(pin2);
						_oldPinsHash = (_oldPinsHash, pin2).GetHashCode();
					}
				}
				int oldPinsHash = _oldPinsHash;
				int pinsHash = _pinsHash;
				_pinsHash = oldPinsHash;
				_oldPinsHash = pinsHash;
			}
			if (_pinsHash != _oldPinsHash)
			{
				_existingPins.Clear();
				vars = zdo.Vars;
				byte[] array = ((ZDOVars)(ref vars)).GetData((byte[])null);
				ZPackage val;
				if (array != null)
				{
					array = Utils.Decompress(array);
					val = new ZPackage(array);
					SharedMap val2 = (SharedMap)val.ReadInt();
					if ((int)val2 != 3)
					{
						((Processor)this).Logger.LogWarning((object)FormattableString.Invariant($"MapTable data version {val2:D} [{val2}] is not supported"));
						return (ProcessResult)0;
					}
					array = val.ReadByteArray();
					if (array.Length != Minimap.instance.m_textureSize * Minimap.instance.m_textureSize)
					{
						((Processor)this).Logger.LogWarning((object)"Invalid explored map data length");
						array = null;
					}
					int num = val.ReadInt();
					if (_existingPins.Capacity < num)
					{
						_existingPins.Capacity = num;
					}
					foreach (int item2 in Enumerable.Range(0, num))
					{
						Pin pin3 = new Pin(val.ReadLong(), val.ReadString(), val.ReadVector3(), (PinType)val.ReadInt(), val.ReadBool(), val.ReadString());
						if (pin3.OwnerId != AutoMapTablesPlugin.PluginGuidHash)
						{
							_existingPins.Add(pin3);
						}
					}
				}
				val = new ZPackage();
				val.Write(3);
				val.Write(array ?? _emptyExplored ?? (_emptyExplored = new byte[Minimap.instance.m_textureSize * Minimap.instance.m_textureSize]));
				val.Write(_pins.Count + _existingPins.Count);
				foreach (Pin item3 in _pins.Concat(_existingPins))
				{
					val.Write(item3.OwnerId);
					val.Write(item3.Tag);
					val.Write(item3.Pos);
					val.Write((int)item3.Type);
					val.Write(item3.IsChecked);
					val.Write(item3.Author);
				}
				vars = zdo.Vars;
				((ZDOVars)(ref vars)).SetData(Utils.Compress(val.GetArray()), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoMapTables\\MapTableProcessor.cs", 139);
				Processor.ShowMessage((IEnumerable<Peer>)peers, zdo, ConfigBase<Config>.Instance.Localization.Value.Updated, ConfigBase<Config>.Instance.UpdatedMessageType.Value, (TextType)0);
				return (ProcessResult)32;
			}
			return (ProcessResult)32;
			static float RoundToMultipleOf(float value)
			{
				return Mathf.Round(value / 5f) * 5f;
			}
		}
	}
	[Processor("5450041b-4bfe-4839-9a55-7762457b2a36")]
	public sealed class ShipProcessor : Processor<ShipProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Ship Ship, Piece Piece, ShipControlls ShipControls) : ProcessorPrefabInfo()
		{
			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Ship = ");
				builder.Append(Ship);
				builder.Append(", Piece = ");
				builder.Append(Piece);
				builder.Append(", ShipControls = ");
				builder.Append(ShipControls);
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return ((((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Ship>.Default.GetHashCode(Ship)) * -1521134295 + EqualityComparer<Piece>.Default.GetHashCode(Piece)) * -1521134295 + EqualityComparer<ShipControlls>.Default.GetHashCode(ShipControls);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other) && EqualityComparer<Ship>.Default.Equals(Ship, other.Ship) && EqualityComparer<Piece>.Default.Equals(Piece, other.Piece))
					{
						return EqualityComparer<ShipControlls>.Default.Equals(ShipControls, other.ShipControls);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Ship = original.Ship;
				Piece = original.Piece;
				ShipControls = original.ShipControls;
			}
		}

		private readonly HashSet<ServersideQoLZDO> _ships = new HashSet<ServersideQoLZDO>();

		public IReadOnlyCollection<ServersideQoLZDO> Ships => _ships;

		protected override void Initialize()
		{
			_ships.Clear();
			foreach (ServersideQoLZDO item in from x in PrivateAccessor.GetObjects(ZDOMan.instance)
				select x.ServersideQoLZDO)
			{
				if ((object)Processor<PrefabInfo>.GetProcessorPrefabInfo(item) != null && _ships.Add(item))
				{
					item.Destroyed += OnShipDestroyed;
				}
			}
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			if (_ships.Add(zdo))
			{
				zdo.Destroyed += OnShipDestroyed;
			}
			return (ProcessResult)2;
		}

		private void OnShipDestroyed(ServersideQoLZDO zdo)
		{
			_ships.Remove(zdo);
		}
	}
}