using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using Microsoft.CodeAnalysis;

[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("Rinor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0")]
[assembly: AssemblyProduct("Waybound")]
[assembly: AssemblyTitle("Ravenbond.Core")]
[assembly: AssemblyVersion("0.2.0.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 Ravenbond.Core
{
	public sealed class ExplorationMap
	{
		public const int DefaultSize = 2048;

		public const int ChunkBytes = 8192;

		public const int MaximumPixelCount = 16777216;

		private static readonly byte[] PopCounts = BuildPopCounts();

		private readonly byte[] _bits;

		private readonly long[] _revisions;

		public int Width { get; }

		public int Height { get; }

		public int PixelCount { get; }

		public int ByteLength => _bits.Length;

		public int ChunkCount => _revisions.Length;

		public int ExploredCount { get; private set; }

		public ExplorationMap(int width = 2048, int height = 2048)
		{
			if (width < 1 || width > 8192)
			{
				throw new ArgumentOutOfRangeException("width");
			}
			if (height < 1 || height > 8192 || (long)width * (long)height > 16777216)
			{
				throw new ArgumentOutOfRangeException("height");
			}
			Width = width;
			Height = height;
			PixelCount = checked(width * height);
			_bits = new byte[(PixelCount + 7) / 8];
			_revisions = new long[(_bits.Length + 8192 - 1) / 8192];
		}

		public bool IsExplored(int pixelIndex)
		{
			ValidatePixel(pixelIndex);
			return (_bits[pixelIndex >> 3] & (1 << (pixelIndex & 7))) != 0;
		}

		public bool Reveal(int pixelIndex)
		{
			ValidatePixel(pixelIndex);
			int num = pixelIndex >> 3;
			byte b = (byte)(1 << (pixelIndex & 7));
			if ((_bits[num] & b) != 0)
			{
				return false;
			}
			_bits[num] |= b;
			ExploredCount++;
			_revisions[num / 8192]++;
			return true;
		}

		public bool Reveal(int x, int y)
		{
			if ((uint)x >= (uint)Width)
			{
				throw new ArgumentOutOfRangeException("x");
			}
			if ((uint)y >= (uint)Height)
			{
				throw new ArgumentOutOfRangeException("y");
			}
			return Reveal(y * Width + x);
		}

		public long GetChunkRevision(int chunkIndex)
		{
			ValidateChunk(chunkIndex);
			return _revisions[chunkIndex];
		}

		public int GetChunkByteLength(int chunkIndex)
		{
			ValidateChunk(chunkIndex);
			return Math.Min(8192, _bits.Length - chunkIndex * 8192);
		}

		public byte[] CopyChunk(int chunkIndex)
		{
			byte[] array = new byte[GetChunkByteLength(chunkIndex)];
			Buffer.BlockCopy(_bits, chunkIndex * 8192, array, 0, array.Length);
			return array;
		}

		public byte[] CopyBytes()
		{
			return (byte[])_bits.Clone();
		}

		public bool MergeChunk(int chunkIndex, byte[] data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			int chunkByteLength = GetChunkByteLength(chunkIndex);
			if (data.Length != chunkByteLength)
			{
				throw new ArgumentException("Unexpected exploration chunk length.", "data");
			}
			if (chunkIndex == ChunkCount - 1 && (PixelCount & 7) != 0 && data[^1] >> (PixelCount & 7) != 0)
			{
				throw new ArgumentException("Exploration chunk contains pixels outside the map.", "data");
			}
			int num = chunkIndex * 8192;
			int num2 = 0;
			for (int i = 0; i < chunkByteLength; i++)
			{
				byte b = _bits[num + i];
				byte b2 = (byte)(data[i] & ~b);
				if (b2 != 0)
				{
					_bits[num + i] = (byte)(b | b2);
					num2 += PopCounts[b2];
				}
			}
			if (num2 == 0)
			{
				return false;
			}
			ExploredCount += num2;
			_revisions[chunkIndex]++;
			return true;
		}

		public int ImportExplored(bool[] source, ref int cursor, int pixelBudget)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			int num = ValidateScan(source.Length, cursor, pixelBudget);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				if (source[cursor] && Reveal(cursor))
				{
					num2++;
				}
				if (++cursor == PixelCount)
				{
					cursor = 0;
				}
			}
			return num2;
		}

		public int ImportExplored(BitArray source, ref int cursor, int pixelBudget)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			int num = ValidateScan(source.Length, cursor, pixelBudget);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				if (source[cursor] && Reveal(cursor))
				{
					num2++;
				}
				if (++cursor == PixelCount)
				{
					cursor = 0;
				}
			}
			return num2;
		}

		public int ApplyTo(bool[] destination, ref int cursor, int pixelBudget)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			int num = ValidateScan(destination.Length, cursor, pixelBudget);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				if (!destination[cursor] && IsExplored(cursor))
				{
					destination[cursor] = true;
					num2++;
				}
				if (++cursor == PixelCount)
				{
					cursor = 0;
				}
			}
			return num2;
		}

		public int ApplyTo(BitArray destination, ref int cursor, int pixelBudget)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			int num = ValidateScan(destination.Length, cursor, pixelBudget);
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				if (!destination[cursor] && IsExplored(cursor))
				{
					destination[cursor] = true;
					num2++;
				}
				if (++cursor == PixelCount)
				{
					cursor = 0;
				}
			}
			return num2;
		}

		public static ExplorationMap FromBytes(int width, int height, byte[] data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			ExplorationMap explorationMap = new ExplorationMap(width, height);
			if (data.Length != explorationMap.ByteLength)
			{
				throw new ArgumentException("Unexpected exploration bitmap length.", "data");
			}
			for (int i = 0; i < explorationMap.ChunkCount; i++)
			{
				byte[] array = new byte[explorationMap.GetChunkByteLength(i)];
				Buffer.BlockCopy(data, i * 8192, array, 0, array.Length);
				explorationMap.MergeChunk(i, array);
			}
			return explorationMap;
		}

		private int ValidateScan(int length, int cursor, int budget)
		{
			if (length != PixelCount)
			{
				throw new ArgumentException("Native exploration dimensions do not match this world map.");
			}
			if ((uint)cursor >= (uint)PixelCount)
			{
				throw new ArgumentOutOfRangeException("cursor");
			}
			if (budget < 0)
			{
				throw new ArgumentOutOfRangeException("budget");
			}
			return Math.Min(budget, PixelCount);
		}

		private void ValidatePixel(int index)
		{
			if ((uint)index >= (uint)PixelCount)
			{
				throw new ArgumentOutOfRangeException("index");
			}
		}

		private void ValidateChunk(int index)
		{
			if ((uint)index >= (uint)ChunkCount)
			{
				throw new ArgumentOutOfRangeException("index");
			}
		}

		private static byte[] BuildPopCounts()
		{
			byte[] array = new byte[256];
			for (int i = 1; i < array.Length; i++)
			{
				array[i] = (byte)(array[i >> 1] + (i & 1));
			}
			return array;
		}
	}
	public sealed class SharedPin
	{
		public long Id;

		public long OwnerId;

		public long Revision;

		public int Type;

		public int ColorIndex;

		public string Name = "";

		public string OwnerName = "";

		public float X;

		public float Y;

		public float Z;

		public bool Checked;

		public bool Deleted;

		public SharedPin Clone()
		{
			return (SharedPin)MemberwiseClone();
		}
	}
	public sealed class PinEdit
	{
		public long Id;

		public long ExpectedRevision;

		public int Type;

		public string Name = "";

		public float X;

		public float Y;

		public float Z;

		public bool Checked;

		public bool Deleted;
	}
	public static class SharedPinRules
	{
		public const int MaximumRecords = 4096;

		public const int MaximumOwners = 4096;

		public const int MaximumBatch = 32;

		public static bool ValidType(int type)
		{
			if (type != 0 && type != 1 && type != 2 && type != 3 && type != 4 && type != 6 && type != 9 && type != 14 && type != 15)
			{
				return type == 16;
			}
			return true;
		}

		public static bool ValidCoordinate(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Abs(value) <= 100000f;
			}
			return false;
		}

		public static string CleanName(string? value)
		{
			StringBuilder stringBuilder = new StringBuilder(48);
			string text = value ?? "";
			foreach (char c in text)
			{
				if (stringBuilder.Length == 48)
				{
					break;
				}
				if (!char.IsControl(c) && !char.IsSurrogate(c) && c != '<' && c != '>' && c != '$')
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Trim();
		}

		public static bool ValidEdit(PinEdit? edit)
		{
			if (edit != null && edit.Id > 0 && edit.ExpectedRevision >= 0 && ValidType(edit.Type) && ValidCoordinate(edit.X) && ValidCoordinate(edit.Y))
			{
				return ValidCoordinate(edit.Z);
			}
			return false;
		}

		public static bool ValidRecord(SharedPin? pin)
		{
			if (pin != null && pin.Id > 0 && pin.OwnerId != 0L && pin.Revision > 0 && pin.ColorIndex >= 0 && pin.ColorIndex < 4096 && ValidType(pin.Type) && ValidCoordinate(pin.X) && ValidCoordinate(pin.Y) && ValidCoordinate(pin.Z) && pin.Name == CleanName(pin.Name))
			{
				return pin.OwnerName == CleanName(pin.OwnerName);
			}
			return false;
		}
	}
	public sealed class SharedPinBoard
	{
		private readonly Dictionary<long, SharedPin> _records = new Dictionary<long, SharedPin>();

		private readonly Dictionary<long, int> _colors = new Dictionary<long, int>();

		public long Revision { get; private set; }

		public int Count { get; private set; }

		public IReadOnlyCollection<SharedPin> Records => new ReadOnlyCollection<SharedPin>(_records.Values.Select((SharedPin pin) => pin.Clone()).ToList());

		internal IEnumerable<KeyValuePair<long, int>> Colors => _colors;

		public int GetColorIndex(long ownerId)
		{
			if (ownerId == 0L)
			{
				throw new ArgumentOutOfRangeException("ownerId");
			}
			if (_colors.TryGetValue(ownerId, out var value))
			{
				return value;
			}
			if (_colors.Count >= 4096 || Revision == long.MaxValue)
			{
				throw new InvalidOperationException("The shared pin owner limit has been reached.");
			}
			int count = _colors.Count;
			_colors.Add(ownerId, count);
			Revision++;
			return count;
		}

		public bool TryApply(PinEdit edit, long ownerId, string ownerName, out SharedPin? current)
		{
			current = null;
			if (edit == null)
			{
				return false;
			}
			_records.TryGetValue(edit.Id, out SharedPin value);
			current = value?.Clone();
			if (ownerId == 0L || !SharedPinRules.ValidEdit(edit) || Revision == long.MaxValue)
			{
				return false;
			}
			if (value == null)
			{
				if (edit.ExpectedRevision != 0L || edit.Deleted || _records.Count >= 4096 || (!_colors.ContainsKey(ownerId) && (_colors.Count >= 4096 || Revision >= 9223372036854775806L)))
				{
					return false;
				}
				int colorIndex = GetColorIndex(ownerId);
				SharedPin sharedPin = new SharedPin
				{
					Id = edit.Id,
					OwnerId = ownerId,
					OwnerName = SharedPinRules.CleanName(ownerName),
					ColorIndex = colorIndex
				};
				CopyEdit(edit, sharedPin);
				sharedPin.Revision = ++Revision;
				_records.Add(sharedPin.Id, sharedPin);
				Count++;
				current = sharedPin.Clone();
				return true;
			}
			if (value.Deleted || edit.ExpectedRevision != value.Revision)
			{
				return false;
			}
			if (edit.Deleted)
			{
				value.Deleted = true;
				Count--;
			}
			else
			{
				string text = SharedPinRules.CleanName(edit.Name);
				if (value.Name == text && value.Type == edit.Type && value.X == edit.X && value.Y == edit.Y && value.Z == edit.Z && value.Checked == edit.Checked)
				{
					return true;
				}
				CopyEdit(edit, value);
			}
			value.Revision = ++Revision;
			current = value.Clone();
			return true;
		}

		public IReadOnlyList<SharedPin> ChangesAfter(long revision, int maximum = 32)
		{
			if (revision < 0)
			{
				throw new ArgumentOutOfRangeException("revision");
			}
			if (maximum < 1 || maximum > 32)
			{
				throw new ArgumentOutOfRangeException("maximum");
			}
			return new ReadOnlyCollection<SharedPin>((from pin in (from pin in _records.Values
					where pin.Revision > revision
					orderby pin.Revision
					select pin).Take(maximum)
				select pin.Clone()).ToList());
		}

		public SharedPinBoard Clone()
		{
			SharedPinBoard sharedPinBoard = new SharedPinBoard
			{
				Revision = Revision,
				Count = Count
			};
			foreach (KeyValuePair<long, int> color in _colors)
			{
				sharedPinBoard._colors.Add(color.Key, color.Value);
			}
			foreach (KeyValuePair<long, SharedPin> record in _records)
			{
				sharedPinBoard._records.Add(record.Key, record.Value.Clone());
			}
			return sharedPinBoard;
		}

		internal static SharedPinBoard Restore(long revision, IEnumerable<KeyValuePair<long, int>> colors, IEnumerable<SharedPin> records)
		{
			if (revision < 0)
			{
				throw new ArgumentException("Invalid board revision.");
			}
			SharedPinBoard sharedPinBoard = new SharedPinBoard
			{
				Revision = revision
			};
			HashSet<int> hashSet = new HashSet<int>();
			foreach (KeyValuePair<long, int> color in colors)
			{
				if (sharedPinBoard._colors.Count >= 4096 || color.Key == 0L || color.Value < 0 || color.Value >= 4096 || sharedPinBoard._colors.ContainsKey(color.Key) || !hashSet.Add(color.Value))
				{
					throw new ArgumentException("Invalid owner color assignment.");
				}
				sharedPinBoard._colors.Add(color.Key, color.Value);
			}
			for (int i = 0; i < hashSet.Count; i++)
			{
				if (!hashSet.Contains(i))
				{
					throw new ArgumentException("Non-consecutive owner colors.");
				}
			}
			HashSet<long> hashSet2 = new HashSet<long>();
			foreach (SharedPin record in records)
			{
				if (sharedPinBoard._records.Count >= 4096 || !SharedPinRules.ValidRecord(record) || record.Revision > revision || sharedPinBoard._records.ContainsKey(record.Id) || !hashSet2.Add(record.Revision) || !sharedPinBoard._colors.TryGetValue(record.OwnerId, out var value) || value != record.ColorIndex)
				{
					throw new ArgumentException("Invalid shared pin record.");
				}
				sharedPinBoard._records.Add(record.Id, record.Clone());
				if (!record.Deleted)
				{
					sharedPinBoard.Count++;
				}
			}
			if (revision < sharedPinBoard._colors.Count + sharedPinBoard._records.Count)
			{
				throw new ArgumentException("Board revision precedes its state.");
			}
			return sharedPinBoard;
		}

		private static void CopyEdit(PinEdit edit, SharedPin pin)
		{
			pin.Name = SharedPinRules.CleanName(edit.Name);
			pin.Type = edit.Type;
			pin.X = edit.X;
			pin.Y = edit.Y;
			pin.Z = edit.Z;
			pin.Checked = edit.Checked;
		}
	}
	public sealed class SharedPinLoadResult
	{
		public SharedPinBoard Board { get; }

		public ExplorationLoadSource Source { get; }

		public string? Warning { get; }

		public bool RecoveredFromBackup => Source == ExplorationLoadSource.Backup;

		internal SharedPinLoadResult(SharedPinBoard board, ExplorationLoadSource source, string? warning)
		{
			Board = board;
			Source = source;
			Warning = warning;
		}
	}
	public sealed class SharedPinStore
	{
		private const int FormatVersion = 1;

		private const int MaximumBytes = 2097152;

		private static readonly byte[] Magic = Encoding.ASCII.GetBytes("RBPINS01");

		private static readonly UTF8Encoding Utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private readonly string _directory;

		public SharedPinStore(string directory)
		{
			if (string.IsNullOrWhiteSpace(directory))
			{
				throw new ArgumentException("A save directory is required.", "directory");
			}
			_directory = Path.GetFullPath(directory);
		}

		public string GetPath(long worldId)
		{
			return Path.Combine(_directory, "world-" + worldId.ToString("X16", CultureInfo.InvariantCulture) + ".rbpins");
		}

		public SharedPinLoadResult Load(long worldId)
		{
			string path = GetPath(worldId);
			if (TryRead(path, worldId, out SharedPinBoard board, out string error))
			{
				return new SharedPinLoadResult(board, ExplorationLoadSource.Primary, null);
			}
			if (TryRead(path + ".bak", worldId, out board, out string error2))
			{
				return new SharedPinLoadResult(board, ExplorationLoadSource.Backup, "Recovered shared pins from backup. " + (error ?? "Primary snapshot was missing."));
			}
			return new SharedPinLoadResult(new SharedPinBoard(), ExplorationLoadSource.Empty, (error == null && error2 == null) ? null : ("Shared pin storage could not be loaded; existing files must be preserved. " + error + " " + error2));
		}

		public void Save(long worldId, SharedPinBoard board)
		{
			if (board == null)
			{
				throw new ArgumentNullException("board");
			}
			Directory.CreateDirectory(_directory);
			string path = GetPath(worldId);
			string text = path + ".bak";
			bool flag = File.Exists(path);
			bool flag2 = File.Exists(text);
			SharedPinBoard board2;
			string error;
			bool flag3 = TryRead(path, worldId, out board2, out error);
			if (!flag3 && (flag || flag2) && !TryRead(text, worldId, out board2, out error))
			{
				throw new InvalidDataException("Existing shared pin snapshots cannot be verified; refusing to overwrite them.");
			}
			byte[] array = Encode(worldId, board);
			string text2 = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
			try
			{
				using (FileStream fileStream = new FileStream(text2, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(array, 0, array.Length);
					fileStream.Flush(flushToDisk: true);
				}
				if (flag)
				{
					File.Replace(text2, path, flag3 ? text : null, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text2, path);
				}
			}
			finally
			{
				if (File.Exists(text2))
				{
					File.Delete(text2);
				}
			}
		}

		private static byte[] Encode(long worldId, SharedPinBoard board)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Utf8, leaveOpen: true))
			{
				binaryWriter.Write(Magic);
				binaryWriter.Write(1);
				binaryWriter.Write(worldId);
				binaryWriter.Write(board.Revision);
				KeyValuePair<long, int>[] array = board.Colors.OrderBy((KeyValuePair<long, int> pair) => pair.Value).ToArray();
				binaryWriter.Write(array.Length);
				KeyValuePair<long, int>[] array2 = array;
				for (int num = 0; num < array2.Length; num++)
				{
					KeyValuePair<long, int> keyValuePair = array2[num];
					binaryWriter.Write(keyValuePair.Key);
					binaryWriter.Write(keyValuePair.Value);
				}
				SharedPin[] array3 = board.Records.OrderBy((SharedPin pin) => pin.Id).ToArray();
				binaryWriter.Write(array3.Length);
				SharedPin[] array4 = array3;
				foreach (SharedPin sharedPin in array4)
				{
					binaryWriter.Write(sharedPin.Id);
					binaryWriter.Write(sharedPin.OwnerId);
					binaryWriter.Write(sharedPin.Revision);
					binaryWriter.Write(sharedPin.Type);
					binaryWriter.Write(sharedPin.ColorIndex);
					WriteName(binaryWriter, sharedPin.Name);
					WriteName(binaryWriter, sharedPin.OwnerName);
					binaryWriter.Write(sharedPin.X);
					binaryWriter.Write(sharedPin.Y);
					binaryWriter.Write(sharedPin.Z);
					binaryWriter.Write(sharedPin.Checked);
					binaryWriter.Write(sharedPin.Deleted);
				}
				binaryWriter.Flush();
			}
			using (SHA256 sHA = SHA256.Create())
			{
				byte[] array5 = sHA.ComputeHash(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
				memoryStream.Write(array5, 0, array5.Length);
			}
			return memoryStream.ToArray();
		}

		private static void WriteName(BinaryWriter writer, string value)
		{
			byte[] bytes = Utf8.GetBytes(value);
			writer.Write((ushort)bytes.Length);
			writer.Write(bytes);
		}

		private static string ReadName(BinaryReader reader)
		{
			int num = reader.ReadUInt16();
			if (num > 144)
			{
				throw new InvalidDataException("Pin name exceeds its limit.");
			}
			byte[] array = reader.ReadBytes(num);
			if (array.Length != num)
			{
				throw new EndOfStreamException();
			}
			string text = Utf8.GetString(array);
			if (text != SharedPinRules.CleanName(text))
			{
				throw new InvalidDataException("Invalid pin name.");
			}
			return text;
		}

		private static bool ReadBool(BinaryReader reader)
		{
			byte num = reader.ReadByte();
			if (num > 1)
			{
				throw new InvalidDataException("Invalid boolean.");
			}
			return num == 1;
		}

		private static bool TryRead(string path, long worldId, out SharedPinBoard? board, out string? error)
		{
			board = null;
			error = null;
			try
			{
				if (!File.Exists(path))
				{
					return false;
				}
				byte[] array;
				using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
				{
					if (fileStream.Length < 68 || fileStream.Length > 2097152)
					{
						throw new InvalidDataException("Invalid pin snapshot length.");
					}
					array = new byte[(int)fileStream.Length];
					int num;
					for (int i = 0; i < array.Length; i += num)
					{
						num = fileStream.Read(array, i, array.Length - i);
						if (num == 0)
						{
							throw new EndOfStreamException();
						}
					}
				}
				using (SHA256 sHA = SHA256.Create())
				{
					byte[] array2 = sHA.ComputeHash(array, 0, array.Length - 32);
					int num2 = 0;
					for (int j = 0; j < 32; j++)
					{
						num2 |= array2[j] ^ array[array.Length - 32 + j];
					}
					if (num2 != 0)
					{
						throw new InvalidDataException("Pin snapshot checksum does not match.");
					}
				}
				using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(array, 0, array.Length - 32, writable: false), Utf8, leaveOpen: false))
				{
					byte[] magic = Magic;
					foreach (byte b in magic)
					{
						if (binaryReader.ReadByte() != b)
						{
							throw new InvalidDataException("Unknown pin snapshot signature.");
						}
					}
					if (binaryReader.ReadInt32() != 1)
					{
						throw new InvalidDataException("Unsupported pin snapshot version.");
					}
					if (binaryReader.ReadInt64() != worldId)
					{
						throw new InvalidDataException("Pin snapshot belongs to another world.");
					}
					long revision = binaryReader.ReadInt64();
					int num3 = binaryReader.ReadInt32();
					if (num3 < 0 || num3 > 4096)
					{
						throw new InvalidDataException("Invalid pin owner count.");
					}
					List<KeyValuePair<long, int>> list = new List<KeyValuePair<long, int>>(num3);
					for (int l = 0; l < num3; l++)
					{
						list.Add(new KeyValuePair<long, int>(binaryReader.ReadInt64(), binaryReader.ReadInt32()));
					}
					int num4 = binaryReader.ReadInt32();
					if (num4 < 0 || num4 > 4096)
					{
						throw new InvalidDataException("Invalid pin count.");
					}
					List<SharedPin> list2 = new List<SharedPin>(num4);
					for (int m = 0; m < num4; m++)
					{
						list2.Add(new SharedPin
						{
							Id = binaryReader.ReadInt64(),
							OwnerId = binaryReader.ReadInt64(),
							Revision = binaryReader.ReadInt64(),
							Type = binaryReader.ReadInt32(),
							ColorIndex = binaryReader.ReadInt32(),
							Name = ReadName(binaryReader),
							OwnerName = ReadName(binaryReader),
							X = binaryReader.ReadSingle(),
							Y = binaryReader.ReadSingle(),
							Z = binaryReader.ReadSingle(),
							Checked = ReadBool(binaryReader),
							Deleted = ReadBool(binaryReader)
						});
					}
					if (binaryReader.BaseStream.Position != binaryReader.BaseStream.Length)
					{
						throw new InvalidDataException("Trailing pin snapshot data.");
					}
					board = SharedPinBoard.Restore(revision, list, list2);
				}
				return true;
			}
			catch (Exception ex) when (ex is InvalidDataException || ex is IOException || ex is UnauthorizedAccessException || ex is ArgumentException)
			{
				error = Path.GetFileName(path) + ": " + ex.Message;
				return false;
			}
		}
	}
	public enum ExplorationLoadSource
	{
		Empty,
		Primary,
		Backup
	}
	public sealed class ExplorationLoadResult
	{
		public ExplorationMap Map { get; }

		public ExplorationLoadSource Source { get; }

		public bool RecoveredFromBackup => Source == ExplorationLoadSource.Backup;

		public string? Warning { get; }

		internal ExplorationLoadResult(ExplorationMap map, ExplorationLoadSource source, string? warning)
		{
			Map = map;
			Source = source;
			Warning = warning;
		}
	}
	public sealed class WorldExplorationStore
	{
		private const int FormatVersion = 1;

		private const int HeaderBytes = 32;

		private const int HashBytes = 32;

		private static readonly byte[] Magic = Encoding.ASCII.GetBytes("RAVENBND");

		private readonly string _directory;

		public WorldExplorationStore(string directory)
		{
			if (string.IsNullOrWhiteSpace(directory))
			{
				throw new ArgumentException("A save directory is required.", "directory");
			}
			_directory = Path.GetFullPath(directory);
		}

		public string GetPath(long worldId)
		{
			return Path.Combine(_directory, "world-" + worldId.ToString("X16", CultureInfo.InvariantCulture) + ".rbmap");
		}

		public ExplorationLoadResult Load(long worldId, int width = 2048, int height = 2048)
		{
			ExplorationMap map = new ExplorationMap(width, height);
			string path = GetPath(worldId);
			if (TryRead(path, worldId, width, height, out ExplorationMap map2, out string error))
			{
				return new ExplorationLoadResult(map2, ExplorationLoadSource.Primary, null);
			}
			if (TryRead(path + ".bak", worldId, width, height, out ExplorationMap map3, out string error2))
			{
				return new ExplorationLoadResult(map3, ExplorationLoadSource.Backup, "Recovered shared exploration from backup. " + (error ?? "Primary snapshot was missing."));
			}
			string warning = ((error == null && error2 == null) ? null : ("Shared exploration could not be loaded; native player exploration is unaffected. " + error + " " + error2));
			return new ExplorationLoadResult(map, ExplorationLoadSource.Empty, warning);
		}

		public void Save(long worldId, ExplorationMap map)
		{
			if (map == null)
			{
				throw new ArgumentNullException("map");
			}
			Directory.CreateDirectory(_directory);
			string path = GetPath(worldId);
			string text = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
			byte[] array = Encode(worldId, map);
			try
			{
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(array, 0, array.Length);
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(path))
				{
					ExplorationMap map2;
					string error;
					bool flag = TryRead(path, worldId, map.Width, map.Height, out map2, out error);
					File.Replace(text, path, flag ? (path + ".bak") : null, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text, path);
				}
			}
			finally
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
		}

		private static byte[] Encode(long worldId, ExplorationMap map)
		{
			byte[] array = map.CopyBytes();
			using MemoryStream memoryStream = new MemoryStream(32 + array.Length + 32);
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true))
			{
				binaryWriter.Write(Magic);
				binaryWriter.Write(1);
				binaryWriter.Write(worldId);
				binaryWriter.Write(map.Width);
				binaryWriter.Write(map.Height);
				binaryWriter.Write(array.Length);
				binaryWriter.Write(array);
				binaryWriter.Flush();
			}
			using (SHA256 sHA = SHA256.Create())
			{
				byte[] array2 = sHA.ComputeHash(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
				memoryStream.Write(array2, 0, array2.Length);
			}
			return memoryStream.ToArray();
		}

		private static bool TryRead(string path, long worldId, int width, int height, out ExplorationMap? map, out string? error)
		{
			map = null;
			error = null;
			try
			{
				if (!File.Exists(path))
				{
					return false;
				}
				int num = checked(width * height + 7) / 8;
				byte[] array;
				using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
				{
					if (fileStream.Length != 32 + num + 32)
					{
						throw new InvalidDataException("Snapshot length or map dimensions do not match.");
					}
					array = new byte[(int)fileStream.Length];
					int num2;
					for (int i = 0; i < array.Length; i += num2)
					{
						num2 = fileStream.Read(array, i, array.Length - i);
						if (num2 == 0)
						{
							throw new EndOfStreamException("Snapshot was truncated.");
						}
					}
				}
				using (SHA256 sHA = SHA256.Create())
				{
					byte[] array2 = sHA.ComputeHash(array, 0, array.Length - 32);
					int num3 = 0;
					for (int j = 0; j < 32; j++)
					{
						num3 |= array2[j] ^ array[array.Length - 32 + j];
					}
					if (num3 != 0)
					{
						throw new InvalidDataException("Snapshot checksum does not match.");
					}
				}
				using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(array, writable: false), Encoding.UTF8, leaveOpen: false))
				{
					for (int k = 0; k < Magic.Length; k++)
					{
						if (binaryReader.ReadByte() != Magic[k])
						{
							throw new InvalidDataException("Unknown snapshot signature.");
						}
					}
					if (binaryReader.ReadInt32() != 1)
					{
						throw new InvalidDataException("Unsupported snapshot version.");
					}
					if (binaryReader.ReadInt64() != worldId)
					{
						throw new InvalidDataException("Snapshot belongs to a different world.");
					}
					if (binaryReader.ReadInt32() != width || binaryReader.ReadInt32() != height)
					{
						throw new InvalidDataException("Snapshot map dimensions do not match.");
					}
					if (binaryReader.ReadInt32() != num)
					{
						throw new InvalidDataException("Snapshot bitmap length does not match.");
					}
					map = ExplorationMap.FromBytes(width, height, binaryReader.ReadBytes(num));
				}
				return true;
			}
			catch (Exception ex) when (ex is InvalidDataException || ex is IOException || ex is UnauthorizedAccessException || ex is ArgumentException)
			{
				error = Path.GetFileName(path) + ": " + ex.Message;
				return false;
			}
		}
	}
}