using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ChainedPuzzles;
using CustomCheckpoints.Data;
using CustomCheckpoints.Extensions;
using CustomCheckpoints.Manager;
using CustomCheckpoints.Utility;
using GTFO.API;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Members;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.FeaturesAPI.Components;
using TheArchive.Core.FeaturesAPI.Settings;
using TheArchive.Core.Localization;
using TheArchive.Interfaces;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("CustomCheckpoints")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0")]
[assembly: AssemblyInformationalVersion("0.1.0+40b602f6c0481751f0013ffe2d085d8eba8bb77a")]
[assembly: AssemblyProduct("CustomCheckpoints")]
[assembly: AssemblyTitle("CustomCheckpoints")]
[assembly: AssemblyVersion("0.1.0.0")]
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;
		}
	}
}
namespace CustomCheckpoints
{
	[BepInPlugin("dev.mbooster.CustomCheckpoints", "CustomCheckpoints", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class CustomCheckpoints : BasePlugin
	{
		public const string ModName = "CustomCheckpoints";

		public const string Author = "mbooster";

		public const string Guid = "dev.mbooster.CustomCheckpoints";

		public const string Version = "0.1.0";

		public override void Load()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GameDataAPI.OnGameDataInitialized += CheckpointConfigManager.ValidateConfig;
			new Harmony("dev.mbooster.CustomCheckpoints").PatchAll();
			LevelAPI.OnBuildStart += Execute;
		}

		private void Execute()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				CheckpointConfigManager.ValidateConfig();
				int num = CustomCheckpointManager.ReplaceDoorsForLevel(RundownDataManager.GetDoorData(CheckpointConfigManager.GetConfig()));
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(19, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Added ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" checkpoints.");
				}
				Log.Logger.LogInfo(val);
			}
			catch (Exception ex)
			{
				ManualLogSource log = ((BasePlugin)this).Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(40, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Error occurred during door replacement: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log.LogError(val2);
			}
		}
	}
	[ArchiveModule("dev.mbooster.CustomCheckpoints", "CustomCheckpoints", "0.1.0")]
	public class CustomCheckpointsArchiveModule : IArchiveModule
	{
		public ILocalizationService LocalizationService { get; set; }

		public IArchiveLogger Logger { get; set; }

		public void Init()
		{
		}
	}
	[GeneratedCode("VersionInfoGenerator", "2.0.0+git50a4b1a-master")]
	[CompilerGenerated]
	internal static class VersionInfo
	{
		public const string RootNamespace = "CustomCheckpoints";

		public const string Version = "0.1.0";

		public const string VersionPrerelease = null;

		public const string VersionMetadata = "git40b602f-dirty-master";

		public const string SemVer = "0.1.0";

		public const string GitRevShort = "40b602f-dirty";

		public const string GitRevLong = "40b602f6c0481751f0013ffe2d085d8eba8bb77a-dirty";

		public const string GitBranch = "master";

		public const string GitTag = null;

		public const bool GitIsDirty = true;
	}
}
namespace CustomCheckpoints.Utility
{
	public class JsonSerializer
	{
		private readonly JsonSerializerOptions _options = new JsonSerializerOptions
		{
			AllowTrailingCommas = true,
			IncludeFields = true,
			PropertyNameCaseInsensitive = true,
			ReadCommentHandling = JsonCommentHandling.Skip,
			WriteIndented = true
		};

		public JsonSerializer()
		{
			_options.Converters.Add(new JsonStringEnumConverter());
		}

		public T Read<T>(string path) where T : new()
		{
			string json = File.ReadAllText(path);
			T val = Deserialize<T>(json);
			if (val == null)
			{
				throw new JsonException("Deserialization returned null.");
			}
			return val;
		}

		public void Write(string path, string json)
		{
			File.WriteAllText(path, json);
		}

		public string Serialize(object value)
		{
			return System.Text.Json.JsonSerializer.Serialize(value, _options);
		}

		public T? Deserialize<T>(string json)
		{
			return System.Text.Json.JsonSerializer.Deserialize<T>(json, _options);
		}
	}
	public static class Log
	{
		public static readonly ManualLogSource Logger = Logger.CreateLogSource("CustomCheckpoints");

		public static void LogObject(object? obj, string prefix = "", int depth = 0)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if (depth > 3 || obj == null)
			{
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(8, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(prefix);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is NULL");
				}
				Logger.LogInfo(val);
				return;
			}
			Type type = obj.GetType();
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			foreach (PropertyInfo propertyInfo in properties)
			{
				try
				{
					object value = propertyInfo.GetValue(obj);
					LogValue(propertyInfo.Name, value, propertyInfo.PropertyType, prefix, depth);
				}
				catch
				{
				}
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				try
				{
					object value2 = fieldInfo.GetValue(obj);
					LogValue(fieldInfo.Name, value2, fieldInfo.FieldType, prefix, depth);
				}
				catch
				{
				}
			}
		}

		private static void LogValue(string name, object? value, Type type, string prefix, int depth)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			if (type == typeof(IntPtr) || type == typeof(UIntPtr))
			{
				return;
			}
			string? text = type.Namespace;
			if ((text != null && text.StartsWith("Il2CppInterop")) || type.Name.Contains("Il2CppMethodInfo"))
			{
				return;
			}
			string text2 = prefix + name;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val;
			if (value == null)
			{
				val = new BepInExInfoLogInterpolatedStringHandler(7, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" = NULL");
				}
				Logger.LogInfo(val);
				return;
			}
			if (type.IsPrimitive || type == typeof(string) || type.IsEnum)
			{
				val = new BepInExInfoLogInterpolatedStringHandler(3, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" = ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<object>(value);
				}
				Logger.LogInfo(val);
				return;
			}
			string? text3 = type.Namespace;
			if (text3 != null && text3.StartsWith("UnityEngine"))
			{
				val = new BepInExInfoLogInterpolatedStringHandler(3, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" = ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<object>(value);
				}
				Logger.LogInfo(val);
				return;
			}
			val = new BepInExInfoLogInterpolatedStringHandler(4, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(type.Name);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("):");
			}
			Logger.LogInfo(val);
			LogObject(value, text2 + ".", depth + 1);
		}
	}
}
namespace CustomCheckpoints.Patches
{
	[HarmonyPatch(typeof(ChainedPuzzleManager), "CreatePuzzleInstance", new Type[]
	{
		typeof(ChainedPuzzleDataBlock),
		typeof(LG_Area),
		typeof(Vector3),
		typeof(Transform)
	})]
	public static class CreatePuzzleInstancePatch
	{
		public static void Prefix(ref ChainedPuzzleDataBlock data, LG_Area sourceArea)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			if (data == null)
			{
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("CreatePuzzleInstance: null datablock for ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>((sourceArea != null) ? ((Object)sourceArea).name : null);
				}
				Log.Logger.LogWarning(val);
				data = GetCheckpointScanReplacement();
			}
		}

		private static ChainedPuzzleDataBlock GetCheckpointScanReplacement()
		{
			return ((IEnumerable<ChainedPuzzleDataBlock>)GameDataBlockBase<ChainedPuzzleDataBlock>.GetAllBlocks()).FirstOrDefault((Func<ChainedPuzzleDataBlock, bool>)((ChainedPuzzleDataBlock b) => ((GameDataBlockBase<ChainedPuzzleDataBlock>)(object)b).name.ToLower().Contains("checkpoint"))) ?? CreateCheckpointBlock();
		}

		private static ChainedPuzzleDataBlock CreateCheckpointBlock()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00ec: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			Il2CppArrayBase<ChainedPuzzleDataBlock> allBlocks = GameDataBlockBase<ChainedPuzzleDataBlock>.GetAllBlocks();
			int count = allBlocks.Count;
			uint num = 0u;
			for (int i = 0; i < count; i++)
			{
				if (((GameDataBlockBase<ChainedPuzzleDataBlock>)(object)allBlocks[i]).persistentID > num)
				{
					num = ((GameDataBlockBase<ChainedPuzzleDataBlock>)(object)allBlocks[i]).persistentID;
				}
			}
			ChainedPuzzleComponent val = new ChainedPuzzleComponent
			{
				PuzzleType = 19u
			};
			List<ChainedPuzzleComponent> val2 = new List<ChainedPuzzleComponent>();
			val2.Add(val);
			ChainedPuzzleDataBlock val3 = new ChainedPuzzleDataBlock
			{
				PublicAlarmName = "Alarm",
				TriggerAlarmOnActivate = false,
				SurvivalWaveSettings = 1u,
				SurvivalWavePopulation = 1u,
				SurvivalWaveAreaDistance = 2,
				DisableSurvivalWaveOnComplete = true,
				UseRandomPositions = false,
				WantedDistanceFromStartPos = 0f,
				WantedDistanceBetweenPuzzleComponents = 1f,
				ChainedPuzzle = val2,
				OnlyShowHUDWhenPlayerIsClose = false,
				AlarmSoundStart = 3339129407u,
				AlarmSoundStop = 42633153u
			};
			((GameDataBlockBase<ChainedPuzzleDataBlock>)val3).name = "Checkpoint";
			((GameDataBlockBase<ChainedPuzzleDataBlock>)val3).internalEnabled = true;
			((GameDataBlockBase<ChainedPuzzleDataBlock>)val3).persistentID = num + 1;
			ChainedPuzzleDataBlock val4 = val3;
			GameDataBlockBase<ChainedPuzzleDataBlock>.AddBlock(val4, -1);
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val5 = new BepInExInfoLogInterpolatedStringHandler(39, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("Injected checkpoint scan block with ID ");
				((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<uint>(((GameDataBlockBase<ChainedPuzzleDataBlock>)(object)val4).persistentID);
			}
			Log.Logger.LogInfo(val5);
			return val4;
		}
	}
}
namespace CustomCheckpoints.Manager
{
	public static class CheckpointConfigManager
	{
		private static readonly global::CustomCheckpoints.Utility.JsonSerializer Serializer = new global::CustomCheckpoints.Utility.JsonSerializer();

		private const string CheckpointsConfigFileName = "CustomCheckpoints.doors.json";

		private static byte[]? _configHash;

		private static List<RundownData>? _config;

		public static List<RundownData>? GetConfig()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				if (_config != null && _configHash == GetConfigHash())
				{
					return _config.GetSorted();
				}
				string configFilepath = GetConfigFilepath();
				List<RundownData> list = Serializer.Read<List<RundownData>>(configFilepath);
				CacheConfig(list);
				return list.GetSorted();
			}
			catch (Exception ex) when (((ex is DirectoryNotFoundException || ex is FileNotFoundException) ? 1 : 0) != 0)
			{
				return null;
			}
			catch (JsonException ex2)
			{
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("CustomCheckpoints.doors.json");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" configuration is invalid. See exception for details: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
				}
				Log.Logger.LogWarning(val);
				return new List<RundownData>();
			}
			catch (Exception ex3)
			{
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Unexpected error occured: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex3.Message);
				}
				Log.Logger.LogError(val2);
				throw;
			}
		}

		public static void ValidateConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			List<RundownData> config = GetConfig();
			if (config == null)
			{
				Log.Logger.LogInfo((object)"No existing configuration detected, creating new checkpoint configuration...");
				SaveConfig(RundownDataManager.RetrieveData());
				return;
			}
			bool flag = default(bool);
			if (config.Count == 0)
			{
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(80, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Config exists, but no door data was found, resetting checkpoint configuration...");
				}
				Log.Logger.LogWarning(val);
				ResetConfig();
			}
			if (HasReadonlyDataChanged(config))
			{
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(69, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Readonly data has been changed, resetting checkpoint configuration...");
				}
				Log.Logger.LogWarning(val);
				ResetConfig();
			}
		}

		public static void SaveConfig(List<RundownData> rundowns)
		{
			string json = Serializer.Serialize(rundowns);
			string configFilepath = GetConfigFilepath();
			Serializer.Write(configFilepath, json);
			CacheConfig(rundowns);
		}

		private static bool HasReadonlyDataChanged(List<RundownData> config)
		{
			List<RundownData> sorted = RundownDataManager.OriginalData.GetSorted();
			return !config.SequenceEqual(sorted);
		}

		private static string GetConfigFilepath()
		{
			return Path.Combine(Paths.ConfigPath, "CustomCheckpoints.doors.json");
		}

		private static void ResetConfig()
		{
			SaveConfig(TryRestoreConfig(_config, RundownDataManager.OriginalData, out List<RundownData> rundowns) ? rundowns : RundownDataManager.OriginalData);
		}

		private static bool TryRestoreConfig(List<RundownData>? configToRestore, List<RundownData> newConfig, out List<RundownData> rundowns)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			rundowns = newConfig;
			if (configToRestore == null || configToRestore.Count == 0)
			{
				return false;
			}
			int num = 0;
			int num2 = 0;
			foreach (RundownData rundown in newConfig)
			{
				RundownData rundownData = configToRestore.FirstOrDefault((RundownData r) => r.Id == rundown.Id);
				if (rundownData == null)
				{
					continue;
				}
				foreach (ExpeditionData expedition in rundown.Expeditions)
				{
					ExpeditionData expeditionData = rundownData.Expeditions.FirstOrDefault((ExpeditionData e) => e.Id == expedition.Id);
					if (expeditionData == null)
					{
						continue;
					}
					foreach (SecurityDoorData door in expedition.Doors)
					{
						num2++;
						SecurityDoorData securityDoorData = expeditionData.Doors.FirstOrDefault((SecurityDoorData d) => d.Id == door.Id);
						if (securityDoorData != null)
						{
							door.IsCheckpoint = securityDoorData.IsCheckpoint;
							num++;
						}
					}
				}
			}
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(34, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Restored ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num2);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" door checkpoint states.");
			}
			Log.Logger.LogInfo(val);
			return num > 0;
		}

		private static void CacheConfig(List<RundownData> config)
		{
			_configHash = GetConfigHash();
			_config = config;
		}

		private static byte[] GetConfigHash()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			try
			{
				string configFilepath = GetConfigFilepath();
				using MD5 mD = MD5.Create();
				using FileStream inputStream = File.OpenRead(configFilepath);
				return mD.ComputeHash(inputStream);
			}
			catch (Exception ex)
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unexpected error occured: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				Log.Logger.LogError(val);
				throw;
			}
		}
	}
	public static class CustomCheckpointManager
	{
		public static int ReplaceDoorsForLevel(Dictionary<string, List<SecurityDoorData>> doorData)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			int num = 0;
			ExpeditionInTierData activeExpedition = RundownManager.ActiveExpedition;
			string key = activeExpedition.LevelLayoutData.GetHashCode().ToString();
			doorData.TryGetValue(key, out List<SecurityDoorData> value);
			if (value == null || value.Count == 0)
			{
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(50, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No door data could be found for the current level.");
				}
				Log.Logger.LogWarning(val);
				return 0;
			}
			num += ReplaceDoors(activeExpedition.LevelLayoutData, value, Layer.Main);
			if (activeExpedition.SecondaryLayerEnabled)
			{
				num += ReplaceDoors(activeExpedition.SecondaryLayout, value, Layer.Secondary);
			}
			if (activeExpedition.ThirdLayerEnabled)
			{
				num += ReplaceDoors(activeExpedition.ThirdLayout, value, Layer.Third);
			}
			return num;
		}

		private static int ReplaceDoors(uint layoutId, List<SecurityDoorData> doors, Layer layer)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			int num = 0;
			LevelLayoutDataBlock block = GameDataBlockBase<LevelLayoutDataBlock>.GetBlock(layoutId);
			if (block == null)
			{
				return 0;
			}
			List<ExpeditionZoneData> zones = block.Zones;
			Il2CppArrayBase<ExpeditionZoneData> items = zones._items;
			int size = zones._size;
			bool flag = default(bool);
			for (int i = 0; i < size; i++)
			{
				ExpeditionZoneData val = items[i];
				string doorId = val.GetDoorId(layer);
				if (val.ChainedPuzzleToEnter == 0)
				{
					continue;
				}
				SecurityDoorData securityDoorData = doors.FirstOrDefault((SecurityDoorData d) => d.Id == doorId);
				if (securityDoorData == null)
				{
					continue;
				}
				if (securityDoorData.IsCheckpoint)
				{
					BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(23, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Adding a checkpoint to ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(securityDoorData.Name);
					}
					Log.Logger.LogInfo(val2);
					num++;
				}
				val.IsCheckpointDoor = securityDoorData.IsCheckpoint;
				items[i] = val;
			}
			return num;
		}
	}
	public static class RundownDataManager
	{
		public static readonly List<RundownData> OriginalData = RetrieveData();

		public static List<RundownData> RetrieveData()
		{
			List<RundownData> list = new List<RundownData>();
			Il2CppArrayBase<RundownDataBlock> allBlocks = GameDataBlockBase<RundownDataBlock>.GetAllBlocks();
			int count = allBlocks.Count;
			for (int i = 0; i < count; i++)
			{
				RundownDataBlock obj = allBlocks[i];
				List<ExpeditionData> list2 = new List<ExpeditionData>();
				uint persistentID = ((GameDataBlockBase<RundownDataBlock>)(object)obj).persistentID;
				string name = ((GameDataBlockBase<RundownDataBlock>)(object)obj).name;
				List<ExpeditionInTierData>[] tiers = obj.GetTiers();
				foreach (List<ExpeditionInTierData> val in tiers)
				{
					if (val == null)
					{
						continue;
					}
					Il2CppArrayBase<ExpeditionInTierData> items = val._items;
					int size = val._size;
					for (int k = 0; k < size; k++)
					{
						ExpeditionInTierData val2 = items[k];
						if (val2 != null && val2.Enabled)
						{
							List<SecurityDoorData> list3 = new List<SecurityDoorData>();
							string expeditionId = val2.GetExpeditionId(k);
							AddAllDoorsFromLayoutId(val2.LevelLayoutData, Layer.Main, list3);
							if (val2.SecondaryLayerEnabled)
							{
								AddAllDoorsFromLayoutId(val2.SecondaryLayout, Layer.Secondary, list3);
							}
							if (val2.ThirdLayerEnabled)
							{
								AddAllDoorsFromLayoutId(val2.ThirdLayout, Layer.Third, list3);
							}
							if (list3.Count != 0)
							{
								ExpeditionData item = new ExpeditionData(expeditionId, val2.LevelLayoutData, list3);
								list2.Add(item);
							}
						}
					}
				}
				if (list2.Count != 0)
				{
					RundownData item2 = new RundownData(persistentID, name, list2);
					list.Add(item2);
				}
			}
			return list;
		}

		public static Dictionary<string, List<SecurityDoorData>> GetDoorData(List<RundownData> config)
		{
			return (from d in config.SelectMany((RundownData r) => r.Expeditions)
				where d.Doors.Count > 0
				select d).ToDictionary((ExpeditionData e) => e.LayoutId.GetHashCode().ToString(), (ExpeditionData e) => e.Doors);
		}

		private static void AddAllDoorsFromLayoutId(uint layoutId, Layer layer, List<SecurityDoorData> doors)
		{
			LevelLayoutDataBlock block = GameDataBlockBase<LevelLayoutDataBlock>.GetBlock(layoutId);
			if (block != null)
			{
				int zoneAliasStart = block.ZoneAliasStart;
				AddDoorsFromLayout(block, layer, doors, zoneAliasStart);
			}
		}

		private static void AddDoorsFromLayout(LevelLayoutDataBlock layout, Layer layer, List<SecurityDoorData> doors, int startAlias)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected I4, but got Unknown
			Il2CppArrayBase<ExpeditionZoneData> items = layout.Zones._items;
			int size = layout.Zones._size;
			for (int i = 0; i < size; i++)
			{
				ExpeditionZoneData val = items[i];
				if ((int)val.LocalIndex != 0)
				{
					string doorId = val.GetDoorId(layer);
					string text = $"Door to zone {startAlias + val.LocalIndex}";
					string value = ((val.ChainedPuzzleToEnter == 0) ? "no alarm" : (((GameDataBlockBase<ChainedPuzzleDataBlock>)(object)GameDataBlockBase<ChainedPuzzleDataBlock>.GetBlock(val.ChainedPuzzleToEnter))?.name ?? "unknown alarm"));
					string description = $"{text} ({layer}) — {value}";
					SecurityDoorData item = new SecurityDoorData(doorId, text, description, val.IsCheckpointDoor);
					doors.Add(item);
				}
			}
		}
	}
}
namespace CustomCheckpoints.Features
{
	[EnableFeatureByDefault]
	[DoNotSaveToConfig]
	public class CustomCheckpointMenu : Feature
	{
		public override string Name => "Custom Checkpoints";

		public override string Description => "Configure which security doors are converted into checkpoints.";

		public override FeatureGroup Group => FeatureGroups.GetOrCreateTopLevelGroup("Custom Checkpoints", (GroupLocalization)null);

		[FeatureConfig]
		public static MenuSettings Settings { get; set; } = new MenuSettings();

		public override void OnGameDataInitialized()
		{
			RebuildMenuData();
		}

		private static void RebuildMenuData()
		{
			CheckpointConfigManager.ValidateConfig();
			List<RundownData> config = CheckpointConfigManager.GetConfig();
			if (config != null)
			{
				Settings.Rebuild(config);
			}
		}

		public override void OnFeatureSettingChanged(FeatureSetting setting)
		{
			foreach (FeatureSettingsHelper settingsHelper in ((Feature)this).SettingsHelpers)
			{
				((object)settingsHelper).GetType().GetProperty("IsDirty")?.SetValue(settingsHelper, false);
			}
		}
	}
	public class DoorMenuItem
	{
		private SecurityDoorData? _door;

		private List<RundownData>? _config;

		private bool _isCheckpoint;

		public FLabel Door { get; set; } = new FLabel();

		public FLabel Description { get; set; } = new FLabel();

		[FSDescription("Set this to 'On' if it should be a checkpoint.")]
		public bool Checkpoint
		{
			get
			{
				return _door?.IsCheckpoint ?? _isCheckpoint;
			}
			set
			{
				_isCheckpoint = value;
				if (_door != null && _door.IsCheckpoint != value)
				{
					_door.IsCheckpoint = value;
					if (_config != null)
					{
						CheckpointConfigManager.SaveConfig(_config);
					}
				}
			}
		}

		public DoorMenuItem()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown


		public DoorMenuItem(SecurityDoorData door, List<RundownData> config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			_door = door;
			_config = config;
			_isCheckpoint = door.IsCheckpoint;
			Door = new FLabel("<color=red>" + door.Name + "</color>", (string)null);
			Description = new FLabel("<color=yellow>" + door.Description + "</color>", (string)null);
		}
	}
	public class ExpeditionMenuItem
	{
		public FLabel Expedition { get; set; } = new FLabel();

		[FSDisplayName("Security Doors")]
		public List<DoorMenuItem> Doors { get; set; } = new List<DoorMenuItem>();

		public ExpeditionMenuItem()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown


		public ExpeditionMenuItem(ExpeditionData expedition, List<RundownData> config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			Expedition = new FLabel("<color=red>" + expedition.Id + "</color>", (string)null);
			Doors = expedition.Doors.Select((SecurityDoorData door) => new DoorMenuItem(door, config)).ToList();
		}
	}
	public class MenuSettings
	{
		[FSDisplayName("Rundowns")]
		[FSDescription("Choose checkpoint doors by rundown, expedition, and security door.")]
		public List<RundownMenuItem> Rundowns { get; set; } = new List<RundownMenuItem>();

		public void Rebuild(List<RundownData> config)
		{
			Rundowns = config.Select((RundownData rundown) => new RundownMenuItem(rundown, config)).ToList();
		}
	}
	public class RundownMenuItem
	{
		public FLabel Rundown { get; set; } = new FLabel();

		[FSDisplayName("Expeditions")]
		public List<ExpeditionMenuItem> Expeditions { get; set; } = new List<ExpeditionMenuItem>();

		public RundownMenuItem()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown


		public RundownMenuItem(RundownData rundown, List<RundownData> config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			Rundown = new FLabel("<color=red>" + rundown.Name + "</color>", (string)null);
			Expeditions = rundown.Expeditions.Select((ExpeditionData expedition) => new ExpeditionMenuItem(expedition, config)).ToList();
		}
	}
}
namespace CustomCheckpoints.Extensions
{
	public static class DataBlockExtensions
	{
		public static List<ExpeditionInTierData>?[] GetTiers(this RundownDataBlock? dataBlock)
		{
			return new List<ExpeditionInTierData>[5]
			{
				(dataBlock != null) ? dataBlock.TierA : null,
				(dataBlock != null) ? dataBlock.TierB : null,
				(dataBlock != null) ? dataBlock.TierC : null,
				(dataBlock != null) ? dataBlock.TierD : null,
				(dataBlock != null) ? dataBlock.TierE : null
			};
		}

		public static string GetDoorId(this ExpeditionZoneData zone, Layer layerName)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			return $"{Enum.GetName(typeof(Layer), layerName)}_{zone.LocalIndex}";
		}

		public static string GetExpeditionId(this ExpeditionInTierData exp, int index)
		{
			return exp.GetShortName(index) + " " + StripRichText(exp.Descriptive.PublicName);
		}

		private static string StripRichText(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}
			return Regex.Replace(input, "<.*?>", string.Empty);
		}
	}
	public static class RundownDataExtensions
	{
		public static List<RundownData> GetSorted(this List<RundownData> rundowns)
		{
			return (from r in rundowns
				orderby GetRundownSortKey(r.Name), r.Name
				select r).ToList();
		}

		private static int GetRundownSortKey(string name)
		{
			Match match = Regex.Match(name, "Rundown (\\d+)\\.0");
			if (match.Success)
			{
				return int.Parse(match.Groups[1].Value);
			}
			return int.MaxValue;
		}
	}
}
namespace CustomCheckpoints.Data
{
	public class ExpeditionData : IEquatable<ExpeditionData>
	{
		public string Id { get; init; }

		public uint LayoutId { get; init; }

		public List<SecurityDoorData> Doors { get; init; }

		public ExpeditionData(string id, uint layoutId, List<SecurityDoorData> doors)
		{
			Id = id;
			LayoutId = layoutId;
			Doors = doors;
		}

		public bool Equals(ExpeditionData? other)
		{
			if (other == null)
			{
				return false;
			}
			if (Id == other.Id && LayoutId == other.LayoutId)
			{
				return Doors.SequenceEqual(other.Doors);
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as ExpeditionData);
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Id, LayoutId);
		}
	}
	public enum Layer
	{
		Main,
		Secondary,
		Third
	}
	public class RundownData : IEquatable<RundownData>
	{
		public uint Id { get; init; }

		public string Name { get; init; }

		public List<ExpeditionData> Expeditions { get; init; }

		public RundownData(uint id, string name, List<ExpeditionData> expeditions)
		{
			Id = id;
			Name = name;
			Expeditions = expeditions;
		}

		public bool Equals(RundownData? other)
		{
			if (other == null)
			{
				return false;
			}
			if (Id == other.Id && Name == other.Name)
			{
				return Expeditions.SequenceEqual(other.Expeditions);
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as RundownData);
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Id, Name);
		}
	}
	public class SecurityDoorData : IEquatable<SecurityDoorData>
	{
		public string Id { get; init; }

		public string Name { get; init; }

		public string Description { get; init; }

		public bool IsCheckpoint { get; set; }

		public SecurityDoorData(string id, string name, string description, bool isCheckpoint)
		{
			Id = id;
			Name = name;
			Description = description;
			IsCheckpoint = isCheckpoint;
		}

		public bool Equals(SecurityDoorData? other)
		{
			if (other == null)
			{
				return false;
			}
			if (Id == other.Id && Name == other.Name)
			{
				return Description == other.Description;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as SecurityDoorData);
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Id, Name, Description);
		}
	}
}