using System;
using System.Collections.Generic;
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.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Cloudward.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+83254ebc1e0f377c73c2296a9412cdb0c1c00f84")]
[assembly: AssemblyProduct("Cloudward.Core")]
[assembly: AssemblyTitle("Cloudward.Core")]
[assembly: InternalsVisibleTo("Cloudward.Tests")]
[assembly: AssemblyMetadata("BuildStamp", "83254ebc 2026-08-28")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 Cloudward.Core
{
	public sealed class CfgDoc
	{
		private static readonly byte[] Bom = new byte[3] { 239, 187, 191 };

		private static readonly byte[] DefaultPrefix = Encoding.ASCII.GetBytes("# Default value:");

		private static readonly Encoding Utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

		private readonly byte[] _raw;

		private readonly byte[] _bom;

		private readonly byte[] _eol;

		private readonly List<byte[]> _lines;

		private readonly Dictionary<CfgKey, int> _index = new Dictionary<CfgKey, int>();

		private readonly Dictionary<CfgKey, string> _defaults = new Dictionary<CfgKey, string>();

		public IReadOnlyList<CfgKey> Keys => (from kv in _index
			orderby kv.Value
			select kv.Key).ToList();

		public byte[] Raw => _raw;

		public CfgDoc(byte[] raw)
		{
			_raw = raw ?? Array.Empty<byte>();
			_bom = (StartsWith(_raw, Bom) ? Bom : Array.Empty<byte>());
			byte[] array = new byte[_raw.Length - _bom.Length];
			Array.Copy(_raw, _bom.Length, array, 0, array.Length);
			_eol = ((!Contains(array, 13, 10)) ? new byte[1] { 10 } : new byte[2] { 13, 10 });
			_lines = SplitOn(array, _eol);
			string text = string.Empty;
			string text2 = null;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < _lines.Count; i++)
			{
				byte[] array2 = _lines[i];
				string text3 = MatchSection(array2);
				if (text3 != null)
				{
					text = text3;
					if (!hashSet.Add(text))
					{
						throw new InvalidDataException("section [" + text + "] appears twice — malformed cfg, refusing");
					}
					text2 = null;
					continue;
				}
				string text4 = MatchDefault(array2);
				if (text4 != null)
				{
					text2 = text4;
				}
				else
				{
					if ((array2.Length != 0 && array2[0] == 35) || IsBlank(array2))
					{
						continue;
					}
					if (TrySplitSetting(array2, out int _, out string key))
					{
						CfgKey key2 = new CfgKey(text, key);
						_index[key2] = i;
						if (text2 != null)
						{
							_defaults[key2] = text2;
						}
					}
					text2 = null;
				}
			}
		}

		public static CfgDoc FromText(string text)
		{
			return new CfgDoc(Utf8.GetBytes(text ?? string.Empty));
		}

		public string? Default(CfgKey key)
		{
			if (!_defaults.TryGetValue(key, out string value))
			{
				return null;
			}
			return value;
		}

		public bool Contains(CfgKey key)
		{
			return _index.ContainsKey(key);
		}

		public string? Get(CfgKey key)
		{
			if (!_index.TryGetValue(key, out var value))
			{
				return null;
			}
			if (!TrySplitSetting(_lines[value], out int preLen, out string _))
			{
				return null;
			}
			return Utf8.GetString(_lines[value], preLen, _lines[value].Length - preLen);
		}

		public bool Set(CfgKey key, string value)
		{
			if (!_index.TryGetValue(key, out var value2))
			{
				return false;
			}
			byte[] array = _lines[value2];
			if (!TrySplitSetting(array, out int preLen, out string _))
			{
				return false;
			}
			byte[] bytes = Utf8.GetBytes(value ?? string.Empty);
			byte[] array2 = new byte[preLen + bytes.Length];
			Array.Copy(array, 0, array2, 0, preLen);
			Array.Copy(bytes, 0, array2, preLen, bytes.Length);
			_lines[value2] = array2;
			return true;
		}

		public byte[] ToBytes()
		{
			int num = _bom.Length;
			for (int i = 0; i < _lines.Count; i++)
			{
				num += _lines[i].Length + ((i > 0) ? _eol.Length : 0);
			}
			byte[] array = new byte[num];
			int num2 = 0;
			Array.Copy(_bom, 0, array, num2, _bom.Length);
			num2 += _bom.Length;
			for (int j = 0; j < _lines.Count; j++)
			{
				if (j > 0)
				{
					Array.Copy(_eol, 0, array, num2, _eol.Length);
					num2 += _eol.Length;
				}
				Array.Copy(_lines[j], 0, array, num2, _lines[j].Length);
				num2 += _lines[j].Length;
			}
			return array;
		}

		public bool Changed()
		{
			return !BytesEqual(ToBytes(), _raw);
		}

		private static string? MatchSection(byte[] line)
		{
			if (line.Length < 3 || line[0] != 91)
			{
				return null;
			}
			int num = line.Length;
			while (num > 0 && IsSpace(line[num - 1]))
			{
				num--;
			}
			if (num < 3 || line[num - 1] != 93)
			{
				return null;
			}
			return Utf8.GetString(line, 1, num - 2);
		}

		private static string? MatchDefault(byte[] line)
		{
			if (!StartsWith(line, DefaultPrefix))
			{
				return null;
			}
			int num = DefaultPrefix.Length;
			if (num < line.Length && line[num] == 32)
			{
				num++;
			}
			return Utf8.GetString(line, num, line.Length - num);
		}

		private static bool TrySplitSetting(byte[] line, out int preLen, out string key)
		{
			preLen = 0;
			key = string.Empty;
			if (line.Length == 0)
			{
				return false;
			}
			byte b = line[0];
			if (b == 35 || b == 91 || b == 13 || b == 10 || b == 61)
			{
				return false;
			}
			int num = Array.IndexOf(line, (byte)61);
			if (num <= 0)
			{
				return false;
			}
			preLen = num + 1;
			if (preLen < line.Length && (line[preLen] == 32 || line[preLen] == 9))
			{
				preLen++;
			}
			key = Utf8.GetString(line, 0, num).Trim();
			return key.Length > 0;
		}

		private static bool IsSpace(byte b)
		{
			if (b != 32 && b != 9 && b != 13)
			{
				return b == 10;
			}
			return true;
		}

		private static bool IsBlank(byte[] line)
		{
			for (int i = 0; i < line.Length; i++)
			{
				if (!IsSpace(line[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool StartsWith(byte[] data, byte[] prefix)
		{
			if (data.Length < prefix.Length)
			{
				return false;
			}
			for (int i = 0; i < prefix.Length; i++)
			{
				if (data[i] != prefix[i])
				{
					return false;
				}
			}
			return true;
		}

		private static bool Contains(byte[] data, byte a, byte b)
		{
			for (int i = 0; i + 1 < data.Length; i++)
			{
				if (data[i] == a && data[i + 1] == b)
				{
					return true;
				}
			}
			return false;
		}

		private static bool BytesEqual(byte[] x, byte[] y)
		{
			if (x.Length != y.Length)
			{
				return false;
			}
			for (int i = 0; i < x.Length; i++)
			{
				if (x[i] != y[i])
				{
					return false;
				}
			}
			return true;
		}

		private static List<byte[]> SplitOn(byte[] data, byte[] sep)
		{
			List<byte[]> list = new List<byte[]>();
			int num = 0;
			for (int i = 0; i + sep.Length <= data.Length; i++)
			{
				bool flag = true;
				for (int j = 0; j < sep.Length; j++)
				{
					if (data[i + j] != sep[j])
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					list.Add(Slice(data, num, i - num));
					i += sep.Length - 1;
					num = i + 1;
				}
			}
			list.Add(Slice(data, num, data.Length - num));
			return list;
		}

		private static byte[] Slice(byte[] data, int offset, int count)
		{
			byte[] array = new byte[count];
			Array.Copy(data, offset, array, 0, count);
			return array;
		}
	}
	public readonly struct CfgKey : IEquatable<CfgKey>, IComparable<CfgKey>
	{
		public string Section { get; }

		public string Key { get; }

		public CfgKey(string section, string key)
		{
			Section = section ?? string.Empty;
			Key = key ?? string.Empty;
		}

		public bool Equals(CfgKey other)
		{
			if (string.Equals(Section, other.Section, StringComparison.Ordinal))
			{
				return string.Equals(Key, other.Key, StringComparison.Ordinal);
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is CfgKey other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (Section.GetHashCode() * 397) ^ Key.GetHashCode();
		}

		public int CompareTo(CfgKey other)
		{
			int num = string.CompareOrdinal(Section, other.Section);
			if (num == 0)
			{
				return string.CompareOrdinal(Key, other.Key);
			}
			return num;
		}

		public override string ToString()
		{
			return "[" + Section + "] " + Key;
		}
	}
	public sealed class CfgMergeResult
	{
		public byte[] Before { get; }

		public byte[] After { get; }

		public IReadOnlyList<string> Changes { get; }

		public IReadOnlyList<string> Skipped { get; }

		public bool Dirty => !SequenceEqual(Before, After);

		public CfgMergeResult(byte[] before, byte[] after, IReadOnlyList<string> changes, IReadOnlyList<string> skipped)
		{
			Before = before;
			After = after;
			Changes = changes;
			Skipped = skipped;
		}

		private static bool SequenceEqual(byte[] x, byte[] y)
		{
			if (x == y)
			{
				return true;
			}
			if (x.Length != y.Length)
			{
				return false;
			}
			for (int i = 0; i < x.Length; i++)
			{
				if (x[i] != y[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class CfgMerge
	{
		public static CfgMergeResult Apply(byte[] raw, IReadOnlyDictionary<CfgKey, string> overlay)
		{
			CfgDoc cfgDoc = new CfgDoc(raw);
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<CfgKey, string> item in (overlay ?? new Dictionary<CfgKey, string>()).OrderBy<KeyValuePair<CfgKey, string>, CfgKey>((KeyValuePair<CfgKey, string> kv) => kv.Key))
			{
				string text = cfgDoc.Get(item.Key);
				if (text == null)
				{
					list2.Add($"{item.Key} — not bound in target (host hasn't launched this build?)");
				}
				else if (!string.Equals(text, item.Value, StringComparison.Ordinal) && cfgDoc.Set(item.Key, item.Value))
				{
					list.Add($"{item.Key}: \"{text}\" -> \"{item.Value}\"");
				}
			}
			byte[] array = cfgDoc.ToBytes();
			if (list.Count == 0 && !BytesEqual(array, cfgDoc.Raw))
			{
				throw new InvalidOperationException("no-op merge must be byte-identical — CfgDoc round-trip is lossy, refusing to write");
			}
			return new CfgMergeResult(raw, array, list, list2);
		}

		public static IReadOnlyDictionary<CfgKey, string> Extract(byte[] raw, IEnumerable<CfgKey> allowed)
		{
			CfgDoc cfgDoc = new CfgDoc(raw);
			Dictionary<CfgKey, string> dictionary = new Dictionary<CfgKey, string>();
			foreach (CfgKey item in allowed ?? Array.Empty<CfgKey>())
			{
				string text = cfgDoc.Get(item);
				if (text != null)
				{
					dictionary[item] = text;
				}
			}
			return dictionary;
		}

		private static bool BytesEqual(byte[] x, byte[] y)
		{
			if (x.Length != y.Length)
			{
				return false;
			}
			for (int i = 0; i < x.Length; i++)
			{
				if (x[i] != y[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	public sealed class CfgOverlay
	{
		public const string FileSuffix = ".cfg.overlay";

		public string Guid { get; }

		public IReadOnlyDictionary<CfgKey, string> Values { get; }

		public int Count => Values.Count;

		public CfgOverlay(string guid, IReadOnlyDictionary<CfgKey, string> values)
		{
			Guid = guid ?? string.Empty;
			Values = values ?? new Dictionary<CfgKey, string>();
		}

		public bool Allows(CfgKey key)
		{
			return Values.ContainsKey(key);
		}

		public static string GuidFromFileName(string fileName)
		{
			string fileName2 = Path.GetFileName(fileName ?? string.Empty);
			if (!fileName2.EndsWith(".cfg.overlay", StringComparison.OrdinalIgnoreCase))
			{
				return fileName2;
			}
			return fileName2.Substring(0, fileName2.Length - ".cfg.overlay".Length);
		}

		public static CfgOverlay Parse(string guid, string? text)
		{
			Dictionary<CfgKey, string> dictionary = new Dictionary<CfgKey, string>();
			if (string.IsNullOrEmpty(text))
			{
				return new CfgOverlay(guid, dictionary);
			}
			string text2 = string.Empty;
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text3 = array[i].Trim();
				if (text3.Length == 0 || text3[0] == '#')
				{
					continue;
				}
				if (text3[0] == '[' && text3[text3.Length - 1] == ']')
				{
					text2 = text3.Substring(1, text3.Length - 2);
					Refuse(text2, "section");
					continue;
				}
				int num = text3.IndexOf('=');
				if (num >= 0)
				{
					string text4 = text3.Substring(0, num).Trim();
					Refuse(text4, "key");
					string text5 = text3.Substring(num + 1);
					if (text5.StartsWith(" ", StringComparison.Ordinal))
					{
						text5 = text5.Substring(1);
					}
					dictionary[new CfgKey(text2, text4)] = text5;
				}
			}
			return new CfgOverlay(guid, dictionary);
		}

		public string Serialize(string header)
		{
			List<string> list = new List<string>
			{
				(header ?? string.Empty).TrimEnd(Array.Empty<char>()),
				string.Empty
			};
			foreach (string section in Values.Keys.Select((CfgKey k) => k.Section).Distinct().OrderBy<string, string>((string s) => s, StringComparer.Ordinal))
			{
				list.Add("[" + section + "]");
				foreach (KeyValuePair<CfgKey, string> item in from kv in Values
					where string.Equals(kv.Key.Section, section, StringComparison.Ordinal)
					orderby kv.Key
					select kv)
				{
					list.Add(item.Key.Key + " = " + item.Value);
				}
				list.Add(string.Empty);
			}
			return string.Join("\n", list) + "\n";
		}

		private static void Refuse(string token, string what)
		{
			if (token.IndexOf('*') >= 0 || token.IndexOf('?') >= 0)
			{
				throw new InvalidDataException("overlay " + what + " \"" + token + "\" contains a wildcard. Overlays name individual keys; there is deliberately no way to say \"everything\" — see config/README.md.");
			}
		}
	}
	public sealed class CfgValueSet
	{
		public sealed class Row
		{
			public string Guid { get; }

			public CfgKey Key { get; }

			public string Value { get; }

			public string RelPath => Guid + ".cfg/" + Key.Section + "/" + Key.Key;

			public Row(string guid, CfgKey key, string value)
			{
				Guid = guid ?? string.Empty;
				Key = key;
				Value = value ?? string.Empty;
			}
		}

		public IReadOnlyList<Row> Rows { get; }

		public static CfgValueSet Empty => new CfgValueSet(Array.Empty<Row>());

		public bool IsEmpty => Rows.Count == 0;

		public CfgValueSet(IEnumerable<Row> rows)
		{
			Rows = (from g in (rows ?? Array.Empty<Row>()).Where((Row r) => r != null && r.Guid.Length > 0).GroupBy<Row, string>((Row r) => r.RelPath, StringComparer.Ordinal)
				select g.First()).OrderBy<Row, string>((Row r) => r.RelPath, StringComparer.Ordinal).ToList();
		}

		public PayloadManifest ToManifest()
		{
			return new PayloadManifest(PayloadTier.Config, Rows.Select((Row r) => new PayloadEntry(r.RelPath, AtomicFile.Utf8NoBom.GetByteCount(r.Value), PayloadHasher.HashBytes(AtomicFile.Utf8NoBom.GetBytes(r.Value)))));
		}

		public string Serialize()
		{
			return string.Join("\n", Rows.Select((Row r) => Escape(r.Guid) + "|" + Escape(r.Key.Section) + "|" + Escape(r.Key.Key) + "|" + Escape(r.Value)));
		}

		public static CfgValueSet Parse(string? text)
		{
			List<Row> list = new List<Row>();
			if (string.IsNullOrEmpty(text))
			{
				return new CfgValueSet(list);
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0 && text2[0] != '#')
				{
					string[] array2 = text2.Split(new char[1] { '|' });
					if (array2.Length >= 4)
					{
						list.Add(new Row(Unescape(array2[0]), new CfgKey(Unescape(array2[1]), Unescape(array2[2])), Unescape(array2[3])));
					}
				}
			}
			return new CfgValueSet(list);
		}

		public IReadOnlyDictionary<string, IReadOnlyDictionary<CfgKey, string>> ByGuid()
		{
			Dictionary<string, IReadOnlyDictionary<CfgKey, string>> dictionary = new Dictionary<string, IReadOnlyDictionary<CfgKey, string>>(StringComparer.OrdinalIgnoreCase);
			foreach (IGrouping<string, Row> item in Rows.GroupBy<Row, string>((Row r) => r.Guid, StringComparer.OrdinalIgnoreCase))
			{
				Dictionary<CfgKey, string> dictionary2 = new Dictionary<CfgKey, string>();
				foreach (Row item2 in item)
				{
					dictionary2[item2.Key] = item2.Value;
				}
				dictionary[item.Key] = dictionary2;
			}
			return dictionary;
		}

		public static CfgValueSet Extract(IEnumerable<CfgOverlay> overlays, Func<string, byte[]?> readCfg)
		{
			IReadOnlyList<string> unreadable;
			return Extract(overlays, readCfg, out unreadable);
		}

		public static CfgValueSet Extract(IEnumerable<CfgOverlay> overlays, Func<string, byte[]?> readCfg, out IReadOnlyList<string> unreadable)
		{
			List<Row> list = new List<Row>();
			List<string> list2 = new List<string>();
			foreach (CfgOverlay item in overlays ?? Array.Empty<CfgOverlay>())
			{
				byte[] array;
				try
				{
					array = readCfg(item.Guid);
				}
				catch
				{
					list2.Add(item.Guid + ".cfg (read failed)");
					continue;
				}
				if (array == null || array.Length == 0)
				{
					continue;
				}
				IReadOnlyDictionary<CfgKey, string> readOnlyDictionary;
				try
				{
					readOnlyDictionary = CfgMerge.Extract(array, item.Values.Keys);
				}
				catch
				{
					list2.Add(item.Guid + ".cfg (parse failed)");
					continue;
				}
				foreach (KeyValuePair<CfgKey, string> item2 in readOnlyDictionary)
				{
					list.Add(new Row(item.Guid, item2.Key, item2.Value));
				}
			}
			unreadable = list2;
			return new CfgValueSet(list);
		}

		private static string Escape(string s)
		{
			return LineCodec.Escape(s);
		}

		private static string Unescape(string s)
		{
			return LineCodec.Unescape(s);
		}
	}
	public enum ForkResolution
	{
		NewestWins,
		ThisDevice,
		OtherDevice,
		KeepBoth,
		AskMe
	}
	public enum ForkGate
	{
		AutoResolve,
		DeferMidSession,
		PauseForManual,
		AlreadyPaused
	}
	public static class ForkResolve
	{
		public static ForkGate Gate(bool autoPolicy, bool mayMutateLocal, bool alreadyPending)
		{
			if (!autoPolicy)
			{
				if (!alreadyPending)
				{
					return ForkGate.PauseForManual;
				}
				return ForkGate.AlreadyPaused;
			}
			if (!mayMutateLocal)
			{
				return ForkGate.DeferMidSession;
			}
			return ForkGate.AutoResolve;
		}

		public static bool DivergenceExists(CharTree? local, CharTree? share)
		{
			if (local != null && !local.IsEmpty && share != null)
			{
				return !share.IsEmpty;
			}
			return false;
		}

		public static bool IsAuto(ForkResolution policy)
		{
			return policy != ForkResolution.AskMe;
		}

		public static bool? LocalWins(ForkResolution policy, bool localIsNewer)
		{
			return policy switch
			{
				ForkResolution.NewestWins => localIsNewer, 
				ForkResolution.ThisDevice => true, 
				ForkResolution.OtherDevice => false, 
				ForkResolution.KeepBoth => true, 
				ForkResolution.AskMe => null, 
				_ => localIsNewer, 
			};
		}
	}
	public static class JoinRaceGate
	{
		public enum PullDecision
		{
			Pull,
			HoldAndRetry,
			DeferToNextLaunch
		}

		public const float DefaultHoldBudgetSeconds = 60f;

		public static PullDecision Decide(bool mayMutateLocal, bool savesPinned, bool characterEverInUse, float heldSeconds, float holdBudgetSeconds = 60f)
		{
			if (!mayMutateLocal)
			{
				return PullDecision.DeferToNextLaunch;
			}
			if (!savesPinned)
			{
				return PullDecision.Pull;
			}
			if (characterEverInUse)
			{
				return PullDecision.DeferToNextLaunch;
			}
			if (heldSeconds > holdBudgetSeconds)
			{
				return PullDecision.DeferToNextLaunch;
			}
			return PullDecision.HoldAndRetry;
		}
	}
	public sealed class LocalCharState
	{
		public int BasedOnGen { get; }

		public string LastPushedHead { get; }

		public LocalCharState(int basedOnGen, string lastPushedHead)
		{
			BasedOnGen = basedOnGen;
			LastPushedHead = lastPushedHead ?? string.Empty;
		}
	}
	public sealed class ForkRecord
	{
		public string LocalHead { get; }

		public string ShareHead { get; }

		public ForkRecord(string localHead, string shareHead)
		{
			LocalHead = localHead ?? string.Empty;
			ShareHead = shareHead ?? string.Empty;
		}
	}
	public sealed class LocalSyncState
	{
		private readonly object _gate = new object();

		private readonly Dictionary<string, LocalCharState> _state = new Dictionary<string, LocalCharState>(StringComparer.Ordinal);

		private readonly Dictionary<string, ForkRecord> _forks = new Dictionary<string, ForkRecord>(StringComparer.Ordinal);

		private readonly HashSet<string> _bootstrapped = new HashSet<string>(StringComparer.Ordinal);

		public IReadOnlyList<string> PendingForks
		{
			get
			{
				lock (_gate)
				{
					return _forks.Keys.ToList();
				}
			}
		}

		public bool HasForks
		{
			get
			{
				lock (_gate)
				{
					return _forks.Count > 0;
				}
			}
		}

		public LocalCharState? Get(string uid)
		{
			lock (_gate)
			{
				LocalCharState value;
				return _state.TryGetValue(uid, out value) ? value : null;
			}
		}

		public void Set(string uid, LocalCharState s)
		{
			lock (_gate)
			{
				_state[uid] = s;
			}
		}

		public ForkRecord? GetFork(string uid)
		{
			lock (_gate)
			{
				ForkRecord value;
				return _forks.TryGetValue(uid, out value) ? value : null;
			}
		}

		public void SetFork(string uid, ForkRecord f)
		{
			lock (_gate)
			{
				_forks[uid] = f;
			}
		}

		public void ClearFork(string uid)
		{
			lock (_gate)
			{
				_forks.Remove(uid);
			}
		}

		public bool IsBootstrapped(string mountPath)
		{
			lock (_gate)
			{
				return _bootstrapped.Contains(mountPath ?? string.Empty);
			}
		}

		public void MarkBootstrapped(string mountPath)
		{
			lock (_gate)
			{
				_bootstrapped.Add(mountPath ?? string.Empty);
			}
		}

		public string Serialize()
		{
			lock (_gate)
			{
				List<string> list = new List<string>();
				foreach (KeyValuePair<string, LocalCharState> item in _state.OrderBy<KeyValuePair<string, LocalCharState>, string>((KeyValuePair<string, LocalCharState> k) => k.Key, StringComparer.Ordinal))
				{
					list.Add("S|" + Escape(item.Key) + "|" + item.Value.BasedOnGen.ToString(CultureInfo.InvariantCulture) + "|" + Escape(item.Value.LastPushedHead));
				}
				foreach (KeyValuePair<string, ForkRecord> item2 in _forks.OrderBy<KeyValuePair<string, ForkRecord>, string>((KeyValuePair<string, ForkRecord> k) => k.Key, StringComparer.Ordinal))
				{
					list.Add("F|" + Escape(item2.Key) + "|" + Escape(item2.Value.LocalHead) + "|" + Escape(item2.Value.ShareHead));
				}
				foreach (string item3 in _bootstrapped.OrderBy<string, string>((string k) => k, StringComparer.Ordinal))
				{
					list.Add("B|" + Escape(item3));
				}
				return string.Join("\n", list);
			}
		}

		public static LocalSyncState Parse(string text)
		{
			LocalSyncState localSyncState = new LocalSyncState();
			if (string.IsNullOrEmpty(text))
			{
				return localSyncState;
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length < 2)
				{
					continue;
				}
				if (array2[0] == "B")
				{
					localSyncState._bootstrapped.Add(Unescape(array2[1]));
				}
				else if (array2.Length >= 4)
				{
					if (array2[0] == "S" && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						localSyncState._state[Unescape(array2[1])] = new LocalCharState(result, Unescape(array2[3]));
					}
					else if (array2[0] == "F")
					{
						localSyncState._forks[Unescape(array2[1])] = new ForkRecord(Unescape(array2[2]), Unescape(array2[3]));
					}
				}
			}
			return localSyncState;
		}

		private static string Escape(string v)
		{
			return (v ?? string.Empty).Replace("|", "%7C");
		}

		private static string Unescape(string v)
		{
			return v.Replace("%7C", "|");
		}
	}
	public enum LockHeldPolicy
	{
		FallbackLocal,
		ReadOnly,
		ForceTake
	}
	public enum LeaseDecision
	{
		Take,
		FallbackLocal
	}
	public static class LockLease
	{
		public static LeaseDecision Decide(DateTime nowUtc, LockStamp? existing, string ownDevice, int ownPid, int staleSeconds, LockHeldPolicy policy, Func<int, bool>? isPidAlive = null)
		{
			if (existing == null)
			{
				return LeaseDecision.Take;
			}
			if (string.Equals(existing.Device, ownDevice, StringComparison.OrdinalIgnoreCase) && (existing.Pid == ownPid || isPidAlive == null || !isPidAlive(existing.Pid)))
			{
				return LeaseDecision.Take;
			}
			if ((nowUtc - existing.HeartbeatUtc).TotalSeconds > (double)staleSeconds)
			{
				return LeaseDecision.Take;
			}
			return Held(policy);
		}

		private static LeaseDecision Held(LockHeldPolicy policy)
		{
			if (policy != LockHeldPolicy.ForceTake)
			{
				return LeaseDecision.FallbackLocal;
			}
			return LeaseDecision.Take;
		}
	}
	public sealed class LockStamp
	{
		public string Device { get; }

		public int Pid { get; }

		public DateTime HeartbeatUtc { get; }

		public LockStamp(string device, int pid, DateTime heartbeatUtc)
		{
			Device = Sanitize(device);
			Pid = pid;
			HeartbeatUtc = heartbeatUtc.ToUniversalTime();
		}

		public string Serialize()
		{
			return Device + "\n" + Pid.ToString(CultureInfo.InvariantCulture) + "\n" + HeartbeatUtc.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture);
		}

		public static bool TryParse(string text, out LockStamp? stamp)
		{
			stamp = null;
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			if (array.Length < 3)
			{
				return false;
			}
			string device = array[0].Trim();
			if (!int.TryParse(array[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (!DateTime.TryParse(array[2].Trim(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result2))
			{
				return false;
			}
			stamp = new LockStamp(device, result, result2);
			return true;
		}

		private static string Sanitize(string s)
		{
			if (!string.IsNullOrEmpty(s))
			{
				return s.Replace("\r", " ").Replace("\n", " ").Trim();
			}
			return string.Empty;
		}
	}
	public enum MountDecision
	{
		Live,
		Offline,
		CreateMarkerThenLive
	}
	public static class MountGuard
	{
		public static bool IsLive(bool markerExists, bool driveReady)
		{
			return markerExists && driveReady;
		}

		public static MountDecision Decide(bool markerExists, bool alreadyBootstrapped, bool shareHasData, bool driveReady, bool requireExistingMarker, bool mountpointConfirmed = false)
		{
			if (!driveReady)
			{
				return MountDecision.Offline;
			}
			if (markerExists)
			{
				return MountDecision.Live;
			}
			if (requireExistingMarker)
			{
				return MountDecision.Offline;
			}
			if (shareHasData)
			{
				return MountDecision.CreateMarkerThenLive;
			}
			if (alreadyBootstrapped)
			{
				return MountDecision.Offline;
			}
			if (!mountpointConfirmed)
			{
				return MountDecision.Offline;
			}
			return MountDecision.CreateMarkerThenLive;
		}

		public static string? WineUnixPath(string? path)
		{
			if (path == null || path.Length < 2)
			{
				return null;
			}
			if ((path[0] != 'Z' && path[0] != 'z') || path[1] != ':')
			{
				return null;
			}
			if (path.Length == 2)
			{
				return "/";
			}
			if (path[2] != '/' && path[2] != '\\')
			{
				return null;
			}
			return path.Substring(2).Replace('\\', '/');
		}

		public static bool TryCoveringMount(string? fullPath, IEnumerable<string>? procMountsLines, out string mountpoint, out string fsType)
		{
			mountpoint = "";
			fsType = "";
			if (string.IsNullOrEmpty(fullPath) || procMountsLines == null)
			{
				return false;
			}
			string text = fullPath.TrimEnd(new char[1] { '/' });
			if (text.Length == 0)
			{
				text = "/";
			}
			int num = -1;
			foreach (string procMountsLine in procMountsLines)
			{
				if (string.IsNullOrEmpty(procMountsLine))
				{
					continue;
				}
				string[] array = procMountsLine.Split(new char[1] { ' ' });
				if (array.Length >= 3)
				{
					string text2 = array[1].Replace("\\040", " ").Replace("\\011", "\t").TrimEnd(new char[1] { '/' });
					if ((text2.Length == 0 || string.Equals(text, text2, StringComparison.Ordinal) || text.StartsWith(text2 + "/", StringComparison.Ordinal)) && text2.Length >= num)
					{
						num = text2.Length;
						mountpoint = ((text2.Length == 0) ? "/" : text2);
						fsType = array[2];
					}
				}
			}
			return num >= 0;
		}

		public static bool IsRemoteFsType(string? fsType)
		{
			if (string.IsNullOrEmpty(fsType))
			{
				return false;
			}
			string text = fsType.ToLowerInvariant();
			if (text.StartsWith("fuse.", StringComparison.Ordinal))
			{
				text = text.Substring(5);
			}
			if (!text.StartsWith("nfs", StringComparison.Ordinal) && !text.StartsWith("smb", StringComparison.Ordinal) && !text.StartsWith("ceph", StringComparison.Ordinal) && !text.StartsWith("davfs", StringComparison.Ordinal))
			{
				switch (text)
				{
				default:
					return text == "afs";
				case "cifs":
				case "9p":
				case "glusterfs":
				case "sshfs":
				case "rclone":
					break;
				}
			}
			return true;
		}

		public static bool IsUnderNonRootMount(string? fullPath, IEnumerable<string>? procMountsLines)
		{
			if (string.IsNullOrEmpty(fullPath) || procMountsLines == null)
			{
				return false;
			}
			string text = fullPath.TrimEnd(new char[1] { '/' });
			if (text.Length == 0)
			{
				return false;
			}
			foreach (string procMountsLine in procMountsLines)
			{
				if (string.IsNullOrEmpty(procMountsLine))
				{
					continue;
				}
				string[] array = procMountsLine.Split(new char[1] { ' ' });
				if (array.Length >= 2)
				{
					string text2 = array[1].Replace("\\040", " ").Replace("\\011", "\t").TrimEnd(new char[1] { '/' });
					if (text2.Length != 0 && (string.Equals(text, text2, StringComparison.Ordinal) || text.StartsWith(text2 + "/", StringComparison.Ordinal)))
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public static class OpWatchdog
	{
		public enum Verdict
		{
			Quiet,
			WarnStalled,
			NoteRecovered
		}

		public const double DefaultWarnAfterSeconds = 60.0;

		public static Verdict Check(bool running, bool alreadyWarned, double heldSeconds, double warnAfterSeconds)
		{
			if (running)
			{
				if (alreadyWarned || !(heldSeconds >= warnAfterSeconds))
				{
					return Verdict.Quiet;
				}
				return Verdict.WarnStalled;
			}
			if (!alreadyWarned)
			{
				return Verdict.Quiet;
			}
			return Verdict.NoteRecovered;
		}
	}
	public static class PathRebase
	{
		public const string SaveBase = "SaveGames";

		public const string PayloadBase = ".cloudward-payload";

		public static string Target(string originalSavePath, string mountRoot)
		{
			string text = LastElement(originalSavePath);
			return TrimTrailingSeparators(mountRoot) + "/SaveGames/" + text;
		}

		public static string PayloadRoot(string mountRoot)
		{
			return TrimTrailingSeparators(mountRoot) + "/.cloudward-payload";
		}

		public static string LastElement(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return string.Empty;
			}
			string text = TrimTrailingSeparators(path);
			int num = text.LastIndexOfAny(new char[2] { '/', '\\' });
			if (num >= 0)
			{
				return text.Substring(num + 1);
			}
			return text;
		}

		private static string TrimTrailingSeparators(string path)
		{
			if (!string.IsNullOrEmpty(path))
			{
				return path.TrimEnd('/', '\\');
			}
			return path;
		}
	}
	public enum StagedRuling
	{
		StillStaged,
		Applied,
		NotApplied,
		Ambiguous
	}
	public sealed class ApplyReceipt
	{
		public const string RelPath = "BepInEx/cloudward-apply-receipt.txt";

		public ApplyOutcome Outcome { get; }

		public int OpsFailed { get; }

		public IReadOnlyDictionary<PayloadTier, int> Generations { get; }

		public string ApplierVersion { get; }

		public string Utc { get; }

		public bool PartiallyApplied
		{
			get
			{
				if (Outcome == ApplyOutcome.Applied)
				{
					return OpsFailed > 0;
				}
				return false;
			}
		}

		public static string PathFor(string gameRoot)
		{
			return Path.Combine(gameRoot ?? string.Empty, PayloadScope.ToNative("BepInEx/cloudward-apply-receipt.txt"));
		}

		public ApplyReceipt(ApplyOutcome outcome, int opsFailed, IReadOnlyDictionary<PayloadTier, int>? generations, string? applierVersion, string? utc = null)
		{
			Outcome = outcome;
			OpsFailed = opsFailed;
			Generations = generations ?? new Dictionary<PayloadTier, int>();
			ApplierVersion = applierVersion ?? string.Empty;
			Utc = utc ?? DateTime.UtcNow.ToString("o");
		}

		public static StagedRuling Judge(ApplyReceipt? receipt, bool stagingStillPresent)
		{
			if (stagingStillPresent)
			{
				return StagedRuling.StillStaged;
			}
			if (receipt == null)
			{
				return StagedRuling.Ambiguous;
			}
			if (receipt.Outcome != ApplyOutcome.Applied || receipt.OpsFailed != 0)
			{
				return StagedRuling.NotApplied;
			}
			return StagedRuling.Applied;
		}

		public static StagedRuling Judge(ApplyReceipt? receipt, bool stagingStillPresent, PayloadTier tier, int stagedGen)
		{
			StagedRuling stagedRuling = Judge(receipt, stagingStillPresent);
			if (stagedRuling == StagedRuling.Applied && receipt.Generations.TryGetValue(tier, out var value) && value != stagedGen)
			{
				return StagedRuling.Ambiguous;
			}
			return stagedRuling;
		}

		public string Serialize()
		{
			List<string> list = new List<string>
			{
				"O|" + Outcome,
				"F|" + OpsFailed.ToString(CultureInfo.InvariantCulture),
				"A|" + LineCodec.Escape(ApplierVersion),
				"U|" + LineCodec.Escape(Utc)
			};
			foreach (KeyValuePair<PayloadTier, int> generation in Generations)
			{
				list.Add("G|" + PayloadTiers.Name(generation.Key) + "|" + generation.Value.ToString(CultureInfo.InvariantCulture));
			}
			return string.Join("\n", list);
		}

		public static ApplyReceipt? Parse(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			ApplyOutcome? applyOutcome = null;
			int result = 0;
			Dictionary<PayloadTier, int> dictionary = new Dictionary<PayloadTier, int>();
			string applierVersion = string.Empty;
			string utc = string.Empty;
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length < 2)
				{
					continue;
				}
				switch (array2[0])
				{
				case "O":
				{
					if (Enum.TryParse<ApplyOutcome>(array2[1], out var result3))
					{
						applyOutcome = result3;
					}
					break;
				}
				case "F":
					int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
					break;
				case "A":
					applierVersion = LineCodec.Unescape(array2[1]);
					break;
				case "U":
					utc = LineCodec.Unescape(array2[1]);
					break;
				case "G":
				{
					if (array2.Length >= 3 && PayloadTiers.TryParse(array2[1], out var tier) && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
					{
						dictionary[tier] = result2;
					}
					break;
				}
				}
			}
			if (applyOutcome.HasValue)
			{
				return new ApplyReceipt(applyOutcome.Value, result, dictionary, applierVersion, utc);
			}
			return null;
		}

		public void WriteTo(string gameRoot)
		{
			try
			{
				AtomicFile.WriteAllText(PathFor(gameRoot), Serialize());
			}
			catch
			{
			}
		}

		public static ApplyReceipt? Consume(string gameRoot)
		{
			string path = PathFor(gameRoot);
			try
			{
				if (!File.Exists(path))
				{
					return null;
				}
				ApplyReceipt result = Parse(File.ReadAllText(path));
				try
				{
					File.Delete(path);
				}
				catch
				{
				}
				return result;
			}
			catch
			{
				return null;
			}
		}
	}
	public static class AtomicFile
	{
		public static readonly Encoding Utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

		public static string ShareTempSuffix(string device, int pid)
		{
			return ".tmp." + SanitizeForFileName(device) + "." + pid.ToString(CultureInfo.InvariantCulture);
		}

		public static void WriteAllText(string path, string content, string? tempSuffix = null)
		{
			WriteAllBytes(path, Utf8NoBom.GetBytes(content ?? string.Empty), tempSuffix);
		}

		public static void WriteAllBytes(string path, byte[] bytes, string? tempSuffix = null)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text = path + (string.IsNullOrEmpty(tempSuffix) ? ".tmp" : tempSuffix);
			try
			{
				File.WriteAllBytes(text, bytes ?? Array.Empty<byte>());
				Swap(text, path);
			}
			catch
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch
				{
				}
				throw;
			}
		}

		public static void Swap(string tmp, string path)
		{
			if (!File.Exists(path))
			{
				File.Move(tmp, path);
				return;
			}
			try
			{
				File.Replace(tmp, path, null);
			}
			catch (PlatformNotSupportedException)
			{
				MoveAsideThenMove(tmp, path);
			}
			catch (IOException)
			{
				MoveAsideThenMove(tmp, path);
			}
		}

		internal static void MoveAsideThenMove(string tmp, string path)
		{
			string text = tmp + ".aside";
			try
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
			catch
			{
			}
			File.Move(path, text);
			try
			{
				File.Move(tmp, path);
			}
			catch
			{
				try
				{
					if (!File.Exists(path))
					{
						File.Move(text, path);
					}
				}
				catch
				{
				}
				throw;
			}
			try
			{
				File.Delete(text);
			}
			catch
			{
			}
		}

		public static string SanitizeForFileName(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				stringBuilder.Append((char.IsLetterOrDigit(c) || c == '-' || c == '_') ? c : '_');
			}
			string text = stringBuilder.ToString();
			if (text.Length != 0)
			{
				return text;
			}
			return "unknown";
		}
	}
	public static class Fnv1a
	{
		public static string HashLines(IEnumerable<string> lines)
		{
			List<string> list = new List<string>(lines ?? Array.Empty<string>());
			list.Sort(StringComparer.Ordinal);
			uint num = 2166136261u;
			foreach (string item in list)
			{
				if (item != null)
				{
					string text = item;
					foreach (char c in text)
					{
						num ^= c;
						num *= 16777619;
					}
					num ^= 0xA;
					num *= 16777619;
				}
			}
			return num.ToString("x8");
		}
	}
	public static class LineCodec
	{
		public static string Escape(string? s)
		{
			return (s ?? string.Empty).Replace("%", "%25").Replace("|", "%7C");
		}

		public static string Unescape(string? s)
		{
			return (s ?? string.Empty).Replace("%7C", "|").Replace("%25", "%");
		}
	}
	public enum ApplyOutcome
	{
		Nothing,
		Disabled,
		Held,
		Refused,
		Applied
	}
	public sealed class ApplyResult
	{
		public ApplyOutcome Outcome { get; }

		public int FilesCopied { get; }

		public int FilesDeleted { get; }

		public int CfgKeysChanged { get; }

		public IReadOnlyList<string> Messages { get; }

		public int OpsFailed { get; }

		public bool PartiallyApplied
		{
			get
			{
				if (Outcome == ApplyOutcome.Applied)
				{
					return OpsFailed > 0;
				}
				return false;
			}
		}

		public ApplyResult(ApplyOutcome outcome, int copied, int deleted, int cfgChanged, IReadOnlyList<string> messages, int opsFailed = 0)
		{
			Outcome = outcome;
			FilesCopied = copied;
			FilesDeleted = deleted;
			CfgKeysChanged = cfgChanged;
			Messages = messages;
			OpsFailed = opsFailed;
		}

		public static ApplyResult Simple(ApplyOutcome outcome, params string[] messages)
		{
			return new ApplyResult(outcome, 0, 0, 0, messages);
		}
	}
	public static class PayloadApply
	{
		public const string KillSwitchFileName = ".cloudward-disable";

		public const string TypeLoaderCache = "BepInEx/cache";

		public const string HoldFileName = "hold";

		public static bool KillSwitchPresent(string gameRoot)
		{
			return File.Exists(Path.Combine(gameRoot ?? string.Empty, ".cloudward-disable"));
		}

		public static bool HeldForManualApply(string stagingRoot)
		{
			return File.Exists(Path.Combine(stagingRoot ?? string.Empty, "hold"));
		}

		public static ApplyResult Execute(string gameRoot, string stagingRoot, string? backupDir, Action<string>? log = null)
		{
			IReadOnlyDictionary<PayloadTier, int> planGens = null;
			try
			{
				if (KillSwitchPresent(gameRoot))
				{
					return ApplyResult.Simple(ApplyOutcome.Disabled, ".cloudward-disable present — payload apply disabled, staging left in place");
				}
				string path = Path.Combine(stagingRoot, "stage.plan");
				if (!Directory.Exists(stagingRoot) || !File.Exists(path))
				{
					return ApplyResult.Simple(ApplyOutcome.Nothing);
				}
				if (HeldForManualApply(stagingRoot))
				{
					return ApplyResult.Simple(ApplyOutcome.Held, "a payload is staged but held ([Payload] ApplyMode=StageOnly) — run the 'payloadapply' verb, then restart, to install it");
				}
				StagePlan stagePlan;
				try
				{
					stagePlan = StagePlan.Parse(File.ReadAllText(path));
				}
				catch (Exception ex)
				{
					stagePlan = null;
					Say("plan unreadable: " + ex.Message);
				}
				if (stagePlan == null)
				{
					Discard(stagingRoot);
					Receipt(ApplyOutcome.Refused, 0);
					return ApplyResult.Simple(ApplyOutcome.Refused, "staged plan was unreadable or unsupported — discarded, install untouched");
				}
				planGens = stagePlan.Generations;
				if (stagePlan.IsEmpty)
				{
					Discard(stagingRoot);
					Receipt(ApplyOutcome.Nothing, 0);
					return ApplyResult.Simple(ApplyOutcome.Nothing, "staged plan was empty");
				}
				string path2 = Path.Combine(stagingRoot, "files");
				List<string> list = new List<string>();
				foreach (FileOp item in stagePlan.FileOps.Where((FileOp o) => o.Kind == FileOpKind.Copy))
				{
					string path3 = Path.Combine(path2, PayloadScope.ToNative(item.RelPath));
					if (!File.Exists(path3))
					{
						list.Add("missing staged file: " + item.RelPath);
						continue;
					}
					string a;
					try
					{
						a = PayloadHasher.HashFile(path3);
					}
					catch (Exception ex2)
					{
						list.Add("unreadable staged file " + item.RelPath + ": " + ex2.Message);
						continue;
					}
					if (!string.Equals(a, item.Sha256, StringComparison.Ordinal))
					{
						list.Add("sha256 mismatch: " + item.RelPath);
					}
				}
				if (list.Count > 0)
				{
					foreach (string item2 in list.Take(20))
					{
						Say("  " + item2);
					}
					Discard(stagingRoot);
					Receipt(ApplyOutcome.Refused, 0);
					return new ApplyResult(ApplyOutcome.Refused, 0, 0, 0, new string[1] { $"staged payload failed verification ({list.Count} problem(s)) — discarded, install untouched" }.Concat(list.Take(20)).ToList());
				}
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				List<string> list2 = new List<string>();
				foreach (FileOp fileOp in stagePlan.FileOps)
				{
					string text = Path.Combine(gameRoot, PayloadScope.ToNative(fileOp.RelPath));
					try
					{
						Backup(backupDir, fileOp.RelPath, text);
						if (fileOp.Kind == FileOpKind.Copy)
						{
							string sourceFileName = Path.Combine(path2, PayloadScope.ToNative(fileOp.RelPath));
							string directoryName = Path.GetDirectoryName(text);
							if (!string.IsNullOrEmpty(directoryName))
							{
								Directory.CreateDirectory(directoryName);
							}
							string text2 = text + ".cloudward-new";
							File.Copy(sourceFileName, text2, overwrite: true);
							AtomicFile.Swap(text2, text);
							num++;
						}
						else if (File.Exists(text))
						{
							File.Delete(text);
							num2++;
						}
					}
					catch (Exception ex3)
					{
						num4++;
						list2.Add("failed " + fileOp.Kind.ToString() + " " + fileOp.RelPath + ": " + ex3.Message);
					}
				}
				foreach (IGrouping<string, CfgOp> item3 in stagePlan.CfgOps.GroupBy<CfgOp, string>((CfgOp o) => o.Guid, StringComparer.OrdinalIgnoreCase))
				{
					string text3 = Path.Combine(gameRoot, PayloadScope.ToNative("BepInEx/config/" + item3.Key + ".cfg"));
					if (!File.Exists(text3))
					{
						list2.Add("cfg absent, skipped: " + item3.Key);
						continue;
					}
					try
					{
						Dictionary<CfgKey, string> dictionary = new Dictionary<CfgKey, string>();
						foreach (CfgOp item4 in item3)
						{
							dictionary[item4.Key] = item4.Value;
						}
						CfgMergeResult cfgMergeResult = CfgMerge.Apply(File.ReadAllBytes(text3), dictionary);
						if (cfgMergeResult.Skipped.Count > 0)
						{
							list2.Add($"cfg {item3.Key}: {cfgMergeResult.Skipped.Count} key(s) skipped — " + string.Join("; ", cfgMergeResult.Skipped.Take(3)) + ((cfgMergeResult.Skipped.Count > 3) ? "; …" : string.Empty));
						}
						if (!cfgMergeResult.Dirty)
						{
							continue;
						}
						Backup(backupDir, "BepInEx/config/" + item3.Key + ".cfg", text3);
						AtomicFile.WriteAllBytes(text3, cfgMergeResult.After);
						num3 += cfgMergeResult.Changes.Count;
						foreach (string change in cfgMergeResult.Changes)
						{
							list2.Add("cfg " + item3.Key + " " + change);
						}
					}
					catch (Exception ex4)
					{
						num4++;
						list2.Add("failed cfg " + item3.Key + ": " + ex4.Message);
					}
				}
				if (num > 0 || num2 > 0)
				{
					try
					{
						string path4 = Path.Combine(gameRoot, PayloadScope.ToNative("BepInEx/cache"));
						if (Directory.Exists(path4))
						{
							Directory.Delete(path4, recursive: true);
							list2.Add("cleared BepInEx/cache");
						}
					}
					catch (Exception ex5)
					{
						list2.Add("could not clear BepInEx/cache: " + ex5.Message);
					}
				}
				Discard(stagingRoot);
				PruneEmptyDirs(Path.Combine(gameRoot, PayloadScope.ToNative("BepInEx/plugins")));
				if (num4 > 0)
				{
					list2.Insert(0, $"PARTIALLY APPLIED — {num4} op(s) failed AFTER verification. The install " + "is now a mix of old and new files; re-run the sync (or restore from the backup dir) before trusting this launch.");
				}
				list2.Insert(0, $"applied staged payload: {num} copied, {num2} deleted, {num3} cfg key(s)" + ((num4 > 0) ? $", {num4} FAILED" : ""));
				foreach (string item5 in list2.Take(40))
				{
					Say("  " + item5);
				}
				Receipt(ApplyOutcome.Applied, num4);
				return new ApplyResult(ApplyOutcome.Applied, num, num2, num3, list2, num4);
			}
			catch (Exception ex6)
			{
				try
				{
					Discard(stagingRoot);
				}
				catch
				{
				}
				try
				{
					Receipt(ApplyOutcome.Refused, 0);
				}
				catch
				{
				}
				return ApplyResult.Simple(ApplyOutcome.Refused, "payload apply aborted: " + ex6.Message);
			}
			void Receipt(ApplyOutcome outcome, int opsFailedCount)
			{
				new ApplyReceipt(outcome, opsFailedCount, planGens, ApplierVersion()).WriteTo(gameRoot);
			}
			void Say(string m)
			{
				try
				{
					log?.Invoke(m);
				}
				catch
				{
				}
			}
		}

		public static string ApplierVersion()
		{
			try
			{
				return typeof(PayloadApply).Assembly.GetName().Version?.ToString() ?? "?";
			}
			catch
			{
				return "?";
			}
		}

		private static void Backup(string? backupDir, string relPath, string source)
		{
			if (string.IsNullOrEmpty(backupDir) || !File.Exists(source))
			{
				return;
			}
			try
			{
				string text = Path.Combine(backupDir, PayloadScope.ToNative(relPath));
				string directoryName = Path.GetDirectoryName(text);
				if (!string.IsNullOrEmpty(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.Copy(source, text, overwrite: true);
			}
			catch
			{
			}
		}

		private static void Discard(string stagingRoot)
		{
			try
			{
				if (Directory.Exists(stagingRoot))
				{
					Directory.Delete(stagingRoot, recursive: true);
				}
			}
			catch
			{
			}
		}

		private static void PruneEmptyDirs(string root)
		{
			if (!Directory.Exists(root))
			{
				return;
			}
			try
			{
				string[] directories = Directory.GetDirectories(root);
				foreach (string text in directories)
				{
					PruneEmptyDirs(text);
					if (Directory.GetFileSystemEntries(text).Length == 0)
					{
						Directory.Delete(text);
					}
				}
			}
			catch
			{
			}
		}
	}
	public static class PayloadBackupName
	{
		public static string Compose(PayloadTier tier, int gen, string? stamp)
		{
			return PayloadTiers.Name(tier) + "-gen" + gen.ToString(CultureInfo.InvariantCulture) + "-" + AtomicFile.SanitizeForFileName(stamp);
		}

		public static string Prefix(PayloadTier tier)
		{
			return PayloadTiers.Name(tier) + "-gen";
		}

		public static bool BelongsTo(string? name, PayloadTier tier)
		{
			if (!string.IsNullOrEmpty(name))
			{
				return name.StartsWith(Prefix(tier), StringComparison.Ordinal);
			}
			return false;
		}

		public static bool TryParse(string? name, PayloadTier tier, out int gen, out string stamp)
		{
			gen = -1;
			stamp = string.Empty;
			if (!BelongsTo(name, tier))
			{
				return false;
			}
			string text = name.Substring(Prefix(tier).Length);
			int num = text.IndexOf('-');
			if (!int.TryParse((num < 0) ? text : text.Substring(0, num), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			gen = result;
			stamp = ((num < 0) ? string.Empty : text.Substring(num + 1));
			return true;
		}

		public static List<string> OrderOldestFirst(IEnumerable<string>? names, PayloadTier tier)
		{
			List<string> list = new List<string>(names ?? Array.Empty<string>());
			list.Sort((string a, string b) => Compare(a, b, tier));
			return list;
		}

		public static List<string> OrderNewestFirst(IEnumerable<string>? names, PayloadTier tier)
		{
			List<string> list = OrderOldestFirst(names, tier);
			list.Reverse();
			return list;
		}

		private static int Compare(string a, string b, PayloadTier tier)
		{
			TryParse(a, tier, out int gen, out string stamp);
			TryParse(b, tier, out int gen2, out string stamp2);
			if (gen != gen2)
			{
				return gen.CompareTo(gen2);
			}
			int num = string.CompareOrdinal(stamp, stamp2);
			if (num == 0)
			{
				return string.CompareOrdinal(a ?? string.Empty, b ?? string.Empty);
			}
			return num;
		}
	}
	public enum PayloadConflictPolicy
	{
		Skip,
		PreferLocal,
		PreferShare
	}
	public enum PayloadResolution
	{
		Local,
		Share
	}
	public static class PayloadConflictResolve
	{
		public static bool IsAuto(PayloadConflictPolicy policy)
		{
			return policy != PayloadConflictPolicy.Skip;
		}

		public static PayloadResolution Winner(PayloadConflictPolicy policy)
		{
			if (policy != PayloadConflictPolicy.PreferLocal)
			{
				return PayloadResolution.Share;
			}
			return PayloadResolution.Local;
		}

		public static bool Gate(PayloadConflictPolicy policy, bool atBoot, bool alreadyPending)
		{
			if (IsAuto(policy) && atBoot)
			{
				return !alreadyPending;
			}
			return false;
		}

		public static bool TryParseResolution(string? text, out PayloadResolution resolution)
		{
			resolution = PayloadResolution.Local;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			string a = text.Trim();
			if (string.Equals(a, "local", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "this", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "mine", StringComparison.OrdinalIgnoreCase))
			{
				resolution = PayloadResolution.Local;
				return true;
			}
			if (string.Equals(a, "share", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "remote", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "other", StringComparison.OrdinalIgnoreCase))
			{
				resolution = PayloadResolution.Share;
				return true;
			}
			return false;
		}
	}
	public sealed class PayloadDiff
	{
		public IReadOnlyList<PayloadEntry> Added { get; }

		public IReadOnlyList<PayloadEntry> Changed { get; }

		public IReadOnlyList<string> Removed { get; }

		public bool IsEmpty
		{
			get
			{
				if (Added.Count == 0 && Changed.Count == 0)
				{
					return Removed.Count == 0;
				}
				return false;
			}
		}

		public int TouchedCount => Added.Count + Changed.Count + Removed.Count;

		public long TransferBytes => Added.Sum((PayloadEntry e) => e.Size) + Changed.Sum((PayloadEntry e) => e.Size);

		private PayloadDiff(IReadOnlyList<PayloadEntry> added, IReadOnlyList<PayloadEntry> changed, IReadOnlyList<string> removed)
		{
			Added = added;
			Changed = changed;
			Removed = removed;
		}

		public static PayloadDiff Between(PayloadManifest? from, PayloadManifest? to)
		{
			Dictionary<string, PayloadEntry> dictionary = (from?.Entries ?? Array.Empty<PayloadEntry>()).ToDictionary<PayloadEntry, string, PayloadEntry>((PayloadEntry e) => e.RelPath, (PayloadEntry e) => e, StringComparer.Ordinal);
			Dictionary<string, PayloadEntry> want = (to?.Entries ?? Array.Empty<PayloadEntry>()).ToDictionary<PayloadEntry, string, PayloadEntry>((PayloadEntry e) => e.RelPath, (PayloadEntry e) => e, StringComparer.Ordinal);
			List<PayloadEntry> list = new List<PayloadEntry>();
			List<PayloadEntry> list2 = new List<PayloadEntry>();
			foreach (PayloadEntry item in want.Values.OrderBy<PayloadEntry, string>((PayloadEntry e) => e.RelPath, StringComparer.Ordinal))
			{
				if (!dictionary.TryGetValue(item.RelPath, out var value))
				{
					list.Add(item);
				}
				else if (!string.Equals(value.Sha256, item.Sha256, StringComparison.Ordinal))
				{
					list2.Add(item);
				}
			}
			List<string> removed = dictionary.Keys.Where((string k) => !want.ContainsKey(k)).OrderBy<string, string>((string k) => k, StringComparer.Ordinal).ToList();
			return new PayloadDiff(list, list2, removed);
		}

		public IEnumerable<string> Describe()
		{
			return Added.Select((PayloadEntry e) => "  + " + e.RelPath).Concat(Changed.Select((PayloadEntry e) => "  ~ " + e.RelPath)).Concat(Removed.Select((string p) => "  - " + p));
		}
	}
	public static class PayloadGuard
	{
		public const int AbsoluteFloor = 5;

		public const int DefaultMaxDeletePercent = 25;

		public static bool IsMassDelete(int previousCount, int deleteCount, int maxDeletePercent, out string why)
		{
			why = string.Empty;
			int num = Math.Max(0, Math.Min(100, maxDeletePercent));
			if (num >= 100)
			{
				return false;
			}
			if (deleteCount <= 5)
			{
				return false;
			}
			if (previousCount <= 0)
			{
				return false;
			}
			if ((long)deleteCount * 100L <= (long)previousCount * (long)num)
			{
				return false;
			}
			why = $"the plan deletes {deleteCount} of {previousCount} file(s) " + $"(> {num}% and > {5} files). This is far more likely a broken scan than a real " + "uninstall. If it IS deliberate, set [Payload] MaxDeletePercent=100 for one pass.";
			return true;
		}
	}
	public sealed class ScanResult
	{
		public PayloadManifest Manifest { get; }

		public bool TierCacheHit { get; }

		public int FilesHashed { get; }

		public int FilesReused { get; }

		public long BytesHashed { get; }

		public IReadOnlyList<string> Unreadable { get; }

		public bool IsComplete => Unreadable.Count == 0;

		public string Summary => (TierCacheHit ? "prefilter hit (0 files hashed)" : $"{FilesHashed} hashed / {FilesReused} reused ({BytesHashed / 1024} KiB read)") + (IsComplete ? string.Empty : $", {Unreadable.Count} UNREADABLE");

		public ScanResult(PayloadManifest manifest, bool tierCacheHit, int hashed, int reused, long bytesHashed, IReadOnlyList<string>? unreadable = null)
		{
			Manifest = manifest;
			TierCacheHit = tierCacheHit;
			FilesHashed = hashed;
			FilesReused = reused;
			BytesHashed = bytesHashed;
			Unreadable = unreadable ?? Array.Empty<string>();
		}
	}
	public static class PayloadHasher
	{
		public static string HashFile(string path)
		{
			using SHA256 sHA = SHA256.Create();
			using FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 65536);
			return ToHex(sHA.ComputeHash(inputStream));
		}

		public static string HashBytes(byte[] bytes)
		{
			using SHA256 sHA = SHA256.Create();
			return ToHex(sHA.ComputeHash(bytes ?? Array.Empty<byte>()));
		}

		public static IReadOnlyList<FileStat> Walk(string root, PayloadScope scope, ICollection<string>? unreadable = null)
		{
			List<FileStat> list = new List<FileStat>();
			if (string.IsNullOrEmpty(root) || !Directory.Exists(root))
			{
				return list;
			}
			string fullPath = Path.GetFullPath(root);
			foreach (string item in SafeEnumerate(fullPath, fullPath, scope, unreadable))
			{
				string text;
				try
				{
					text = PayloadScope.Normalize(Path.GetFullPath(item).Substring(fullPath.Length));
				}
				catch
				{
					unreadable?.Add(item);
					continue;
				}
				if (text.Length == 0 || scope.IsExcluded(text))
				{
					continue;
				}
				try
				{
					FileInfo fileInfo = new FileInfo(item);
					if (fileInfo.Exists)
					{
						list.Add(new FileStat(text, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks));
					}
				}
				catch
				{
					unreadable?.Add(text);
				}
			}
			return list.OrderBy<FileStat, string>((FileStat s) => s.RelPath, StringComparer.Ordinal).ToList();
		}

		public static ScanResult Scan(PayloadTier tier, string root, IReadOnlyList<FileStat> stats, PayloadScanCache cache, IReadOnlyDictionary<string, string>? modVersions = null, bool force = false, IReadOnlyList<string>? walkUnreadable = null)
		{
			string statSignature = PayloadScanCache.StatSignature(stats);
			bool flag = walkUnreadable != null && walkUnreadable.Count > 0;
			if (!force && !flag && cache.TryReuseTier(tier, statSignature, out string fingerprint))
			{
				List<PayloadEntry> list = new List<PayloadEntry>(stats.Count);
				bool flag2 = true;
				foreach (FileStat stat in stats)
				{
					if (!cache.TryReuse(tier, stat, out string sha))
					{
						flag2 = false;
						break;
					}
					list.Add(new PayloadEntry(stat.RelPath, stat.Size, sha));
				}
				if (flag2)
				{
					PayloadManifest payloadManifest = new PayloadManifest(tier, list, modVersions);
					if (string.Equals(payloadManifest.Fingerprint, fingerprint, StringComparison.Ordinal))
					{
						return new ScanResult(payloadManifest, tierCacheHit: true, 0, list.Count, 0L);
					}
				}
			}
			List<PayloadEntry> list2 = new List<PayloadEntry>(stats.Count);
			List<string> list3 = null;
			int num = 0;
			int num2 = 0;
			long num3 = 0L;
			foreach (FileStat stat2 in stats)
			{
				string sha3;
				if (!force && cache.TryReuse(tier, stat2, out string sha2))
				{
					sha3 = sha2;
					num2++;
				}
				else
				{
					try
					{
						sha3 = HashFile(Path.Combine(root, stat2.RelPath.Replace('/', Path.DirectorySeparatorChar)));
					}
					catch
					{
						(list3 ?? (list3 = new List<string>())).Add(stat2.RelPath);
						continue;
					}
					num++;
					num3 += stat2.Size;
					cache.Record(tier, stat2, sha3);
				}
				list2.Add(new PayloadEntry(stat2.RelPath, stat2.Size, sha3));
			}
			if (flag)
			{
				(list3 ?? (list3 = new List<string>())).AddRange(walkUnreadable);
			}
			PayloadManifest payloadManifest2 = new PayloadManifest(tier, list2, modVersions);
			if (list3 == null)
			{
				cache.RecordTier(tier, statSignature, payloadManifest2.Fingerprint, stats);
			}
			return new ScanResult(payloadManifest2, tierCacheHit: false, num, num2, num3, list3);
		}

		private static IEnumerable<string> SafeEnumerate(string root, string rootFull, PayloadScope? scope, ICollection<string>? unreadable)
		{
			Stack<string> pending = new Stack<string>();
			pending.Push(root);
			while (pending.Count > 0)
			{
				string text = pending.Pop();
				string[] files;
				string[] dirs;
				try
				{
					files = Directory.GetFiles(text);
					dirs = Directory.GetDirectories(text);
				}
				catch
				{
					if (unreadable != null)
					{
						string item;
						try
						{
							item = PayloadScope.Normalize(Path.GetFullPath(text).Substring(rootFull.Length)) + "/**";
						}
						catch
						{
							item = text + "/**";
						}
						unreadable.Add(item);
					}
					continue;
				}
				string[] array = files;
				for (int i = 0; i < array.Length; i++)
				{
					yield return array[i];
				}
				string[] array2 = dirs;
				foreach (string text2 in array2)
				{
					if (scope == null || !IsExcludedDir(text2, rootFull, scope))
					{
						pending.Push(text2);
					}
				}
			}
		}

		private static bool IsExcludedDir(string dir, string rootFull, PayloadScope scope)
		{
			try
			{
				string text = PayloadScope.Normalize(Path.GetFullPath(dir).Substring(rootFull.Length));
				return text.Length > 0 && scope.IsExcluded(text);
			}
			catch
			{
				return false;
			}
		}

		private static string ToHex(byte[] hash)
		{
			char[] array = new char[hash.Length * 2];
			for (int i = 0; i < hash.Length; i++)
			{
				array[i * 2] = "0123456789abcdef"[hash[i] >> 4];
				array[i * 2 + 1] = "0123456789abcdef"[hash[i] & 0xF];
			}
			return new string(array);
		}
	}
	public sealed class PayloadLedgerEntry
	{
		public int Gen { get; }

		public string Fingerprint { get; }

		public string Device { get; }

		public string PublishedUtc { get; }

		public PayloadLedgerEntry(int gen, string fingerprint, string device, string publishedUtc)
		{
			Gen = gen;
			Fingerprint = fingerprint ?? string.Empty;
			Device = device ?? string.Empty;
			PublishedUtc = publishedUtc ?? string.Empty;
		}
	}
	public sealed class PayloadLedger
	{
		private readonly Dictionary<PayloadTier, PayloadLedgerEntry> _entries = new Dictionary<PayloadTier, PayloadLedgerEntry>();

		public PayloadLedgerEntry? Get(PayloadTier tier)
		{
			if (!_entries.TryGetValue(tier, out PayloadLedgerEntry value))
			{
				return null;
			}
			return value;
		}

		public void Set(PayloadTier tier, PayloadLedgerEntry entry)
		{
			_entries[tier] = entry;
		}

		public string Serialize()
		{
			return string.Join("\n", PayloadTiers.All.Where((PayloadTier t) => _entries.ContainsKey(t)).Select(delegate(PayloadTier t)
			{
				PayloadLedgerEntry payloadLedgerEntry = _entries[t];
				return PayloadTiers.Name(t) + "|" + payloadLedgerEntry.Gen.ToString(CultureInfo.InvariantCulture) + "|" + Escape(payloadLedgerEntry.Fingerprint) + "|" + Escape(payloadLedgerEntry.Device) + "|" + Escape(payloadLedgerEntry.PublishedUtc);
			}));
		}

		public static PayloadLedger Parse(string? text)
		{
			PayloadLedger payloadLedger = new PayloadLedger();
			if (string.IsNullOrEmpty(text))
			{
				return payloadLedger;
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					string[] array2 = text2.Split(new char[1] { '|' });
					if (array2.Length >= 4 && PayloadTiers.TryParse(array2[0], out var tier) && int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						payloadLedger._entries[tier] = new PayloadLedgerEntry(result, Unescape(array2[2]), Unescape(array2[3]), (array2.Length >= 5) ? Unescape(array2[4]) : string.Empty);
					}
				}
			}
			return payloadLedger;
		}

		private static string Escape(string s)
		{
			return LineCodec.Escape(s);
		}

		private static string Unescape(string s)
		{
			return LineCodec.Unescape(s);
		}
	}
	public sealed class PayloadEntry
	{
		public string RelPath { get; }

		public long Size { get; }

		public string Sha256 { get; }

		public PayloadEntry(string relPath, long size, string sha256)
		{
			RelPath = PayloadScope.Normalize(relPath);
			Size = size;
			Sha256 = (sha256 ?? string.Empty).ToLowerInvariant();
		}
	}
	public sealed class PayloadManifest
	{
		public const int FormatVersion = 1;

		public PayloadTier Tier { get; }

		public IReadOnlyList<PayloadEntry> Entries { get; }

		public IReadOnlyDictionary<string, string> ModVersions { get; }

		public bool IsEmpty => Entries.Count == 0;

		public long TotalBytes => Entries.Sum((PayloadEntry e) => e.Size);

		public string Fingerprint => Fnv1a.HashLines(Entries.Select((PayloadEntry e) => e.RelPath + "|" + e.Sha256));

		public PayloadManifest(PayloadTier tier, IEnumerable<PayloadEntry> entries, IReadOnlyDictionary<string, string>? modVersions = null)
		{
			Tier = tier;
			Entries = (from g in (entries ?? Array.Empty<PayloadEntry>()).Where((PayloadEntry e) => e != null && e.RelPath.Length > 0).GroupBy<PayloadEntry, string>((PayloadEntry e) => e.RelPath, StringComparer.Ordinal)
				select g.First()).OrderBy<PayloadEntry, string>((PayloadEntry e) => e.RelPath, StringComparer.Ordinal).ToList();
			ModVersions = modVersions ?? new Dictionary<string, string>(StringComparer.Ordinal);
		}

		public static PayloadManifest Empty(PayloadTier tier)
		{
			return new PayloadManifest(tier, Array.Empty<PayloadEntry>());
		}

		public PayloadEntry? Get(string relPath)
		{
			string norm = PayloadScope.Normalize(relPath);
			return Entries.FirstOrDefault((PayloadEntry e) => string.Equals(e.RelPath, norm, StringComparison.Ordinal));
		}

		public string Serialize()
		{
			List<string> list = new List<string> { "V|" + 1.ToString(CultureInfo.InvariantCulture) + "|" + PayloadTiers.Name(Tier) };
			foreach (KeyValuePair<string, string> item in ModVersions.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.Ordinal))
			{
				list.Add("M|" + Escape(item.Key) + "|" + Escape(item.Value));
			}
			foreach (PayloadEntry entry in Entries)
			{
				list.Add("F|" + Escape(entry.RelPath) + "|" + entry.Size.ToString(CultureInfo.InvariantCulture) + "|" + entry.Sha256);
			}
			return string.Join("\n", list);
		}

		public static PayloadManifest? Parse(string? text, PayloadTier fallbackTier)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			PayloadTier tier = fallbackTier;
			List<PayloadEntry> list = new List<PayloadEntry>();
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			bool flag = false;
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length < 2)
				{
					continue;
				}
				switch (array2[0])
				{
				case "V":
				{
					if (!int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
					{
						return null;
					}
					if (result2 > 1)
					{
						return null;
					}
					if (array2.Length >= 3 && PayloadTiers.TryParse(array2[2], out var tier2))
					{
						tier = tier2;
					}
					flag = true;
					break;
				}
				case "M":
					if (array2.Length >= 3)
					{
						dictionary[Unescape(array2[1])] = Unescape(array2[2]);
					}
					break;
				case "F":
				{
					if (array2.Length >= 4 && long.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						list.Add(new PayloadEntry(Unescape(array2[1]), result, array2[3]));
					}
					break;
				}
				}
			}
			if (!flag)
			{
				return null;
			}
			return new PayloadManifest(tier, list, dictionary);
		}

		private static string Escape(string s)
		{
			return LineCodec.Escape(s);
		}

		private static string Unescape(string s)
		{
			return LineCodec.Unescape(s);
		}
	}
	public enum PayloadAction
	{
		UpToDate,
		Pull,
		Push,
		Conflict,
		ShareEmpty
	}
	public sealed class PayloadPlan
	{
		public PayloadTier Tier { get; }

		public PayloadAction Action { get; }

		public int NewGen { get; }

		public string LocalFingerprint { get; }

		public string ShareFingerprint { get; }

		public string Reason { get; }

		public PayloadPlan(PayloadTier tier, PayloadAction action, int newGen, string localFingerprint, string shareFingerprint, string reason)
		{
			Tier = tier;
			Action = action;
			NewGen = newGen;
			LocalFingerprint = localFingerprint ?? string.Empty;
			ShareFingerprint = shareFingerprint ?? string.Empty;
			Reason = reason ?? string.Empty;
		}
	}
	public static class PayloadReconciler
	{
		public static PayloadPlan Plan(PayloadTier tier, string? localFingerprint, bool localScanned, PayloadManifest? shareManifest, PayloadLedgerEntry? ledger, PayloadTierState? state)
		{
			string text = localFingerprint ?? string.Empty;
			string text2 = shareManifest?.Fingerprint ?? string.Empty;
			int num = ledger?.Gen ?? 0;
			int num2 = state?.BasedOnGen ?? 0;
			if (shareManifest == null || shareManifest.IsEmpty || num <= 0 || text2.Length <= 0)
			{
				if (!localScanned || text.Length == 0)
				{
					return Make(tier, PayloadAction.ShareEmpty, num, text, text2, "share has no published payload and this device has nothing scanned");
				}
				return Make(tier, PayloadAction.Push, Math.Max(num, num2) + 1, text, text2, "first publish — share has no payload for this tier");
			}
			if (!localScanned)
			{
				return Make(tier, PayloadAction.ShareEmpty, num, text, text2, "local tier could not be scanned — refusing to act");
			}
			if (string.Equals(text, text2, StringComparison.Ordinal))
			{
				return Make(tier, PayloadAction.UpToDate, Math.Max(num, num2), text, text2, "fingerprints match");
			}
			if (state == null)
			{
				return Make(tier, PayloadAction.Conflict, num, text, text2, "no lineage record and both sides hold a payload");
			}
			bool flag = !string.Equals(text, state.LastPushedFingerprint, StringComparison.Ordinal);
			bool flag2 = num > num2;
			if (flag && !flag2)
			{
				return Make(tier, PayloadAction.Push, num2 + 1, text, text2, "this device changed since its last publish");
			}
			if (!flag && flag2)
			{
				return Make(tier, PayloadAction.Pull, num, text, text2, "share advanced to gen " + num + " and this device is unchanged");
			}
			if (!flag && !flag2)
			{
				if (num < num2)
				{
					return Make(tier, PayloadAction.Conflict, num, text, text2, "ledger generation went backwards (share gen " + num + " < basedOn " + num2 + ")");
				}
				if (tier == PayloadTier.Config)
				{
					return Make(tier, PayloadAction.UpToDate, Math.Max(num, num2), text, text2, "converged — this device reproduces its last sync and the share is unchanged");
				}
				return Make(tier, PayloadAction.Conflict, num, text, text2, "share fingerprint changed without a generation bump");
			}
			return Make(tier, PayloadAction.Conflict, num, text, text2, "both this device and the share changed");
		}

		private static PayloadPlan Make(PayloadTier tier, PayloadAction action, int gen, string localFp, string shareFp, string reason)
		{
			return new PayloadPlan(tier, action, gen, localFp, shareFp, reason);
		}
	}
	public sealed class FileStat
	{
		public string RelPath { get; }

		public long Size { get; }

		public long MtimeTicks { get; }

		public FileStat(string relPath, long size, long mtimeTicks)
		{
			RelPath = PayloadScope.Normalize(relPath);
			Size = size;
			MtimeTicks = mtimeTicks;
		}
	}
	public sealed class PayloadScanCache
	{
		private sealed class Row
		{
			public long Size;

			public long MtimeTicks;

			public string Sha256 = string.Empty;
		}

		private readonly object _gate = new object();

		private readonly Dictionary<string, Row> _rows = new Dictionary<string, Row>(StringComparer.Ordinal);

		private readonly Dictionary<PayloadTier, string> _statSig = new Dictionary<PayloadTier, string>();

		private readonly Dictionary<PayloadTier, string> _fingerprint = new Dictionary<PayloadTier, string>();

		public static string StatSignature(IEnumerable<FileStat> stats)
		{
			return Fnv1a.HashLines((stats ?? Array.Empty<FileStat>()).Select((FileStat s) => s.RelPath + "|" + s.Size.ToString(CultureInfo.InvariantCulture) + "|" + s.MtimeTicks.ToString(CultureInfo.InvariantCulture)));
		}

		public bool TryReuseTier(PayloadTier tier, string statSignature, out string fingerprint)
		{
			lock (_gate)
			{
				fingerprint = string.Empty;
				if (!_statSig.TryGetValue(tier, out string value) || !string.Equals(value, statSignature, StringComparison.Ordinal))
				{
					return false;
				}
				if (!_fingerprint.TryGetValue(tier, out string value2) || value2.Length == 0)
				{
					return false;
				}
				fingerprint = value2;
				return true;
			}
		}

		public bool TryReuse(PayloadTier tier, FileStat stat, out string sha256)
		{
			lock (_gate)
			{
				sha256 = string.Empty;
				if (!_rows.TryGetValue(Key(tier, stat.RelPath), out Row value))
				{
					return false;
				}
				if (value.Size != stat.Size || value.MtimeTicks != stat.MtimeTicks)
				{
					return false;
				}
				if (value.Sha256.Length == 0)
				{
					return false;
				}
				sha256 = value.Sha256;
				return true;
			}
		}

		public void Record(PayloadTier tier, FileStat stat, string sha256)
		{
			lock (_gate)
			{
				_rows[Key(tier, stat.RelPath)] = new Row
				{
					Size = stat.Size,
					MtimeTicks = stat.MtimeTicks,
					Sha256 = (sha256 ?? string.Empty).ToLowerInvariant()
				};
			}
		}

		public void RecordTier(PayloadTier tier, string statSignature, string fingerprint, IEnumerable<FileStat> present)
		{
			lock (_gate)
			{
				_statSig[tier] = statSignature ?? string.Empty;
				_fingerprint[tier] = fingerprint ?? string.Empty;
				HashSet<string> keep = new HashSet<string>((present ?? Array.Empty<FileStat>()).Select((FileStat s) => Key(tier, s.RelPath)), StringComparer.Ordinal);
				string prefix = PayloadTiers.Name(tier) + "|";
				foreach (string item in _rows.Keys.Where((string k) => k.StartsWith(prefix, StringComparison.Ordinal) && !keep.Contains(k)).ToList())
				{
					_rows.Remove(item);
				}
			}
		}

		public void Invalidate(PayloadTier tier)
		{
			lock (_gate)
			{
				_statSig.Remove(tier);
				_fingerprint.Remove(tier);
				string prefix = PayloadTiers.Name(tier) + "|";
				foreach (string item in _rows.Keys.Where((string k) => k.StartsWith(prefix, StringComparison.Ordinal)).ToList())
				{
					_rows.Remove(item);
				}
			}
		}

		public string Serialize()
		{
			lock (_gate)
			{
				List<string> list = new List<string>();
				PayloadTier[] all = PayloadTiers.All;
				foreach (PayloadTier payloadTier in all)
				{
					if (_statSig.TryGetValue(payloadTier, out string value))
					{
						_fingerprint.TryGetValue(payloadTier, out string value2);
						list.Add("T|" + PayloadTiers.Name(payloadTier) + "|" + value + "|" + (value2 ?? string.Empty));
					}
				}
				foreach (KeyValuePair<string, Row> item in _rows.OrderBy<KeyValuePair<string, Row>, string>((KeyValuePair<string, Row> k) => k.Key, StringComparer.Ordinal))
				{
					int num = item.Key.IndexOf('|');
					string text = item.Key.Substring(0, num);
					string s = item.Key.Substring(num + 1);
					list.Add("R|" + text + "|" + Escape(s) + "|" + item.Value.Size.ToString(CultureInfo.InvariantCulture) + "|" + item.Value.MtimeTicks.ToString(CultureInfo.InvariantCulture) + "|" + item.Value.Sha256);
				}
				return string.Join("\n", list);
			}
		}

		public static PayloadScanCache Parse(string? text)
		{
			PayloadScanCache payloadScanCache = new PayloadScanCache();
			if (string.IsNullOrEmpty(text))
			{
				return payloadScanCache;
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length >= 3 && PayloadTiers.TryParse(array2[1], out var tier))
				{
					long result;
					long result2;
					if (array2[0] == "T")
					{
						payloadScanCache._statSig[tier] = array2[2];
						payloadScanCache._fingerprint[tier] = ((array2.Length >= 4) ? array2[3] : string.Empty);
					}
					else if (array2[0] == "R" && array2.Length >= 6 && long.TryParse(array2[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out result) && long.TryParse(array2[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2))
					{
						payloadScanCache._rows[Key(tier, Unescape(array2[2]))] = new Row
						{
							Size = result,
							MtimeTicks = result2,
							Sha256 = array2[5]
						};
					}
				}
			}
			return payloadScanCache;
		}

		private static string Key(PayloadTier tier, string relPath)
		{
			return PayloadTiers.Name(tier) + "|" + relPath;
		}

		private static string Escape(string s)
		{
			return (s ?? string.Empty).Replace("|", "%7C");
		}

		private static string Unescape(string s)
		{
			return s.Replace("%7C", "|");
		}
	}
	public sealed class PayloadScope
	{
		public static readonly string[] ExcludedNames = new string[20]
		{
			"*.cfg", "*.log", "*_cmd.txt", "bw_pets_*", "bw_registries", "ck_expeditions*", "bw_expeditions*", "*.bak*", "SaveGames*", "OptionSettings*",
			"*Keymappings*", "cloudward_state.txt", "cloudward_payload_state.txt", "cloudward_payload_cache.txt", ".cloudward-*", "cloudward-staged", ".owner.lock", ".payload-ledger", ".sync-backups", ".cloudward-disable"
		};

		public static readonly string[] ExcludedPaths = new string[4] { "BepInEx/config", "BepInEx/cache", "BepInEx/cloudward-staged", "SaveGames" };

		private readonly string[] _extra;

		public IReadOnlyList<string> ActivePatterns => ExcludedNames.Concat(_extra).ToList();

		public PayloadScope(IEnumerable<string>? extra = null)
		{
			_extra = (from p in extra ?? Array.Empty<string>()
				select (p ?? string.Empty).Trim() into p
				where p.Length > 0
				select p).ToArray();
		}

		public static PayloadScope FromConfig(string? extraExcludes)
		{
			return new PayloadScope((extraExcludes ?? string.Empty).Split(new char[1] { ';' }));
		}

		public bool IsExcluded(string? relPath)
		{
			string text = Normalize(relPath);
			if (text.Length == 0)
			{
				return true;
			}
			string[] excludedPaths = ExcludedPaths;
			foreach (string text2 in excludedPaths)
			{
				if (text.Equals(text2, StringComparison.OrdinalIgnoreCase) || text.StartsWith(text2 + "/", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			excludedPaths = text.Split(new char[1] { '/' });
			foreach (string text3 in excludedPaths)
			{
				if (text3.Length == 0)
				{
					continue;
				}
				string[] excludedNames = ExcludedNames;
				for (int j = 0; j < excludedNames.Length; j++)
				{
					if (GlobMatch(excludedNames[j], text3))
					{
						return true;
					}
				}
				excludedNames = _extra;
				for (int j = 0; j < excludedNames.Length; j++)
				{
					if (GlobMatch(excludedNames[j], text3))
					{
						return true;
					}
				}
			}
			return false;
		}

		public IReadOnlyList<string> Filter(IEnumerable<string> relPaths)
		{
			return (from p in (relPaths ?? Array.Empty<string>()).Select(Normalize)
				where p.Length > 0 && !IsExcluded(p)
				select p).OrderBy<string, string>((string p) => p, StringComparer.Ordinal).ToList();
		}

		public static string Normalize(string? relPath)
		{
			return (relPath ?? string.Empty).Replace('\\', '/').Trim(new char[1] { '/' });
		}

		public static string ToNative(string? relPath)
		{
			return (relPath ?? string.Empty).Replace('/', Path.DirectorySeparatorChar);
		}

		public static bool GlobMatch(string pattern, string text)
		{
			int i = 0;
			int num = 0;
			int num2 = -1;
			int num3 = 0;
			while (num < text.Length)
			{
				if (i < pattern.Length && (pattern[i] == '?' || Same(pattern[i], text[num])))
				{
					i++;
					num++;
					continue;
				}
				if (i < pattern.Length && pattern[i] == '*')
				{
					num2 = i++;
					num3 = num;
					continue;
				}
				if (num2 >= 0)
				{
					i = num2 + 1;
					num = ++num3;
					continue;
				}
				return false;
			}
			for (; i < pattern.Length && pattern[i] == '*'; i++)
			{
			}
			return i == pattern.Length;
		}

		private static bool Same(char a, char b)
		{
			return char.ToUpperInvariant(a) == char.ToUpperInvariant(b);
		}
	}
	public enum FileOpKind
	{
		Copy,
		Delete
	}
	public sealed class FileOp
	{
		public FileOpKind Kind { get; }

		public string RelPath { get; }

		public string Sha256 { get; }

		public FileOp(FileOpKind kind, string relPath, string sha256)
		{
			Kind = kind;
			RelPath = PayloadScope.Normalize(relPath);
			Sha256 = (sha256 ?? string.Empty).ToLowerInvariant();
		}
	}
	public sealed class CfgOp
	{
		public string Guid { get; }

		public CfgKey Key { get; }

		public string Value { get; }

		public string CfgRelPath => "BepInEx/config/" + Guid + ".cfg";

		public CfgOp(string guid, CfgKey key, string value)
		{
			Guid = guid ?? string.Empty;
			Key = key;
			Value = value ?? string.Empty;
		}
	}
	public sealed class StagePlan
	{
		public const int FormatVersion = 1;

		public const string FilesDir = "files";

		public const string PlanFileName = "stage.plan";

		public const string PluginsRoot = "BepInEx/plugins";

		public const string ConfigRoot = "BepInEx/config";

		public IReadOnlyList<PayloadTier> Tiers { get; }

		public IReadOnlyList<FileOp> FileOps { get; }

		public IReadOnlyList<CfgOp> CfgOps { get; }

		public IReadOnlyDictionary<PayloadTier, int> Generations { get; }

		public bool IsEmpty
		{
			get
			{
				if (FileOps.Count == 0)
				{
					return CfgOps.Count == 0;
				}
				return false;
			}
		}

		public StagePlan(IEnumerable<PayloadTier> tiers, IEnumerable<FileOp> fileOps, IEnumerable<CfgOp> cfgOps, IReadOnlyDictionary<PayloadTier, int>? generations = null)
		{
			Tiers = (from t in (tiers ?? Array.Empty<PayloadTier>()).Distinct()
				orderby (int)t
				select t).ToList();
			FileOps = (fileOps ?? Array.Empty<FileOp>()).OrderBy<FileOp, string>((FileOp o) => o.RelPath, StringComparer.Ordinal).ToList();
			CfgOps = (cfgOps ?? Array.Empty<CfgOp>()).OrderBy<CfgOp, string>((CfgOp o) => o.Guid, StringComparer.Ordinal).ThenBy((CfgOp o) => o.Key).ToList();
			Generations = generations ?? new Dictionary<PayloadTier, int>();
			Validate();
		}

		private void Validate()
		{
			PayloadScope payloadScope = new PayloadScope();
			foreach (FileOp fileOp in FileOps)
			{
				if (fileOp.RelPath.Length == 0)
				{
					throw new InvalidDataException("stage op with an empty path");
				}
				if (fileOp.RelPath.Contains(".."))
				{
					throw new InvalidDataException("stage op escapes the tree: " + fileOp.RelPath);
				}
				if (!fileOp.RelPath.StartsWith("BepInEx/plugins/", StringComparison.OrdinalIgnoreCase))
				{
					throw new InvalidDataException("stage op outside BepInEx/plugins/: " + fileOp.RelPath);
				}
				string relPath = fileOp.RelPath.Substring("BepInEx/plugins".Length + 1);
				if (payloadScope.IsExcluded(relPath))
				{
					throw new InvalidDataException("stage op names an excluded path: " + fileOp.RelPath);
				}
				if (fileOp.Kind == FileOpKind.Copy && fileOp.Sha256.Length != 64)
				{
					throw new InvalidDataException("copy op without a usable sha256: " + fileOp.RelPath);
				}
			}
			foreach (CfgOp cfgOp in CfgOps)
			{
				if (cfgOp.Guid.Length == 0 || cfgOp.Guid.IndexOfAny(new char[3] { '/', '\\', '.' }) == 0)
				{
					throw new InvalidDataException("cfg op with a bad guid: \"" + cfgOp.Guid + "\"");
				}
				if (cfgOp.Guid.Contains("..") || cfgOp.Guid.IndexOf('/') >= 0 || cfgOp.Guid.IndexOf('\\') >= 0)
				{
					throw new InvalidDataException("cfg op escapes the config dir: \"" + cfgOp.Guid + "\"");
				}
			}
		}

		public string Serialize()
		{
			List<string> list = new List<string> { "V|" + 1.ToString(CultureInfo.InvariantCulture) };
			foreach (PayloadTier tier in Tiers)
			{
				Generations.TryGetValue(tier, out var value);
				list.Add("T|" + PayloadTiers.Name(tier) + "|" + value.ToString(CultureInfo.InvariantCulture));
			}
			foreach (FileOp fileOp in FileOps)
			{
				list.Add(((fileOp.Kind == FileOpKind.Copy) ? "C|" : "D|") + Escape(fileOp.RelPath) + ((fileOp.Kind == FileOpKind.Copy) ? ("|" + fileOp.Sha256) : string.Empty));
			}
			foreach (CfgOp cfgOp in CfgOps)
			{
				list.Add("K|" + Escape(cfgOp.Guid) + "|" + Escape(cfgOp.Key.Section) + "|" + Escape(cfgOp.Key.Key) + "|" + Escape(cfgOp.Value));
			}
			return string.Join("\n", list);
		}

		public static StagePlan? Parse(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			List<PayloadTier> list = new List<PayloadTier>();
			Dictionary<PayloadTier, int> dictionary = new Dictionary<PayloadTier, int>();
			List<FileOp> list2 = new List<FileOp>();
			List<CfgOp> list3 = new List<CfgOp>();
			bool flag = false;
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length < 2)
				{
					continue;
				}
				switch (array2[0])
				{
				case "V":
				{
					if (!int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
					{
						return null;
					}
					if (result2 > 1)
					{
						return null;
					}
					flag = true;
					break;
				}
				case "T":
				{
					if (!PayloadTiers.TryParse(array2[1], out var tier))
					{
						return null;
					}
					list.Add(tier);
					if (array2.Length >= 3 && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						dictionary[tier] = result;
					}
					break;
				}
				case "C":
					if (array2.Length < 3)
					{
						return null;
					}
					list2.Add(new FileOp(FileOpKind.Copy, Unescape(array2[1]), array2[2]));
					break;
				case "D":
					list2.Add(new FileOp(FileOpKind.Delete, Unescape(array2[1]), string.Empty));
					break;
				case "K":
					if (array2.Length < 5)
					{
						return null;
					}
					list3.Add(new CfgOp(Unescape(array2[1]), new CfgKey(Unescape(array2[2]), Unescape(array2[3])), Unescape(array2[4])));
					break;
				default:
					return null;
				}
			}
			if (!flag)
			{
				return null;
			}
			try
			{
				return new StagePlan(list, list2, list3, dictionary);
			}
			catch (InvalidDataException)
			{
				return null;
			}
		}

		public static IReadOnlyList<FileOp> PluginOps(PayloadDiff diff)
		{
			List<FileOp> list = new List<FileOp>();
			foreach (PayloadEntry item in diff.Added.Concat(diff.Changed))
			{
				list.Add(new FileOp(FileOpKind.Copy, "BepInEx/plugins/" + item.RelPath, item.Sha256));
			}
			foreach (string item2 in diff.Removed)
			{
				list.Add(new FileOp(FileOpKind.Delete, "BepInEx/plugins/" + item2, string.Empty));
			}
			return list;
		}

		private static string Escape(string s)
		{
			return LineCodec.Escape(s);
		}

		private static string Unescape(string s)
		{
			return LineCodec.Unescape(s);
		}
	}
	public sealed class PayloadTierState
	{
		public int BasedOnGen { get; }

		public string LastPushedFingerprint { get; }

		public PayloadTierState(int basedOnGen, string lastPushedFingerprint)
		{
			BasedOnGen = basedOnGen;
			LastPushedFingerprint = lastPushedFingerprint ?? string.Empty;
		}
	}
	public sealed class PayloadConflictRecord
	{
		public string LocalFingerprint { get; }

		public string ShareFingerprint { get; }

		public int ShareGen { get; }

		public PayloadConflictRecord(string localFingerprint, string shareFingerprint, int shareGen)
		{
			LocalFingerprint = localFingerprint ?? string.Empty;
			ShareFingerprint = shareFingerprint ?? string.Empty;
			ShareGen = shareGen;
		}
	}
	public sealed class PayloadState
	{
		private readonly object _gate = new object();

		private readonly Dictionary<PayloadTier, PayloadTierState> _state = new Dictionary<PayloadTier, PayloadTierState>();

		private readonly Dictionary<PayloadTier, PayloadConflictRecord> _conflicts = new Dictionary<PayloadTier, PayloadConflictRecord>();

		private readonly Dictionary<PayloadTier, PayloadTierState> _staged = new Dictionary<PayloadTier, PayloadTierState>();

		private readonly HashSet<string> _introduced = new HashSet<string>(StringComparer.Ordinal);

		public IReadOnlyList<PayloadTier> PendingConflicts
		{
			get
			{
				lock (_gate)
				{
					return _conflicts.Keys.ToList();
				}
			}
		}

		public bool HasConflicts
		{
			get
			{
				lock (_gate)
				{
					return _conflicts.Count > 0;
				}
			}
		}

		public IReadOnlyList<PayloadTier> Staged
		{
			get
			{
				lock (_gate)
				{
					return _staged.Keys.ToList();
				}
			}
		}

		public PayloadTierState? Get(PayloadTier t)
		{
			lock (_gate)
			{
				PayloadTierState value;
				return _state.TryGetValue(t, out value) ? value : null;
			}
		}

		public void Set(PayloadTier t, PayloadTierState s)
		{
			lock (_gate)
			{
				_state[t] = s;
			}
		}

		public PayloadConflictRecord? GetConflict(PayloadTier t)
		{
			lock (_gate)
			{
				PayloadConflictRecord value;
				return _conflicts.TryGetValue(t, out value) ? value : null;
			}
		}

		public void SetConflict(PayloadTier t, PayloadConflictRecord c)
		{
			lock (_gate)
			{
				_conflicts[t] = c;
			}
		}

		public void ClearConflict(PayloadTier t)
		{
			lock (_gate)
			{
				_conflicts.Remove(t);
			}
		}

		public PayloadTierState? GetStaged(PayloadTier t)
		{
			lock (_gate)
			{
				PayloadTierState value;
				return _staged.TryGetValue(t, out value) ? value : null;
			}
		}

		public void SetStaged(PayloadTier t, PayloadTierState s)
		{
			lock (_gate)
			{
				_staged[t] = s;
			}
		}

		public void ClearStaged(PayloadTier t)
		{
			lock (_gate)
			{
				_staged.Remove(t);
			}
		}

		public bool IsIntroduced(string payloadRoot)
		{
			lock (_gate)
			{
				return _introduced.Contains(payloadRoot ?? string.Empty);
			}
		}

		public void MarkIntroduced(string payloadRoot)
		{
			lock (_gate)
			{
				_introduced.Add(payloadRoot ?? string.Empty);
			}
		}

		public string Serialize()
		{
			lock (_gate)
			{
				List<string> list = new List<string>();
				PayloadTier[] all = PayloadTiers.All;
				foreach (PayloadTier payloadTier in all)
				{
					if (_state.TryGetValue(payloadTier, out PayloadTierState value))
					{
						list.Add("S|" + PayloadTiers.Name(payloadTier) + "|" + value.BasedOnGen.ToString(CultureInfo.InvariantCulture) + "|" + Escape(value.LastPushedFingerprint));
					}
					if (_conflicts.TryGetValue(payloadTier, out PayloadConflictRecord value2))
					{
						list.Add("C|" + PayloadTiers.Name(payloadTier) + "|" + Escape(value2.LocalFingerprint) + "|" + Escape(value2.ShareFingerprint) + "|" + value2.ShareGen.ToString(CultureInfo.InvariantCulture));
					}
					if (_staged.TryGetValue(payloadTier, out PayloadTierState value3))
					{
						list.Add("G|" + PayloadTiers.Name(payloadTier) + "|" + Escape(value3.LastPushedFingerprint) + "|" + value3.BasedOnGen.ToString(CultureInfo.InvariantCulture));
					}
				}
				foreach (string item in _introduced.OrderBy<string, string>((string k) => k, StringComparer.Ordinal))
				{
					list.Add("I|" + Escape(item));
				}
				return string.Join("\n", list);
			}
		}

		public static PayloadState Parse(string? text)
		{
			PayloadState payloadState = new PayloadState();
			if (string.IsNullOrEmpty(text))
			{
				return payloadState;
			}
			string[] array = text.Replace("\r\n", "\n").Replace('\r', '\n').Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				if (array2.Length < 2)
				{
					continue;
				}
				PayloadTier tier;
				if (array2[0] == "I")
				{
					payloadState._introduced.Add(Unescape(array2[1]));
				}
				else if (PayloadTiers.TryParse(array2[1], out tier))
				{
					int result2;
					int result3;
					if (array2[0] == "S" && array2.Length >= 4 && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						payloadState._state[tier] = new PayloadTierState(result, Unescape(array2[3]));
					}
					else if (array2[0] == "C" && array2.Length >= 5 && int.TryParse(array2[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2))
					{
						payloadState._conflicts[tier] = new PayloadConflictRecord(Unescape(array2[2]), Unescape(array2[3]), result2);
					}
					else if (array2[0] == "G" && array2.Length >= 4 && int.TryParse(array2[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out result3))
					{
						payloadState._staged[tier] = new PayloadTierState(result3, Unescape(array2[2]));
					}
				}
			}
			return payloadState;
		}

		private static string Escape(string v)
		{
			return LineCodec.Escape(v);
		}

		private static string Unescape(string v)
		{
			return LineCodec.Unescape(v);
		}
	}
	public static class PayloadStore
	{
		public const string LedgerFileName = ".payload-ledger";

		public const string LockFileName = ".owner.lock";

		public const string ManifestDir = "manifest";

		public const string TreeDir = "tree";

		public const string DevicesDir = "devices";

		public const string BackupDir = ".payload-forks";

		public const int HeartbeatEveryFiles = 25;

		public static string LedgerPath(string payloadRoot)
		{
			return Path.Combine(payloadRoot, ".payload-ledger");
		}

		public static string ManifestPath(string payloadRoot, PayloadTier tier)
		{
			return Path.Combine(payloadRoot, "manifest", PayloadTiers.Name(tier) + ".manifest");
		}

		public static string TreePath(string payloadRoot, PayloadTier tier)
		{
			return Path.Combine(payloadRoot, "tree", PayloadTiers.Name(tier));
		}

		public static string DevicePath(string payloadRoot, string device)
		{
			return Path.Combine(payloadRoot, "devices", AtomicFile.SanitizeForFileName(device) + ".json");
		}

		public static PayloadLedger ReadLedger(string payloadRoot, Action<string>? warn = null)
		{
			string text = LedgerPath(payloadRoot);
			try
			{
				return File.Exists(text) ? PayloadLedger.Parse(File.ReadAllText(text)) : new PayloadLedger();
			}
			catch (Exception ex)
			{
				Warn(warn, "payload ledger at '" + text + "' is unreadable (" + ex.GetType().Name + ": " + ex.Message + ") — reading the share as EMPTY, which means this device will try to republish its whole payload. Check the mount before letting that happen.");
				return new PayloadLedger();
			}
		}

		public static PayloadManifest? ReadManifest(string payloadRoot, PayloadTier tier, Action<string>? warn = null)
		{
			string text = ManifestPath(payloadRoot, tier);
			try
			{
				if (!File.Exists(text))
				{
					return null;
				}
				PayloadManifest payloadManifest = PayloadManifest.Parse(File.ReadAllText(text), tier);
				if (payloadManifest == null)
				{
					Warn(warn, "the share's " + PayloadTiers.Name(tier) + " manifest at '" + text + "' could not be parsed (written by a newer Cloudward?) — this device will act as if the share published nothing.");
				}
				return payloadManifest;
			}
			catch (Exception ex)
			{
				Warn(warn, "the share's " + PayloadTiers.Name(tier) + " manifest at '" + text + "' is unreadable (" + ex.GetType().Name + ": " + ex.Message + ") — this device will act as if the share published nothing.");
				return null;
			}
		}

		private static void Warn(Action<string>? warn, string message)
		{
			try
			{
				warn?.Invoke(message);
			}
			catch
			{
			}
		}

		public static void PublishTree(string payloadRoot, PayloadTier tier, string localRoot, PayloadManifest manifest, string tempSuffix, string? backupPath, Action? heartbeat = null)
		{
			string text = TreePath(payloadRoot, tier);
			string text2 = text + tempSuffix;
			try
			{
				if (Directory.Exists(text2))
				{
					Directory.Delete(text2, recursive: true);
				}
				Directory.CreateDirectory(text2);
				List<string> list = null;
				int num = 0;
				foreach (PayloadEntry entry in manifest.Entries)
				{
					if (heartbeat != null && num++ % 25 == 0)
					{
						try
						{
							heartbeat();
						}
						catch
						{
						}
					}
					string text3 = Path.Combine(localRoot, PayloadScope.ToNative(entry.RelPath));
					if (!File.Exists(text3))
					{
						(list ?? (list = new List<string>())).Add(entry.RelPath);
						continue;
					}
					string text4 = Path.Combine(text2, PayloadScope.ToNative(entry.RelPath));
					string directoryName = Path.GetDirectoryName(text4);
					if (!string.IsNullOrEmpty(directoryName))
					{
						Directory.CreateDirectory(directoryName);
					}
					File.Copy(text3, text4, overwrite: true);
				}
				if (list != null)
				{
					throw new FileNotFoundException($"{list.Count} file(s) named by the {PayloadTiers.Name(tier)} manifest vanished between " + "the scan and the publish — publish ABORTED so the share keeps a whole payload (first: " + list[0] + ")");
				}
				SwapDirIntoPlace(text2, text, backupPath);
			}
			catch
			{
				try
				{
					if (Directory.Exists(text2))
					{
						Directory.Delete(text2, recursive: true);
					}
				}
				catch
				{
				}
				try
				{
					if (!Directory.Exists(text) && !string.IsNullOrEmpty(backupPath) && Directory.Exists(backupPath))
					{
						MoveOrCopy(backupPath, text);
					}
				}
				catch
				{
				}
				throw;
			}
			WriteManifest(payloadRoot, tier, manifest, tempSuffix);
		}

		public static bool RepairTreeFromBackup(string payloadRoot, PayloadTier tier, Action<string>? warn = null, string? tempSuffix = null)
		{
			string text = TreePath(payloadRoot, tier) + (string.IsNullOrEmpty(tempSuffix) ? ".tmp-repair" : (tempSuffix + ".repair"));
			try
			{
				string path = ManifestPath(payloadRoot, tier);
				string text2 = TreePath(payloadRoot, tier);
				if (!File.Exists(path) || Directory.Exists(text2))
				{
					return false;
				}
				IReadOnlyList<string> readOnlyList = ListBackups(payloadRoot, tier);
				if (readOnlyList.Count == 0)
				{
					Warn(warn, "the share's " + PayloadTiers.Name(tier) + " manifest names a tree that DOES NOT EXIST and no backup is available — an interrupted publish; peers cannot fetch this tier until somebody publishes again.");
					return false;
				}
				if (Directory.Exists(text))
				{
					Directory.Delete(text, recursive: true);
				}
				CopyDir(Path.Combine(payloadRoot, ".payload-forks", readOnlyList[0]), text);
				if (Directory.Exists(text2))
				{
					try
					{
						Directory.Delete(text, recursive: true);
					}
					catch
					{
					}
					return false;
				}
				Directory.Move(text, text2);
				Warn(warn, "the share's " + PayloadTiers.Name(tier) + " tree was MISSING under a live manifest (interrupted publish) — restored from backup '" + readOnlyList[0] + "'.");
				return true;
			}
			catch (Exception ex)
			{
				try
				{
					if (Directory.Exists(text))
					{
						Directory.Delete(text, recursive: true);
					}
				}
				catch
				{
				}
				Warn(warn, "boot repair of the " + PayloadTiers.Name(tier) + " tree failed (" + ex.GetType().Name + ": " + ex.Message + ").");
				return false;
			}
		}

		public static void WriteManifest(string payloadRoot, PayloadTier tier, PayloadManifest manifest, string tempSuffix)
		{
			string path = ManifestPath(payloadRoot, tier);
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			AtomicFile.WriteAllText(path, manifest.Serialize(), tempSuffix);
		}

		public static void WriteLedger(string payloadRoot, PayloadLedger ledger, string tempSuffix)
		{
			Directory.CreateDirectory(payloadRoot);
			AtomicFile.WriteAllText(LedgerPath(payloadRoot), ledger.Serialize(), tempSuffix);
		}

		public static string ConfigValuesPath(string payloadRoot)
		{
			return Path.Combine(TreePath(payloadRoot, PayloadTier.Config), "values.txt");
		}

		public static void PublishConfigValues(string payloadRoot, CfgValueSet values, PayloadManifest manifest, string tempSuffix)
		{
			string path = ConfigValuesPath(payloadRoot);
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			AtomicFile.WriteAllText(path, values.Serialize(), tempSuffix);
			WriteManifest(payloadRoot, PayloadTier.Config, manifest, tempSuffix);
		}

		public static CfgValueSet ReadConfigValues(string payloadRoot)
		{
			try
			{
				string path = ConfigValuesPath(payloadRoot);
				return File.Exists(path) ? CfgValueSet.Parse(File.ReadAllText(path)) : CfgValueSet.Empty;
			}
			catch
			{
				return CfgValueSet.Empty;
			}
		}

		public static int FetchFiles(string payloadRoot