using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using HylandHelper.BridgeContracts;
using HylandHelper.BridgeMod;
using HylandHelper.PhoneTile;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.UI;
using MelonLoader;
using Microsoft.CodeAnalysis;
using S1API.GameTime;
using S1API.Leveling;
using S1API.Lifecycle;
using S1API.Money;
using S1API.PhoneApp;
using S1API.Property;
using S1API.UI;
using S1API.Utils;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(PhoneTileMod), "Hyland Helper Phone Tile", "0.1.3", "MadJag Studios", null)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MadJag Studios")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 MadJag Studios")]
[assembly: AssemblyDescription("Hyland Helper in-game phone tile for Schedule I")]
[assembly: AssemblyFileVersion("0.1.3.0")]
[assembly: AssemblyInformationalVersion("0.1.3")]
[assembly: AssemblyProduct("Hyland Helper")]
[assembly: AssemblyTitle("HylandHelper.PhoneTile")]
[assembly: AssemblyVersion("0.1.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HylandHelper.BridgeMod
{
	[Flags]
	internal enum LocalRefreshSurface
	{
		None = 0,
		ActiveSave = 1,
		MyMixes = 2,
		Status = 4,
		AdvisorDispatches = 8,
		PendingCommandResult = 0x10,
		LiveContext = 0x20
	}
	internal readonly record struct LocalFileSignature(bool Exists, long Length, long LastWriteUtcTicks)
	{
		internal static LocalFileSignature Missing => new LocalFileSignature(Exists: false, 0L, 0L);
	}
	internal enum LocalRefreshReason
	{
		Initial,
		Dirty,
		SignatureChanged,
		ForcedRecovery,
		Unchanged
	}
	internal interface ILocalRefreshInvalidationSource
	{
		LocalRefreshSurface Pending { get; }

		event Action<LocalRefreshSurface>? Invalidated;
	}
	internal sealed class LocalRefreshInvalidationHub : ILocalRefreshInvalidationSource
	{
		public LocalRefreshSurface Pending { get; private set; }

		public event Action<LocalRefreshSurface>? Invalidated;

		public void Invalidate(LocalRefreshSurface surfaces)
		{
			if (surfaces != LocalRefreshSurface.None)
			{
				LocalRefreshSurface localRefreshSurface = surfaces & ~Pending;
				Pending |= surfaces;
				if (localRefreshSurface != LocalRefreshSurface.None)
				{
					this.Invalidated?.Invoke(localRefreshSurface);
				}
			}
		}

		public bool Take(LocalRefreshSurface surface)
		{
			if ((Pending & surface) == 0)
			{
				return false;
			}
			Pending &= ~surface;
			return true;
		}

		public void Reset(LocalRefreshSurface surfaces)
		{
			Pending &= ~surfaces;
		}
	}
	internal sealed class LocalFileRefreshGate
	{
		private readonly TimeSpan _forcedRecoveryInterval;

		private LocalFileSignature _lastAccepted;

		private DateTimeOffset _lastAcceptedAt;

		private bool _hasAccepted;

		private bool _retryTransient;

		public LocalFileRefreshGate(TimeSpan forcedRecoveryInterval)
		{
			if (forcedRecoveryInterval <= TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("forcedRecoveryInterval");
			}
			_forcedRecoveryInterval = forcedRecoveryInterval;
		}

		public bool ShouldRefresh(LocalFileSignature signature, DateTimeOffset now, bool dirty, out LocalRefreshReason reason)
		{
			if (!_hasAccepted)
			{
				reason = LocalRefreshReason.Initial;
				return true;
			}
			if (dirty || _retryTransient)
			{
				reason = LocalRefreshReason.Dirty;
				return true;
			}
			if (signature != _lastAccepted)
			{
				reason = LocalRefreshReason.SignatureChanged;
				return true;
			}
			if (now - _lastAcceptedAt >= _forcedRecoveryInterval)
			{
				reason = LocalRefreshReason.ForcedRecovery;
				return true;
			}
			reason = LocalRefreshReason.Unchanged;
			return false;
		}

		public void Accept(LocalFileSignature signature, DateTimeOffset now)
		{
			_lastAccepted = signature;
			_lastAcceptedAt = now;
			_hasAccepted = true;
			_retryTransient = false;
		}

		public void RejectTransient()
		{
			_retryTransient = true;
		}

		public void Reset()
		{
			_lastAccepted = default(LocalFileSignature);
			_lastAcceptedAt = default(DateTimeOffset);
			_hasAccepted = false;
			_retryTransient = false;
		}
	}
	internal sealed record ProvenSaveIdentity(string SteamIdHash, string SlotId, string Fingerprint);
	internal static class SaveGenerationIdentity
	{
		internal const string FingerprintV2Prefix = "v2-";

		private const long MaxMetadataBytes = 1048576L;

		internal static bool TryCreate(string activeSaveDirectory, out ProvenSaveIdentity? identity, out string reason)
		{
			identity = null;
			reason = "generation-metadata-unavailable";
			try
			{
				if (!TryGetDirectoryIdentity(activeSaveDirectory, out string steamDirectory, out string slotId))
				{
					reason = "generation-save-path-invalid";
					return false;
				}
				if (!TryReadMetadata(activeSaveDirectory, out var creation) || !TryReadSeed(activeSaveDirectory, out var seed))
				{
					return false;
				}
				string text = Sha256(Path.GetFileName(steamDirectory));
				string value = string.Join("\n", "hyland-helper/save-fingerprint/v2", "steam=" + text, "slot=" + slotId.ToLowerInvariant(), "created=" + creation.ToString("yyyy-MM-dd'T'HH:mm:ss", CultureInfo.InvariantCulture), "seed=" + seed.ToString(CultureInfo.InvariantCulture));
				identity = new ProvenSaveIdentity(text, slotId, "v2-" + Sha256(value));
				reason = string.Empty;
				return true;
			}
			catch (IOException)
			{
				return false;
			}
			catch (JsonException)
			{
				return false;
			}
			catch (UnauthorizedAccessException)
			{
				return false;
			}
		}

		internal static bool IsV2Fingerprint(string? value)
		{
			if (value == null || value.Length != "v2-".Length + 64 || !value.StartsWith("v2-", StringComparison.Ordinal))
			{
				return false;
			}
			for (int i = "v2-".Length; i < value.Length; i++)
			{
				char c = value[i];
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryGetDirectoryIdentity(string activeSaveDirectory, out string steamDirectory, out string slotId)
		{
			steamDirectory = string.Empty;
			slotId = string.Empty;
			if (string.IsNullOrWhiteSpace(activeSaveDirectory))
			{
				return false;
			}
			string path = Path.GetFullPath(activeSaveDirectory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			if (!Directory.Exists(path))
			{
				return false;
			}
			slotId = Path.GetFileName(path);
			if (!IsSaveSlot(slotId))
			{
				return false;
			}
			steamDirectory = Path.GetDirectoryName(path) ?? string.Empty;
			return !string.IsNullOrWhiteSpace(Path.GetFileName(steamDirectory));
		}

		private static bool TryReadMetadata(string saveDirectory, out DateTime creation)
		{
			creation = default(DateTime);
			if (!TryReadJson(Path.Combine(saveDirectory, "Metadata.json"), out JsonDocument document))
			{
				return false;
			}
			using (document)
			{
				JsonElement rootElement = document.RootElement;
				if (!HasString(rootElement, "DataType", "MetaData") || !HasInt32(rootElement, "DataVersion") || !HasNonEmptyString(rootElement, "GameVersion") || !HasNonEmptyString(rootElement, "CreationVersion") || !TryGetUniqueProperty(rootElement, "CreationDate", out var value) || value.ValueKind != JsonValueKind.Object || !HasNonEmptyString(value, "DataType") || !HasInt32(value, "DataVersion") || !HasNonEmptyString(value, "GameVersion") || !TryGetInt32(value, "Year", out var value2) || !TryGetInt32(value, "Month", out var value3) || !TryGetInt32(value, "Day", out var value4) || !TryGetInt32(value, "Hour", out var value5) || !TryGetInt32(value, "Minute", out var value6) || !TryGetInt32(value, "Second", out var value7))
				{
					return false;
				}
				try
				{
					creation = new DateTime(value2, value3, value4, value5, value6, value7, DateTimeKind.Unspecified);
					return true;
				}
				catch (ArgumentOutOfRangeException)
				{
					return false;
				}
			}
		}

		private static bool TryReadSeed(string saveDirectory, out long seed)
		{
			seed = 0L;
			if (!TryReadJson(Path.Combine(saveDirectory, "Game.json"), out JsonDocument document))
			{
				return false;
			}
			using (document)
			{
				JsonElement rootElement = document.RootElement;
				return HasString(rootElement, "DataType", "GameData") && HasInt32(rootElement, "DataVersion") && HasNonEmptyString(rootElement, "GameVersion") && TryGetInt64(rootElement, "Seed", out seed);
			}
		}

		private static bool TryReadJson(string path, out JsonDocument document)
		{
			document = null;
			FileInfo fileInfo = new FileInfo(path);
			if (!fileInfo.Exists || fileInfo.Length > 1048576)
			{
				return false;
			}
			using FileStream utf8Json = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
			document = JsonDocument.Parse(utf8Json);
			return true;
		}

		private static bool HasString(JsonElement element, string propertyName, string expected)
		{
			if (TryGetUniqueProperty(element, propertyName, out var value) && value.ValueKind == JsonValueKind.String)
			{
				return string.Equals(value.GetString(), expected, StringComparison.Ordinal);
			}
			return false;
		}

		private static bool HasNonEmptyString(JsonElement element, string propertyName)
		{
			if (TryGetUniqueProperty(element, propertyName, out var value) && value.ValueKind == JsonValueKind.String)
			{
				return !string.IsNullOrWhiteSpace(value.GetString());
			}
			return false;
		}

		private static bool HasInt32(JsonElement element, string propertyName)
		{
			int value;
			return TryGetInt32(element, propertyName, out value);
		}

		private static bool TryGetInt32(JsonElement element, string propertyName, out int value)
		{
			value = 0;
			if (TryGetUniqueProperty(element, propertyName, out var value2) && value2.ValueKind == JsonValueKind.Number)
			{
				return value2.TryGetInt32(out value);
			}
			return false;
		}

		private static bool TryGetInt64(JsonElement element, string propertyName, out long value)
		{
			value = 0L;
			if (TryGetUniqueProperty(element, propertyName, out var value2) && value2.ValueKind == JsonValueKind.Number)
			{
				return value2.TryGetInt64(out value);
			}
			return false;
		}

		private static bool TryGetUniqueProperty(JsonElement element, string propertyName, out JsonElement value)
		{
			value = default(JsonElement);
			if (element.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			bool flag = false;
			foreach (JsonProperty item in element.EnumerateObject())
			{
				if (string.Equals(item.Name, propertyName, StringComparison.Ordinal))
				{
					if (flag)
					{
						value = default(JsonElement);
						return false;
					}
					flag = true;
					value = item.Value;
				}
			}
			return flag;
		}

		private static bool IsSaveSlot(string value)
		{
			if (!value.StartsWith("SaveGame_", StringComparison.OrdinalIgnoreCase) || value.Length == "SaveGame_".Length)
			{
				return false;
			}
			for (int i = "SaveGame_".Length; i < value.Length; i++)
			{
				if (value[i] < '0' || value[i] > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static string Sha256(string value)
		{
			using SHA256 sHA = SHA256.Create();
			return Convert.ToHexString(sHA.ComputeHash(Encoding.UTF8.GetBytes(value))).ToLowerInvariant();
		}
	}
	internal sealed class LiveOverlayDocument
	{
		public const int SchemaVersionCurrent = 1;

		public const int MaxSerializedBytes = 8192;

		[JsonPropertyName("schemaVersion")]
		public int SchemaVersion { get; set; } = 1;

		[JsonPropertyName("playthroughGeneration")]
		public string PlaythroughGeneration { get; set; } = "";

		[JsonPropertyName("runtimeSession")]
		public string RuntimeSession { get; set; } = "";

		[JsonPropertyName("tileInstanceId")]
		public string TileInstanceId { get; set; } = "";

		[JsonPropertyName("loadEpoch")]
		public int LoadEpoch { get; set; }

		[JsonPropertyName("sequence")]
		public long Sequence { get; set; }

		[JsonPropertyName("observedAt")]
		public string ObservedAt { get; set; } = "";

		[JsonPropertyName("tileVersion")]
		public string TileVersion { get; set; } = "";

		[JsonPropertyName("s1ApiVersion")]
		public string S1ApiVersion { get; set; } = "";

		[JsonPropertyName("facts")]
		public LiveOverlayFacts Facts { get; set; } = new LiveOverlayFacts();
	}
	internal sealed class LiveOverlayFacts
	{
		[JsonPropertyName("rank")]
		public LiveRankFact? Rank { get; set; }

		[JsonPropertyName("elapsedDays")]
		public LiveElapsedDaysFact? ElapsedDays { get; set; }

		[JsonPropertyName("properties")]
		public LivePropertiesFact? Properties { get; set; }

		[JsonPropertyName("money")]
		public LiveMoneyFact? Money { get; set; }
	}
	internal sealed class LiveRankFact
	{
		[JsonPropertyName("scope")]
		public string Scope { get; set; } = "shared";

		[JsonPropertyName("rankName")]
		public string RankName { get; set; } = "";

		[JsonPropertyName("tier")]
		public int Tier { get; set; }

		[JsonPropertyName("xp")]
		public int Xp { get; set; }

		[JsonPropertyName("totalXp")]
		public int TotalXp { get; set; }
	}
	internal sealed class LiveElapsedDaysFact
	{
		[JsonPropertyName("scope")]
		public string Scope { get; set; } = "shared";

		[JsonPropertyName("value")]
		public int Value { get; set; }
	}
	internal sealed class LivePropertiesFact
	{
		[JsonPropertyName("scope")]
		public string Scope { get; set; } = "shared";

		[JsonPropertyName("codes")]
		public List<string> Codes { get; set; } = new List<string>();

		[JsonPropertyName("businessCodes")]
		public List<string> BusinessCodes { get; set; } = new List<string>();
	}
	internal sealed class LiveMoneyFact
	{
		[JsonPropertyName("cashOnHand")]
		public LiveMoneyValue CashOnHand { get; set; } = new LiveMoneyValue
		{
			Scope = "player"
		};

		[JsonPropertyName("onlineBalance")]
		public LiveMoneyValue OnlineBalance { get; set; } = new LiveMoneyValue();

		[JsonPropertyName("netWorth")]
		public LiveMoneyValue NetWorth { get; set; } = new LiveMoneyValue();
	}
	internal sealed class LiveMoneyValue
	{
		[JsonPropertyName("scope")]
		public string Scope { get; set; } = "shared";

		[JsonPropertyName("value")]
		public double Value { get; set; }
	}
	internal static class LiveOverlaySerializer
	{
		private static readonly JsonSerializerOptions Options = new JsonSerializerOptions
		{
			DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
		};

		private static readonly string[] TopLevelKeys = new string[10] { "schemaVersion", "playthroughGeneration", "runtimeSession", "tileInstanceId", "loadEpoch", "sequence", "observedAt", "tileVersion", "s1ApiVersion", "facts" };

		private static readonly string[] FactKeys = new string[4] { "rank", "elapsedDays", "properties", "money" };

		private static readonly string[] RankKeys = new string[5] { "scope", "rankName", "tier", "xp", "totalXp" };

		private static readonly string[] ValueFactKeys = new string[2] { "scope", "value" };

		private static readonly string[] PropertiesKeys = new string[3] { "scope", "codes", "businessCodes" };

		private static readonly string[] MoneyKeys = new string[3] { "cashOnHand", "onlineBalance", "netWorth" };

		internal static bool TrySerialize(LiveOverlayDocument document, out byte[] utf8, out string? reason)
		{
			utf8 = JsonSerializer.SerializeToUtf8Bytes(document, Options);
			if (utf8.Length > 8192)
			{
				reason = "overBudget";
				utf8 = Array.Empty<byte>();
				return false;
			}
			reason = null;
			return true;
		}

		internal static bool TryParse(byte[] utf8, out LiveOverlayDocument? document, out string reason)
		{
			document = null;
			if (utf8 == null || utf8.Length == 0)
			{
				reason = "empty";
				return false;
			}
			if (utf8.Length > 8192)
			{
				reason = "overBudget";
				return false;
			}
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(utf8);
				JsonElement rootElement = jsonDocument.RootElement;
				if (rootElement.ValueKind != JsonValueKind.Object)
				{
					reason = "rootNotObject";
					return false;
				}
				if (!CheckExactKeys(rootElement, TopLevelKeys, requireAll: true, out reason))
				{
					return false;
				}
				LiveOverlayDocument liveOverlayDocument = new LiveOverlayDocument();
				if (!TryInt(rootElement, "schemaVersion", 1, 1, out var value, out reason))
				{
					return false;
				}
				liveOverlayDocument.SchemaVersion = value;
				JsonElement property = rootElement.GetProperty("playthroughGeneration");
				if (property.ValueKind != JsonValueKind.String || !SaveGenerationIdentity.IsV2Fingerprint(property.GetString()))
				{
					reason = "playthroughGeneration";
					return false;
				}
				liveOverlayDocument.PlaythroughGeneration = property.GetString();
				if (!TryBoundedString(rootElement, "runtimeSession", 1, 64, out string value2, out reason))
				{
					return false;
				}
				liveOverlayDocument.RuntimeSession = value2;
				if (!TryBoundedString(rootElement, "tileInstanceId", 32, 32, out string value3, out reason))
				{
					return false;
				}
				if (!IsLowerHex(value3))
				{
					reason = "tileInstanceId";
					return false;
				}
				liveOverlayDocument.TileInstanceId = value3;
				if (!TryInt(rootElement, "loadEpoch", 1, 1000000, out var value4, out reason))
				{
					return false;
				}
				liveOverlayDocument.LoadEpoch = value4;
				if (!TryLong(rootElement, "sequence", 1L, 999999999999L, out var value5, out reason))
				{
					return false;
				}
				liveOverlayDocument.Sequence = value5;
				if (!TryBoundedString(rootElement, "observedAt", 1, 40, out string value6, out reason))
				{
					return false;
				}
				if (!DateTimeOffset.TryParse(value6, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var _))
				{
					reason = "observedAt";
					return false;
				}
				liveOverlayDocument.ObservedAt = value6;
				if (!TryBoundedString(rootElement, "tileVersion", 1, 64, out string value7, out reason))
				{
					return false;
				}
				liveOverlayDocument.TileVersion = value7;
				if (!TryBoundedString(rootElement, "s1ApiVersion", 1, 64, out string value8, out reason))
				{
					return false;
				}
				liveOverlayDocument.S1ApiVersion = value8;
				JsonElement property2 = rootElement.GetProperty("facts");
				if (property2.ValueKind != JsonValueKind.Object)
				{
					reason = "facts";
					return false;
				}
				if (!CheckExactKeys(property2, FactKeys, requireAll: false, out reason))
				{
					return false;
				}
				if (property2.TryGetProperty("rank", out var value9))
				{
					if (!TryParseRank(value9, out LiveRankFact fact, out reason))
					{
						return false;
					}
					liveOverlayDocument.Facts.Rank = fact;
				}
				if (property2.TryGetProperty("elapsedDays", out var value10))
				{
					if (!TryParseElapsedDays(value10, out LiveElapsedDaysFact fact2, out reason))
					{
						return false;
					}
					liveOverlayDocument.Facts.ElapsedDays = fact2;
				}
				if (property2.TryGetProperty("properties", out var value11))
				{
					if (!TryParseProperties(value11, out LivePropertiesFact fact3, out reason))
					{
						return false;
					}
					liveOverlayDocument.Facts.Properties = fact3;
				}
				if (property2.TryGetProperty("money", out var value12))
				{
					if (!TryParseMoney(value12, out LiveMoneyFact fact4, out reason))
					{
						return false;
					}
					liveOverlayDocument.Facts.Money = fact4;
				}
				document = liveOverlayDocument;
				reason = "ok";
				return true;
			}
			catch (JsonException)
			{
				reason = "malformedJson";
				return false;
			}
		}

		private static bool TryParseRank(JsonElement element, out LiveRankFact? fact, out string reason)
		{
			fact = null;
			if (element.ValueKind != JsonValueKind.Object || !CheckExactKeys(element, RankKeys, requireAll: true, out reason))
			{
				reason = "rank";
				return false;
			}
			if (!IsScope(element, "shared"))
			{
				reason = "rank.scope";
				return false;
			}
			if (!TryBoundedString(element, "rankName", 1, 32, out string value, out string reason2))
			{
				reason = "rank.rankName";
				return false;
			}
			if (!TryInt(element, "tier", 1, 99999, out int value2, out reason2))
			{
				reason = "rank.tier";
				return false;
			}
			if (!TryInt(element, "xp", 0, 999999999, out int value3, out reason2))
			{
				reason = "rank.xp";
				return false;
			}
			if (!TryInt(element, "totalXp", 0, 999999999, out int value4, out reason2))
			{
				reason = "rank.totalXp";
				return false;
			}
			fact = new LiveRankFact
			{
				RankName = value,
				Tier = value2,
				Xp = value3,
				TotalXp = value4
			};
			reason = "ok";
			return true;
		}

		private static bool TryParseElapsedDays(JsonElement element, out LiveElapsedDaysFact? fact, out string reason)
		{
			fact = null;
			if (element.ValueKind != JsonValueKind.Object || !CheckExactKeys(element, ValueFactKeys, requireAll: true, out reason))
			{
				reason = "elapsedDays";
				return false;
			}
			if (!IsScope(element, "shared"))
			{
				reason = "elapsedDays.scope";
				return false;
			}
			if (!TryInt(element, "value", 0, 99999, out int value, out string _))
			{
				reason = "elapsedDays.value";
				return false;
			}
			fact = new LiveElapsedDaysFact
			{
				Value = value
			};
			reason = "ok";
			return true;
		}

		private static bool TryParseProperties(JsonElement element, out LivePropertiesFact? fact, out string reason)
		{
			fact = null;
			if (element.ValueKind != JsonValueKind.Object || !CheckExactKeys(element, PropertiesKeys, requireAll: true, out reason))
			{
				reason = "properties";
				return false;
			}
			if (!IsScope(element, "shared"))
			{
				reason = "properties.scope";
				return false;
			}
			if (!TryCodes(element, "codes", 64, out HashSet<string> codes))
			{
				reason = "properties.codes";
				return false;
			}
			if (!TryCodes(element, "businessCodes", 32, out HashSet<string> codes2))
			{
				reason = "properties.businessCodes";
				return false;
			}
			foreach (string item in codes2)
			{
				if (!codes.Contains(item))
				{
					reason = "properties.businessSubset";
					return false;
				}
			}
			fact = new LivePropertiesFact
			{
				Codes = new List<string>(codes),
				BusinessCodes = new List<string>(codes2)
			};
			reason = "ok";
			return true;
		}

		private static bool TryParseMoney(JsonElement element, out LiveMoneyFact? fact, out string reason)
		{
			fact = null;
			if (element.ValueKind != JsonValueKind.Object || !CheckExactKeys(element, MoneyKeys, requireAll: true, out reason))
			{
				reason = "money";
				return false;
			}
			if (!TryMoneyValue(element, "cashOnHand", "player", 0.0, out LiveMoneyValue value))
			{
				reason = "money.cashOnHand";
				return false;
			}
			if (!TryMoneyValue(element, "onlineBalance", "shared", 0.0, out LiveMoneyValue value2))
			{
				reason = "money.onlineBalance";
				return false;
			}
			if (!TryMoneyValue(element, "netWorth", "shared", -1000000000.0, out LiveMoneyValue value3))
			{
				reason = "money.netWorth";
				return false;
			}
			fact = new LiveMoneyFact
			{
				CashOnHand = value,
				OnlineBalance = value2,
				NetWorth = value3
			};
			reason = "ok";
			return true;
		}

		private static bool TryMoneyValue(JsonElement parent, string name, string scope, double minimum, out LiveMoneyValue? value)
		{
			value = null;
			if (!parent.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			if (!CheckExactKeys(value2, ValueFactKeys, requireAll: true, out string _))
			{
				return false;
			}
			if (!IsScope(value2, scope))
			{
				return false;
			}
			if (!value2.TryGetProperty("value", out var value3) || value3.ValueKind != JsonValueKind.Number)
			{
				return false;
			}
			if (!decimal.TryParse(value3.GetRawText(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (result != Math.Round(result, 2))
			{
				return false;
			}
			if (result < (decimal)minimum || result >= 1000000000m)
			{
				return false;
			}
			value = new LiveMoneyValue
			{
				Scope = scope,
				Value = (double)result
			};
			return true;
		}

		private static bool TryCodes(JsonElement parent, string name, int max, out HashSet<string> codes)
		{
			codes = new HashSet<string>(StringComparer.Ordinal);
			if (!parent.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.Array)
			{
				return false;
			}
			int num = 0;
			foreach (JsonElement item in value.EnumerateArray())
			{
				if (++num > max)
				{
					return false;
				}
				if (item.ValueKind != JsonValueKind.String)
				{
					return false;
				}
				string text = item.GetString();
				if (string.IsNullOrEmpty(text) || text.Length > 48 || !IsCanonicalCode(text))
				{
					return false;
				}
				if (!codes.Add(text))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool IsCanonicalCode(string code)
		{
			for (int i = 0; i < code.Length; i++)
			{
				bool flag;
				switch (code[i])
				{
				case '-':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case '_':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsLowerHex(string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				bool flag;
				switch (value[i])
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsScope(JsonElement element, string expected)
		{
			if (element.TryGetProperty("scope", out var value) && value.ValueKind == JsonValueKind.String)
			{
				return value.GetString() == expected;
			}
			return false;
		}

		private static bool CheckExactKeys(JsonElement element, string[] allowed, bool requireAll, out string reason)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item in element.EnumerateObject())
			{
				if (Array.IndexOf(allowed, item.Name) < 0)
				{
					reason = "unknownField:" + Bound(item.Name);
					return false;
				}
				if (!hashSet.Add(item.Name))
				{
					reason = "duplicateField:" + Bound(item.Name);
					return false;
				}
			}
			if (requireAll)
			{
				foreach (string text in allowed)
				{
					if (!hashSet.Contains(text))
					{
						reason = "missingField:" + text;
						return false;
					}
				}
			}
			reason = "ok";
			return true;
		}

		private static string Bound(string value)
		{
			if (value.Length > 32)
			{
				return value.Substring(0, 32);
			}
			return value;
		}

		private static bool TryBoundedString(JsonElement parent, string name, int minLength, int maxLength, out string value, out string reason)
		{
			value = "";
			if (!parent.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.String)
			{
				reason = name;
				return false;
			}
			string text = value2.GetString() ?? "";
			if (text.Trim().Length == 0 || text.Length < minLength || text.Length > maxLength)
			{
				reason = name;
				return false;
			}
			value = text;
			reason = "ok";
			return true;
		}

		private static bool TryInt(JsonElement parent, string name, int minimum, int maximum, out int value, out string reason)
		{
			value = 0;
			if (!parent.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.Number || !value2.TryGetInt32(out var value3) || value3 < minimum || value3 > maximum)
			{
				reason = name;
				return false;
			}
			value = value3;
			reason = "ok";
			return true;
		}

		private static bool TryLong(JsonElement parent, string name, long minimum, long maximum, out long value, out string reason)
		{
			value = 0L;
			if (!parent.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.Number || !value2.TryGetInt64(out var value3) || value3 < minimum || value3 > maximum)
			{
				reason = name;
				return false;
			}
			value = value3;
			reason = "ok";
			return true;
		}
	}
	internal enum ScreenActivityScreen
	{
		PhoneRecipes,
		AdvisorDispatches
	}
	internal sealed class ScreenActivityDocument
	{
		public const int SchemaVersionCurrent = 1;

		public const int MaxSerializedBytes = 2048;

		[JsonPropertyName("schemaVersion")]
		public int SchemaVersion { get; set; } = 1;

		[JsonPropertyName("playthroughGeneration")]
		public string PlaythroughGeneration { get; set; } = "";

		[JsonPropertyName("runtimeSession")]
		public string RuntimeSession { get; set; } = "";

		[JsonPropertyName("tileInstanceId")]
		public string TileInstanceId { get; set; } = "";

		[JsonPropertyName("sequence")]
		public long Sequence { get; set; }

		[JsonPropertyName("updatedAt")]
		public string UpdatedAt { get; set; } = "";

		[JsonPropertyName("visibleScreen")]
		public string? VisibleScreen { get; set; }
	}
	internal static class ScreenActivitySerializer
	{
		private static readonly JsonSerializerOptions Options = new JsonSerializerOptions();

		private static readonly string[] Required = new string[6] { "schemaVersion", "playthroughGeneration", "runtimeSession", "tileInstanceId", "sequence", "updatedAt" };

		private static readonly string[] Allowed = new string[7] { "schemaVersion", "playthroughGeneration", "runtimeSession", "tileInstanceId", "sequence", "updatedAt", "visibleScreen" };

		internal static bool TrySerialize(ScreenActivityDocument document, out byte[] utf8, out string? reason)
		{
			utf8 = JsonSerializer.SerializeToUtf8Bytes(document, Options);
			if (utf8.Length > 2048)
			{
				utf8 = Array.Empty<byte>();
				reason = "overBudget";
				return false;
			}
			reason = null;
			return true;
		}

		internal static bool TryParse(byte[] utf8, out ScreenActivityDocument? document, out string? reason)
		{
			document = null;
			if (utf8 == null || utf8.Length == 0)
			{
				reason = "empty";
				return false;
			}
			if (utf8.Length > 2048)
			{
				reason = "overBudget";
				return false;
			}
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(utf8);
				JsonElement rootElement = jsonDocument.RootElement;
				if (rootElement.ValueKind != JsonValueKind.Object)
				{
					reason = "rootNotObject";
					return false;
				}
				if (!ExactKeys(rootElement, out reason))
				{
					return false;
				}
				if (!Int(rootElement, "schemaVersion", 1, 1, out var value) || !Text(rootElement, "playthroughGeneration", 1, 80, out string value2) || !IsGeneration(value2) || !Text(rootElement, "runtimeSession", 1, 64, out string value3) || !Text(rootElement, "tileInstanceId", 32, 32, out string value4) || !IsLowerHex(value4) || !Long(rootElement, "sequence", 1L, long.MaxValue, out var value5) || !Text(rootElement, "updatedAt", 1, 40, out string value6) || !DateTimeOffset.TryParse(value6, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var _))
				{
					reason = "invalidField";
					return false;
				}
				string visibleScreen = null;
				if (rootElement.TryGetProperty("visibleScreen", out var value7))
				{
					if (value7.ValueKind == JsonValueKind.Null)
					{
						visibleScreen = null;
					}
					else
					{
						if (value7.ValueKind != JsonValueKind.String || !ParseScreen(value7.GetString()).HasValue)
						{
							reason = "visibleScreen";
							return false;
						}
						visibleScreen = value7.GetString();
					}
				}
				document = new ScreenActivityDocument
				{
					SchemaVersion = value,
					PlaythroughGeneration = value2,
					RuntimeSession = value3,
					TileInstanceId = value4,
					Sequence = value5,
					UpdatedAt = value6,
					VisibleScreen = visibleScreen
				};
				reason = "ok";
				return true;
			}
			catch (JsonException)
			{
				reason = "malformedJson";
				return false;
			}
		}

		internal static ScreenActivityScreen? ParseScreen(string? value)
		{
			if (!(value == "phoneRecipes"))
			{
				if (value == "advisorDispatches")
				{
					return ScreenActivityScreen.AdvisorDispatches;
				}
				return null;
			}
			return ScreenActivityScreen.PhoneRecipes;
		}

		private static bool ExactKeys(JsonElement root, out string? reason)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item2 in root.EnumerateObject())
			{
				if (Array.IndexOf(Allowed, item2.Name) < 0)
				{
					reason = "unknownField";
					return false;
				}
				if (!hashSet.Add(item2.Name))
				{
					reason = "duplicateField";
					return false;
				}
			}
			string[] required = Required;
			foreach (string item in required)
			{
				if (!hashSet.Contains(item))
				{
					reason = "missingField";
					return false;
				}
			}
			reason = null;
			return true;
		}

		private static bool Text(JsonElement root, string name, int min, int max, out string value)
		{
			value = "";
			if (!root.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			value = value2.GetString() ?? "";
			if (value.Trim().Length >= min)
			{
				return value.Length <= max;
			}
			return false;
		}

		private static bool Int(JsonElement root, string name, int min, int max, out int value)
		{
			value = 0;
			if (root.TryGetProperty(name, out var value2) && value2.ValueKind == JsonValueKind.Number && value2.TryGetInt32(out value) && value >= min)
			{
				return value <= max;
			}
			return false;
		}

		private static bool Long(JsonElement root, string name, long min, long max, out long value)
		{
			value = 0L;
			if (root.TryGetProperty(name, out var value2) && value2.ValueKind == JsonValueKind.Number && value2.TryGetInt64(out value) && value >= min)
			{
				return value <= max;
			}
			return false;
		}

		private static bool IsGeneration(string value)
		{
			if (value.Length == 67 && value.StartsWith("v2-", StringComparison.Ordinal))
			{
				return IsLowerHex(value.Substring(3, value.Length - 3));
			}
			return false;
		}

		private static bool IsLowerHex(string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				bool flag;
				switch (value[i])
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}
	}
}
namespace HylandHelper.BridgeContracts
{
	public static class GameDatasetIds
	{
		private static readonly Dictionary<string, string> CanonicalAliases = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["ogkush"] = "og_kush",
			["sourdiesel"] = "sour_diesel",
			["greencrack"] = "green_crack",
			["granddaddypurple"] = "granddaddy_purple",
			["shroom"] = "shrooms",
			["energydrink"] = "energy_drink",
			["motoroil"] = "motor_oil",
			["megabean"] = "mega_bean",
			["flumedicine"] = "flu_medicine",
			["horsesemen"] = "horse_semen",
			["viagor"] = "viagra"
		};

		private static readonly Dictionary<string, string> FriendlyLabels = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["og_kush"] = "OG Kush",
			["sour_diesel"] = "Sour Diesel",
			["green_crack"] = "Green Crack",
			["granddaddy_purple"] = "Granddaddy Purple",
			["shrooms"] = "Shrooms",
			["meth"] = "Meth",
			["cocaine"] = "Cocaine",
			["flu_medicine"] = "Flu Medicine",
			["energy_drink"] = "Energy Drink",
			["motor_oil"] = "Motor Oil",
			["mega_bean"] = "Mega Bean",
			["horse_semen"] = "Horse Semen",
			["viagra"] = "Viagor"
		};

		private static readonly HashSet<string> BaseProducts = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "og_kush", "sour_diesel", "green_crack", "granddaddy_purple", "meth", "cocaine", "shrooms" };

		public static string Canonicalize(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			string text = value.Trim();
			if (!CanonicalAliases.TryGetValue(text, out string value2))
			{
				return text;
			}
			return value2;
		}

		public static bool IsBaseProduct(string value)
		{
			return BaseProducts.Contains(Canonicalize(value));
		}

		public static string FriendlyName(string value)
		{
			string text = Canonicalize(value);
			if (FriendlyLabels.TryGetValue(text, out string value2))
			{
				return value2;
			}
			string[] array = text.Replace('_', ' ').Split(' ', StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Length != 0)
				{
					array[i] = char.ToUpperInvariant(array[i][0]) + array[i].Substring(1);
				}
			}
			return string.Join(" ", array);
		}
	}
	public static class PendingMixLimits
	{
		public const int MaxChainSteps = 64;

		public const int MaxEffectsPerStep = 12;

		public const int MaxStringLength = 64;

		public static string OverLimitReason(int stepCount)
		{
			return $"Save/Track unavailable: this mix has {stepCount} steps; the shared limit is {64}.";
		}
	}
	public static class PhoneRecipeLimits
	{
		public const int MaxRecipes = 50;

		public const int MaxChainSteps = 64;

		public const int MaxEffects = 8;

		public const int MaxStringLength = 64;

		public const int MaxBodyBytes = 73728;

		public const int StaleGraceHours = 24;
	}
	public sealed class BridgePhoneRecipe
	{
		[JsonPropertyName("recipeId")]
		public string RecipeId { get; set; } = "";

		[JsonPropertyName("name")]
		public string Name { get; set; } = "";

		[JsonPropertyName("productId")]
		public string ProductId { get; set; } = "";

		[JsonPropertyName("ingredientIds")]
		public List<string> IngredientIds { get; set; } = new List<string>();

		[JsonPropertyName("effects")]
		public List<string>? Effects { get; set; }

		[JsonPropertyName("effectsAvailable")]
		public bool EffectsAvailable { get; set; }

		[JsonPropertyName("sellPrice")]
		public double SellPrice { get; set; }

		[JsonPropertyName("profit")]
		public double Profit { get; set; }

		[JsonPropertyName("profitMargin")]
		public double ProfitMargin { get; set; }

		[JsonPropertyName("profileMode")]
		public string ProfileMode { get; set; } = "standard";

		[JsonPropertyName("source")]
		public string Source { get; set; } = "app-saved";

		[JsonPropertyName("publishedAt")]
		public string PublishedAt { get; set; } = "";

		[JsonPropertyName("expiresAt")]
		public string ExpiresAt { get; set; } = "";
	}
	public sealed class BridgePhoneRecipeSnapshot
	{
		[JsonPropertyName("schemaVersion")]
		public int SchemaVersion { get; set; } = 1;

		[JsonPropertyName("snapshotId")]
		public string SnapshotId { get; set; } = "";

		[JsonPropertyName("publishedAt")]
		public string PublishedAt { get; set; } = "";

		[JsonPropertyName("expiresAt")]
		public string ExpiresAt { get; set; } = "";

		[JsonPropertyName("omittedCount")]
		public int OmittedCount { get; set; }

		[JsonPropertyName("recipes")]
		public List<BridgePhoneRecipe> Recipes { get; set; } = new List<BridgePhoneRecipe>();
	}
}
namespace HylandHelper.PhoneTile
{
	internal sealed record AdvisorDispatchesDestinationCard(GameObject Root, Text UnreadText);
	internal static class AdvisorDispatchesDestinationCardUi
	{
		public static AdvisorDispatchesDestinationCard Create(Transform parent, Action onClick)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.Panel("AdvisorDispatchesDestination", parent, new Color(0.23f, 0.24f, 0.38f), (Vector2?)null, (Vector2?)null, false);
			Image component = val.GetComponent<Image>();
			Button obj = val.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)component;
			ButtonUtils.AddListener(obj, onClick);
			RectTransform component2 = ((Component)UIFactory.Text("AdvisorDispatchesDestinationTitle", "Advisor Dispatches", val.transform, 17, (TextAnchor)0, (FontStyle)0)).GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(18f, 19f);
			component2.offsetMax = new Vector2(-72f, -5f);
			Text obj2 = UIFactory.Text("AdvisorDispatchesDestinationSubtitle", "Incoming only", val.transform, 11, (TextAnchor)6, (FontStyle)0);
			((Graphic)obj2).color = new Color(0.68f, 0.72f, 0.79f);
			RectTransform component3 = ((Component)obj2).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(18f, 5f);
			component3.offsetMax = new Vector2(-72f, -23f);
			Text val2 = UIFactory.Text("AdvisorDispatchesDestinationUnread", "0 unread", val.transform, 11, (TextAnchor)5, (FontStyle)0);
			((Graphic)val2).color = Color.white;
			RectTransform component4 = ((Component)val2).GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.offsetMin = new Vector2(-86f, 0f);
			component4.offsetMax = new Vector2(-28f, 0f);
			RectTransform component5 = ((Component)UIFactory.Text("AdvisorDispatchesDestinationArrow", "›", val.transform, 20, (TextAnchor)5, (FontStyle)0)).GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = new Vector2(-12f, 0f);
			LayoutElement obj3 = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			obj3.minHeight = 52f;
			obj3.preferredHeight = 52f;
			obj3.flexibleHeight = 0f;
			return new AdvisorDispatchesDestinationCard(val, val2);
		}

		public static void SetUnreadCount(Text unreadText, int count)
		{
			unreadText.text = $"{Math.Clamp(count, 0, 20)} unread";
		}
	}
	public sealed record AdvisorDispatchesHostView(AdvisorDispatchesRead Cache, AdvisorDispatchesUiSnapshot UiState, int UnreadCount, bool StorageAvailable, bool NotificationAttempted);
	public sealed class AdvisorDispatchesHostCoordinator
	{
		private readonly Func<DateTimeOffset, string?, AdvisorDispatchesRead> _readCache;

		private readonly AdvisorDispatchesUiState _uiState;

		private readonly AdvisorDispatchesNotificationCoordinator _notifications;

		private AdvisorDispatchesUiSnapshot? _lastKnownGoodUiState;

		private AdvisorDispatchesHostView? _lastKnownGoodView;

		private string? _activeSaveFingerprint;

		public AdvisorDispatchesHostCoordinator(Func<DateTimeOffset, string?, AdvisorDispatchesRead> readCache, AdvisorDispatchesUiState uiState, AdvisorDispatchesNotificationCoordinator notifications)
		{
			_readCache = readCache;
			_uiState = uiState;
			_notifications = notifications;
		}

		public void ObserveSaveScope(string? saveFingerprint)
		{
			string text = (SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint) ? saveFingerprint : null);
			if (!string.Equals(_activeSaveFingerprint, text, StringComparison.Ordinal))
			{
				_activeSaveFingerprint = text;
				_lastKnownGoodUiState = null;
				_lastKnownGoodView = null;
			}
		}

		public AdvisorDispatchesHostView Poll(DateTimeOffset now)
		{
			AdvisorDispatchesRead advisorDispatchesRead = _readCache(now, _activeSaveFingerprint);
			AdvisorDispatchesReadState state = advisorDispatchesRead.State;
			if ((uint)(state - 3) <= 1u)
			{
				return BuildUnusable(advisorDispatchesRead);
			}
			if (_activeSaveFingerprint == null || advisorDispatchesRead.ScopeGeneration == null)
			{
				return BuildWithoutScope(advisorDispatchesRead);
			}
			HashSet<string> validIds = advisorDispatchesRead.Messages.Select((AdvisorDispatchMessage message) => message.Id).ToHashSet<string>(StringComparer.Ordinal);
			AdvisorDispatchesUiLoad advisorDispatchesUiLoad = _uiState.Load(_activeSaveFingerprint, advisorDispatchesRead.ScopeGeneration, validIds);
			if (!advisorDispatchesUiLoad.StorageAvailable)
			{
				if (_lastKnownGoodView != null && string.Equals(_lastKnownGoodView.UiState.ScopeGeneration, advisorDispatchesRead.ScopeGeneration, StringComparison.Ordinal))
				{
					return _lastKnownGoodView;
				}
				return BuildView(advisorDispatchesRead, new AdvisorDispatchesUiSnapshot(_activeSaveFingerprint, advisorDispatchesRead.ScopeGeneration, Array.Empty<string>(), Array.Empty<string>()), storageAvailable: false, notificationAttempted: false);
			}
			AdvisorDispatchesUiSnapshot state2 = advisorDispatchesUiLoad.State;
			AdvisorDispatchesHostView advisorDispatchesHostView = BuildView(advisorDispatchesRead, state2, storageAvailable: true, notificationAttempted: false);
			_lastKnownGoodUiState = state2;
			_lastKnownGoodView = advisorDispatchesHostView;
			if (!advisorDispatchesUiLoad.Repaired && advisorDispatchesRead.State == AdvisorDispatchesReadState.Fresh)
			{
				List<AdvisorDispatchMessage> newlyUnnotified = advisorDispatchesRead.Messages.Where((AdvisorDispatchMessage message) => !state2.NotifiedIds.Contains<string>(message.Id, StringComparer.Ordinal)).ToList();
				bool notificationAttempted = _notifications.TryNotify(newlyUnnotified, now, delegate(IReadOnlyCollection<string> ids)
				{
					if (!_uiState.TryMarkNotified(state2, ids, validIds, out AdvisorDispatchesUiSnapshot next))
					{
						return false;
					}
					state2 = next;
					_lastKnownGoodUiState = next;
					return true;
				});
				advisorDispatchesHostView = (_lastKnownGoodView = BuildView(advisorDispatchesRead, state2, storageAvailable: true, notificationAttempted));
			}
			return advisorDispatchesHostView;
		}

		public AdvisorDispatchesHostView OpenInbox(DateTimeOffset now)
		{
			if (_lastKnownGoodView == null)
			{
				return Poll(now);
			}
			AdvisorDispatchesHostView lastKnownGoodView = _lastKnownGoodView;
			if (lastKnownGoodView.Cache.ScopeGeneration == null)
			{
				return lastKnownGoodView;
			}
			HashSet<string> validIds = lastKnownGoodView.Cache.Messages.Select((AdvisorDispatchMessage message) => message.Id).ToHashSet<string>(StringComparer.Ordinal);
			string[] displayedValidatedIds = lastKnownGoodView.Cache.Messages.Select((AdvisorDispatchMessage message) => message.Id).ToArray();
			if (!_uiState.TryMarkRead(lastKnownGoodView.UiState, (IReadOnlyCollection<string>)(object)displayedValidatedIds, validIds, out AdvisorDispatchesUiSnapshot next))
			{
				return lastKnownGoodView;
			}
			AdvisorDispatchesHostView advisorDispatchesHostView = BuildView(lastKnownGoodView.Cache, next, lastKnownGoodView.StorageAvailable, notificationAttempted: false);
			_lastKnownGoodUiState = next;
			_lastKnownGoodView = advisorDispatchesHostView;
			return advisorDispatchesHostView;
		}

		private static AdvisorDispatchesHostView BuildView(AdvisorDispatchesRead cache, AdvisorDispatchesUiSnapshot state, bool storageAvailable, bool notificationAttempted)
		{
			return new AdvisorDispatchesHostView(cache, state, AdvisorDispatchesUiState.CountUnread(cache.Messages, state), storageAvailable, notificationAttempted);
		}

		private AdvisorDispatchesHostView BuildUnusable(AdvisorDispatchesRead cache)
		{
			AdvisorDispatchesUiSnapshot state = _lastKnownGoodUiState ?? new AdvisorDispatchesUiSnapshot(_activeSaveFingerprint ?? "unavailable", "unavailable", Array.Empty<string>(), Array.Empty<string>());
			return BuildView(cache with
			{
				Messages = Array.Empty<AdvisorDispatchMessage>()
			}, state, _lastKnownGoodView?.StorageAvailable ?? false, notificationAttempted: false);
		}

		private AdvisorDispatchesHostView BuildWithoutScope(AdvisorDispatchesRead cache)
		{
			AdvisorDispatchesUiSnapshot state = _lastKnownGoodUiState ?? new AdvisorDispatchesUiSnapshot(_activeSaveFingerprint ?? "unscoped", "unscoped", Array.Empty<string>(), Array.Empty<string>());
			return BuildView(cache with
			{
				Messages = Array.Empty<AdvisorDispatchMessage>()
			}, state, _lastKnownGoodView?.StorageAvailable ?? false, notificationAttempted: false);
		}
	}
	public interface IAdvisorDispatchNotificationSink
	{
		bool TryShow(string text);
	}
	public sealed class NoOpAdvisorDispatchNotificationSink : IAdvisorDispatchNotificationSink
	{
		public bool TryShow(string text)
		{
			return false;
		}
	}
	public sealed class AdvisorDispatchesNotificationCoordinator
	{
		public static readonly TimeSpan MinimumInterval = TimeSpan.FromSeconds(30.0);

		private readonly IAdvisorDispatchNotificationSink _sink;

		private DateTimeOffset? _lastNotificationAt;

		public AdvisorDispatchesNotificationCoordinator(IAdvisorDispatchNotificationSink sink)
		{
			_sink = sink;
		}

		public bool TryNotify(IReadOnlyList<AdvisorDispatchMessage> newlyUnnotified, DateTimeOffset now, Func<IReadOnlyCollection<string>, bool> persistNotifiedIds)
		{
			List<AdvisorDispatchMessage> list = (from @group in newlyUnnotified.Where((AdvisorDispatchMessage message) => message != null && !string.IsNullOrWhiteSpace(message.Id)).GroupBy<AdvisorDispatchMessage, string>((AdvisorDispatchMessage message) => message.Id, StringComparer.Ordinal)
				select @group.First()).Take(20).ToList();
			if (list.Count == 0 || (_lastNotificationAt.HasValue && now - _lastNotificationAt.Value < MinimumInterval))
			{
				return false;
			}
			string[] arg = list.Select((AdvisorDispatchMessage message) => message.Id).ToArray();
			bool flag;
			try
			{
				flag = persistNotifiedIds((IReadOnlyCollection<string>)(object)arg);
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				return false;
			}
			_lastNotificationAt = now;
			string text = AdvisorDispatchNotificationCopy.ForBatch(list);
			try
			{
				_sink.TryShow(text);
			}
			catch
			{
			}
			return true;
		}
	}
	public static class AdvisorDispatchNotificationCopy
	{
		public static string ForBatch(IReadOnlyList<AdvisorDispatchMessage> messages)
		{
			if (messages.Count == 0)
			{
				return "";
			}
			if (messages.Count != 1)
			{
				return $"{messages.Count} new Advisor Dispatches";
			}
			return messages[0].Headline;
		}
	}
	public enum AdvisorDispatchesReadState
	{
		Missing,
		Fresh,
		Expired,
		Malformed,
		Unavailable
	}
	public sealed record AdvisorDispatchMessage(string Id, string PersonaLabel, string LocalTimestamp, string Headline, string Body);
	public sealed record AdvisorDispatchesRead(AdvisorDispatchesReadState State, string? ScopeGeneration, string? Revision, DateTimeOffset? CapturedAt, IReadOnlyList<AdvisorDispatchMessage> Messages, string StatusText);
	public sealed record AdvisorDispatchesViewState(AdvisorDispatchesReadState State, IReadOnlyList<AdvisorDispatchMessage> Messages, AdvisorDispatchesUiSnapshot? UiState, int UnreadCount, string StatusText, bool StorageAvailable);
	public sealed class AdvisorDispatchesReader
	{
		private sealed record ParsedDispatch(string Id, DateTimeOffset CreatedAt, string Headline, string Body, string PersonaId);

		public const int MaxCacheBytes = 65536;

		public const int MaxDispatches = 20;

		public const int MaxScopeGenerationLength = 128;

		public const int MaxRevisionLength = 128;

		public const int MaxDispatchIdLength = 64;

		public const int MaxHeadlineLength = 60;

		public const int MaxBodyLength = 512;

		public const int MaxPersonaLength = 64;

		public const int MaxTimestampLength = 128;

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

		private static readonly HashSet<string> DocumentFields = new HashSet<string>(StringComparer.Ordinal) { "version", "saveFingerprint", "scopeGeneration", "revision", "capturedAt", "dispatches" };

		private static readonly HashSet<string> DispatchFields = new HashSet<string>(StringComparer.Ordinal) { "id", "createdAt", "headline", "body", "personaId", "voiceVersion", "triggerId" };

		private readonly string _path;

		private readonly Func<string, LocalFileSignature> _signatureReader;

		private readonly Func<string, byte[]> _readBytes;

		private readonly LocalFileRefreshGate _refreshGate;

		private AdvisorDispatchesRead? _lastRead;

		private string? _lastSaveFingerprint;

		public static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "advisor-dispatches-cache.json");

		public AdvisorDispatchesReader(string path)
			: this(path, null, null, null)
		{
		}

		internal AdvisorDispatchesReader(string path, Func<string, LocalFileSignature>? signatureReader, Func<string, byte[]>? readBytes, TimeSpan? forcedRecovery)
		{
			_path = path;
			_signatureReader = signatureReader ?? new Func<string, LocalFileSignature>(ReadSignature);
			_readBytes = readBytes ?? new Func<string, byte[]>(File.ReadAllBytes);
			_refreshGate = new LocalFileRefreshGate(forcedRecovery ?? TimeSpan.FromSeconds(15.0));
		}

		public AdvisorDispatchesRead Read(DateTimeOffset now, string? activeSaveFingerprint)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint))
			{
				return Result(AdvisorDispatchesReadState.Missing, "No Advisor Dispatches available yet.");
			}
			LocalFileSignature signature = _signatureReader(_path);
			if (string.Equals(_lastSaveFingerprint, activeSaveFingerprint, StringComparison.Ordinal) && _lastRead != null && !_refreshGate.ShouldRefresh(signature, now, dirty: false, out var _))
			{
				return _lastRead;
			}
			AdvisorDispatchesRead advisorDispatchesRead = (_lastRead = ReadCurrent(now, activeSaveFingerprint, signature));
			_lastSaveFingerprint = activeSaveFingerprint;
			if (advisorDispatchesRead.State == AdvisorDispatchesReadState.Unavailable)
			{
				_refreshGate.RejectTransient();
			}
			else
			{
				_refreshGate.Accept(signature, now);
			}
			return advisorDispatchesRead;
		}

		private AdvisorDispatchesRead ReadCurrent(DateTimeOffset now, string activeSaveFingerprint, LocalFileSignature signature)
		{
			if (!signature.Exists)
			{
				return Result(AdvisorDispatchesReadState.Missing, "No Advisor Dispatches available yet.");
			}
			byte[] array;
			try
			{
				if (signature.Length <= 0 || signature.Length > 65536)
				{
					return Result(AdvisorDispatchesReadState.Malformed, "Advisor Dispatches unavailable right now.");
				}
				array = _readBytes(_path);
			}
			catch
			{
				return Result(AdvisorDispatchesReadState.Unavailable, "Advisor Dispatches unavailable right now.");
			}
			if (array.Length == 0 || array.Length > 65536)
			{
				return Result(AdvisorDispatchesReadState.Malformed, "Advisor Dispatches unavailable right now.");
			}
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(StrictUtf8.GetBytes(StrictUtf8.GetString(array)));
				JsonElement rootElement = jsonDocument.RootElement;
				if (rootElement.ValueKind != JsonValueKind.Object || !HasExactFields(rootElement, DocumentFields))
				{
					return Malformed();
				}
				if (!TryGetInt(rootElement, "version", out var value) || value != 2 || !TryGetBoundedString(rootElement, "saveFingerprint", 67, out string value2) || !SaveGenerationIdentity.IsV2Fingerprint(value2) || !string.Equals(value2, activeSaveFingerprint, StringComparison.Ordinal) || !TryGetBoundedString(rootElement, "scopeGeneration", 128, out string value3) || !TryGetBoundedString(rootElement, "revision", 128, out string value4) || !TryGetTimestamp(rootElement, "capturedAt", out var value5) || rootElement.GetProperty("dispatches").ValueKind != JsonValueKind.Array)
				{
					return Malformed();
				}
				JsonElement property = rootElement.GetProperty("dispatches");
				if (property.GetArrayLength() > 20)
				{
					return Malformed();
				}
				HashSet<string> ids = new HashSet<string>(StringComparer.Ordinal);
				List<ParsedDispatch> list = new List<ParsedDispatch>(property.GetArrayLength());
				foreach (JsonElement item in property.EnumerateArray())
				{
					if (!TryParseDispatch(item, value5, ids, out ParsedDispatch dispatch))
					{
						return Malformed();
					}
					list.Add(dispatch);
				}
				List<AdvisorDispatchMessage> list2 = list.Where((ParsedDispatch parsedDispatch) => now < parsedDispatch.CreatedAt + TimeSpan.FromDays(7.0)).Select(Project).ToList();
				int num = ((list.Count <= 0 || list2.Count != 0) ? 1 : 2);
				return new AdvisorDispatchesRead(StatusText: (num == 2) ? "Dispatches expired. New dispatches unavailable." : ((list2.Count == 0) ? "No Advisor Dispatches yet." : "Incoming only"), State: (AdvisorDispatchesReadState)num, ScopeGeneration: value3, Revision: value4, CapturedAt: value5, Messages: list2);
			}
			catch
			{
				return Malformed();
			}
		}

		private static LocalFileSignature ReadSignature(string path)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				return fileInfo.Exists ? new LocalFileSignature(Exists: true, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks) : LocalFileSignature.Missing;
			}
			catch
			{
				return LocalFileSignature.Missing;
			}
		}

		private static AdvisorDispatchMessage Project(ParsedDispatch dispatch)
		{
			return new AdvisorDispatchMessage(dispatch.Id, PersonaLabel(dispatch.PersonaId), dispatch.CreatedAt.ToLocalTime().ToString("g", CultureInfo.CurrentCulture), dispatch.Headline, dispatch.Body);
		}

		private static string PersonaLabel(string personaId)
		{
			return personaId switch
			{
				"default" => "Advisor", 
				"roast" => "Roast Master", 
				"kingpin" => "Hardened Kingpin", 
				"accountant" => "Nervous Accountant", 
				"chemist" => "Shady Chemist", 
				_ => "Advisor", 
			};
		}

		private static bool TryParseDispatch(JsonElement element, DateTimeOffset capturedAt, HashSet<string> ids, out ParsedDispatch? dispatch)
		{
			dispatch = null;
			if (element.ValueKind != JsonValueKind.Object || !HasExactFields(element, DispatchFields) || !TryGetBoundedString(element, "id", 64, out string value) || !ids.Add(value) || !TryGetTimestamp(element, "createdAt", out var value2) || value2 > capturedAt || capturedAt - value2 > TimeSpan.FromDays(7.0) || !TryGetBoundedString(element, "headline", 60, out string value3) || !TryGetBoundedString(element, "body", 512, out string value4) || !TryGetBoundedString(element, "personaId", 64, out string value5) || !TryGetBoundedString(element, "voiceVersion", 64, out string value6) || !TryGetBoundedString(element, "triggerId", 64, out value6))
			{
				return false;
			}
			dispatch = new ParsedDispatch(value, value2, value3, value4, value5);
			return true;
		}

		private static bool HasExactFields(JsonElement element, HashSet<string> allowed)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item in element.EnumerateObject())
			{
				if (!allowed.Contains(item.Name) || !hashSet.Add(item.Name))
				{
					return false;
				}
			}
			return hashSet.SetEquals(allowed);
		}

		private static bool TryGetInt(JsonElement element, string name, out int value)
		{
			value = 0;
			if (element.TryGetProperty(name, out var value2) && value2.ValueKind == JsonValueKind.Number)
			{
				return value2.TryGetInt32(out value);
			}
			return false;
		}

		private static bool TryGetBoundedString(JsonElement element, string name, int maxLength, out string value)
		{
			value = "";
			if (!element.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			value = value2.GetString() ?? "";
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value.Length <= maxLength;
			}
			return false;
		}

		private static bool TryGetTimestamp(JsonElement element, string name, out DateTimeOffset value)
		{
			value = default(DateTimeOffset);
			if (!TryGetBoundedString(element, name, 128, out string value2))
			{
				return false;
			}
			return DateTimeOffset.TryParse(value2, CultureInfo.InvariantCulture, DateTimeStyles.None, out value);
		}

		private static AdvisorDispatchesRead Malformed()
		{
			return Result(AdvisorDispatchesReadState.Malformed, "Advisor Dispatches unavailable right now.");
		}

		private static AdvisorDispatchesRead Result(AdvisorDispatchesReadState state, string text)
		{
			return new AdvisorDispatchesRead(state, null, null, null, Array.Empty<AdvisorDispatchMessage>(), text);
		}
	}
	public sealed record AdvisorDispatchesUiSnapshot(string SaveFingerprint, string ScopeGeneration, IReadOnlyList<string> ReadIds, IReadOnlyList<string> NotifiedIds);
	public sealed record AdvisorDispatchesUiLoad(AdvisorDispatchesUiSnapshot State, bool StorageAvailable, bool Repaired);
	public sealed class AdvisorDispatchesUiState
	{
		private sealed class UiDocument
		{
			[JsonPropertyName("version")]
			public int Version { get; set; }

			[JsonPropertyName("saveFingerprint")]
			public string SaveFingerprint { get; set; } = "";

			[JsonPropertyName("scopeGeneration")]
			public string ScopeGeneration { get; set; } = "";

			[JsonPropertyName("readIds")]
			public string[] ReadIds { get; set; } = Array.Empty<string>();

			[JsonPropertyName("notifiedIds")]
			public string[] NotifiedIds { get; set; } = Array.Empty<string>();
		}

		public const int MaxStateBytes = 8192;

		public const int MaxIds = 20;

		public const int MaxIdLength = 64;

		public const int MaxScopeGenerationLength = 128;

		private static readonly HashSet<string> Fields = new HashSet<string>(StringComparer.Ordinal) { "version", "saveFingerprint", "scopeGeneration", "readIds", "notifiedIds" };

		private readonly string _path;

		private readonly Action<string, string> _replaceFile;

		private readonly Action<string> _deleteFile;

		private readonly Func<string, byte[]> _readFile;

		private readonly Func<string, LocalFileSignature> _signatureReader;

		private readonly Func<DateTimeOffset> _clock;

		private readonly LocalFileRefreshGate _refreshGate;

		private AdvisorDispatchesUiLoad? _lastLoad;

		private string? _lastSaveFingerprint;

		private string? _lastScopeGeneration;

		private string? _lastValidIds;

		public static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "advisor-dispatches-ui.json");

		public AdvisorDispatchesUiState(string path)
			: this(path, null, null)
		{
		}

		internal AdvisorDispatchesUiState(string path, Action<string, string>? replaceFile, Action<string>? deleteFile, Func<string, byte[]>? readFile = null, Func<string, LocalFileSignature>? signatureReader = null, Func<DateTimeOffset>? clock = null, TimeSpan? forcedRecovery = null)
		{
			_path = path;
			_replaceFile = replaceFile ?? ((Action<string, string>)delegate(string source, string destination)
			{
				File.Move(source, destination, overwrite: true);
			});
			_deleteFile = deleteFile ?? new Action<string>(File.Delete);
			_readFile = readFile ?? new Func<string, byte[]>(File.ReadAllBytes);
			_signatureReader = signatureReader ?? new Func<string, LocalFileSignature>(ReadSignature);
			_clock = clock ?? ((Func<DateTimeOffset>)(() => DateTimeOffset.UtcNow));
			_refreshGate = new LocalFileRefreshGate(forcedRecovery ?? TimeSpan.FromSeconds(15.0));
		}

		public AdvisorDispatchesUiLoad Load(string saveFingerprint, string scopeGeneration, IReadOnlySet<string> validIds)
		{
			AdvisorDispatchesUiSnapshot advisorDispatchesUiSnapshot = Empty(saveFingerprint, scopeGeneration);
			if (!SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint) || !IsBounded(scopeGeneration, 128) || !ValidIds(validIds))
			{
				return new AdvisorDispatchesUiLoad(advisorDispatchesUiSnapshot, StorageAvailable: false, Repaired: false);
			}
			LocalFileSignature signature = _signatureReader(_path);
			string text = string.Join("\u001f", validIds.OrderBy<string, string>((string id) => id, StringComparer.Ordinal));
			if (string.Equals(_lastSaveFingerprint, saveFingerprint, StringComparison.Ordinal) && string.Equals(_lastScopeGeneration, scopeGeneration, StringComparison.Ordinal) && string.Equals(_lastValidIds, text, StringComparison.Ordinal) && _lastLoad != null && !_refreshGate.ShouldRefresh(signature, _clock(), dirty: false, out var _))
			{
				return _lastLoad;
			}
			AdvisorDispatchesUiLoad result = (_lastLoad = LoadCurrent(advisorDispatchesUiSnapshot, saveFingerprint, scopeGeneration, validIds, signature));
			_lastSaveFingerprint = saveFingerprint;
			_lastScopeGeneration = scopeGeneration;
			_lastValidIds = text;
			_refreshGate.Accept(signature, _clock());
			return result;
		}

		private AdvisorDispatchesUiLoad LoadCurrent(AdvisorDispatchesUiSnapshot empty, string saveFingerprint, string scopeGeneration, IReadOnlySet<string> validIds, LocalFileSignature signature)
		{
			if (!signature.Exists)
			{
				return new AdvisorDispatchesUiLoad(empty, StorageAvailable: true, Repaired: false);
			}
			try
			{
				if (signature.Length <= 0 || signature.Length > 8192)
				{
					return new AdvisorDispatchesUiLoad(empty, StorageAvailable: false, Repaired: false);
				}
				if (!TryParse(_readFile(_path), out AdvisorDispatchesUiSnapshot snapshot))
				{
					return new AdvisorDispatchesUiLoad(empty, StorageAvailable: false, Repaired: false);
				}
				if (!string.Equals(snapshot.SaveFingerprint, saveFingerprint, StringComparison.Ordinal) || !string.Equals(snapshot.ScopeGeneration, scopeGeneration, StringComparison.Ordinal))
				{
					return new AdvisorDispatchesUiLoad(empty, StorageAvailable: true, Repaired: false);
				}
				AdvisorDispatchesUiSnapshot advisorDispatchesUiSnapshot = Reconcile(snapshot, saveFingerprint, scopeGeneration, validIds);
				if (Equivalent(snapshot, advisorDispatchesUiSnapshot))
				{
					return new AdvisorDispatchesUiLoad(advisorDispatchesUiSnapshot, StorageAvailable: true, Repaired: false);
				}
				return TryPersist(advisorDispatchesUiSnapshot) ? new AdvisorDispatchesUiLoad(advisorDispatchesUiSnapshot, StorageAvailable: true, Repaired: true) : new AdvisorDispatchesUiLoad(advisorDispatchesUiSnapshot, StorageAvailable: false, Repaired: true);
			}
			catch
			{
				return new AdvisorDispatchesUiLoad(empty, StorageAvailable: false, Repaired: false);
			}
		}

		public bool TryMarkRead(AdvisorDispatchesUiSnapshot current, IReadOnlyCollection<string> displayedValidatedIds, IReadOnlySet<string> validIds, out AdvisorDispatchesUiSnapshot next)
		{
			return TryMark(current, displayedValidatedIds, validIds, read: true, out next);
		}

		public bool TryMarkNotified(AdvisorDispatchesUiSnapshot current, IReadOnlyCollection<string> notifiedValidatedIds, IReadOnlySet<string> validIds, out AdvisorDispatchesUiSnapshot next)
		{
			return TryMark(current, notifiedValidatedIds, validIds, read: false, out next);
		}

		public static AdvisorDispatchesUiSnapshot Reconcile(AdvisorDispatchesUiSnapshot? persisted, string saveFingerprint, string scopeGeneration, IReadOnlySet<string> validIds)
		{
			if (persisted == null || !string.Equals(persisted.SaveFingerprint, saveFingerprint, StringComparison.Ordinal) || !string.Equals(persisted.ScopeGeneration, scopeGeneration, StringComparison.Ordinal))
			{
				return Empty(saveFingerprint, scopeGeneration);
			}
			return new AdvisorDispatchesUiSnapshot(saveFingerprint, scopeGeneration, Intersect(persisted.ReadIds, validIds), Intersect(persisted.NotifiedIds, validIds));
		}

		public static int CountUnread(IReadOnlyCollection<AdvisorDispatchMessage> displayedMessages, AdvisorDispatchesUiSnapshot state)
		{
			return displayedMessages.Count((AdvisorDispatchMessage message) => !state.ReadIds.Contains<string>(message.Id, StringComparer.Ordinal));
		}

		private bool TryMark(AdvisorDispatchesUiSnapshot current, IReadOnlyCollection<string> candidateIds, IReadOnlySet<string> validIds, bool read, out AdvisorDispatchesUiSnapshot next)
		{
			string[] second = candidateIds.Where((string id) => validIds.Contains(id) && IsBounded(id, 64)).Distinct<string>(StringComparer.Ordinal).Take(20)
				.ToArray();
			string[] array = (read ? current.ReadIds : current.NotifiedIds).Concat(second).Distinct<string>(StringComparer.Ordinal).Take(20)
				.OrderBy<string, string>((string id) => id, StringComparer.Ordinal)
				.ToArray();
			next = (read ? current with
			{
				ReadIds = array
			} : current with
			{
				NotifiedIds = array
			});
			if (Equivalent(current, next))
			{
				return true;
			}
			if (TryPersist(next))
			{
				_refreshGate.Reset();
				_lastLoad = null;
				return true;
			}
			next = current;
			return false;
		}

		private static LocalFileSignature ReadSignature(string path)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				return fileInfo.Exists ? new LocalFileSignature(Exists: true, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks) : LocalFileSignature.Missing;
			}
			catch
			{
				return LocalFileSignature.Missing;
			}
		}

		private bool TryPersist(AdvisorDispatchesUiSnapshot state)
		{
			try
			{
				if (!SaveGenerationIdentity.IsV2Fingerprint(state.SaveFingerprint) || !IsBounded(state.ScopeGeneration, 128))
				{
					return false;
				}
				byte[] array = JsonSerializer.SerializeToUtf8Bytes(new UiDocument
				{
					Version = 2,
					SaveFingerprint = state.SaveFingerprint,
					ScopeGeneration = state.ScopeGeneration,
					ReadIds = state.ReadIds.ToArray(),
					NotifiedIds = state.NotifiedIds.ToArray()
				}, new JsonSerializerOptions
				{
					WriteIndented = true
				});
				if (array.Length > 8192)
				{
					return false;
				}
				if (File.Exists(_path) && _readFile(_path).SequenceEqual(array))
				{
					return true;
				}
				string directoryName = Path.GetDirectoryName(_path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				string text = $"{_path}.{Guid.NewGuid():N}.tmp";
				try
				{
					using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
					{
						fileStream.Write(array, 0, array.Length);
						fileStream.Flush(flushToDisk: true);
					}
					_replaceFile(text, _path);
					text = "";
					return true;
				}
				finally
				{
					if (!string.IsNullOrEmpty(text))
					{
						try
						{
							File.Delete(text);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
				return false;
			}
		}

		private static bool TryParse(byte[] bytes, out AdvisorDispatchesUiSnapshot? snapshot)
		{
			snapshot = null;
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(bytes);
				JsonElement rootElement = jsonDocument.RootElement;
				if (rootElement.ValueKind != JsonValueKind.Object || !ExactFields(rootElement) || !rootElement.TryGetProperty("version", out var value) || value.ValueKind != JsonValueKind.Number || value.GetInt32() != 2 || !TrySaveFingerprint(rootElement, out string saveFingerprint) || !TryScope(rootElement, out string scope) || !TryIds(rootElement, "readIds", out IReadOnlyList<string> ids) || !TryIds(rootElement, "notifiedIds", out IReadOnlyList<string> ids2))
				{
					return false;
				}
				snapshot = new AdvisorDispatchesUiSnapshot(saveFingerprint, scope, ids, ids2);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool ExactFields(JsonElement root)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item in root.EnumerateObject())
			{
				if (!Fields.Contains(item.Name) || !hashSet.Add(item.Name))
				{
					return false;
				}
			}
			return hashSet.SetEquals(Fields);
		}

		private static bool TryScope(JsonElement root, out string scope)
		{
			scope = "";
			if (!root.TryGetProperty("scopeGeneration", out var value) || value.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			scope = value.GetString() ?? "";
			return IsBounded(scope, 128);
		}

		private static bool TrySaveFingerprint(JsonElement root, out string saveFingerprint)
		{
			saveFingerprint = "";
			if (!root.TryGetProperty("saveFingerprint", out var value) || value.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			saveFingerprint = value.GetString() ?? "";
			return SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint);
		}

		private static bool TryIds(JsonElement root, string name, out IReadOnlyList<string> ids)
		{
			ids = Array.Empty<string>();
			if (!root.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.Array || value.GetArrayLength() > 20)
			{
				return false;
			}
			List<string> list = new List<string>();
			foreach (JsonElement item in value.EnumerateArray())
			{
				if (item.ValueKind != JsonValueKind.String)
				{
					return false;
				}
				string text = item.GetString() ?? "";
				if (!IsBounded(text, 64) || list.Contains<string>(text, StringComparer.Ordinal))
				{
					return false;
				}
				list.Add(text);
			}
			ids = list.OrderBy<string, string>((string id) => id, StringComparer.Ordinal).ToArray();
			return true;
		}

		private static IReadOnlyList<string> Intersect(IEnumerable<string> ids, IReadOnlySet<string> validIds)
		{
			return ids.Where(validIds.Contains).Distinct<string>(StringComparer.Ordinal).Take(20)
				.OrderBy<string, string>((string id) => id, StringComparer.Ordinal)
				.ToArray();
		}

		private static bool ValidIds(IEnumerable<string> ids)
		{
			if (ids.Count() <= 20)
			{
				return ids.All((string id) => IsBounded(id, 64));
			}
			return false;
		}

		private static bool IsBounded(string? value, int maxLength)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value.Length <= maxLength;
			}
			return false;
		}

		private static AdvisorDispatchesUiSnapshot Empty(string saveFingerprint, string scope)
		{
			return new AdvisorDispatchesUiSnapshot(saveFingerprint, scope, Array.Empty<string>(), Array.Empty<string>());
		}

		private static bool Equivalent(AdvisorDispatchesUiSnapshot left, AdvisorDispatchesUiSnapshot right)
		{
			if (string.Equals(left.SaveFingerprint, right.SaveFingerprint, StringComparison.Ordinal) && string.Equals(left.ScopeGeneration, right.ScopeGeneration, StringComparison.Ordinal) && left.ReadIds.SequenceEqual<string>(right.ReadIds, StringComparer.Ordinal))
			{
				return left.NotifiedIds.SequenceEqual<string>(right.NotifiedIds, StringComparer.Ordinal);
			}
			return false;
		}
	}
	internal static class BoundedHttpResponse
	{
		public static async Task<byte[]> ReadBytesAsync(HttpResponseMessage response, int maxBytes, CancellationToken cancellationToken)
		{
			if (maxBytes <= 0)
			{
				throw new ArgumentOutOfRangeException("maxBytes");
			}
			long? contentLength = response.Content.Headers.ContentLength;
			if (contentLength.HasValue && contentLength.GetValueOrDefault() > 0 && response.Content.Headers.ContentLength > maxBytes)
			{
				throw new InvalidDataException("Backend response exceeded the local byte limit.");
			}
			byte[] result;
			await using (Stream source = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))
			{
				using MemoryStream destination = new MemoryStream();
				byte[] buffer = new byte[Math.Min(8192, maxBytes + 1)];
				while (true)
				{
					int num = await source.ReadAsync(buffer.AsMemory(0, buffer.Length), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num == 0)
					{
						break;
					}
					if (destination.Length + num > maxBytes)
					{
						throw new InvalidDataException("Backend response exceeded the local byte limit.");
					}
					destination.Write(buffer, 0, num);
				}
				result = destination.ToArray();
			}
			return result;
		}
	}
	internal sealed class BridgeCommandFileWriter
	{
		private readonly string _path;

		public BridgeCommandFileWriter(string path)
		{
			_path = path;
		}

		public bool TryWrite(object command)
		{
			string text = null;
			try
			{
				if (File.Exists(_path))
				{
					return false;
				}
				string directoryName = Path.GetDirectoryName(_path);
				if (string.IsNullOrWhiteSpace(directoryName))
				{
					return false;
				}
				Directory.CreateDirectory(directoryName);
				text = $"{_path}.{Guid.NewGuid():N}.tmp";
				File.WriteAllText(text, JsonSerializer.Serialize(command));
				File.Move(text, _path, overwrite: false);
				text = null;
				return true;
			}
			catch
			{
				return false;
			}
			finally
			{
				if (text != null)
				{
					try
					{
						File.Delete(text);
					}
					catch
					{
					}
				}
			}
		}
	}
	internal sealed record BridgeCommandResult(string RequestId, string Status);
	internal static class BridgeCommandResultReader
	{
		private const int MaxResultBytes = 4096;

		private static readonly HashSet<string> Fields = new HashSet<string>(StringComparer.Ordinal) { "version", "requestId", "status", "saveFingerprint" };

		internal static IReadOnlyList<BridgeCommandResult> Take(string directory, string? activeSaveFingerprint)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint) || string.IsNullOrWhiteSpace(directory) || !Directory.Exists(directory))
			{
				return Array.Empty<BridgeCommandResult>();
			}
			try
			{
				return TakePaths(Directory.GetFiles(directory, "bridge-command-result-*.json"), activeSaveFingerprint);
			}
			catch
			{
				return Array.Empty<BridgeCommandResult>();
			}
		}

		internal static IReadOnlyList<BridgeCommandResult> TakeKnown(string directory, IEnumerable<string> requestIds, string? activeSaveFingerprint)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint) || string.IsNullOrWhiteSpace(directory))
			{
				return Array.Empty<BridgeCommandResult>();
			}
			List<string> list = new List<string>();
			foreach (string requestId in requestIds)
			{
				if (IsSafeRequestId(requestId))
				{
					string text = Path.Combine(directory, "bridge-command-result-" + requestId + ".json");
					if (File.Exists(text))
					{
						list.Add(text);
					}
				}
			}
			return TakePaths(list, activeSaveFingerprint);
		}

		internal static IReadOnlyList<BridgeCommandResult> TakePaths(IEnumerable<string> paths, string? activeSaveFingerprint)
		{
			List<BridgeCommandResult> list = new List<BridgeCommandResult>();
			if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint))
			{
				return list;
			}
			foreach (string path in paths)
			{
				try
				{
					if (new FileInfo(path).Length <= 0 || new FileInfo(path).Length > 4096)
					{
						continue;
					}
					using JsonDocument jsonDocument = JsonDocument.Parse(File.ReadAllBytes(path));
					JsonElement rootElement = jsonDocument.RootElement;
					if (HasExactFields(rootElement) && TryInt(rootElement, "version", out var value) && value == 1 && TryString(rootElement, "requestId", 64, out string value2) && IsSafeRequestId(value2) && TryString(rootElement, "status", 32, out string value3) && IsSafeStatus(value3) && TryString(rootElement, "saveFingerprint", 67, out string value4) && SaveGenerationIdentity.IsV2Fingerprint(value4) && string.Equals(value4, activeSaveFingerprint, StringComparison.Ordinal) && string.Equals(Path.GetFileNameWithoutExtension(path), "bridge-command-result-" + value2, StringComparison.Ordinal))
					{
						list.Add(new BridgeCommandResult(value2, value3));
					}
				}
				catch
				{
				}
				finally
				{
					try
					{
						File.Delete(path);
					}
					catch
					{
					}
				}
			}
			return list;
		}

		private static bool HasExactFields(JsonElement root)
		{
			if (root.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(Fields, StringComparer.Ordinal);
			foreach (JsonProperty item in root.EnumerateObject())
			{
				if (!hashSet.Remove(item.Name))
				{
					return false;
				}
			}
			return hashSet.Count == 0;
		}

		private static bool TryInt(JsonElement root, string name, out int value)
		{
			value = 0;
			if (root.TryGetProperty(name, out var value2) && value2.ValueKind == JsonValueKind.Number)
			{
				return value2.TryGetInt32(out value);
			}
			return false;
		}

		private static bool TryString(JsonElement root, string name, int maxLength, out string value)
		{
			value = "";
			if (!root.TryGetProperty(name, out var value2) || value2.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			value = value2.GetString() ?? "";
			if (value.Length > 0)
			{
				return value.Length <= maxLength;
			}
			return false;
		}

		private static bool IsSafeRequestId(string requestId)
		{
			foreach (char c in requestId)
			{
				if (!char.IsLetterOrDigit(c) && c != '-' && c != '_')
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSafeStatus(string status)
		{
			switch (status)
			{
			case "sent":
			case "alreadySent":
			case "failed":
			case "unauthorized":
				return true;
			default:
				return false;
			}
		}
	}
	public sealed class BridgeStatus
	{
		public string? Status;

		public string? PairingCode;

		public string? SaveLine;

		public string? LatestLine;

		public long Sequence;

		public bool? CanUnlink;
	}
	internal sealed record BridgeStatusFileRead(BridgeStatus? Status, string? TileChallenge, LocalFileSignature Signature, bool RefreshAttempted, string? RuntimeSession = null);
	internal sealed class BridgeStatusFileReader
	{
		private const int MaxStatusBytes = 65536;

		private const int MaxRuntimeSessionLength = 64;

		private static readonly HashSet<string> ChallengeFields = new HashSet<string>(StringComparer.Ordinal) { "version", "challenge", "protocolVersion" };

		private readonly string _path;

		private readonly Func<string, LocalFileSignature> _signatureReader;

		private readonly Func<string, byte[]> _readBytes;

		private readonly LocalFileRefreshGate _gate;

		private BridgeStatusFileRead _last;

		internal BridgeStatusFileReader(string path, Func<string, LocalFileSignature>? signatureReader = null, Func<string, byte[]>? readBytes = null, TimeSpan? forcedRecovery = null)
		{
			_path = path;
			_signatureReader = signatureReader ?? new Func<string, LocalFileSignature>(ReadSignature);
			_readBytes = readBytes ?? new Func<string, byte[]>(File.ReadAllBytes);
			_gate = new LocalFileRefreshGate(forcedRecovery ?? TimeSpan.FromSeconds(15.0));
			_last = new BridgeStatusFileRead(null, null, LocalFileSignature.Missing, RefreshAttempted: false);
		}

		internal BridgeStatusFileRead ReadIfDue(DateTimeOffset now, bool dirty)
		{
			LocalFileSignature signature = _signatureReader(_path);
			if (!_gate.ShouldRefresh(signature, now, dirty, out var _))
			{
				return _last with
				{
					RefreshAttempted = false
				};
			}
			try
			{
				if (!signature.Exists || signature.Length <= 0 || signature.Length > 65536)
				{
					return Reject(signature);
				}
				byte[] array = _readBytes(_path);
				if (array.Length == 0 || array.Length > 65536)
				{
					return Reject(signature);
				}
				using JsonDocument jsonDocument = JsonDocument.Parse(array);
				if (jsonDocument.RootElement.ValueKind != JsonValueKind.Object)
				{
					return Reject(signature);
				}
				JsonElement rootElement = jsonDocument.RootElement;
				BridgeStatus status = new BridgeStatus
				{
					Status = GetString(rootElement, "status"),
					PairingCode = GetString(rootElement, "pairingCode"),
					SaveLine = GetString(rootElement, "saveLine"),
					LatestLine = GetString(rootElement, "latestLine"),
					Sequence = GetLong(rootElement, "sequence"),
					CanUnlink = GetBoolean(rootElement, "canUnlink")
				};
				if (!TryReadChallenge(rootElement, out string challenge))
				{
					challenge = null;
				}
				_gate.Accept(signature, now);
				_last = new BridgeStatusFileRead(status, challenge, signature, RefreshAttempted: true, ReadRuntimeSession(rootElement));
				return _last;
			}
			catch
			{
				return Reject(signature);
			}
		}

		private BridgeStatusFileRead Reject(LocalFileSignature signature)
		{
			_gate.RejectTransient();
			return new BridgeStatusFileRead(null, null, signature, RefreshAttempted: true);
		}

		private static LocalFileSignature ReadSignature(string path)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				return fileInfo.Exists ? new LocalFileSignature(Exists: true, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks) : LocalFileSignature.Missing;
			}
			catch
			{
				return LocalFileSignature.Missing;
			}
		}

		internal static bool TryReadChallenge(JsonElement root, out string? challenge)
		{
			challenge = null;
			if (!root.TryGetProperty("tileChallenge", out var value) || value.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item in value.EnumerateObject())
			{
				if (!ChallengeFields.Contains(item.Name) || !hashSet.Add(item.Name))
				{
					return false;
				}
			}
			if (!hashSet.SetEquals(ChallengeFields) || !value.TryGetProperty("version", out var value2) || value2.ValueKind != JsonValueKind.Number || value2.GetInt32() != 1 || !value.TryGetProperty("protocolVersion", out var value3) || value3.ValueKind != JsonValueKind.Number || value3.GetInt32() != 1 || !value.TryGetProperty("challenge", out var value4) || value4.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			string text = value4.GetString();
			if (string.IsNullOrWhiteSpace(text) || text.Length > 128)
			{
				return false;
			}
			challenge = text;
			return true;
		}

		private static string? ReadRuntimeSession(JsonElement root)
		{
			string text = GetString(root, "runtimeSession")?.Trim();
			if (!string.IsNullOrEmpty(text) && text.Length <= 64)
			{
				return text;
			}
			return null;
		}

		private static string? GetString(JsonElement root, string name)
		{
			if (!root.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.String)
			{
				return null;
			}
			return value.GetString();
		}

		private static long GetLong(JsonElement root, string name)
		{
			if (!root.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.Number || !value.TryGetInt64(out var value2))
			{
				return 0L;
			}
			return value2;
		}

		private static bool? GetBoolean(JsonElement root, string name)
		{
			if (!root.TryGetProperty(name, out var value))
			{
				return null;
			}
			return value.ValueKind switch
			{
				JsonValueKind.True => true, 
				JsonValueKind.False => false, 
				_ => null, 
			};
		}
	}
	internal static class CurrentSaveSlotReader
	{
		private const string LoadManagerTypeName = "Il2CppScheduleOne.Persistence.LoadManager, Assembly-CSharp";

		private static readonly BindingFlags PublicInstanceOrStatic = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;

		private static readonly Regex SaveSlotPattern = new Regex("(?<![A-Za-z0-9_])SaveGame_[0-9]+(?![A-Za-z0-9_])", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);

		public static string? TryRead()
		{
			string source;
			return TryRead(out source);
		}

		public static string? TryRead(out string? source)
		{
			source = null;
			try
			{
				Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => string.Equals(assembly.GetName().Name, "Assembly-CSharp", StringComparison.Ordinal))?.GetType("Il2CppScheduleOne.Persistence.LoadManager, Assembly-CSharp".Split(',')[0].Trim(), throwOnError: false);
				if (type == null)
				{
					source = "Assembly-CSharp LoadManager type unavailable";
					return null;
				}
				PropertyInfo propertyInfo = FindProperty(type, "Instance") ?? FindProperty(type, "instance");
				object obj = propertyInfo?.GetValue(null);
				if (obj == null)
				{
					source = ((propertyInfo == null) ? "LoadManager singleton property unavailable" : "LoadManager singleton instance unavailable");
					return null;
				}
				PropertyInfo propertyInfo2 = FindProperty(type, "ActiveSaveInfo");
				object obj2 = propertyInfo2?.GetValue(obj);
				if (obj2 == null && propertyInfo2 == null)
				{
					source = "LoadManager.ActiveSaveInfo property unavailable";
				}
				string text = ExtractSaveSlot(FindProperty(obj2?.GetType(), "SavePath")?.GetValue(obj2) as string);
				if (text != null)
				{
					source = "LoadManager.ActiveSaveInfo.SavePath";
					return text;
				}
				if (FindProperty(obj2?.GetType(), "SaveSlotNumber")?.GetValue(obj2) is int slotNumber)
				{
					text = FormatSaveSlotNumber(slotNumber);
					if (text != null)
					{
						source = "LoadManager.ActiveSaveInfo.SaveSlotNumber";
						return text;
					}
				}
				text = ExtractSaveSlot(FindProperty(type, "LoadedGameFolderPath")?.GetValue(obj) as string);
				if (text != null)
				{
					source = "LoadManager.LoadedGameFolderPath";
				}
				if (text == null && source == null)
				{
					source = "LoadManager identity properties contained no SaveGame_N value";
				}
				return text;
			}
			catch (Exception ex)
			{
				source = "LoadManager identity read failed: " + ex.GetType().Name;
			}
			return null;
		}

		public static bool TryReadActiveDirectory(out string? saveDirectory, out string? source)
		{
			saveDirectory = null;
			source = null;
			try
			{
				Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => string.Equals(assembly.GetName().Name, "Assembly-CSharp", StringComparison.Ordinal))?.GetType("Il2CppScheduleOne.Persistence.LoadManager, Assembly-CSharp".Split(',')[0].Trim(), throwOnError: false);
				object obj = FindProperty(type, "Instance")?.GetValue(null) ?? FindProperty(type, "instance")?.GetValue(null);
				if (obj == null)
				{
					return false;
				}
				object obj2 = FindProperty(type, "ActiveSaveInfo")?.GetValue(obj);
				if (TryValidateActiveDirectory(FindProperty(obj2?.GetType(), "SavePath")?.GetValue(obj2) as string, out saveDirectory))
				{
					source = "active-save-path";
					return true;
				}
				if (TryValidateActiveDirectory(FindProperty(type, "LoadedGameFolderPath")?.GetValue(obj) as string, out saveDirectory))
				{
					source = "loaded-game-folder";
					return true;
				}
			}
			catch
			{
				source = "runtime-save-read-failed";
			}
			return false;
		}

		internal static bool TryValidateActiveDirectory(string? value, out string? saveDirectory)
		{
			saveDirectory = null;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			try
			{
				string text = Path.GetFullPath(value).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
				if (!Directory.Exists(text) || ExtractSaveSlot(Path.GetFileName(text)) == null)
				{
					return false;
				}
				string directoryName = Path.GetDirectoryName(text);
				string path = (string.IsNullOrWhiteSpace(directoryName) ? null : Path.GetDirectoryName(directoryName));
				if (string.IsNullOrWhiteSpace(directoryName) || string.IsNullOrWhiteSpace(Path.GetFileName(directoryName)) || !string.Equals(Path.GetFileName(path), "Saves", StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				saveDirectory = text;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static PropertyInfo? FindProperty(Type? type, string name)
		{
			Type type2 = type;
			while (type2 != null)
			{
				PropertyInfo property = type2.GetProperty(name, PublicInstanceOrStatic | BindingFlags.DeclaredOnly);
				if (property != null)
				{
					return property;
				}
				type2 = type2.BaseType;
			}
			return null;
		}

		public static string? FormatSaveSlotNumber(int slotNumber)
		{
			if (slotNumber < 1 || slotNumber > 99)
			{
				return null;
			}
			return $"SaveGame_{slotNumber}";
		}

		public static string? ExtractSaveSlot(string? value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return null;
			}
			Match match = SaveSlotPattern.Match(value);
			if (!match.Success)
			{
				return null;
			}
			return match.Value;
		}
	}
	internal enum DiscoveredMixBaseFilter
	{
		All,
		Weed,
		Meth,
		Cocaine,
		Shrooms
	}
	internal sealed class DiscoveredMixFilterState
	{
		public IReadOnlyList<DiscoveredMixBaseFilter> BaseFilters { get; private set; } = new DiscoveredMixBaseFilter[1];

		public IReadOnlyList<ObservedEffectFilter> EffectFilters { get; private set; } = new ObservedEffectFilter[1]
		{
			new ObservedEffectFilter
			{
				Key = "",
				Label = "All effects"
			}
		};

		public DiscoveredMixBaseFilter SelectedBase { get; private set; }

		public string SelectedEffect { get; private set; } = "";

		public bool PricedOnly { get; private set; }

		public void Refresh(IEnumerable<LocalMix> mixes)
		{
			List<LocalMix> mixes2 = mixes.ToList();
			BaseFilters = DiscoveredMixFilterCatalog.GetBaseFilters(mixes2);
			EffectFilters = ObservedEffects.GetFilters(mixes2);
			if (!BaseFilters.Contains(SelectedBase))
			{
				SelectedBase = DiscoveredMixBaseFilter.All;
			}
			if (!EffectFilters.Any((ObservedEffectFilter filter) => filter.Key == SelectedEffect))
			{
				SelectedEffect = "";
			}
		}

		public void SelectBase(DiscoveredMixBaseFilter filter)
		{
			if (BaseFilters.Contains(filter))
			{
				SelectedBase = filter;
			}
		}

		public void SelectEffect(string filterKey)
		{
			if (EffectFilters.Any((ObservedEffectFilter filter) => filter.Key == filterKey))
			{
				SelectedEffect = filterKey;
			}
		}

		public void SetPricedOnly(bool value)
		{
			PricedOnly = value;
		}

		public bool Matches(LocalMix mix, bool pricedAvailable)
		{
			if ((SelectedBase == DiscoveredMixBaseFilter.All || DiscoveredMixFilterCatalog.ClassifyBase(mix.Base) == SelectedBase) && ObservedEffects.Matches(mix, SelectedEffect))
			{
				return !PricedOnly || pricedAvailable;
			}
			return false;
		}
	}
	internal static class DiscoveredMixFilterCatalog
	{
		public static List<DiscoveredMixBaseFilter> GetBaseFilters(IEnumerable<LocalMix> mixes)
		{
			List<DiscoveredMixBaseFilter> list = new List<DiscoveredMixBaseFilter> { DiscoveredMixBaseFilter.All };
			foreach (LocalMix mix in mixes)
			{
				DiscoveredMixBaseFilter? discoveredMixBaseFilter = ClassifyBase(mix.Base);
				if (discoveredMixBaseFilter.HasValue && !list.Contains(discoveredMixBaseFilter.Value))
				{
					list.Add(discoveredMixBaseFilter.Value);
				}
			}
			return list;
		}

		public static DiscoveredMixBaseFilter? ClassifyBase(string baseId)
		{
			switch (baseId.Replace("_", "", StringComparison.Ordinal).ToLowerInvariant())
			{
			case "meth":
				return DiscoveredMixBaseFilter.Meth;
			case "cocaine":
				return DiscoveredMixBaseFilter.Cocaine;
			case "shrooms":
			case "shroom":
				return DiscoveredMixBaseFilter.Shrooms;
			case "ogkush":
			case "greencrack":
			case "sourdiesel":
			case "granddaddypurple":
				return DiscoveredMixBaseFilter.Weed;
			default:
				return null;
			}
		}

		public static string FilterLabel(DiscoveredMixBaseFilter filter)
		{
			return filter switch
			{
				DiscoveredMixBaseFilter.All => "All", 
				DiscoveredMixBaseFilter.Weed => "Weed", 
				DiscoveredMixBaseFilter.Meth => "Meth", 
				DiscoveredMixBaseFilter.Cocaine => "Cocaine", 
				DiscoveredMixBaseFilter.Shrooms => "Shrooms", 
				_ => filter.ToString(), 
			};
		}
	}
	public sealed class EconomicsRequestQueue<T>
	{
		public const int MaxConcurrent = 3;

		private readonly Queue<(string Key, T Value)> _pending = new Queue<(string, T)>();

		private readonly HashSet<string> _knownKeys = new HashSet<string>();

		private int _active;

		public int ActiveCount => _active;

		public int PendingCount => _pending.Count;

		public bool Enqueue(string key, T value)
		{
			if (!_knownKeys.Add(key))
			{
				return false;
			}
			_pending.Enqueue((key, value));
			return true;
		}

		public bool TryStart(out T value)
		{
			if (_active >= 3 || _pending.Count == 0)
			{
				value = default(T);
				return false;
			}
			(string, T) tuple = _pending.Dequeue();
			_active++;
			value = tuple.Item2;
			return true;
		}

		public void Complete(string key)
		{
			_knownKeys.Remove(key);
			if (_active > 0)
			{
				_active--;
			}
		}
	}
	public sealed class EconomicsResult
	{
		public string Key = "";

		public bool Available;

		public string Error = "Price unavailable";

		public double SellPrice;

		public double IngredientCost;

		public double BaseCostPerUnit;

		public double ProductionCost;

		public double Profit;

		public double ProfitMargin;
	}
	internal sealed class ObservedEconomicsRequest
	{
		public string Key = "";

		public bool Valid;

		public string Base = "";

		public List<string> Ingredients = new List<string>();

		public List<string> Effects = new List<string>();
	}
	internal static class EconomicsService
	{
		private const string Url = "https://hyland-helper-backend.vercel.app/api/calculator/mix-observed";

		private const int MaxResponseBytes = 65536;

		private static readonly HttpClient Http = new HttpClient
		{
			Timeout = TimeSpan.FromSeconds(15.0)
		};

		private static readonly object Gate = new object();

		private static readonly EconomicsRequestQueue<ObservedEconomicsRequest> Queue = new EconomicsRequestQueue<ObservedEconomicsRequest>();

		private static readonly Dictionary<string, EconomicsResult> Cache = new Dictionary<string, EconomicsResult>();

		private static readonly Queue<EconomicsResult> Completed = new Queue<EconomicsResult>();

		public static string CacheKey(LocalMix mix)
		{
			List<string> list;
			if (mix.Steps.Count != 0)
			{
				List<LocalMixStep> steps = mix.Steps;
				list = steps[steps.Count - 1].OutputEffects;
			}
			else
			{
				list = new List<string>();
			}
			List<string> observedFinalEffects = list;
			return JsonSerializer.Serialize(new
			{
				baseId = mix.Base,
				ingredients = mix.Ingredients,
				observedFinalEffects = observedFinalEffects
			});
		}

		public static bool TryGetCached(string key, out EconomicsResult result)
		{
			lock (Gate)
			{
				return Cache.TryGetValue(key, out result);
			}
		}

		public static void Enqueue(LocalMix mix)
		{
			ObservedEconomicsRequest observedEconomicsRequest = BuildRequest(mix);
			lock (Gate)
			{
				if (!Cache.ContainsKey(observedEconomicsRequest.Key))
				{
					if (!observedEconomicsRequest.Valid)
					{
						EconomicsResult economicsResult = Unavailable(observedEconomicsRequest.Key);
						Cache[observedEconomicsRequest.Key] = economicsResult;
						Completed.Enqueue(economicsResult);
					}
					else if (Queue.Enqueue(observedEconomicsRequest.Key, observedEconomicsRequest))
					{
						PumpLocked();
					}
				}
			}
		}

		public static bool TryTakeResult(out EconomicsResult result)
		{
			lock (Gate)
			{
				if (Completed.Count == 0)
				{
					result = null;
					return false;
				}
				result = Completed.Dequeue();
				return true;
			}
		}

		private static ObservedEconomicsRequest BuildRequest(LocalMix mix)
		{
			int num;
			if (mix.Steps.Count > 0)
			{
				List<LocalMixStep> steps = mix.Steps;
				num = (steps[steps.Count - 1].EffectsAvailable ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool flag = (byte)num != 0;
			List<string> list;
			if (!flag)
			{
				list = new List<string>();
			}
			else
			{
				List<LocalMixStep> steps2 = mix.Steps;
				list = new List<string>(steps2[steps2.Count - 1].OutputEffects);
			}
			List<string> effects = list;
			return new ObservedEconomicsRequest
			{
				Key = CacheKey(mix),
				Valid = flag,
				Base = mix.Base,
				Ingredients = new List<string>(mix.Ingredients),
				Effects = effects
			};
		}

		private static void PumpLocked()
		{
			ObservedEconomicsRequest value;
			while (Queue.TryStart(out value))
			{
				FetchAsync(value);
			}
		}

		private static async Task FetchAsync(ObservedEconomicsRequest request)
		{
			_ = 1;
			EconomicsResult economicsResult;
			try
			{
				string content = JsonSerializer.Serialize(new
				{
					@base = request.Base,
					ingredients = request.Ingredients,
					effects = request.Effects
				});
				using HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Post, "https://hyland-helper-backend.vercel.app/api/calculator/mix-observed")
				{
					Content = new StringContent(content, Encoding.UTF8, "application/json")
				};
				using HttpResponseMessage response = await Http.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(continueOnCapturedContext: false);
				byte[] bytes = await BoundedHttpResponse.ReadBytesAsync(response, 65536, default(CancellationToken)).ConfigureAwait(continueOnCapturedContext: false);
				string body = Encoding.UTF8.GetString(bytes);
				economicsResult = (response.IsSuccessStatusCode ? ParseResult(request.Key, body) : Unavailable(request.Key));
			}
			catch
			{
				economicsResult = Unavailable(request.Key);
			}
			lock (Gate)
			{
				Cache[request.Key] = economicsResult;
				Completed.Enqueue(economicsResult);
				Queue.Complete(request.Key);
				PumpLocked();
			}
		}

		private static EconomicsResult ParseResult(string key, string body)
		{
			try
			{
				using JsonDocument jsonDocument = JsonDocument.Parse(body);
				if (!jsonDocument.RootElement.TryGetProperty("result", out var value) || value.ValueKind != JsonValueKind.Object)
				{
					return Unavailable(key);
				}
				EconomicsResult economicsResult = new EconomicsResult
				{
					Key = key,
					Available = true,
					SellPrice = GetNumber(value, "sellPrice"),
					IngredientCost = GetNumber(value, "ingredientCost"),
					BaseCostPerUnit = GetNumber(value, "baseCostPerUnit"),
					ProductionCost = GetNumber(value, "productionCost"),
					Profit = GetNumber(value, "profit"),
					ProfitMargin = GetNumber(value, "profitMargin")
				};
				return (double.IsFinite(economicsResult.SellPrice) && double.IsFinite(economicsResult.IngredientCost) && double.IsFinite(economicsResult.BaseCostPerUnit) && double.IsFinite(economicsResult.ProductionCost) && double.IsFinite(economicsResult.Profit) && double.IsFinite(economicsResult.ProfitMargin)) ? economicsResult : Unavailable(key);
			}
			catch
			{
				return Unavailable(key);
			}
		}

		private static double GetNumber(JsonElement parent, string name)
		{
			if (!parent.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.Number || !value.TryGetDouble(out var value2))
			{
				return double.NaN;
			}
			return value2;
		}

		private static EconomicsResult Unavailable(string key)
		{
			return new EconomicsResult
			{
				Key = key,
				Available = false,
				Error = "Price unavailable"
			};
		}
	}
	public static class EconomicsViewport
	{
		public static (int Start, int End) GetWindow(int cardCount, float verticalNormalizedPosition, int windowSize)
		{
			if (cardCount <= 0)
			{
				return (Start: 0, End: 0);
			}
			int num = Math.Min(cardCount, Math.Max(1, windowSize));
			float num2 = (float.IsNaN(verticalNormalizedPosition) ? 1f : Math.Clamp(verticalNormalizedPosition, 0f, 1f));
			int num3 = cardCount - num;
			int num4 = (int)Math.Round((1f - num2) * (float)num3, MidpointRounding.AwayFromZero);
			return (Start: num4, End: num4 + num);
		}
	}
	public sealed class HylandHelperApp : PhoneApp
	{
		private enum Screen
		{
			Home,
			Community,
			DiscoveredMixes,
			SavedRecipes,
			PhoneRecipes,
			AdvisorDispatches
		}

		private sealed class LocalMixCard
		{
			public string Key = "";

			public LocalMix Mix = new LocalMix();

			public RecipeCardUi Ui;

			public Func<EconomicsResult, string> Render;
		}

		private static readonly string CommandPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "bridge-command.json");

		private static readonly BridgeCommandFileWriter CommandWriter = new BridgeCommandFileWriter(CommandPath);

		private static readonly Color Bg = new Color(0.08f, 0.09f, 0.12f);

		internal static HylandHelperApp? Instance;

		private GameObject? _container;

		private GameObject? _content;

		private GameObject? _homeView;

		private GameObject? _listView;

		private CanvasGroup? _homeVisibility;

		private CanvasGroup? _listVisibility;

		private GameObject? _filterRow;

		private CanvasGroup? _filterVisibility;

		private readonly List<(DiscoveredMixBaseFilter filter, Image image)> _filterButtons = new List<(DiscoveredMixBaseFilter, Image)>();

		private readonly List<GameObject> _filterButtonObjects = new List<GameObject>();

		private Screen _screen;

		private readonly DiscoveredMixFilterState _filterState = new DiscoveredMixFilterState();

		private GameObject? _effectFilterRow;

		private CanvasGroup? _effectFilterVisibility;

		private GameObject? _effectFilterViewport;

		private GameObject? _effectFilterContent;

		private ScrollRect? _effectFilterScroll;

		private readonly List<(string key, Image image)> _effectFilterButtons = new List<(string, Image)>();

		private readonly List<GameObject> _effectFilterButtonObjects = new List<GameObject>();

		private Text? _statusText;

		private Text? _pairingText;

		private Text? _saveText;

		private Text? _latestText;

		private Text? _liveContextText;

		private string? _lastLiveContextRendered;

		private GameObject? _manualSyncButtonObject;

		private Button? _manualSyncButton;

		private Text? _manualSyncButtonText;

		private Func<long, ManualSyncViewState>? _manualSyncRequestHandler;

		private ManualSyncViewState _lastManualSyncState = ManualSyncViewState.Idle;

		private GameObject? _unlinkButton;

		private Text? _listHeading;

		private Text? _listStatus;

		private Text? _advisorUnreadText;

		private AdvisorDispatchesViewState? _advisorDispatchesView;

		private Func<AdvisorDispatchesViewState>? _advisorDispatchesOpenHandler;

		private GameObject? _listContainer;

		private ScrollRect? _mixScroll;

		private readonly List<GameObject> _listRows = new List<GameObject>();

		private readonly Dictionary<string, List<LocalMixCard>> _economicsCards = new Dictionary<string, List<LocalMixCard>>();

		private readonly Dictionary<string, (LocalMix mix, RecipeCardUi card)> _pendingSaveTrack = new Dictionary<string, (LocalMix, RecipeCardUi)>();

		private LocalSavedRecipeStore? _savedRecipeStore;

		private string? _saveFingerprint;

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

		private readonly PhoneRecipeAvailabilityReader _phoneRecipeReader = new PhoneRecipeAvailabilityReader(PhoneRecipeAvailabilityReader.DefaultPath);

		private GameObject? _priceFilterGO;

		private Image? _priceFilterImage;

		private float _lastScrollPosition = float.NaN;

		private BridgeStatus? _lastStatus;

		private bool _wasVisible;

		internal ScreenActivityScreen? CurrentBridgeScreen => ScreenActivityProjection.Project((Object)(object)_container != (Object)null && _container.activeInHierarchy, _screen == Screen.PhoneRecipes, _screen == Screen.AdvisorDispatches);

		private DiscoveredMixBaseFilter _baseFilter => _filterState.SelectedBase;

		private string _effectFilter => _filterState.SelectedEffect;

		private bool _pricedOnly => _filterState.PricedOnly;

		protected override string AppName => "HylandHelper";

		protected override string AppTitle => "Hyland Helper";

		protected override string IconLabel => "Hyland Helper";

		protected override string IconFileName => "hylandhelper_icon.png";

		internal void RefreshPhoneRecipesIfVisible()
		{
			if (_screen == Screen.PhoneRecipes)
			{
				PopulatePhoneRecipes();
			}
		}

		protected override void OnCreatedUI(GameObject container)
		{
			_container = container;
			Instance = this;
			_screen = Screen.Home;
			BuildPersistentUi();
			ShowHome();
		}

		public void TickVisibility()
		{
			if (!((Object)(object)_container == (Object)null))
			{
				bool activeInHierarchy = _container.activeInHierarchy;
				if (PhoneTileNavigationState.ShouldReturnHome(_wasVisible, activeInHierarchy, _screen == Screen.Home))
				{
					ShowHome();
				}
				_wasVisible = activeInHierarchy;
			}
		}

		private void GoHome()
		{
			Go(Screen.Home);
		}

		private void GoCommunity()
		{
			Go(Screen.Community);
		}

		private void GoDiscoveredMixes()
		{
			Go(Screen.DiscoveredMixes);
		}

		private void GoSavedRecipes()
		{
			Go(Screen.SavedRecipes);
		}

		private void GoPhoneRecipes()
		{
			Go(Screen.PhoneRecipes);
		}

		private void GoAdvisorDispatches()
		{
			Go(Screen.AdvisorDispatches);
		}

		private void Go(Screen screen)
		{
			PhoneTileMod.LogNavigation(_screen, screen);
			switch (screen)
			{
			case Screen.Home:
				ShowHome();
				break;
			case Screen.Community:
				ShowCommunity();
				break;
			case Screen.DiscoveredMixes:
				ShowDiscoveredMixes();
				break;
			case Screen.SavedRecipes:
				ShowSavedRecipes();
				break;
			case Screen.PhoneRecipes:
				ShowPhoneRecipes();
				break;
			case Screen.AdvisorDispatches:
				ShowAdvisorDispatches();
				break;
			}
		}

		private void BuildPersistentUi()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_container == (Object)null))
			{
				_content = UIFactory.Panel("HylandHelperContent", _container.transform, Bg, (Vector2?)null, (Vector2?)null, true);
				_homeView = UIFactory.Panel("HomeView", _content.transform, Bg, (Vector2?)null, (Vector2?)null, true);
				_listView = UIFactory.Panel("ListView", _content.transform, Bg, (Vector2?)null, (Vector2?)null, true);
				_homeVisibility = _homeView.AddComponent<CanvasGroup>();
				_listVisibility = _listView.AddComponent<CanvasGroup>();
				PackTop(_homeView);
				PackTop(_listView);
				BuildHome(_homeView);
				BuildList(_listView);
			}
		}

		private void BuildHome(GameObject panel)
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			SetHeight(((Component)UIFactory.Text("Heading", "Hyland Helper", panel.transform, 28, (TextAnchor)1, (FontStyle)0)).gameObject, 42f);
			_statusText = UIFactory.Text("Status", "Connecting to Hyland Helper…", panel.transform, 18, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_statusText).gameObject, 28f);
			_pairingText = UIFactory.Text("Pairing", "", panel.transform, 22, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_pairingText).gameObject, 30f);
			_saveText = UIFactory.Text("Save", "", panel.transform, 14, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_saveText).gameObject, 22f);
			_latestText = UIFactory.Text("Latest", "", panel.transform, 14, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_latestText).gameObject, 22f);
			_liveContextText = UIFactory.Text("LiveContext", "", panel.transform, 14, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_liveContextText).gameObject, 0f);
			((Component)_liveContextText).gameObject.SetActive(false);
			var (val, val2, manualSyncButtonText) = UIFactory.RoundedButtonWithLabel("ManualSyncButton", "Sync Now", panel.transform, new Color(0.18f, 0.3f, 0.38f), 160f, 32f, 14, Color.white);
			ButtonUtils.AddListener(val2, (Action)OnManualSyncClicked);
			SetHeight(val, 34f);
			_manualSyncButtonObject = val;
			_manualSyncButton = val2;
			_manualSyncButtonText = manualSyncButtonText;
			RenderManualSync(_lastManualSyncState);
			RecipeDestinationCardUi.Create("CommunityRecipesDestination", "Community Recipes", "Browse public mixes", panel.transform, new Color(0.16f, 0.28f, 0.36f), GoCommunity);
			RecipeDestinationCardUi.Create("DiscoveredMixesDestination", "Discovered Mixes", "Found in this game save", panel.transform, new Color(0.16f, 0.32f, 0.23f), GoDiscoveredMixes);
			RecipeDestinationCardUi.Create("SavedRecipesDestination", "Saved Recipes", "Recipes you chose to keep", panel.transform, new Color(0.18f, 0.29f, 0.35f), GoSavedRecipes);
			RecipeDestinationCardUi.Create("PhoneRecipesDestination", "Phone Recipes", "Sent from the Hyland Helper app", panel.transform, new Color(0.16f, 0.27f, 0.36f), GoPhoneRecipes);
			AdvisorDispatchesDestinationCard advisorDispatchesDestinationCard = AdvisorDispatchesDestinationCardUi.Create(panel.transform, GoAdvisorDispatches);
			_advisorUnreadText = advisorDispatchesDestinationCard.UnreadText;
			RenderAdvisorDispatches(_advisorDispatchesView ?? new AdvisorDispatchesViewState(AdvisorDispatchesReadState.Missing, Array.Empty<AdvisorDispatchMessage>(), null, 0, "No Advisor Dispatches available yet.", StorageAvailable: false));
			ValueTuple<GameObject, Button, Text> valueTuple = UIFactory.RoundedButtonWithLabel("UnlinkButton", "Unlink", panel.transform, new Color(0.45f, 0.18f, 0.18f), 180f, 40f, 16, Color.white);
			var (val3, _, _) = valueTuple;
			ButtonUtils.AddListener(valueTuple.Item2, (Action)OnUnlinkClicked);
			SetHeight(val3, 42f);
			_unlinkButton = val3;
			ApplyStatus(_lastStatus);
		}

		private void BuildList(GameObject panel)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			_listHeading = UIFactory.Text("ListHeading", "", panel.transform, 24, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_listHeading).gameObject, 36f);
			ValueTuple<GameObject, Button, Text> valueTuple = UIFactory.RoundedButtonWithLabel("BackButton", "← Back", panel.transform, new Color(0.25f, 0.27f, 0.32f), 130f, 40f, 16, Color.white);
			var (go, _, _) = valueTuple;
			ButtonUtils.AddListener(valueTuple.Item2, (Action)GoHome);
			SetHeight(go, 40f);
			_listStatus = UIFactory.Text("ListStatus", "", panel.transform, 15, (TextAnchor)1, (FontStyle)0);
			SetHeight(((Component)_listStatus).gameObject, 24f);
			List<LocalMix> mixes = LocalMixesService.Read(_saveFingerprint);
			_filterState.Refresh(mixes);
			BuildFilterRow(panel);
			BuildEffectFilterRow(panel);
			BuildScrollList(panel);
		}

		private void ShowHome()
		{
			_screen = Screen.Home;
			SetViewVisible(_homeVisibility, visible: true);
			SetViewVisible(_listVisibility, visible: false);
			ApplyStatus(_lastStatus);
			RenderManualSync(_lastManualSyncState);
		}

		private void ShowCommunity()
		{
			_screen = Screen.Community;
			ShowList("Community Recipes");
			SetFilterVisible(visible: false);
			if ((Object)(object)_listStatus != (Object)null)
			{
				_listStatus.text = "Loading community recipes…";
			}
			RecipeService.BeginFetch();
		}

		private void ShowDiscoveredMixes()
		{
			_screen = Screen.DiscoveredMixes;
			ShowList("Discovered Mixes");
			SetFilterVisible(visible: true);
			PopulateDiscoveredMixes();
		}

		private void ShowSavedRecipes()
		{
			_screen = Screen.SavedRecipes;
			ShowList("Saved Recipes");
			SetFilterVisible(visible: false);
			PopulateSavedRecipes();
		}

		private void ShowPhoneRecipes()
		{
			_screen = Screen.PhoneRecipes;
			ShowList("Phone Recipes");
			SetFilterVisible(visible: false);
			PopulatePhoneRecipes();
		}

		private void ShowAdvisorDispatches()
		{
			_screen = Screen.AdvisorDispatches;
			ShowList("Advisor Dispatches");
			SetFilterVisible(visible: false);
			AdvisorDispatchesViewState advisorDispatchesViewState = _advisorDispatchesOpenHandler?.Invoke() ?? _advisorDispatchesView;
			if (advisorDispatchesViewState != null)
			{
				RenderAdvisorDispatches(advisorDispatchesViewState);
			}
		}

		public void SetAdvisorDispatchesView(AdvisorDispatchesViewState view)
		{
			_advisorDispatchesView = view;
			if ((Object)(object)_advisorUnreadText != (Object)null)
			{
				AdvisorDispatchesDestinationCardUi.SetUnreadCount(_advisorUnreadText, view.UnreadCount);
			}
			if (_screen == Screen.AdvisorDispatches)
			{
				PopulateAdvisorDispatches();
			}
		}

		public void SetAdvisorDispatchesOpenHandler(Func<AdvisorDispatchesViewState> handler)
		{
			_advisorDispatchesOpenHandler = handler;
		}

		public void RenderAdvisorDispatches(AdvisorDispatchesViewState view)
		{
			SetAdvisorDispatchesView(view);
		}

		private void PopulateAdvisorDispatches()
		{
			ClearListRows();
			AdvisorDispatchesViewState advisorDispatchesView = _advisorDispatchesView;
			if (!(advisorDispatchesView == null))
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = ((advisorDispatchesView.Messages.Count == 0) ? advisorDispatchesView.StatusText : "Incoming only");
				}
				for (int i = 0; i < advisorDispatchesView.Messages.Count; i++)
				{
					AdvisorDispatchMessage advisorDispatchMessage = advisorDispatchesView.Messages[i];
					string body = $"{advisorDispatchMessage.PersonaLabel} · {advisorDispatchMessage.LocalTimestamp}\n{advisorDispatchMessage.Headline}\n{advisorDispatchMessage.Body}";
					AddCard("AdvisorDispatch" + i, body);
				}
			}
		}

		private void PopulateSavedRecipes()
		{
			ClearListRows();
			if (_savedRecipeStore == null)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = "Load a game save before using saved recipes.";
				}
				return;
			}
			List<LocalSavedRecipe> list = _savedRecipeStore.Read();
			if (list.Count == 0)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = "No recipes saved in the tile yet.\nUse Save Recipe on a discovered in-game mix.";
				}
				return;
			}
			if ((Object)(object)_listStatus != (Object)null)
			{
				string value = _saveFingerprint ?? "current save";
				_listStatus.text = $"{list.Count} private recipe{((list.Count == 1) ? "" : "s")} saved for {value}";
			}
			for (int i = 0; i < list.Count; i++)
			{
				LocalSavedRecipe recipe = list[i];
				LocalMix mix = SavedRecipeAsMix(recipe);
				string key = EconomicsService.CacheKey(mix);
				EconomicsResult result;
				string economicsText = (EconomicsService.TryGetCached(key, out result) ? EconomicsText(result) : RecipeCardPresentation.FormatEconomicsPending());
				RecipeCardUi ui = AddCard($"SavedRecipe{i}", BuildSavedRecipeCard(recipe, mix, economicsText));
				RegisterEconomicsCard(new LocalMixCard
				{
					Key = key,
					Mix = mix,
					Ui = ui,
					Render = (EconomicsResult result2) => BuildSavedRecipeCard(recipe, mix, EconomicsText(result2))
				});
			}
			QueueVisibleEconomics();
		}

		private void PopulatePhoneRecipes()
		{
			ClearListRows();
			PhoneRecipeAvailabilityRead phoneRecipeAvailabilityRead = _phoneRecipeReader.Read(DateTimeOffset.UtcNow, _saveFingerprint);
			if (phoneRecipeAvailabilityRead.Snapshot == null)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = ((phoneRecipeAvailabilityRead.State == PhoneRecipeAvailabilityState.Expired) ? "Phone recipes expired. Open the app and send them again." : "No private phone recipes are available yet.\nSend an individual saved recipe from the app.");
				}
				return;
			}
			if ((Object)(object)_listStatus != (Object)null)
			{
				string value = ((phoneRecipeAvailabilityRead.State == PhoneRecipeAvailabilityState.Offline) ? "Offline; showing the last fetched private snapshot." : ((phoneRecipeAvailabilityRead.State == PhoneRecipeAvailabilityState.Stale) ? "Showing stale recipes; reconnect the paired bridge to refresh." : "Private recipes from your paired phone"));
				_listStatus.text = $"{phoneRecipeAvailabilityRead.Snapshot.Recipes.Count} recipe{((phoneRecipeAvailabilityRead.Snapshot.Recipes.Count == 1) ? "" : "s")} · {value}";
			}
			for (int i = 0; i < phoneRecipeAvailabilityRead.Snapshot.Recipes.Count; i++)
			{
				AddCard($"PhoneRecipe{i}", BuildPhoneRecipeCard(phoneRecipeAvailabilityRead.Snapshot.Recipes[i], phoneRecipeAvailabilityRead.State));
			}
		}

		private void PopulateDiscoveredMixes()
		{
			ClearListRows();
			List<LocalMix> list = LocalMixesService.Read(_saveFingerprint);
			_savedRecipeKeys.Clear();
			if (_savedRecipeStore != null)
			{
				foreach (LocalSavedRecipe item in _savedRecipeStore.Read())
				{
					_savedRecipeKeys.Add(item.RecipeId);
				}
			}
			if (list.Count == 0)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = "No discovered mixes found yet.\nMake a mix at the station, then check back.";
				}
				return;
			}
			List<LocalMix> list2 = new List<LocalMix>();
			foreach (LocalMix item2 in list)
			{
				EconomicsResult result;
				bool pricedAvailable = EconomicsService.TryGetCached(EconomicsService.CacheKey(item2), out result) && result.Available;
				if (_filterState.Matches(item2, pricedAvailable))
				{
					list2.Add(item2);
				}
			}
			if ((Object)(object)_listStatus != (Object)null)
			{
				if (list2.Count == 0 && _effectFilter != "")
				{
					_listStatus.text = "No mixes match \"" + ObservedEffects.FilterLabel(_effectFilter) + "\".\nClear the effect filter to see all observed mixes.";
				}
				else if (list2.Count == 0 && _baseFilter != DiscoveredMixBaseFilter.All)
				{
					_listStatus.text = "No mixes match this base filter.";
				}
				else if (list2.Count == 0 && _pricedOnly)
				{
					_listStatus.text = "No priced mixes are available yet.";
				}
				else if (_pricedOnly)
				{
					_listStatus.text = $"{list2.Count} priced of {list.Count} mixes";
				}
				else if (_baseFilter == DiscoveredMixBaseFilter.All)
				{
					_listStatus.text = $"{list2.Count} mixes from your save";
				}
				else
				{
					_listStatus.text = $"{list2.Count} of {list.Count} mixes";
				}
			}
			for (int i = 0; i < list2.Count; i++)
			{
				AddLocalMixCard($"DiscoveredMix{i}", list2[i]);
			}
			QueueVisibleEconomics();
		}

		private void ShowList(string title)
		{
			SetViewVisible(_homeVisibility, visible: false);
			SetViewVisible(_listVisibility, visible: true);
			if ((Object)(object)_listHeading != (Object)null)
			{
				_listHeading.text = title;
			}
			ClearListRows();
		}

		private void BuildFilterRow(GameObject panel)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			_filterRow = UIFactory.Panel("BaseFilters", panel.transform, Color.clear, (Vector2?)null, (Vector2?)null, false);
			Image component = _filterRow.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).raycastTarget = false;
			}
			_filterVisibility = _filterRow.AddComponent<CanvasGroup>();
			UIFactory.HorizontalLayoutOnGO(_filterRow, 6, 0, 0, 0, 0, (TextAnchor)4);
			SetHeight(_filterRow, 38f);
			RebuildBaseFilterButtons();
		}

		private void RebuildBaseFilterButtons()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject filterButtonObject in _filterButtonObjects)
			{
				Object.Destroy((Object)(object)filterButtonObject);
			}
			_filterButtonObjects.Clear();
			_filterButtons.Clear();
			if ((Object)(object)_filterRow == (Object)null)
			{
				return;
			}
			foreach (DiscoveredMixBaseFilter baseFilter in _filterState.BaseFilters)
			{
				DiscoveredMixBaseFilter selectedFilter = baseFilter;
				var (val, val2, _) = UIFactory.RoundedButtonWithLabel($"{baseFilter}Filter", DiscoveredMixFilterCatalog.FilterLabel(baseFilter), _filterRow.transform, new Color(0.23f, 0.28f, 0.36f), 82f, 32f, 14, Color.white);
				ButtonUtils.AddListener(val2, (Action)delegate
				{
					SelectFilter(selectedFilter);
				});
				SetHeight(val, 32f);
				_filterButtonObjects.Add(val);
				if ((Object)(object)((Selectable)val2).image != (Object)null)
				{
					_filterButtons.Add((baseFilter, ((Selectable)val2).image));
				}
			}
			UpdateFilterButtonStyles();
		}

		private void BuildEffectFilterRow(GameObject panel)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			_effectFilterRow = UIFactory.Panel("EffectFilters", panel.transform, Color.clear, (Vector2?)null, (Vector2?)null, false);
			_effectFilterVisibility = _effectFilterRow.AddComponent<CanvasGroup>();
			SetHeight(_effectFilterRow, 38f);
			_effectFilterViewport = UIFactory.Panel("EffectFilterViewport", _effectFilterRow.transform, Color.clear, (Vector2?)null, (Vector2?)null, false);
			RectTransform component = _effectFilterViewport.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			_effectFilterViewport.AddComponent<RectMask2D>();
			_effectFilterScroll = _effectFilterViewport.AddComponent<ScrollRect>();
			_effectFilterScroll.horizontal = true;
			_effectFilterScroll.vertical = false;
			_effectFilterScroll.movementType = (MovementType)2;
			_effectFilterScroll.viewport = component;
			_effectFilterScroll.scrollSensitivity = 40f;
			_effectFilterContent = UIFactory.Panel("EffectFilterContent", _effectFilterViewport.transform, Color.clear, (Vector2?)null, (Vector2?)null, false);
			RectTransform component2 = _effectFilterContent.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.5f);
			component2.anchorMax = new Vector2(0f, 0.5f);
			component2.pivot = new Vector2(0f, 0.5f);
			component2.anchoredPosition = Vector2.zero;
			HorizontalLayoutGroup component3 = _effectFilterContent.GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component3 == (Object)null)
			{
				UIFactory.HorizontalLayoutOnGO(_effectFilterContent, 6, 0, 0, 0, 0, (TextAnchor)4);
				component3 = _effectFilterContent.GetComponent<HorizontalLayoutGroup>();
			}
			if ((Object)(object)component3 != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = false;
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			}
			ContentSizeFitter obj = _effectFilterContent.AddComponent<ContentSizeFitter>();
			obj.horizontalFit = (FitMode)2;
			obj.verticalFit = (FitMode)0;
			_effectFilterScroll.content = component2;
			RebuildEffectFilterButtons();
		}

		private void RebuildEffectFilterButtons()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject effectFilterButtonObject in _effectFilterButtonObjects)
			{
				Object.Destroy((Object)(object)effectFilterButtonObject);
			}
			_effectFilterButtonObjects.Clear();
			_effectFilterButtons.Clear();
			if ((Object)(object)_effectFilterContent == (Object)null)
			{
				return;
			}
			foreach (ObservedEffectFilter effectFilter in _filterState.EffectFilters)
			{
				string selectedKey = effectFilter.Key;
				float num = ((effectFilter.Label.Length > 13) ? 128f : 100f);
				var (val, val2, _) = UIFactory.RoundedButtonWithLabel("EffectFilter" + selectedKey, effectFilter.Label, _effectFilterContent.transform, new Color(0.23f, 0.28f, 0.36f), num, 32f, 14, Color.white);
				ButtonUtils.AddListener(val2, (Action)delegate
				{
					SelectEffectFilter(selectedKey);
				});
				SetHeight(val, 32f);
				_effectFilterButtonObjects.Add(val);
				if ((Object)(object)((Selectable)val2).image != (Object)null)
				{
					_effectFilterButtons.Add((selectedKey, ((Selectable)val2).image));
				}
			}
			UpdateEffectFilterStyles();
		}

		private void EnsurePriceFilterButton()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_priceFilterGO != (Object)null || (Object)(object)_filterRow == (Object)null)
			{
				return;
			}
			var (val, val2, _) = UIFactory.RoundedButtonWithLabel("PricedFilter", "Priced", _filterRow.transform, new Color(0.23f, 0.28f, 0.36f), 82f, 32f, 14, Color.white);
			ButtonUtils.AddListener(val2, (Action)delegate
			{
				_filterState.SetPricedOnly(!_pricedOnly);
				UpdatePriceFilterStyle();
				if (_screen == Screen.DiscoveredMixes)
				{
					PopulateDiscoveredMixes();
				}
			});
			SetHeight(val, 32f);
			_priceFilterGO = val;
			_priceFilterImage = ((Selectable)val2).image;
			UpdatePriceFilterStyle();
		}

		private void UpdatePriceFilterStyle()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_priceFilterImage != (Object)null)
			{
				((Graphic)_priceFilterImage).color = (_pricedOnly ? new Color(0.22f, 0.48f, 0.34f) : new Color(0.23f, 0.28f, 0.36f));
			}
		}

		private void SelectFilter(DiscoveredMixBaseFilter filter)
		{
			_filterState.SelectBase(filter);
			UpdateFilterButtonStyles();
			if (_screen == Screen.DiscoveredMixes)
			{
				PopulateDiscoveredMixes();
			}
		}

		private void SetFilterVisible(bool visible)
		{
			SetViewVisible(_filterVisibility, visible);
			SetViewVisible(_effectFilterVisibility, visible);
			if ((Object)(object)_filterRow != (Object)null)
			{
				SetHeight(_filterRow, visible ? 38 : 0);
			}
			if ((Object)(object)_effectFilterRow != (Object)null)
			{
				SetHeight(_effectFilterRow, visible ? 38 : 0);
			}
		}

		private void UpdateFilterButtonStyles()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			foreach (var filterButton in _filterButtons)
			{
				var (discoveredMixBaseFilter, _) = filterButton;
				((Graphic)filterButton.image).color = ((discoveredMixBaseFilter == _baseFilter) ? new Color(0.22f, 0.48f, 0.34f) : new Color(0.23f, 0.28f, 0.36f));
			}
		}

		private void SelectEffectFilter(string filterKey)
		{
			_filterState.SelectEffect(filterKey);
			UpdateEffectFilterStyles();
			if (_screen == Screen.DiscoveredMixes)
			{
				PopulateDiscoveredMixes();
			}
		}

		private void UpdateEffectFilterStyles()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			foreach (var effectFilterButton in _effectFilterButtons)
			{
				var (text, _) = effectFilterButton;
				((Graphic)effectFilterButton.image).color = ((text == _effectFilter) ? new Color(0.22f, 0.48f, 0.34f) : new Color(0.23f, 0.28f, 0.36f));
			}
		}

		private void BuildScrollList(GameObject panel)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			ScrollRect val2 = default(ScrollRect);
			RectTransform val = UIFactory.ScrollableVerticalList("List", panel.transform, ref val2);
			_listContainer = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null);
			if ((Object)(object)_listContainer != (Object)null)
			{
				VerticalLayoutGroup component = _listContainer.GetComponent<VerticalLayoutGroup>();
				if ((Object)(object)component != (Object)null)
				{
					int num = 44;
					((LayoutGroup)component).padding = new RectOffset(num, num, 12, 12);
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				_mixScroll = val2;
				val2.scrollSensitivity = 40f;
				SetFlexibleFill(((Component)val2).gameObject);
			}
		}

		private RecipeCardUi AddCard(string name, string body)
		{
			if ((Object)(object)_listContainer == (Object)null)
			{
				throw new InvalidOperationException("Recipe list is unavailable.");
			}
			RecipeCardUi recipeCardUi = RecipeCardUiFactory.Create(_listContainer.transform, name, body, showPrimary: false, "", null, null);
			recipeCardUi.RefreshHeight();
			_listRows.Add(recipeCardUi.Row);
			return recipeCardUi;
		}

		private void AddLocalMixCard(string name, LocalMix mix)
		{
			if ((Object)(object)_listContainer == (Object)null)
			{
				return;
			}
			string key = EconomicsService.CacheKey(mix);
			bool flag = _savedRecipeKeys.Contains(LocalSavedRecipeStore.BuildRecipeId(mix.Base, mix.Ingredients));
			EconomicsResult result;
			string economicsText = (EconomicsService.TryGetCached(key, out result) ? EconomicsText(result) : RecipeCardPresentation.FormatEconomicsPending());
			RecipeCardUi ui = null;
			ui = RecipeCardUiFactory.Create(_listContainer.transform, name, BuildLocalCard(mix, economicsText), showPrimary: true, flag ? "Saved ✓" : "Save Recipe", delegate
			{
				SaveRecipeAndSend(mix, ui);
			}, delegate
			{
				TrySendToPhone(mix, ui);
			});
			ui.SetSaved(flag);
			ui.Status.text = RecipeCardPresentation.FormatSaveStatus(flag, RecipePhoneDeliveryState.None);
			ui.ShowPhoneAction(flag, "Send to phone");
			if (!string.IsNullOrWhiteSpace(mix.SaveDisabledReason))
			{
				ui.Status.text = mix.SaveDisabledReason;
				if ((Object)(object)ui.PrimaryButton != (Object)null)
				{
					((Selectable)ui.PrimaryButton).interactable = false;
				}
				ui.ShowPhoneAction(visible: false, "Retry phone");
			}
			ui.RefreshHeight();
			RegisterEconomicsCard(new LocalMixCard
			{
				Key = key,
				Mix = mix,
				Ui = ui,
				Render = (EconomicsResult result2) => BuildLocalCard(mix, EconomicsText(result2))
			});
			_listRows.Add(ui.Row);
		}

		private void RegisterEconomicsCard(LocalMixCard card)
		{
			if (!_economicsCards.TryGetValue(card.Key, out List<LocalMixCard> value))
			{
				value = new List<LocalMixCard>();
				_economicsCards[card.Key] = value;
			}
			value.Add(card);
		}

		private void ClearListRows()
		{
			if ((Object)(object)_listContainer != (Object)null)
			{
				UIFactory.ClearChildren(_listContainer.transform);
			}
			_listRows.Clear();
			_economicsCards.Clear();
			_pendingSaveTrack.Clear();
		}

		public void Render(BridgeStatus status)
		{
			_lastStatus = status;
			if (_screen == Screen.Home)
			{
				ApplyStatus(status);
			}
		}

		internal void SetManualSyncRequestHandler(Func<long, ManualSyncViewState> handler)
		{
			_manualSyncRequestHandler = handler;
		}

		internal void RenderManualSync(ManualSyncViewState state)
		{
			_lastManualSyncState = state;
			if ((Object)(object)_manualSyncButtonText != (Object)null)
			{
				_manualSyncButtonText.text = state.Label;
			}
			if ((Object)(object)_manualSyncButton != (Object)null)
			{
				((Selectable)_manualSyncButton).interactable = state.CanRequest;
			}
			if ((Object)(object)_manualSyncButtonObject != (Object)null)
			{
				_manualSyncButtonObject.SetActive(true);
			}
		}

		private void OnManualSyncClicked()
		{
			long arg = _lastStatus?.Sequence ?? 0;
			ManualSyncViewState state = _manualSyncRequestHandler?.Invoke(arg) ?? new ManualSyncViewState(ManualSyncState.Unavailable, "Unavailable", CanRequest: true);
			RenderManualSync(state);
		}

		public void RenderLiveContext(LiveContextSnapshot snapshot)
		{
			string text = LiveContextPresentation.Format(snapshot);
			if (LiveContextPresentation.ShouldRender(_lastLiveContextRendered, text))
			{
				_lastLiveContextRendered = text;
				if (!((Object)(object)_liveContextText == (Object)null))
				{
					bool flag = !string.IsNullOrEmpty(text);
					((Component)_liveContextText).gameObject.SetActive(flag);
					SetHeight(((Component)_liveContextText).gameObject, flag ? 22f : 0f);
					_liveContextText.text = text ?? "";
				}
			}
		}

		public void SetSaveScope(string? saveFingerprint)
		{
			SetSaveFingerprint(SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint) ? saveFingerprint : null);
		}

		private void SetSaveFingerprint(string? saveFingerprint)
		{
			if (!string.Equals(_saveFingerprint, saveFingerprint, StringComparison.Ordinal))
			{
				_saveFingerprint = saveFingerprint;
				_advisorDispatchesView = new AdvisorDispatchesViewState(AdvisorDispatchesReadState.Missing, Array.Empty<AdvisorDispatchMessage>(), null, 0, "No Advisor Dispatches available yet.", StorageAvailable: false);
				_savedRecipeStore = (string.IsNullOrWhiteSpace(saveFingerprint) ? null : new LocalSavedRecipeStore(LocalSavedRecipeStore.BuildScopedPath(saveFingerprint)));
				_savedRecipeKeys.Clear();
				_pendingSaveTrack.Clear();
				List<LocalMix> mixes = LocalMixesService.Read(_saveFingerprint);
				_filterState.Refresh(mixes);
				RebuildBaseFilterButtons();
				RebuildEffectFilterButtons();
				if (_screen == Screen.SavedRecipes)
				{
					PopulateSavedRecipes();
				}
				else if (_screen == Screen.DiscoveredMixes)
				{
					PopulateDiscoveredMixes();
				}
				else if (_screen == Screen.PhoneRecipes)
				{
					PopulatePhoneRecipes();
				}
				else if (_screen == Screen.AdvisorDispatches)
				{
					PopulateAdvisorDispatches();
				}
				if ((Object)(object)_advisorUnreadText != (Object)null)
				{
					AdvisorDispatchesDestinationCardUi.SetUnreadCount(_advisorUnreadText, 0);
				}
			}
		}

		private void ApplyStatus(BridgeStatus? s)
		{
			if (s != null && !((Object)(object)_statusText == (Object)null))
			{
				_statusText.text = s.Status ?? "";
				if ((Object)(object)_pairingText != (Object)null)
				{
					_pairingText.text = (string.IsNullOrEmpty(s.PairingCode) ? "" : ("Pairing code:  " + s.PairingCode));
				}
				if ((Object)(object)_saveText != (Object)null)
				{
					_saveText.text = (string.IsNullOrWhiteSpace(_saveFingerprint) ? (s.SaveLine ?? "") : ("Active save: " + _saveFingerprint));
				}
				if ((Object)(object)_latestText != (Object)null)
				{
					_latestText.text = s.LatestLine ?? "";
				}
				if ((Object)(object)_unlinkButton != (Object)null)
				{
					_unlinkButton.SetActive(UnlinkAvailability.IsAvailable(s));
				}
			}
		}

		public void PopulateRecipes(List<CommunityMix>? mixes, string? error)
		{
			if (_screen != Screen.Community)
			{
				return;
			}
			ClearListRows();
			if (error != null)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = "Couldn't load recipes:\n" + error;
				}
				return;
			}
			if (mixes == null || mixes.Count == 0)
			{
				if ((Object)(object)_listStatus != (Object)null)
				{
					_listStatus.text = "No community recipes found.";
				}
				return;
			}
			if ((Object)(object)_listStatus != (Object)null)
			{
				_listStatus.text = ((mixes.Count == 1) ? "1 community mix" : $"{mixes.Count} community mixes");
			}
			for (int i = 0; i < mixes.Count; i++)
			{
				AddCard($"Recipe{i}", BuildCommunityCard(mixes[i]));
			}
		}

		private static string BuildCommunityCard(CommunityMix m)
		{
			string value = FriendlyEffects(m.Effects);
			string value2 = m.Addiction.ToString("0.0", CultureInfo.InvariantCulture);
			string value3 = GameDatasetIds.FriendlyName(m.Product);
			string value4 = ((m.Ingredients.Count > 0) ? string.Join("  →  ", m.Ingredients.ConvertAll<string>(GameDatasetIds.FriendlyName)) : "(no ingredients)");
			string value5 = RecipeCardPresentation.FriendlyRecipeTitle(m.Name, m.Product);
			return $"{value5}   ({value3})\n${m.SellPrice} · {m.ProfitMargin}% margin · addiction {value2} · ▲{m.Upvotes}\n{value4}\nEffects: {value}";
		}

		private static LocalMix SavedRecipeAsMix(LocalSavedRecipe recipe)
		{
			return new LocalMix
			{
				Name = recipe.Name,
				GameName = recipe.Name,
				ProductId = recipe.ProductId,
				Base = recipe.Base,
				Ingredients = new List<string>(recipe.Ingredients),
				Steps = new List<LocalMixStep>(recipe.Steps)
			};
		}

		private static string BuildSavedRecipeCard(LocalSavedRecipe recipe, LocalMix mix, string economicsText)
		{
			string value = RecipeCardPresentation.FriendlyRecipeTitle(recipe.Name, recipe.ProductId);
			string value2 = ((mix.Ingredients.Count > 0) ? string.Join("  →  ", mix.Ingredients.ConvertAll<string>(GameDatasetIds.FriendlyName)) : "(base product only)");
			return $"{value}   ({GameDatasetIds.FriendlyName(mix.Base)})\n{mix.Ingredients.Count}-step mix · saved locally\n{value2}\nEffects: {ObservedEffects.FromMix(mix).DisplayText}\n" + economicsText;
		}

		private static string BuildPhoneRecipeCard(BridgePhoneRecipe recipe, PhoneRecipeAvailabilityState state)
		{
			string value = ((recipe.IngredientIds.Count > 0) ? string.Join("  →  ", recipe.IngredientIds.ConvertAll<string>(GameDatasetIds.FriendlyName)) : "(no ingredients)");
			string displayText = ObservedEffects.FromMix(new LocalMix
			{
				Steps = new List<LocalMixStep>
				{
					new LocalMixStep
					{
						EffectsAvailable = recipe.EffectsAvailable,
						OutputProductId = recipe.ProductId,
						OutputEffects = ((recipe.Effects == null) ? new List<string>() : new List<string>(recipe.Effects))
					}
				}
			}).DisplayText;
			string value2 = ((recipe.ProfileMode == "seeded") ? "Seeded profile" : "Standard profile");
			string value3 = state switch
			{
				PhoneRecipeAvailabilityState.Stale => " · stale snapshot", 
				PhoneRecipeAvailabilityState.Offline => " · offline snapshot", 
				_ => "", 
			};
			string value4 = RecipeCardPresentation.FriendlyRecipeTitle(recipe.Name, recipe.ProductId);
			return $"{value4}   ({GameDatasetIds.FriendlyName(recipe.ProductId)})\n{value2} · private from phone{value3}\n{value}\n{RecipeCardPresentation.FormatPhoneEconomics(recipe.SellPrice, recipe.Profit, recipe.ProfitMargin)}\nEffects: {displayText}";
		}

		private static string FriendlyEffects(List<string> effects)
		{
			return ObservedEffects.FromMix(new LocalMix
			{
				Steps = new List<LocalMixStep>
				{
					new LocalMixStep
					{
						EffectsAvailable = true,
						OutputProductId = "community",
						OutputEffects = new List<string>(effects)
					}
				}
			}).DisplayText;
		}

		private static string BuildLocalCard(LocalMix m, string economicsText)
		{
			string value = ((m.Ingredients.Count > 0) ? string.Join("  →  ", m.Ingredients.ConvertAll<string>(GameDatasetIds.FriendlyName)) : "(base product only)");
			string value2 = RecipeCardPresentation.FriendlyRecipeTitle(m.GameName, m.Name);
			string displayText = ObservedEffects.FromMix(m).DisplayText;
			return $"{value2}   ({GameDatasetIds.FriendlyName(m.Base)})\n{m.Ingredients.Count}-step mix\n{value}\nEffects: {displayText}\n" + economicsText;
		}

		private static string EconomicsText(EconomicsResult result)
		{
			if (!result.Available)
			{
				return RecipeCardPresentation.FormatEconomicsUnavailable();
			}
			return RecipeCardPresentation.FormatEconomics(result.SellPrice, result.ProductionCost, result.Profit, result.ProfitMargin);
		}

		public void TickEconomics()
		{
			if ((_screen == Screen.DiscoveredMixes || _screen == Screen.SavedRecipes) && !((Object)(object)_mixScroll == (Object)null))
			{
				float verticalNormalizedPosition = _mixScroll.verticalNormalizedPosition;
				if (float.IsNaN(_lastScrollPosition) || Math.Abs(verticalNormalizedPosition - _lastScrollPosition) > 0.001f)
				{
					_lastScrollPosition = verticalNormalizedPosition;
					QueueVisibleEconomics();
				}
			}
		}

		public void ApplyEconomics(EconomicsResult result)
		{
			if (result.Available && _screen == Screen.DiscoveredMixes)
			{
				EnsurePriceFilterButton();
			}
			if (!_economicsCards.TryGetValue(result.Key, out List<LocalMixCard> value))
			{
				return;
			}
			foreach (LocalMixCard item in value)
			{
				item.Ui.Body.text = item.Render(result);
				item.Ui.RefreshHeight();
			}
			if (result.Available && _pricedOnly && _screen == Screen.DiscoveredMixes)
			{
				PopulateDiscoveredMixes();
			}
		}

		private void QueueVisibleEconomics()
		{
			if ((_screen != Screen.DiscoveredMixes && _screen != Screen.SavedRecipes) || _economicsCards.Count == 0)
			{
				return;
			}
			List<LocalMixCard> list = new List<LocalMixCard>();
			foreach (List<LocalMixCard> value in _economicsCards.Values)
			{
				list.AddRange(value);
			}
			int count = list.Count;
			ScrollRect? mixScroll = _mixScroll;
			(int, int) window = EconomicsViewport.GetWindow(count, (mixScroll != null) ? mixScroll.verticalNormalizedPosition : 1f, 6);
			var (i, _) = window;
			for (; i < window.Item2; i++)
			{
				EconomicsService.Enqueue(list[i].Mix);
			}
		}

		private void SaveRecipeAndSend(LocalMix mix, RecipeCardUi card)
		{
			if (mix.Steps.Count != mix.Ingredients.Count || HasInvalidSteps(mix))
			{
				card.Status.text = "Mix data incomplete; refresh and try again.";
				card.RefreshHeight();
				return;
			}
			if (_savedRecipeStore == null)
			{
				card.Status.text = "Load a game save before saving a recipe.";
				card.RefreshHeight();
				return;
			}
			if (!_savedRecipeStore.Save(mix).Accepted)
			{
				card.Status.text = "Couldn't save here · Try again";
				card.RefreshHeight();
				return;
			}
			_savedRecipeKeys.Add(LocalSavedRecipeStore.BuildRecipeId(mix.Base, mix.Ingredients));
			card.SetSaved(saved: true);
			card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.None);
			card.RefreshHeight();
			TrySendToPhone(mix, card);
		}

		private void TrySendToPhone(LocalMix mix, RecipeCardUi card)
		{
			try
			{
				if (!SaveGenerationIdentity.IsV2Fingerprint(_saveFingerprint))
				{
					card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Unavailable);
					card.ShowPhoneAction(visible: true, "Retry phone");
					card.RefreshHeight();
					return;
				}
				if (File.Exists(CommandPath))
				{
					card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Busy);
					card.ShowPhoneAction(visible: true, "Retry phone");
					card.RefreshHeight();
					return;
				}
				string text = Guid.NewGuid().ToString("N");
				object command = ScopedSaveTrackCommand.Create(_saveFingerprint, mix, text, DateTimeOffset.UtcNow);
				if (!CommandWriter.TryWrite(command))
				{
					if (File.Exists(CommandPath))
					{
						card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Busy);
						card.ShowPhoneAction(visible: true, "Retry phone");
					}
					else
					{
						card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Unavailable);
						card.ShowPhoneAction(visible: true, "Retry phone");
					}
					card.RefreshHeight();
				}
				else
				{
					_pendingSaveTrack[text] = (mix, card);
					card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Pending);
					card.ShowPhoneAction(visible: false, "Retry phone");
					card.RefreshHeight();
				}
			}
			catch
			{
				card.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, RecipePhoneDeliveryState.Unavailable);
				card.ShowPhoneAction(visible: true, "Retry phone");
				card.RefreshHeight();
			}
		}

		public void ApplySaveTrackResult(string requestId, string status)
		{
			if (_pendingSaveTrack.TryGetValue(requestId, out (LocalMix, RecipeCardUi) value))
			{
				_pendingSaveTrack.Remove(requestId);
				RecipePhoneDeliveryState recipePhoneDeliveryState = (string.Equals(status, "sent", StringComparison.OrdinalIgnoreCase) ? RecipePhoneDeliveryState.Sent : (string.Equals(status, "alreadySent", StringComparison.OrdinalIgnoreCase) ? RecipePhoneDeliveryState.AlreadySent : ((!string.Equals(status, "unauthorized", StringComparison.OrdinalIgnoreCase)) ? RecipePhoneDeliveryState.Unavailable : RecipePhoneDeliveryState.Unauthorized)));
				RecipePhoneDeliveryState phone = recipePhoneDeliveryState;
				value.Item2.Status.text = RecipeCardPresentation.FormatSaveStatus(saved: true, phone);
				value.Item2.SetSaved(saved: true);
				value.Item2.ShowPhoneAction(visible: true, RecipeCardPresentation.PhoneActionLabel(phone));
				value.Item2.RefreshHeight();
			}
		}

		private static bool HasInvalidSteps(LocalMix mix)
		{
			return RecipeCardPresentation.HasInvalidSteps(mix);
		}

		private void OnUnlinkClicked()
		{
			try
			{
				if (File.Exists(CommandPath))
				{
					if ((Object)(object)_statusText != (Object)null)
					{
						_statusText.text = "Finish sending your mix first.";
					}
				}
				else if (CommandWriter.TryWrite(new
				{
					command = "unlink"
				}) && (Object)(object)_statusText != (Object)null)
				{
					_statusText.text = "Unlinking…";
				}
			}
			catch
			{
			}
		}

		private static void PackTop(GameObject panel)
		{
			UIFactory.VerticalLayoutOnGO(panel, 8, (RectOffset)null);
			VerticalLayoutGroup component = panel.GetComponent<VerticalLayoutGroup>();
			if (!((Object)(object)component == (Object)null))
			{
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
				((LayoutGroup)component).childAlignment = (TextAnchor)1;
				((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			}
		}

		private static void SetHeight(GameObject go, float height)
		{
			LayoutElement val = go.GetComponent<LayoutElement>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<LayoutElement>();
			}
			val.minHeight = height;
			val.preferredHeight = height;
			val.flexibleHeight = 0f;
		}

		private static void SetFlexibleFill(GameObject go)
		{
			LayoutElement val = go.GetComponent<LayoutElement>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<LayoutElement>();
			}
			val.minHeight = 220f;
			val.flexibleHeight = 1f;
		}

		private static void SetViewVisible(CanvasGroup? group, bool visible)
		{
			if (!((Object)(object)group == (Object)null))
			{
				group.alpha = (visible ? 1f : 0f);
				group.interactable = visible;
				group.blocksRaycasts = visible;
			}
		}
	}
	public sealed record LiveContextSnapshot(string? RankName, int? Tier, int? ElapsedDays, string? Weekday);
	public static class LiveContextPresentation
	{
		private static readonly IReadOnlyDictionary<string, string> RankLabels = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["StreetRat"] = "Street Rat",
			["Hoodlum"] = "Hoodlum",
			["Peddler"] = "Peddler",
			["Hustler"] = "Hustler",
			["Bagman"] = "Bagman",
			["Enforcer"] = "Enforcer",
			["ShotCaller"] = "Shot Caller",
			["BlockBoss"] = "Block Boss",
			["Underlord"] = "Underlord",
			["Baron"] = "Baron",
			["Kingpin"] = "Kingpin"
		};

		private static readonly IReadOnlyDictionary<string, string> WeekdayLabels = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["Monday"] = "Monday",
			["Tuesday"] = "Tuesday",
			["Wednesday"] = "Wednesday",
			["Thursday"] = "Thursday",
			["Friday"] = "Friday",
			["Saturday"] = "Saturday",
			["Sunday"] = "Sunday"
		};

		public static string? Format(LiveContextSnapshot snapshot)
		{
			List<string> list = new List<string>(3);
			string text = FormatRank(snapshot.RankName, snapshot.Tier);
			if (text != null)
			{
				list.Add(text);
			}
			if (snapshot.ElapsedDays.HasValue)
			{
				list.Add($"Day {snapshot.ElapsedDays.Value}");
			}
			if (snapshot.Weekday != null && WeekdayLabels.TryGetValue(snapshot.Weekday, out string value))
			{
				list.Add(value);
			}
			if (list.Count != 0)
			{
				return string.Join(" · ", list);
			}
			return null;
		}

		public static bool ShouldRender(string? lastRendered, string? nextRendered)
		{
			return !string.Equals(lastRendered, nextRendered, StringComparison.Ordinal);
		}

		private static string? FormatRank(string? rankName, int? tier)
		{
			if (rankName == null)
			{
				return null;
			}
			if (!RankLabels.TryGetValue(rankName, out string value))
			{
				return "Rank unavailable";
			}
			if (!tier.HasValue || tier.Value <= 0)
			{
				return value;
			}
			if (tier.Value <= 5)
			{
				return value + " " + RomanNumeral(tier.Value);
			}
			if (!string.Equals(rankName, "Kingpin", StringComparison.Ordinal))
			{
				return value;
			}
			return $"{value} {tier.Value}";
		}

		private static string RomanNumeral(int value)
		{
			return value switch
			{
				1 => "I", 
				2 => "II", 
				3 => "III", 
				4 => "IV", 
				5 => "V", 
				_ => "", 
			};
		}
	}
	internal sealed class LiveContextRefreshScheduler
	{
		private readonly TimeSpan _fallbackInterval;

		private DateTimeOffset? _nextFallbackAt;

		internal LiveContextRefreshScheduler(TimeSpan fallbackInterval)
		{
			_fallbackInterval = fallbackInterval;
		}

		internal bool Take(DateTimeOffset now, bool dirty)
		{
			if (dirty || !_nextFallbackAt.HasValue || now >= _nextFallbackAt.Value)
			{
				_nextFallbackAt = now.Add(_fallbackInterval);
				return true;
			}
			return false;
		}
	}
	public sealed record LiveContextRank(string RankName, int Tier);
	public sealed record LiveContextDay(int ElapsedDays, string Weekday);
	public sealed class LiveContextRuntimeReader
	{
		private readonly Func<LiveContextRank?> _readRank;

		private readonly Func<LiveContextDay?> _readDay;

		public LiveContextRuntimeReader(Func<LiveContextRank?> readRank, Func<LiveContextDay?> readDay)
		{
			_readRank = readRank;
			_readDay = readDay;
		}

		public LiveContextSnapshot TryRead()
		{
			LiveContextRank liveContextRank = null;
			try
			{
				liveContextRank = _readRank();
			}
			catch
			{
			}
			LiveContextDay liveContextDay = null;
			try
			{
				liveContextDay = _readDay();
			}
			catch
			{
			}
			return new LiveContextSnapshot(liveContextRank?.RankName, liveContextRank?.Tier, liveContextDay?.ElapsedDays, liveContextDay?.Weekday);
		}
	}
	internal sealed class LiveFactObserver
	{
		internal static readonly TimeSpan LoadDedupeWindow = TimeSpan.FromSeconds(5.0);

		private readonly ILiveFactSource _source;

		private readonly Func<DateTimeOffset> _now;

		private int _loadEpoch;

		private DateTimeOffset? _lastAcceptedLoad;

		private bool _dirty;

		internal int LoadEpoch => _loadEpoch;

		internal LiveFactObserver(ILiveFactSource source, Func<DateTimeOffset>? now = null)
		{
			_source = source;
			_now = now ?? ((Func<DateTimeOffset>)(() => DateTimeOffset.UtcNow));
		}

		internal bool NotifyLoadComplete()
		{
			DateTimeOffset dateTimeOffset = _now();
			if (_lastAcceptedLoad.HasValue && dateTimeOffset - _lastAcceptedLoad.Value < LoadDedupeWindow)
			{
				return false;
			}
			_lastAcceptedLoad = dateTimeOffset;
			_loadEpoch++;
			_dirty = true;
			return true;
		}

		internal void NotifyRankUp()
		{
			_dirty = true;
		}

		internal bool TakeDirty()
		{
			bool dirty = _dirty;
			_dirty = false;
			return dirty;
		}

		internal bool TryObserve(out int loadEpoch, out LiveOverlayFacts facts)
		{
			loadEpoch = _loadEpoch;
			facts = new LiveOverlayFacts();
			if (_loadEpoch < 1)
			{
				return false;
			}
			try
			{
				LiveRankReading liveRankReading = _source.ReadRank();
				if (!string.IsNullOrWhiteSpace(liveRankReading.RankName) && liveRankReading.RankName.Length <= 32 && liveRankReading.Tier >= 1 && liveRankReading.Xp >= 0 && liveRankReading.TotalXp >= 0)
				{
					facts.Rank = new LiveRankFact
					{
						RankName = liveRankReading.RankName,
						Tier = liveRankReading.Tier,
						Xp = liveRankReading.Xp,
						TotalXp = liveRankReading.TotalXp
					};
				}
			}
			catch
			{
			}
			try
			{
				int num = _source.ReadElapsedDays();
				if (num >= 0)
				{
					facts.ElapsedDays = new LiveElapsedDaysFact
					{
						Value = num
					};
				}
			}
			catch
			{
			}
			try
			{
				facts.Properties = NormalizeProperties(_source.ReadProperties());
			}
			catch
			{
				facts.Properties = null;
			}
			try
			{
				LiveMoneyReading liveMoneyReading = _source.ReadMoney();
				if (IsMoneyValue(liveMoneyReading.CashOnHand) && IsMoneyValue(liveMoneyReading.OnlineBalance) && IsNetWorthValue(liveMoneyReading.NetWorth))
				{
					facts.Money = new LiveMoneyFact
					{
						CashOnHand = new LiveMoneyValue
						{
							Scope = "player",
							Value = Round2(liveMoneyReading.CashOnHand)
						},
						OnlineBalance = new LiveMoneyValue
						{
							Scope = "shared",
							Value = Round2(liveMoneyReading.OnlineBalance)
						},
						NetWorth = new LiveMoneyValue
						{
							Scope = "shared",
							Value = Round2(liveMoneyReading.NetWorth)
						}
					};
				}
			}
			catch
			{
				facts.Money = null;
			}
			return true;
		}

		private static LivePropertiesFact? NormalizeProperties(LivePropertiesReading reading)
		{
			if (reading.RawPropertyCodes.Count > 64 || reading.RawBusinessCodes.Count > 32)
			{
				return null;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string rawPropertyCode in reading.RawPropertyCodes)
			{
				string text = NormalizeCode(rawPropertyCode);
				if (text == null || !hashSet.Add(text))
				{
					return null;
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (string rawBusinessCode in reading.RawBusinessCodes)
			{
				string text2 = NormalizeCode(rawBusinessCode);
				if (text2 == null || !hashSet2.Add(text2))
				{
					return null;
				}
				hashSet.Add(text2);
			}
			if (hashSet.Count > 64)
			{
				return null;
			}
			LivePropertiesFact livePropertiesFact = new LivePropertiesFact();
			foreach (string item in hashSet)
			{
				livePropertiesFact.Codes.Add(item);
			}
			livePropertiesFact.Codes.Sort(StringComparer.Ordinal);
			foreach (string item2 in hashSet2)
			{
				livePropertiesFact.BusinessCodes.Add(item2);
			}
			livePropertiesFact.BusinessCodes.Sort(StringComparer.Ordinal);
			return livePropertiesFact;
		}

		internal static string? NormalizeCode(string? raw)
		{
			string text = raw?.Trim().ToLowerInvariant();
			if (string.IsNullOrEmpty(text) || text.Length > 48)
			{
				return null;
			}
			if (!LiveOverlaySerializer.IsCanonicalCode(text))
			{
				return null;
			}
			return text;
		}

		private static bool IsMoneyValue(double value)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value) && value >= 0.0)
			{
				return value < 1000000000.0;
			}
			return false;
		}

		private static bool IsNetWorthValue(double value)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value) && value > -1000000000.0)
			{
				return value < 1000000000.0;
			}
			return false;
		}

		private static double Round2(double value)
		{
			return Math.Round(value, 2, MidpointRounding.AwayFromZero);
		}
	}
	internal interface ILiveFactSource
	{
		LiveRankReading ReadRank();

		LiveMoneyReading ReadMoney();

		LivePropertiesReading ReadProperties();

		int ReadElapsedDays();
	}
	internal readonly record struct LiveRankReading(string RankName, int Tier, int Xp, int TotalXp);
	internal readonly record struct LiveMoneyReading(double CashOnHand, double OnlineBalance, double NetWorth);
	internal sealed record LivePropertiesReading(IReadOnlyList<string> RawPropertyCodes, IReadOnlyList<string> RawBusinessCodes);
	internal sealed class LiveOverlayWriter
	{
		internal static readonly TimeSpan SampleInterval = TimeSpan.FromSeconds(5.0);

		internal static readonly TimeSpan CoalesceWindow = TimeSpan.FromSeconds(2.5);

		internal static readonly TimeSpan KeepaliveInterval = TimeSpan.FromSeconds(60.0);

		private static readonly JsonSerializerOptions FactsComparisonOptions = new JsonSerializerOptions
		{
			DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
		};

		private readonly LiveFactObserver _observer;

		private readonly Func<string?> _runtimeSession;

		private readonly Func<string?> _playthroughGeneration;

		private readonly string _tileVersion;

		private readonly string _s1ApiVersion;

		private readonly string _path;

		private readonly Action<string, byte[]> _writeAtomic;

		private readonly string _tileInstanceId = Guid.NewGuid().ToString("N");

		private DateTimeOffset _lastSample = DateTimeOffset.MinValue;

		private DateTimeOffset? _pendingSince;

		private LiveOverlayFacts? _pendingFacts;

		private string? _lastWrittenFactsJson;

		private DateTimeOffset _lastWrite = DateTimeOffset.MinValue;

		private bool _hasWritten;

		private long _sequence;

		private int _sequenceEpoch;

		private string? _sequenceSession;

		private string? _lastWrittenSession;

		private string? _lastWrittenGeneration;

		private int _lastWrittenEpoch;

		private LiveOverlayFacts _lastFacts = new LiveOverlayFacts();

		internal static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "live-context-overlay.json");

		internal string TileInstanceId => _tileInstanceId;

		internal LiveOverlayWriter(LiveFactObserver observer, Func<string?> runtimeSession, Func<string?> playthroughGeneration, string tileVersion, string s1ApiVersion, string? path = null, Action<string, byte[]>? writeAtomic = null)
		{
			_observer = observer;
			_runtimeSession = runtimeSession;
			_playthroughGeneration = playthroughGeneration;
			_tileVersion = tileVersion;
			_s1ApiVersion = s1ApiVersion;
			_path = path ?? DefaultPath;
			_writeAtomic = writeAtomic ?? new Action<string, byte[]>(WriteAtomic);
		}

		internal void Tick(DateTimeOffset now)
		{
			bool num = _observer.TakeDirty();
			bool flag = HasWrittenIdentityChanged();
			if (num || flag || now - _lastSample >= SampleInterval)
			{
				_lastSample = now;
				Sample(now, flag);
			}
			if (_pendingSince.HasValue && now - _pendingSince.Value >= CoalesceWindow)
			{
				TryWrite(now, _pendingFacts);
			}
			else if (!_pendingSince.HasValue && _hasWritten && now - _lastWrite >= KeepaliveInterval)
			{
				TryWrite(now, _pendingKeepaliveFacts());
			}
		}

		private LiveOverlayFacts _pendingKeepaliveFacts()
		{
			return _lastFacts;
		}

		private void Sample(DateTimeOffset now, bool identityChanged = false)
		{
			if (!_observer.TryObserve(out int _, out LiveOverlayFacts facts))
			{
				return;
			}
			string text = JsonSerializer.Serialize(facts, FactsComparisonOptions);
			if (!identityChanged)
			{
				if (text == _lastWrittenFactsJson && !_pendingSince.HasValue)
				{
					return;
				}
				if (_pendingSince.HasValue && text == _lastWrittenFactsJson)
				{
					_pendingSince = null;
					_pendingFacts = null;
					return;
				}
			}
			_pendingFacts = facts;
			DateTimeOffset valueOrDefault = _pendingSince.GetValueOrDefault();
			if (!_pendingSince.HasValue)
			{
				valueOrDefault = now;
				_pendingSince = valueOrDefault;
			}
		}

		private bool HasWrittenIdentityChanged()
		{
			if (!_hasWritten)
			{
				return false;
			}
			string text = _runtimeSession();
			string text2 = _playthroughGeneration();
			if (string.IsNullOrWhiteSpace(text) || !SaveGenerationIdentity.IsV2Fingerprint(text2))
			{
				return false;
			}
			int loadEpoch = _observer.LoadEpoch;
			if (loadEpoch < 1)
			{
				return false;
			}
			if (loadEpoch == _lastWrittenEpoch && string.Equals(text, _lastWrittenSession, StringComparison.Ordinal))
			{
				return !string.Equals(text2, _lastWrittenGeneration, StringComparison.Ordinal);
			}
			return true;
		}

		private void TryWrite(DateTimeOffset now, LiveOverlayFacts facts)
		{
			string text = _runtimeSession();
			string text2 = _playthroughGeneration();
			if (string.IsNullOrWhiteSpace(text) || !SaveGenerationIdentity.IsV2Fingerprint(text2))
			{
				return;
			}
			int loadEpoch = _observer.LoadEpoch;
			if (loadEpoch < 1)
			{
				return;
			}
			if (_sequenceEpoch != loadEpoch || !string.Equals(_sequenceSession, text, StringComparison.Ordinal))
			{
				_sequence = 0L;
				_sequenceEpoch = loadEpoch;
				_sequenceSession = text;
			}
			LiveOverlayDocument liveOverlayDocument = new LiveOverlayDocument
			{
				PlaythroughGeneration = text2,
				RuntimeSession = text,
				TileInstanceId = _tileInstanceId,
				LoadEpoch = loadEpoch,
				Sequence = _sequence + 1,
				ObservedAt = now.UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'"),
				TileVersion = _tileVersion,
				S1ApiVersion = _s1ApiVersion,
				Facts = facts
			};
			if (!LiveOverlaySerializer.TrySerialize(liveOverlayDocument, out byte[] utf, out string reason))
			{
				liveOverlayDocument.Facts = new LiveOverlayFacts
				{
					Rank = facts.Rank,
					ElapsedDays = facts.ElapsedDays,
					Money = facts.Money
				};
				if (!LiveOverlaySerializer.TrySerialize(liveOverlayDocument, out utf, out reason))
				{
					liveOverlayDocument.Facts = new LiveOverlayFacts();
					if (!LiveOverlaySerializer.TrySerialize(liveOverlayDocument, out utf, out reason))
					{
						return;
					}
				}
			}
			try
			{
				_writeAtomic(_path, utf);
			}
			catch
			{
				return;
			}
			_sequence++;
			_lastWrite = now;
			_hasWritten = true;
			_lastWrittenSession = text;
			_lastWrittenGeneration = text2;
			_lastWrittenEpoch = loadEpoch;
			_lastFacts = liveOverlayDocument.Facts;
			_lastWrittenFactsJson = JsonSerializer.Serialize(liveOverlayDocument.Facts, FactsComparisonOptions);
			_pendingSince = null;
			_pendingFacts = null;
		}

		private static void WriteAtomic(string path, byte[] utf8)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text = $"{path}.{Guid.NewGuid():N}.tmp";
			try
			{
				File.WriteAllBytes(text, utf8);
				File.Move(text, path, overwrite: true);
			}
			finally
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch
				{
				}
			}
		}
	}
	public sealed class LocalMix
	{
		public string Name = "";

		public string ProductId = "";

		public string GameName = "";

		public string Base = "";

		public List<string> Ingredients = new List<string>();

		public List<LocalMixStep> Steps = new List<LocalMixStep>();

		public string? SaveDisabledReason;
	}
	public sealed class LocalMixStep
	{
		public string IngredientId = "";

		public string OutputProductId = "";

		public bool EffectsAvailable;

		public List<string> OutputEffects = new List<string>();
	}
	internal static class LocalMixesService
	{
		private static readonly string Root = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper");

		public static string BuildScopedPath(string saveFingerprint)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint))
			{
				throw new ArgumentException("Save fingerprint is not a safe discovered-mix scope.", "saveFingerprint");
			}
			return Path.Combine(Root, "my-mixes", saveFingerprint + ".json");
		}

		public static List<LocalMix> Read(string? saveFingerprint)
		{
			List<LocalMix> list = new List<LocalMix>();
			try
			{
				if (!SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint))
				{
					return list;
				}
				string path = BuildScopedPath(saveFingerprint);
				if (!File.Exists(path))
				{
					return list;
				}
				using JsonDocument jsonDocument = JsonDocument.Parse(File.ReadAllText(path));
				if (!jsonDocument.RootElement.TryGetProperty("mixes", out var value) || value.ValueKind != JsonValueKind.Array)
				{
					return list;
				}
				foreach (JsonElement item in value.EnumerateArray())
				{
					LocalMix localMix = new LocalMix
					{
						Name = (GetStr(item, "name") ?? ""),
						ProductId = GameDatasetIds.Canonicalize(GetStr(item, "productId") ?? GetStr(item, "name") ?? ""),
						GameName = (GetStr(item, "gameName") ?? ""),
						Base = GameDatasetIds.Canonicalize(GetStr(item, "base") ?? "")
					};
					if (item.TryGetProperty("ingredients", out var value2) && value2.ValueKind == JsonValueKind.Array)
					{
						foreach (JsonElement item2 in value2.EnumerateArray())
						{
							if (item2.ValueKind == JsonValueKind.String)
							{
								localMix.Ingredients.Add(GameDatasetIds.Canonicalize(item2.GetString()));
							}
						}
					}
					if (item.TryGetProperty("steps", out var value3) && value3.ValueKind == JsonValueKind.Array)
					{
						foreach (JsonElement item3 in value3.EnumerateArray())
						{
							if (item3.ValueKind != JsonValueKind.Object)
							{
								continue;
							}
							LocalMixStep localMixStep = new LocalMixStep
							{
								IngredientId = GameDatasetIds.Canonicalize(GetStr(item3, "ingredientId") ?? ""),
								OutputProductId = (GetStr(item3, "outputProductId") ?? ""),
								EffectsAvailable = GetBool(item3, "effectsAvailable")
							};
							if (item3.TryGetProperty("outputEffects", out var value4) && value4.ValueKind == JsonValueKind.Array)
							{
								foreach (JsonElement item4 in value4.EnumerateArray())
								{
									if (item4.ValueKind == JsonValueKind.String)
									{
										localMixStep.OutputEffects.Add(item4.GetString());
									}
								}
							}
							localMix.Steps.Add(localMixStep);
						}
					}
					int num = Math.Max(localMix.Ingredients.Count, localMix.Steps.Count);
					if (num > 64)
					{
						localMix.SaveDisabledReason = PendingMixLimits.OverLimitReason(num);
					}
					list.Add(localMix);
				}
			}
			catch
			{
			}
			return list;
		}

		private static string? GetStr(JsonElement e, string p)
		{
			if (!e.TryGetProperty(p, out var value) || value.ValueKind != JsonValueKind.String)
			{
				return null;
			}
			return value.GetString();
		}

		private static bool GetBool(JsonElement e, string p)
		{
			if (e.TryGetProperty(p, out var value))
			{
				return value.ValueKind == JsonValueKind.True;
			}
			return false;
		}
	}
	public sealed class LocalSavedRecipe
	{
		[JsonPropertyName("recipeId")]
		public string RecipeId { get; set; } = "";

		[JsonPropertyName("name")]
		public string Name { get; set; } = "";

		[JsonPropertyName("productId")]
		public string ProductId { get; set; } = "";

		[JsonPropertyName("base")]
		public string Base { get; set; } = "";

		[JsonPropertyName("ingredients")]
		public List<string> Ingredients { get; set; } = new List<string>();

		[JsonPropertyName("steps")]
		public List<LocalMixStep> Steps { get; set; } = new List<LocalMixStep>();

		[JsonPropertyName("savedAt")]
		public DateTimeOffset SavedAt { get; set; }
	}
	public readonly record struct LocalSavedRecipeSaveResult(bool Accepted, bool Deduped, string? Reason, int Count);
	public sealed class LocalSavedRecipeStore
	{
		public const int MaxRecipes = 50;

		private static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
		{
			IncludeFields = true,
			WriteIndented = true,
			DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
		};

		private readonly string _path;

		public static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "saved-recipes.json");

		public LocalSavedRecipeStore(string path)
		{
			_path = path;
		}

		public static string BuildScopedPath(string saveFingerprint)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(saveFingerprint))
			{
				throw new ArgumentException("Save fingerprint is not a safe recipe-store scope.", "saveFingerprint");
			}
			return Path.Combine(Path.GetDirectoryName(DefaultPath), "saved-recipes", saveFingerprint + ".json");
		}

		public List<LocalSavedRecipe> Read()
		{
			try
			{
				if (!File.Exists(_path))
				{
					return new List<LocalSavedRecipe>();
				}
				return (JsonSerializer.Deserialize<List<LocalSavedRecipe>>(File.ReadAllText(_path), JsonOptions) ?? new List<LocalSavedRecipe>()).Where(IsValidStoredEntry).Take(50).ToList();
			}
			catch
			{
				return new List<LocalSavedRecipe>();
			}
		}

		public LocalSavedRecipeSaveResult Save(LocalMix mix, DateTimeOffset? savedAt = null)
		{
			string text = Validate(mix);
			if (text != null)
			{
				return new LocalSavedRecipeSaveResult(Accepted: false, Deduped: false, text, Read().Count);
			}
			List<LocalSavedRecipe> list = Read();
			string recipeId = BuildRecipeId(mix.Base, mix.Ingredients);
			int num = list.FindIndex((LocalSavedRecipe entry) => string.Equals(entry.RecipeId, recipeId, StringComparison.Ordinal));
			LocalSavedRecipe item = new LocalSavedRecipe
			{
				RecipeId = recipeId,
				Name = RecipeCardPresentation.FriendlyRecipeTitle(mix.GameName, mix.Name),
				ProductId = (mix.ProductId ?? ""),
				Base = GameDatasetIds.Canonicalize(mix.Base),
				Ingredients = mix.Ingredients.Select(GameDatasetIds.Canonicalize).ToList(),
				Steps = mix.Steps.Select(CloneStep).ToList(),
				SavedAt = (savedAt ?? DateTimeOffset.UtcNow)
			};
			bool flag = num >= 0;
			if (flag)
			{
				list.RemoveAt(num);
			}
			list.Insert(0, item);
			if (list.Count > 50)
			{
				list.RemoveRange(50, list.Count - 50);
			}
			try
			{
				string directoryName = Path.GetDirectoryName(_path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				string obj = $"{_path}.{Guid.NewGuid():N}.tmp";
				File.WriteAllText(obj, JsonSerializer.Serialize(list, JsonOptions));
				File.Move(obj, _path, overwrite: true);
				return new LocalSavedRecipeSaveResult(Accepted: true, flag, null, list.Count);
			}
			catch (Exception ex)
			{
				return new LocalSavedRecipeSaveResult(Accepted: false, flag, ex.Message, Read().Count);
			}
		}

		public static string BuildRecipeId(string baseId, IEnumerable<string> ingredients)
		{
			string s = GameDatasetIds.Canonicalize(baseId).ToLowerInvariant() + "|" + string.Join('|', from id in ingredients.Select(GameDatasetIds.Canonicalize)
				select id.ToLowerInvariant());
			return Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(s))).ToLowerInvariant();
		}

		private static string? Validate(LocalMix? mix)
		{
			if (mix == null)
			{
				return "Mix data is missing.";
			}
			if (!IsBoundedString(mix.Base))
			{
				return "Mix base product is missing.";
			}
			if (mix.Ingredients == null || mix.Ingredients.Count == 0 || mix.Ingredients.Count > 64)
			{
				return $"Mix must contain between 1 and {64} ingredients.";
			}
			if (mix.Steps == null || mix.Steps.Count != mix.Ingredients.Count)
			{
				return "Mix step data is incomplete.";
			}
			if (mix.Ingredients.Any((string id) => !IsBoundedString(id)))
			{
				return "Mix contains an invalid ingredient.";
			}
			if (mix.Name != null && mix.Name.Length > 64)
			{
				return "Mix name is too long.";
			}
			for (int num = 0; num < mix.Steps.Count; num++)
			{
				LocalMixStep localMixStep = mix.Steps[num];
				if (localMixStep == null || !IsBoundedString(localMixStep.IngredientId) || !string.Equals(localMixStep.IngredientId, mix.Ingredients[num], StringComparison.OrdinalIgnoreCase) || !IsBoundedString(localMixStep.OutputProductId))
				{
					return "Mix step data is invalid.";
				}
			}
			return null;
		}

		private static bool IsValidStoredEntry(LocalSavedRecipe entry)
		{
			if (entry != null && IsBoundedString(entry.RecipeId) && entry.Name != null && entry.Name.Length <= 64 && IsBoundedString(entry.Base) && entry.Ingredients != null && entry.Steps != null && entry.Ingredients.Count > 0 && entry.Ingredients.Count <= 64 && entry.Steps.Count == entry.Ingredients.Count && entry.Ingredients.All(IsBoundedString))
			{
				return entry.Steps.All((LocalMixStep step) => step != null && IsBoundedString(step.IngredientId) && IsBoundedString(step.OutputProductId));
			}
			return false;
		}

		private static bool IsBoundedString(string? value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value.Length <= 64;
			}
			return false;
		}

		private static LocalMixStep CloneStep(LocalMixStep step)
		{
			return new LocalMixStep
			{
				IngredientId = GameDatasetIds.Canonicalize(step.IngredientId),
				OutputProductId = step.OutputProductId,
				EffectsAvailable = step.EffectsAvailable,
				OutputEffects = (step.OutputEffects?.Take(8).ToList() ?? new List<string>())
			};
		}
	}
	internal enum ManualSyncState
	{
		Idle,
		Queued,
		Syncing,
		Success,
		Unavailable
	}
	internal sealed record ManualSyncStatusSnapshot(long Sequence, string? Status, bool PairingReady);
	internal sealed record ManualSyncViewState(ManualSyncState State, string Label, bool CanRequest)
	{
		public static ManualSyncViewState Idle { get; } = new ManualSyncViewState(ManualSyncState.Idle, "Sync Now", CanRequest: true);

		[CompilerGenerated]
		private ManualSyncViewState(ManualSyncViewState original)
		{
			State = original.State;
			Label = original.Label;
			CanRequest = original.CanRequest;
		}
	}
	internal sealed class ManualSyncStateController
	{
		private const string ImmediateSyncStatus = "Immediate snapshot synced.";

		private static readonly TimeSpan SuccessDisplayDuration = TimeSpan.FromSeconds(3.0);

		private readonly TimeSpan _timeout;

		private DateTimeOffset _deadline = DateTimeOffset.MinValue;

		private long _baselineSequence;

		private string? _requestId;

		private bool _active;

		private bool _flushed;

		private DateTimeOffset _terminalUntil = DateTimeOffset.MinValue;

		public ManualSyncViewState Current { get; private set; }

		public ManualSyncStateController(TimeSpan timeout)
		{
			if (timeout <= TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			_timeout = timeout;
			Current = ManualSyncViewState.Idle;
		}

		public ManualSyncViewState Request(long baselineSequence, bool pairingReady, DateTimeOffset now)
		{
			if (_active)
			{
				return Current;
			}
			if (!pairingReady)
			{
				Current = new ManualSyncViewState(ManualSyncState.Unavailable, "Unavailable", CanRequest: true);
				return Current;
			}
			_baselineSequence = baselineSequence;
			_requestId = null;
			_flushed = false;
			_terminalUntil = DateTimeOffset.MinValue;
			_active = true;
			_deadline = now.Add(_timeout);
			Current = new ManualSyncViewState(ManualSyncState.Queued, "Queued…", CanRequest: false);
			return Current;
		}

		public void AttachRequest(string requestId)
		{
			if (_active)
			{
				_requestId = requestId;
			}
		}

		public ManualSyncViewState MarkFlushed(string requestId, DateTimeOffset now)
		{
			if (!_active || !string.Equals(_requestId, requestId, StringComparison.Ordinal))
			{
				return Current;
			}
			_flushed = true;
			_deadline = now.Add(_timeout);
			Current = new ManualSyncViewState(ManualSyncState.Syncing, "Syncing…", CanRequest: false);
			return Current;
		}

		public ManualSyncViewState Observe(ManualSyncStatusSnapshot snapshot, DateTimeOffset now)
		{
			if (!_active)
			{
				if (Current.State == ManualSyncState.Success && now >= _terminalUntil)
				{
					Current = ManualSyncViewState.Idle;
				}
				else if (Current.State == ManualSyncState.Unavailable && snapshot.PairingReady && !IsFailureStatus(snapshot.Status))
				{
					Current = ManualSyncViewState.Idle;
				}
				return Current;
			}
			if (!snapshot.PairingReady || IsFailureStatus(snapshot.Status))
			{
				ClearActive();
				_terminalUntil = DateTimeOffset.MinValue;
				Current = new ManualSyncViewState(ManualSyncState.Unavailable, "Unavailable", CanRequest: true);
				return Current;
			}
			if (_flushed && snapshot.Sequence > _baselineSequence && string.Equals(snapshot.Status, "Immediate snapshot synced.", StringComparison.Ordinal))
			{
				ClearActive();
				_terminalUntil = now.Add(SuccessDisplayDuration);
				Current = new ManualSyncViewState(ManualSyncState.Success, "Synced", CanRequest: true);
			}
			return Current;
		}

		public ManualSyncViewState Tick(DateTimeOffset now)
		{
			if (_active && now >= _deadline)
			{
				ClearActive();
				_terminalUntil = DateTimeOffset.MinValue;
				Current = new ManualSyncViewState(ManualSyncState.Unavailable, "Retry Sync", CanRequest: true);
			}
			else if (!_active && Current.State == ManualSyncState.Success && now >= _terminalUntil)
			{
				Current = ManualSyncViewState.Idle;
			}
			return Current;
		}

		private void ClearActive()
		{
			_active = false;
			_flushed = false;
			_requestId = null;
			_deadline = DateTimeOffset.MinValue;
		}

		private static bool IsFailureStatus(string? status)
		{
			if (string.IsNullOrWhiteSpace(status))
			{
				return false;
			}
			if (!status.Contains("Pairing pending", StringComparison.OrdinalIgnoreCase) && !status.Contains("Requesting pairing", StringComparison.OrdinalIgnoreCase) && !status.Contains("Pairing revoked", StringComparison.OrdinalIgnoreCase) && !status.Contains("Unlinked", StringComparison.OrdinalIgnoreCase))
			{
				return status.Contains("quiet-failed", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	public enum ObservedEffectsState
	{
		Unavailable,
		Empty,
		Observed
	}
	public sealed class ObservedEffect
	{
		public string Key = "";

		public string Label = "";

		public bool IsUnknown;
	}
	public sealed class ObservedEffectsPresentation
	{
		public ObservedEffectsState State;

		public List<ObservedEffect> Effects = new List<ObservedEffect>();

		public string DisplayText = "";
	}
	public sealed class ObservedEffectFilter
	{
		public string Key = "";

		public string Label = "";
	}
	public static class ObservedEffects
	{
		public const string AllFilterKey = "";

		public const string UnknownFilterKey = "unknown";

		private static readonly string[] CanonicalNames = new string[34]
		{
			"Shrinking", "Zombifying", "Cyclopean", "Anti-Gravity", "Long-Faced", "Electrifying", "Glowing", "Tropic Thunder", "Thought-Provoking", "Jennerising",
			"Bright-Eyed", "Spicy", "Foggy", "Slippery", "Athletic", "Balding", "Calorie-Dense", "Sedating", "Sneaky", "Energizing",
			"Gingeritis", "Euphoric", "Focused", "Refreshing", "Munchies", "Calming", "Disorienting", "Explosive", "Laxative", "Paranoia",
			"Schizophrenic", "Seizure-Inducing", "Smelly", "Toxic"
		};

		private static readonly Dictionary<string, string> CanonicalByFolded = CanonicalNames.ToDictionary<string, string, string>(FoldToken, (string label) => label, StringComparer.Ordinal);

		public static string FoldToken(string raw)
		{
			return new string(raw.Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray());
		}

		public static ObservedEffectsPresentation FromMix(LocalMix mix)
		{
			ObservedEffectsPresentation observedEffectsPresentation = new ObservedEffectsPresentation();
			if (mix.Steps.Count != 0)
			{
				List<LocalMixStep> steps = mix.Steps;
				if (steps[steps.Count - 1].EffectsAvailable)
				{
					HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
					List<LocalMixStep> steps2 = mix.Steps;
					foreach (string outputEffect in steps2[steps2.Count - 1].OutputEffects)
					{
						if (string.IsNullOrWhiteSpace(outputEffect))
						{
							continue;
						}
						string text = FoldToken(outputEffect);
						if (text.Length != 0)
						{
							string value;
							bool flag = CanonicalByFolded.TryGetValue(text, out value);
							string text2 = (flag ? text : "unknown");
							if (hashSet.Add(text2))
							{
								observedEffectsPresentation.Effects.Add(new ObservedEffect
								{
									Key = text2,
									Label = (flag ? value : "Unknown game effect"),
									IsUnknown = !flag
								});
							}
						}
					}
					if (observedEffectsPresentation.Effects.Count == 0)
					{
						observedEffectsPresentation.State = ObservedEffectsState.Empty;
						observedEffectsPresentation.DisplayText = "No observed effects";
						return observedEffectsPresentation;
					}
					observedEffectsPresentation.State = ObservedEffectsState.Observed;
					observedEffectsPresentation.DisplayText = string.Join(", ", observedEffectsPresentation.Effects.Select((ObservedEffect effect) => effect.Label));
					return observedEffectsPresentation;
				}
			}
			observedEffectsPresentation.State = ObservedEffectsState.Unavailable;
			observedEffectsPresentation.DisplayText = "Effects unavailable";
			return observedEffectsPresentation;
		}

		public static bool Matches(LocalMix mix, string filterKey)
		{
			if (!(filterKey == ""))
			{
				return FromMix(mix).Effects.Any((ObservedEffect effect) => effect.Key == filterKey);
			}
			return true;
		}

		public static List<ObservedEffectFilter> GetFilters(IEnumerable<LocalMix> mixes)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (LocalMix mix in mixes)
			{
				foreach (ObservedEffect effect in FromMix(mix).Effects)
				{
					dictionary[effect.Key] = (effect.IsUnknown ? "Unknown effect" : effect.Label);
				}
			}
			List<ObservedEffectFilter> list = new List<ObservedEffectFilter>
			{
				new ObservedEffectFilter
				{
					Key = "",
					Label = "All effects"
				}
			};
			list.AddRange(from pair in dictionary.Where((KeyValuePair<string, string> pair) => pair.Key != "unknown").OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Value, StringComparer.OrdinalIgnoreCase)
				select new ObservedEffectFilter
				{
					Key = pair.Key,
					Label = pair.Value
				});
			if (dictionary.ContainsKey("unknown"))
			{
				list.Add(new ObservedEffectFilter
				{
					Key = "unknown",
					Label = "Unknown effect"
				});
			}
			return list;
		}

		public static string FilterLabel(string filterKey)
		{
			if (filterKey == "")
			{
				return "All effects";
			}
			if (filterKey == "unknown")
			{
				return "Unknown effect";
			}
			if (!CanonicalByFolded.TryGetValue(filterKey, out string value))
			{
				return "Unknown effect";
			}
			return value;
		}
	}
	internal sealed class PendingBridgeCommandResultPoller
	{
		private readonly string _directory;

		private readonly Func<string, string, string[]> _enumerateFiles;

		private readonly TimeSpan _fallbackInterval;

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

		private DateTimeOffset? _nextFallbackAt;

		internal PendingBridgeCommandResultPoller(string directory, Func<string, string, string[]>? enumerateFiles = null, TimeSpan? fallbackInterval = null)
		{
			_directory = directory;
			_enumerateFiles = enumerateFiles ?? new Func<string, string, string[]>(Directory.GetFiles);
			_fallbackInterval = fallbackInterval ?? TimeSpan.FromSeconds(15.0);
		}

		internal void Track(string requestId)
		{
			if (!string.IsNullOrWhiteSpace(requestId))
			{
				_pendingRequestIds.Add(requestId);
			}
		}

		internal IReadOnlyList<BridgeCommandResult> Take(string? activeSaveFingerprint, DateTimeOffset now)
		{
			IReadOnlyList<BridgeCommandResult> readOnlyList = BridgeCommandResultReader.TakeKnown(_directory, _pendingRequestIds, activeSaveFingerprint);
			foreach (BridgeCommandResult item in readOnlyList)
			{
				_pendingRequestIds.Remove(item.RequestId);
			}
			if (!_nextFallbackAt.HasValue)
			{
				_nextFallbackAt = now.Add(_fallbackInterval);
				return readOnlyList;
			}
			if (now < _nextFallbackAt.Value)
			{
				return readOnlyList;
			}
			_nextFallbackAt = now.Add(_fallbackInterval);
			try
			{
				IReadOnlyList<BridgeCommandResult> readOnlyList2 = BridgeCommandResultReader.TakePaths(_enumerateFiles(_directory, "bridge-command-result-*.json"), activeSaveFingerprint);
				foreach (BridgeCommandResult item2 in readOnlyList2)
				{
					_pendingRequestIds.Remove(item2.RequestId);
				}
				return readOnlyList.Concat(readOnlyList2).ToArray();
			}
			catch
			{
				return readOnlyList;
			}
		}
	}
	internal sealed class PhoneActiveSaveScopeReader
	{
		private readonly Func<(bool Success, string? Directory, string? Source)> _readActiveDirectory;

		private readonly Func<string, LocalFileSignature> _metadataSignature;

		private readonly Func<string, LocalFileSignature> _gameSignature;

		private readonly Func<string, string?> _readGeneration;

		private readonly LocalFileRefreshGate _refreshGate;

		private string? _lastDirectory;

		private string? _lastFingerprint;

		private LocalFileSignature _lastMetadata;

		private LocalFileSignature _lastGame;

		internal PhoneActiveSaveScopeReader(Func<(bool Success, string? Directory, string? Source)> readActiveDirectory, Func<string, LocalFileSignature>? metadataSignature = null, Func<string, LocalFileSignature>? gameSignature = null, Func<string, string?>? readGeneration = null, TimeSpan? forcedRecovery = null)
		{
			_readActiveDirectory = readActiveDirectory;
			_metadataSignature = metadataSignature ?? new Func<string, LocalFileSignature>(ReadSignature);
			_gameSignature = gameSignature ?? new Func<string, LocalFileSignature>(ReadSignature);
			_readGeneration = readGeneration ?? new Func<string, string>(ReadGeneration);
			_refreshGate = new LocalFileRefreshGate(forcedRecovery ?? TimeSpan.FromMinutes(5.0));
		}

		internal string? Read(DateTimeOffset now, out string scopeSource)
		{
			(bool, string, string) tuple = _readActiveDirectory();
			scopeSource = tuple.Item3 ?? "unavailable";
			if (!tuple.Item1 || string.IsNullOrWhiteSpace(tuple.Item2))
			{
				_lastDirectory = null;
				_lastFingerprint = null;
				_refreshGate.Reset();
				return null;
			}
			LocalFileSignature localFileSignature = _metadataSignature(Path.Combine(tuple.Item2, "Metadata.json"));
			LocalFileSignature localFileSignature2 = _gameSignature(Path.Combine(tuple.Item2, "Game.json"));
			if (string.Equals(_lastDirectory, tuple.Item2, StringComparison.Ordinal) && !(localFileSignature != _lastMetadata) && !(localFileSignature2 != _lastGame) && _lastFingerprint != null && !_refreshGate.ShouldRefresh(localFileSignature, now, dirty: false, out var _))
			{
				return _lastFingerprint;
			}
			string text = _readGeneration(tuple.Item2);
			if (!SaveGenerationIdentity.IsV2Fingerprint(text))
			{
				_refreshGate.RejectTransient();
				return null;
			}
			_lastDirectory = tuple.Item2;
			_lastFingerprint = text;
			_lastMetadata = localFileSignature;
			_lastGame = localFileSignature2;
			_refreshGate.Accept(localFileSignature, now);
			return text;
		}

		private static string? ReadGeneration(string directory)
		{
			if (!SaveGenerationIdentity.TryCreate(directory, out ProvenSaveIdentity identity, out string _))
			{
				return null;
			}
			return identity.Fingerprint;
		}

		private static LocalFileSignature ReadSignature(string path)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				return fileInfo.Exists ? new LocalFileSignature(Exists: true, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks) : LocalFileSignature.Missing;
			}
			catch
			{
				return LocalFileSignature.Missing;
			}
		}
	}
	public enum PhoneRecipeAvailabilityState
	{
		Empty,
		Fresh,
		Offline,
		Stale,
		Expired
	}
	public sealed class PhoneRecipeAvailabilityRead
	{
		public PhoneRecipeAvailabilityState State { get; init; }

		public BridgePhoneRecipeSnapshot? Snapshot { get; init; }

		public DateTimeOffset? FetchedAt { get; init; }

		public DateTimeOffset? OfflineSince { get; init; }
	}
	public sealed class PhoneRecipeAvailabilityReader
	{
		private sealed class PhoneRecipeCacheDocument
		{
			[JsonPropertyName("version")]
			public int Version { get; set; }

			[JsonPropertyName("saveFingerprint")]
			public string SaveFingerprint { get; set; } = "";

			[JsonPropertyName("snapshot")]
			public BridgePhoneRecipeSnapshot? Snapshot { get; set; }

			[JsonPropertyName("fetchedAt")]
			public DateTimeOffset FetchedAt { get; set; }

			[JsonPropertyName("offlineSince")]
			public DateTimeOffset? OfflineSince { get; set; }
		}

		private const int MaxCacheBytes = 524288;

		private static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
		{
			PropertyNameCaseInsensitive = true
		};

		private readonly string _path;

		public static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "phone-recipes-cache.json");

		public PhoneRecipeAvailabilityReader(string path)
		{
			_path = path;
		}

		public PhoneRecipeAvailabilityRead Read(DateTimeOffset now, string? activeSaveFingerprint)
		{
			try
			{
				if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint) || !File.Exists(_path))
				{
					return Empty();
				}
				FileInfo fileInfo = new FileInfo(_path);
				if (fileInfo.Length <= 0 || fileInfo.Length > 524288)
				{
					return Empty();
				}
				byte[] array = File.ReadAllBytes(_path);
				using JsonDocument jsonDocument = JsonDocument.Parse(array);
				if (!HasExactProperties(jsonDocument.RootElement, "version", "saveFingerprint", "snapshot", "fetchedAt", "offlineSince"))
				{
					return Empty();
				}
				PhoneRecipeCacheDocument phoneRecipeCacheDocument = JsonSerializer.Deserialize<PhoneRecipeCacheDocument>(array, JsonOptions);
				BridgePhoneRecipeSnapshot bridgePhoneRecipeSnapshot = phoneRecipeCacheDocument?.Snapshot;
				if (phoneRecipeCacheDocument == null || phoneRecipeCacheDocument.Version != 2 || !string.Equals(phoneRecipeCacheDocument.SaveFingerprint, activeSaveFingerprint, StringComparison.Ordinal) || !SaveGenerationIdentity.IsV2Fingerprint(phoneRecipeCacheDocument.SaveFingerprint))
				{
					return Empty();
				}
				if (bridgePhoneRecipeSnapshot == null || bridgePhoneRecipeSnapshot.SchemaVersion != 1 || bridgePhoneRecipeSnapshot.Recipes == null || bridgePhoneRecipeSnapshot.Recipes.Count > 50 || !DateTimeOffset.TryParse(bridgePhoneRecipeSnapshot.ExpiresAt, out var result) || !IsSafeSnapshot(bridgePhoneRecipeSnapshot))
				{
					return Empty();
				}
				DateTimeOffset fetchedAt = phoneRecipeCacheDocument.FetchedAt;
				DateTimeOffset? offlineSince = phoneRecipeCacheDocument.OfflineSince;
				bridgePhoneRecipeSnapshot.Recipes = bridgePhoneRecipeSnapshot.Recipes.Where((BridgePhoneRecipe recipe) => recipe != null && DateTimeOffset.TryParse(recipe.ExpiresAt, out var result2) && now <= result2).ToList();
				if (bridgePhoneRecipeSnapshot.Recipes.Count == 0)
				{
					if (now <= result)
					{
						return new PhoneRecipeAvailabilityRead
						{
							State = PhoneRecipeAvailabilityState.Fresh,
							Snapshot = bridgePhoneRecipeSnapshot,
							FetchedAt = fetchedAt,
							OfflineSince = offlineSince
						};
					}
					if (now <= result.AddHours(24.0))
					{
						return new PhoneRecipeAvailabilityRead
						{
							State = PhoneRecipeAvailabilityState.Stale,
							Snapshot = bridgePhoneRecipeSnapshot,
							FetchedAt = fetchedAt,
							OfflineSince = offlineSince
						};
					}
					return new PhoneRecipeAvailabilityRead
					{
						State = PhoneRecipeAvailabilityState.Expired,
						FetchedAt = fetchedAt
					};
				}
				if (offlineSince.HasValue && now >= offlineSince.Value && now <= result)
				{
					return new PhoneRecipeAvailabilityRead
					{
						State = PhoneRecipeAvailabilityState.Offline,
						Snapshot = bridgePhoneRecipeSnapshot,
						FetchedAt = fetchedAt,
						OfflineSince = offlineSince
					};
				}
				if (now <= result)
				{
					return new PhoneRecipeAvailabilityRead
					{
						State = PhoneRecipeAvailabilityState.Fresh,
						Snapshot = bridgePhoneRecipeSnapshot,
						FetchedAt = fetchedAt,
						OfflineSince = offlineSince
					};
				}
				if (now <= result.AddHours(24.0))
				{
					return new PhoneRecipeAvailabilityRead
					{
						State = PhoneRecipeAvailabilityState.Stale,
						Snapshot = bridgePhoneRecipeSnapshot,
						FetchedAt = fetchedAt,
						OfflineSince = offlineSince
					};
				}
				return new PhoneRecipeAvailabilityRead
				{
					State = PhoneRecipeAvailabilityState.Expired,
					FetchedAt = fetchedAt
				};
			}
			catch
			{
				return Empty();
			}
		}

		private static PhoneRecipeAvailabilityRead Empty()
		{
			return new PhoneRecipeAvailabilityRead
			{
				State = PhoneRecipeAvailabilityState.Empty
			};
		}

		private static bool HasExactProperties(JsonElement element, params string[] expected)
		{
			if (element.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(expected, StringComparer.Ordinal);
			foreach (JsonProperty item in element.EnumerateObject())
			{
				if (!hashSet.Remove(item.Name))
				{
					return false;
				}
			}
			return hashSet.Count == 0;
		}

		private static bool IsSafeSnapshot(BridgePhoneRecipeSnapshot snapshot)
		{
			if (string.IsNullOrWhiteSpace(snapshot.SnapshotId) || snapshot.SnapshotId.Length > 64 || snapshot.OmittedCount < 0)
			{
				return false;
			}
			foreach (BridgePhoneRecipe recipe in snapshot.Recipes)
			{
				if (recipe == null || string.IsNullOrWhiteSpace(recipe.RecipeId) || recipe.RecipeId.Length > 64 || recipe.Name == null || recipe.Name.Length > 64 || string.IsNullOrWhiteSpace(recipe.ProductId) || recipe.ProductId.Length > 64 || recipe.IngredientIds == null || recipe.IngredientIds.Count == 0 || recipe.IngredientIds.Count > 64 || recipe.IngredientIds.Exists((string id) => string.IsNullOrWhiteSpace(id) || id.Length > 64) || !double.IsFinite(recipe.SellPrice) || recipe.SellPrice < 0.0 || !double.IsFinite(recipe.Profit) || !double.IsFinite(recipe.ProfitMargin) || recipe.ProfitMargin < -100000.0 || recipe.ProfitMargin > 100000.0 || (recipe.ProfileMode != "standard" && recipe.ProfileMode != "seeded") || (recipe.Source != "app-saved" && recipe.Source != "game-observed") || !DateTimeOffset.TryParse(recipe.PublishedAt, out var result) || !DateTimeOffset.TryParse(recipe.ExpiresAt, out result))
				{
					return false;
				}
				if (recipe.EffectsAvailable)
				{
					if (recipe.Effects == null || recipe.Effects.Count > 8 || recipe.Effects.Exists((string effect) => string.IsNullOrWhiteSpace(effect) || effect.Length > 64))
					{
						return false;
					}
				}
				else if (recipe.Effects != null && recipe.Effects.Count > 0)
				{
					return false;
				}
			}
			return true;
		}
	}
	internal sealed class PhoneRecipesRefreshCoordinator
	{
		private LocalFileSignature _anchor;

		private bool _hasAnchor;

		internal bool ShouldReload(LocalFileSignature observed)
		{
			if (_hasAnchor)
			{
				return observed != _anchor;
			}
			return true;
		}

		internal void NotifyRendered(LocalFileSignature observed)
		{
			_anchor = observed;
			_hasAnchor = true;
		}

		internal void Reset()
		{
			_anchor = LocalFileSignature.Missing;
			_hasAnchor = false;
		}
	}
	public static class PhoneTileHostStartup
	{
		public static TileChallengeSyncResult Initialize(TileChallengeHandshakeWriter writer, Action armRuntimeState)
		{
			TileChallengeSyncResult result = writer.Sync();
			armRuntimeState();
			return result;
		}
	}
	public sealed class PhoneTileMod : MelonMod
	{
		internal const string TileBuildIdentity = "0.1.3";

		private static readonly string CommandDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper");

		private static readonly string StatusPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "bridge-status.json");

		private static readonly string HandshakePath = Path.Combine(CommandDirectory, "bridge-tile-handshake.json");

		private static readonly string AdvisorDispatchCachePath = Path.Combine(CommandDirectory, "advisor-dispatches-cache.json");

		private static readonly string AdvisorDispatchUiPath = Path.Combine(CommandDirectory, "advisor-dispatches-ui.json");

		private const float PollSeconds = 1f;

		private float _nextPoll;

		private string? _lastRecipeScopeDiagnostic;

		private bool _liveContextRefreshPending;

		private LiveContextRefreshScheduler _liveContextRefreshScheduler = new LiveContextRefreshScheduler(TimeSpan.FromSeconds(15.0));

		private SaveCompleteSyncCoordinator? _saveCompleteSync;

		private SaveCompleteLifecycleSubscription? _saveCompleteSubscription;

		private ManualSyncStateController _manualSyncState = new ManualSyncStateController(TimeSpan.FromSeconds(10.0));

		private ManualSyncViewState _manualSyncViewState = ManualSyncViewState.Idle;

		private string? _manualSyncRequestId;

		private bool _manualSyncPairingReady;

		private TileChallengeHandshakeWriter? _challengeWriter;

		private BridgeStatusFileReader? _statusReader;

		private PhoneActiveSaveScopeReader? _activeSaveScopeReader;

		private AdvisorDispatchesReader? _advisorDispatchesReader;

		private AdvisorDispatchesHostCoordinator? _advisorDispatchesHost;

		private AdvisorDispatchesHostView? _advisorDispatchesView;

		private PendingBridgeCommandResultPoller? _resultPoller;

		private string? _activeSaveFingerprint;

		private LiveFactObserver? _liveFactObserver;

		private LiveOverlayWriter? _liveOverlayWriter;

		private ScreenActivityWriter? _screenActivityWriter;

		private PhoneRecipesRefreshCoordinator? _phoneRecipesRefresh;

		private SaveCompleteLifecycleSubscription? _loadCompleteSubscription;

		private SaveCompleteLifecycleSubscription? _rankUpSubscription;

		private string? _lastRuntimeSession;

		internal static void LogNavigation(object from, object to)
		{
			MelonLogger.Msg($"[Hyland Helper] navigation {from} -> {to}");
		}

		public override void OnInitializeMelon()
		{
			_liveContextRefreshPending = true;
			_liveContextRefreshScheduler = new LiveContextRefreshScheduler(TimeSpan.FromSeconds(15.0));
			_manualSyncState = new ManualSyncStateController(TimeSpan.FromSeconds(10.0));
			_manualSyncViewState = ManualSyncViewState.Idle;
			_manualSyncRequestId = null;
			_manualSyncPairingReady = false;
			_challengeWriter = new TileChallengeHandshakeWriter(StatusPath, HandshakePath, "0.1.3");
			_statusReader = new BridgeStatusFileReader(StatusPath);
			_activeSaveScopeReader = new PhoneActiveSaveScopeReader(ReadActiveSaveDirectory);
			_advisorDispatchesReader = new AdvisorDispatchesReader(AdvisorDispatchCachePath);
			_resultPoller = new PendingBridgeCommandResultPoller(CommandDirectory, null, TimeSpan.FromSeconds(15.0));
			PhoneTileHostStartup.Initialize(_challengeWriter, delegate
			{
				_advisorDispatchesHost = new AdvisorDispatchesHostCoordinator((DateTimeOffset now, string? saveFingerprint) => _advisorDispatchesReader.Read(now, saveFingerprint), new AdvisorDispatchesUiState(AdvisorDispatchUiPath), new AdvisorDispatchesNotificationCoordinator(new ScheduleINotificationSink()));
				_saveCompleteSubscription?.Dispose();
				_saveCompleteSync = new SaveCompleteSyncCoordinator(new BridgeCommandFileWriter(Path.Combine(CommandDirectory, "bridge-command.json")), () => DateTimeOffset.UtcNow, TimeSpan.FromSeconds(2.0));
				_saveCompleteSubscription = new SaveCompleteLifecycleSubscription(delegate(Action handler)
				{
					GameLifecycle.OnSaveComplete += handler;
				}, delegate(Action handler)
				{
					GameLifecycle.OnSaveComplete -= handler;
				}, delegate
				{
					_activeSaveFingerprint = ReadActiveSaveFingerprint(out string _);
					_saveCompleteSync.HandleSaveComplete(_activeSaveFingerprint);
					_liveContextRefreshPending = true;
				});
				LiveFactObserver liveFactObserver = new LiveFactObserver(new S1ApiLiveFactSource());
				_liveFactObserver = liveFactObserver;
				_liveOverlayWriter = new LiveOverlayWriter(liveFactObserver, () => _lastRuntimeSession, () => _activeSaveFingerprint, "0.1.3", ReadS1ApiVersion());
				_screenActivityWriter = new ScreenActivityWriter(() => _lastRuntimeSession, () => _activeSaveFingerprint);
				_phoneRecipesRefresh = new PhoneRecipesRefreshCoordinator();
				_loadCompleteSubscription?.Dispose();
				_loadCompleteSubscription = new SaveCompleteLifecycleSubscription(delegate(Action handler)
				{
					GameLifecycle.OnLoadComplete += handler;
				}, delegate(Action handler)
				{
					GameLifecycle.OnLoadComplete -= handler;
				}, delegate
				{
					liveFactObserver.NotifyLoadComplete();
				});
				_rankUpSubscription?.Dispose();
				Action<FullRank, FullRank> rankUpForwarder = null;
				_rankUpSubscription = new SaveCompleteLifecycleSubscription(delegate(Action handler)
				{
					rankUpForwarder = delegate
					{
						handler();
					};
					LevelManager.OnRankUp += rankUpForwarder;
				}, delegate
				{
					if (rankUpForwarder != null)
					{
						LevelManager.OnRankUp -= rankUpForwarder;
						rankUpForwarder = null;
					}
				}, delegate
				{
					liveFactObserver.NotifyRankUp();
				});
			});
			((MelonBase)this).LoggerInstance.Msg("Hyland Helper phone tile loaded; save-complete sync armed.");
		}

		public override void OnDeinitializeMelon()
		{
			_saveCompleteSubscription?.Dispose();
			_saveCompleteSubscription = null;
			_saveCompleteSync = null;
			_loadCompleteSubscription?.Dispose();
			_loadCompleteSubscription = null;
			_rankUpSubscription?.Dispose();
			_rankUpSubscription = null;
			_liveOverlayWriter = null;
			_screenActivityWriter = null;
			_phoneRecipesRefresh = null;
			_liveFactObserver = null;
			_lastRuntimeSession = null;
			_liveContextRefreshPending = false;
			_manualSyncState = new ManualSyncStateController(TimeSpan.FromSeconds(10.0));
			_manualSyncViewState = ManualSyncViewState.Idle;
			_manualSyncRequestId = null;
			_manualSyncPairingReady = false;
			_challengeWriter = null;
			_statusReader = null;
			_activeSaveScopeReader = null;
			_advisorDispatchesReader = null;
			_advisorDispatchesHost = null;
			_advisorDispatchesView = null;
			_resultPoller = null;
			_activeSaveFingerprint = null;
		}

		public override void OnUpdate()
		{
			HylandHelperApp.Instance?.TickVisibility();
			if (RecipeService.TryTakeResult(out List<CommunityMix> mixes, out string error))
			{
				HylandHelperApp.Instance?.PopulateRecipes(mixes, error);
			}
			if (Time.time < _nextPoll)
			{
				return;
			}
			_nextPoll = Time.time + 1f;
			string scopeSource;
			string text = ReadActiveSaveFingerprint(out scopeSource);
			if (!string.Equals(_activeSaveFingerprint, text, StringComparison.Ordinal))
			{
				_phoneRecipesRefresh?.Reset();
			}
			_activeSaveFingerprint = text;
			string text2 = ((text == null) ? "unavailable" : "validated") + "|" + scopeSource;
			if (!string.Equals(_lastRecipeScopeDiagnostic, text2, StringComparison.Ordinal))
			{
				_lastRecipeScopeDiagnostic = text2;
				((MelonBase)this).LoggerInstance.Msg("Hyland Helper recipe scope: " + text2 + ".");
			}
			if (_saveCompleteSync != null && _saveCompleteSync.TryFlush(_activeSaveFingerprint, out SyncNowFlushResult result) && result != null)
			{
				if (string.Equals(_manualSyncRequestId, result.RequestId, StringComparison.Ordinal))
				{
					_manualSyncViewState = _manualSyncState.MarkFlushed(result.RequestId, DateTimeOffset.UtcNow);
					_manualSyncRequestId = null;
				}
				_resultPoller?.Track(result.RequestId);
			}
			_manualSyncViewState = _manualSyncState.Tick(DateTimeOffset.UtcNow);
			BridgeStatusFileRead bridgeStatusFileRead = _statusReader?.ReadIfDue(DateTimeOffset.UtcNow, dirty: false) ?? new BridgeStatusFileRead(null, null, LocalFileSignature.Missing, RefreshAttempted: false);
			_challengeWriter?.Sync(bridgeStatusFileRead.TileChallenge);
			_lastRuntimeSession = bridgeStatusFileRead.RuntimeSession;
			_liveOverlayWriter?.Tick(DateTimeOffset.UtcNow);
			_screenActivityWriter?.Tick(HylandHelperApp.Instance?.CurrentBridgeScreen, DateTimeOffset.UtcNow);
			if (HylandHelperApp.Instance?.CurrentBridgeScreen == ScreenActivityScreen.PhoneRecipes && _phoneRecipesRefresh != null)
			{
				LocalFileSignature observed = ProbeSignature(PhoneRecipeAvailabilityReader.DefaultPath);
				if (_phoneRecipesRefresh.ShouldReload(observed))
				{
					HylandHelperApp.Instance?.RefreshPhoneRecipesIfVisible();
					_phoneRecipesRefresh.NotifyRendered(observed);
				}
			}
			else
			{
				_phoneRecipesRefresh?.Reset();
			}
			_advisorDispatchesHost?.ObserveSaveScope(text);
			if (_advisorDispatchesHost != null)
			{
				_advisorDispatchesView = _advisorDispatchesHost.Poll(DateTimeOffset.UtcNow);
			}
			HylandHelperApp instance = HylandHelperApp.Instance;
			if (instance != null)
			{
				instance.SetSaveScope(text);
				if (_advisorDispatchesView != null)
				{
					instance.SetAdvisorDispatchesView(ToAppView(_advisorDispatchesView));
					instance.SetAdvisorDispatchesOpenHandler(OpenAdvisorDispatches);
				}
				instance.SetManualSyncRequestHandler(RequestManualSync);
				instance.RenderManualSync(_manualSyncViewState);
				if (_liveContextRefreshScheduler.Take(DateTimeOffset.UtcNow, _liveContextRefreshPending))
				{
					_liveContextRefreshPending = false;
					instance.RenderLiveContext(S1ApiLiveContextReader.TryRead());
				}
				instance.TickEconomics();
				EconomicsResult result2;
				while (EconomicsService.TryTakeResult(out result2))
				{
					instance.ApplyEconomics(result2);
				}
				PollSaveTrackResults(instance, _activeSaveFingerprint);
				if (bridgeStatusFileRead.Status != null)
				{
					BridgeStatus status = bridgeStatusFileRead.Status;
					_manualSyncPairingReady = IsPairingReady(status);
					_manualSyncViewState = _manualSyncState.Observe(new ManualSyncStatusSnapshot(status.Sequence, status.Status, _manualSyncPairingReady), DateTimeOffset.UtcNow);
					instance.Render(status);
					instance.RenderManualSync(_manualSyncViewState);
				}
			}
		}

		private static LocalFileSignature ProbeSignature(string path)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				return fileInfo.Exists ? new LocalFileSignature(Exists: true, fileInfo.Length, fileInfo.LastWriteTimeUtc.Ticks) : LocalFileSignature.Missing;
			}
			catch
			{
				return LocalFileSignature.Missing;
			}
		}

		private AdvisorDispatchesViewState OpenAdvisorDispatches()
		{
			if (_advisorDispatchesHost != null)
			{
				_advisorDispatchesView = _advisorDispatchesHost.OpenInbox(DateTimeOffset.UtcNow);
			}
			return ToAppView(_advisorDispatchesView);
		}

		private static AdvisorDispatchesViewState ToAppView(AdvisorDispatchesHostView? view)
		{
			if (view == null)
			{
				return new AdvisorDispatchesViewState(AdvisorDispatchesReadState.Missing, Array.Empty<AdvisorDispatchMessage>(), null, 0, "No Advisor Dispatches available yet.", StorageAvailable: false);
			}
			return new AdvisorDispatchesViewState(view.Cache.State, view.Cache.Messages, view.UiState, view.UnreadCount, view.Cache.StatusText, view.StorageAvailable);
		}

		private ManualSyncViewState RequestManualSync(long baselineSequence)
		{
			ManualSyncViewState current = _manualSyncState.Current;
			if (!current.CanRequest)
			{
				return current;
			}
			ManualSyncViewState manualSyncViewState = _manualSyncState.Request(baselineSequence, _manualSyncPairingReady, DateTimeOffset.UtcNow);
			if (manualSyncViewState.State != ManualSyncState.Queued || _saveCompleteSync == null)
			{
				_manualSyncViewState = manualSyncViewState;
				return manualSyncViewState;
			}
			if (!_saveCompleteSync.TryRequestManual(_activeSaveFingerprint, out string requestId))
			{
				_manualSyncViewState = new ManualSyncViewState(ManualSyncState.Unavailable, "Unavailable", CanRequest: true);
				return _manualSyncViewState;
			}
			_manualSyncState.AttachRequest(requestId);
			_manualSyncRequestId = requestId;
			_manualSyncViewState = manualSyncViewState;
			return manualSyncViewState;
		}

		private static bool IsPairingReady(BridgeStatus status)
		{
			if (!string.IsNullOrEmpty(status.PairingCode))
			{
				return false;
			}
			string text = status.Status ?? "";
			if (text.Contains("Pairing pending", StringComparison.OrdinalIgnoreCase) || text.Contains("Requesting pairing", StringComparison.OrdinalIgnoreCase) || text.Contains("Pairing revoked", StringComparison.OrdinalIgnoreCase) || text.Contains("Unlinked", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (status.Sequence <= 0 && !text.Contains("Paired", StringComparison.OrdinalIgnoreCase) && !text.Contains("synced", StringComparison.OrdinalIgnoreCase))
			{
				return text.Contains("sync requested", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private void PollSaveTrackResults(HylandHelperApp app, string? activeSaveFingerprint)
		{
			if (_resultPoller == null)
			{
				return;
			}
			foreach (BridgeCommandResult item in _resultPoller.Take(activeSaveFingerprint, DateTimeOffset.UtcNow))
			{
				app.ApplySaveTrackResult(item.RequestId, item.Status);
			}
		}

		private string? ReadActiveSaveFingerprint(out string scopeSource)
		{
			if (_activeSaveScopeReader == null)
			{
				scopeSource = "unavailable";
				return null;
			}
			return _activeSaveScopeReader.Read(DateTimeOffset.UtcNow, out scopeSource);
		}

		private static (bool Success, string? Directory, string? Source) ReadActiveSaveDirectory()
		{
			if (!CurrentSaveSlotReader.TryReadActiveDirectory(out string saveDirectory, out string source))
			{
				return (Success: false, Directory: null, Source: source);
			}
			return (Success: true, Directory: saveDirectory, Source: source);
		}

		private static string ReadS1ApiVersion()
		{
			try
			{
				string text = typeof(LevelManager).Assembly.GetName().Version?.ToString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return "unknown";
				}
				return (text.Length <= 64) ? text : text.Substring(0, 64);
			}
			catch
			{
				return "unknown";
			}
		}
	}
	public static class PhoneTileNavigationState
	{
		public static bool ShouldReturnHome(bool wasVisible, bool isVisible, bool isHome)
		{
			if (!wasVisible && isVisible)
			{
				return !isHome;
			}
			return false;
		}

		public static string BackTarget()
		{
			return "Home";
		}
	}
	public enum RecipePhoneDeliveryState
	{
		None,
		Pending,
		Sent,
		Unavailable,
		Busy,
		AlreadySent,
		Unauthorized
	}
	public static class RecipeCardPresentation
	{
		public const string CommunityTitle = "Community Recipes";

		public const string DiscoveredTitle = "Discovered Mixes";

		public const string SavedTitle = "Saved Recipes";

		public const string PhoneTitle = "Phone Recipes";

		public const string SaveAction = "Save Recipe";

		public const string SavedAction = "Saved ✓";

		public const string SendToPhoneAction = "Send to phone";

		public const string RetryPhoneAction = "Retry phone";

		public const float ListHorizontalPadding = 44f;

		public static string PhoneActionLabel(RecipePhoneDeliveryState phone)
		{
			if ((phone != RecipePhoneDeliveryState.None && phone != RecipePhoneDeliveryState.Sent && phone != RecipePhoneDeliveryState.AlreadySent) || 1 == 0)
			{
				return "Retry phone";
			}
			return "Send to phone";
		}

		public static string FormatEconomics(double sell, double cost, double profit, double margin)
		{
			return $"Sell {Money(sell)} · Cost {Money(cost)} · Profit {Money(profit)} ({Number(margin)}%)";
		}

		public static string FormatPhoneEconomics(double sell, double profit, double margin)
		{
			return FormatEconomics(sell, sell - profit, profit, margin);
		}

		public static string FormatEconomicsPending()
		{
			return "Calculating sell price, cost, and margin…";
		}

		public static string FormatEconomicsUnavailable()
		{
			return "Economics unavailable";
		}

		public static string FormatSaveStatus(bool saved, RecipePhoneDeliveryState phone)
		{
			if (!saved)
			{
				return "";
			}
			return phone switch
			{
				RecipePhoneDeliveryState.Pending => "Saved here · Sending to phone…", 
				RecipePhoneDeliveryState.Sent => "Saved here · Sent to phone ✓", 
				RecipePhoneDeliveryState.Unavailable => "Saved here · Phone unavailable", 
				RecipePhoneDeliveryState.Busy => "Saved here · Finish phone send first", 
				RecipePhoneDeliveryState.AlreadySent => "already sent", 
				RecipePhoneDeliveryState.Unauthorized => "Pairing required; check the bridge.", 
				_ => "Saved here", 
			};
		}

		public static string FriendlyRecipeTitle(string? gameName, string? fallback)
		{
			string value = (string.IsNullOrWhiteSpace(gameName) ? fallback : gameName);
			if (!string.IsNullOrWhiteSpace(value))
			{
				return GameDatasetIds.FriendlyName(value);
			}
			return "Custom Mix";
		}

		public static float RequiredCardHeight(float bodyPreferredHeight, float statusPreferredHeight)
		{
			return Math.Max(118f, Math.Max(bodyPreferredHeight + 28f, statusPreferredHeight + 108f));
		}

		public static bool HasInvalidSteps(LocalMix mix)
		{
			if (mix == null || mix.Steps.Count != mix.Ingredients.Count)
			{
				return true;
			}
			for (int i = 0; i < mix.Steps.Count; i++)
			{
				LocalMixStep localMixStep = mix.Steps[i];
				if (localMixStep == null || !string.Equals(localMixStep.IngredientId, mix.Ingredients[i], StringComparison.OrdinalIgnoreCase) || string.IsNullOrWhiteSpace(localMixStep.OutputProductId) || !localMixStep.EffectsAvailable)
				{
					return true;
				}
			}
			return false;
		}

		private static string Money(double value)
		{
			return "$" + Number(value);
		}

		private static string Number(double value)
		{
			return value.ToString("0.##", CultureInfo.InvariantCulture);
		}
	}
	internal sealed class RecipeCardUi
	{
		public GameObject Row;

		public Text Body;

		public GameObject? PrimaryRoot;

		public Button? PrimaryButton;

		public Text? PrimaryLabel;

		public Text Status;

		public GameObject? RetryRoot;

		public Button? RetryButton;

		public Text? RetryLabel;

		public void RefreshHeight()
		{
			Canvas.ForceUpdateCanvases();
			float num = RecipeCardPresentation.RequiredCardHeight(Body.preferredHeight, Status.preferredHeight);
			LayoutElement obj = Row.GetComponent<LayoutElement>() ?? Row.AddComponent<LayoutElement>();
			obj.minHeight = num;
			obj.preferredHeight = num;
			obj.flexibleHeight = 0f;
		}

		public void SetSaved(bool saved)
		{
			if ((Object)(object)PrimaryLabel != (Object)null)
			{
				PrimaryLabel.text = (saved ? "Saved ✓" : "Save Recipe");
			}
			if ((Object)(object)PrimaryButton != (Object)null)
			{
				((Selectable)PrimaryButton).interactable = !saved;
			}
		}

		public void ShowPhoneAction(bool visible, string label)
		{
			if ((Object)(object)RetryLabel != (Object)null)
			{
				RetryLabel.text = label;
			}
			if ((Object)(object)RetryRoot != (Object)null)
			{
				RetryRoot.SetActive(visible);
			}
		}
	}
	internal static class RecipeCardUiFactory
	{
		public static RecipeCardUi Create(Transform parent, string name, string body, bool showPrimary, string primaryLabel, Action? onPrimary, Action? onRetry)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.Panel(name, parent, new Color(0.095f, 0.11f, 0.14f, 1f), (Vector2?)null, (Vector2?)null, false);
			Image component = val.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).raycastTarget = false;
			}
			Outline obj = val.AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(0.28f, 0.32f, 0.39f, 1f);
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
			RecipeCardUi recipeCardUi = new RecipeCardUi
			{
				Row = val
			};
			recipeCardUi.Body = UIFactory.Text(name + "Body", body, val.transform, 14, (TextAnchor)0, (FontStyle)0);
			recipeCardUi.Body.supportRichText = false;
			((Graphic)recipeCardUi.Body).raycastTarget = false;
			recipeCardUi.Body.horizontalOverflow = (HorizontalWrapMode)0;
			recipeCardUi.Body.verticalOverflow = (VerticalWrapMode)1;
			RectTransform component2 = ((Component)recipeCardUi.Body).GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(18f, 10f);
			component2.offsetMax = new Vector2(showPrimary ? (-150f) : (-18f), -10f);
			recipeCardUi.Status = UIFactory.Text(name + "Status", "", val.transform, 11, (TextAnchor)1, (FontStyle)0);
			((Graphic)recipeCardUi.Status).raycastTarget = false;
			RectTransform component3 = ((Component)recipeCardUi.Status).GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(1f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(1f, 0.5f);
			component3.sizeDelta = new Vector2(122f, 44f);
			component3.anchoredPosition = new Vector2(-14f, -40f);
			if (showPrimary)
			{
				ValueTuple<GameObject, Button, Text> valueTuple = UIFactory.RoundedButtonWithLabel(name + "Primary", primaryLabel, val.transform, new Color(0.2f, 0.42f, 0.55f), 112f, 32f, 12, Color.white);
				GameObject item = valueTuple.Item1;
				Button item2 = valueTuple.Item2;
				Text item3 = valueTuple.Item3;
				recipeCardUi.PrimaryRoot = item;
				recipeCardUi.PrimaryButton = item2;
				recipeCardUi.PrimaryLabel = item3;
				RectTransform component4 = item.GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(1f, 1f);
				component4.anchorMax = new Vector2(1f, 1f);
				component4.pivot = new Vector2(1f, 1f);
				component4.anchoredPosition = new Vector2(-14f, -14f);
				if (onPrimary != null)
				{
					ButtonUtils.AddListener(item2, onPrimary);
				}
				ValueTuple<GameObject, Button, Text> valueTuple2 = UIFactory.RoundedButtonWithLabel(name + "Retry", "Retry phone", val.transform, new Color(0.31f, 0.34f, 0.4f), 112f, 24f, 10, Color.white);
				GameObject item4 = valueTuple2.Item1;
				Button item5 = valueTuple2.Item2;
				Text item6 = valueTuple2.Item3;
				recipeCardUi.RetryRoot = item4;
				recipeCardUi.RetryButton = item5;
				recipeCardUi.RetryLabel = item6;
				RectTransform component5 = item4.GetComponent<RectTransform>();
				component5.anchorMin = new Vector2(1f, 0f);
				component5.anchorMax = new Vector2(1f, 0f);
				component5.pivot = new Vector2(1f, 0f);
				component5.anchoredPosition = new Vector2(-14f, 12f);
				if (onRetry != null)
				{
					ButtonUtils.AddListener(item5, onRetry);
				}
				item4.SetActive(false);
			}
			recipeCardUi.RefreshHeight();
			return recipeCardUi;
		}
	}
	internal static class RecipeDestinationCardUi
	{
		public static GameObject Create(string name, string title, string subtitle, Transform parent, Color color, Action onClick)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.Panel(name, parent, color, (Vector2?)null, (Vector2?)null, false);
			Image component = val.GetComponent<Image>();
			Button obj = val.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)component;
			ButtonUtils.AddListener(obj, onClick);
			RectTransform component2 = ((Component)UIFactory.Text(name + "Title", title, val.transform, 17, (TextAnchor)0, (FontStyle)0)).GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(18f, 19f);
			component2.offsetMax = new Vector2(-18f, -5f);
			Text obj2 = UIFactory.Text(name + "Subtitle", subtitle, val.transform, 11, (TextAnchor)6, (FontStyle)0);
			((Graphic)obj2).color = new Color(0.68f, 0.72f, 0.79f);
			RectTransform component3 = ((Component)obj2).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(18f, 5f);
			component3.offsetMax = new Vector2(-18f, -23f);
			RectTransform component4 = ((Component)UIFactory.Text(name + "Arrow", "›", val.transform, 20, (TextAnchor)5, (FontStyle)0)).GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.offsetMin = Vector2.zero;
			component4.offsetMax = new Vector2(-12f, 0f);
			LayoutElement obj3 = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			obj3.minHeight = 52f;
			obj3.preferredHeight = 52f;
			obj3.flexibleHeight = 0f;
			return val;
		}
	}
	public sealed class CommunityMix
	{
		public string Name = "";

		public string Author = "";

		public string Product = "";

		public List<string> Ingredients = new List<string>();

		public List<string> Effects = new List<string>();

		public int ProfitMargin;

		public double Addiction;

		public int SellPrice;

		public int Upvotes;
	}
	internal static class RecipeService
	{
		private const string Url = "https://hyland-helper-backend.vercel.app/api/community/mixes?sort=top&page=0";

		internal const int MaxResponseBytes = 262144;

		internal const int MaxMixes = 20;

		internal const int MaxNameLength = 128;

		internal const int MaxFieldLength = 64;

		internal const int MaxIngredients = 64;

		internal const int MaxEffects = 32;

		private static readonly HttpClient Http = new HttpClient
		{
			Timeout = TimeSpan.FromSeconds(15.0)
		};

		private static volatile int _state;

		private static List<CommunityMix>? _result;

		private static string? _error;

		public static void BeginFetch()
		{
			if (_state != 1)
			{
				_state = 1;
				_result = null;
				_error = null;
				FetchAsync();
			}
		}

		private static async Task FetchAsync()
		{
			_ = 1;
			try
			{
				using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "https://hyland-helper-backend.vercel.app/api/community/mixes?sort=top&page=0");
				using HttpResponseMessage response = await Http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
				response.EnsureSuccessStatusCode();
				byte[] bytes = await BoundedHttpResponse.ReadBytesAsync(response, 262144, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
				_result = Parse(Encoding.UTF8.GetString(bytes));
			}
			catch (Exception ex)
			{
				_error = ex.Message;
				_result = null;
			}
			finally
			{
				_state = 2;
			}
		}

		public static bool TryTakeResult(out List<CommunityMix>? mixes, out string? error)
		{
			mixes = null;
			error = null;
			if (_state != 2)
			{
				return false;
			}
			mixes = _result;
			error = _error;
			_state = 0;
			return true;
		}

		internal static List<CommunityMix> Parse(string json)
		{
			List<CommunityMix> list = new List<CommunityMix>();
			using JsonDocument jsonDocument = JsonDocument.Parse(json);
			if (!jsonDocument.RootElement.TryGetProperty("mixes", out var value) || value.ValueKind != JsonValueKind.Array)
			{
				return list;
			}
			foreach (JsonElement item in value.EnumerateArray())
			{
				if (list.Count >= 20)
				{
					break;
				}
				if (item.ValueKind == JsonValueKind.Object)
				{
					CommunityMix communityMix = new CommunityMix
					{
						Name = Normalize(GetStr(item, "mix_name"), 128, "Unnamed mix"),
						Author = Normalize(GetStr(item, "display_name"), 64, "anonymous"),
						Product = Normalize(GetStr(item, "product"), 64, ""),
						ProfitMargin = GetInt(item, "profit_margin"),
						Addiction = GetDouble(item, "addiction_level"),
						SellPrice = GetInt(item, "sell_price"),
						Upvotes = GetInt(item, "upvotes")
					};
					AddStrings(item, "ingredients", communityMix.Ingredients, 64);
					AddStrings(item, "effects", communityMix.Effects, 32);
					list.Add(communityMix);
				}
			}
			return list;
		}

		private static void AddStrings(JsonElement e, string prop, List<string> into, int maxItems)
		{
			if (!e.TryGetProperty(prop, out var value) || value.ValueKind != JsonValueKind.Array)
			{
				return;
			}
			foreach (JsonElement item in value.EnumerateArray())
			{
				if (into.Count >= maxItems)
				{
					break;
				}
				if (item.ValueKind == JsonValueKind.String)
				{
					string text = Normalize(item.GetString(), 64, "");
					if (text.Length > 0)
					{
						into.Add(text);
					}
				}
			}
		}

		private static string Normalize(string? value, int maxLength, string fallback)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return fallback;
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Min(value.Length, maxLength));
			bool flag = false;
			foreach (char c in value)
			{
				if (stringBuilder.Length >= maxLength)
				{
					break;
				}
				if (char.IsControl(c) || char.IsWhiteSpace(c))
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
						flag = true;
					}
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			string text = stringBuilder.ToString().Trim();
			if (text.Length != 0)
			{
				return text;
			}
			return fallback;
		}

		private static string? GetStr(JsonElement e, string p)
		{
			if (!e.TryGetProperty(p, out var value) || value.ValueKind != JsonValueKind.String)
			{
				return null;
			}
			return value.GetString();
		}

		private static int GetInt(JsonElement e, string p)
		{
			if (!e.TryGetProperty(p, out var value) || value.ValueKind != JsonValueKind.Number || !value.TryGetInt32(out var value2))
			{
				return 0;
			}
			return value2;
		}

		private static double GetDouble(JsonElement e, string p)
		{
			if (!e.TryGetProperty(p, out var value) || value.ValueKind != JsonValueKind.Number || !value.TryGetDouble(out var value2))
			{
				return 0.0;
			}
			return value2;
		}
	}
	internal static class S1ApiLiveContextReader
	{
		private static readonly LiveContextRuntimeReader Reader = new LiveContextRuntimeReader(ReadRank, ReadDay);

		public static LiveContextSnapshot TryRead()
		{
			return Reader.TryRead();
		}

		private static LiveContextRank? ReadRank()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelManager.Exists)
			{
				return null;
			}
			return new LiveContextRank(((object)LevelManager.Rank/*cast due to .constrained prefix*/).ToString(), LevelManager.Tier);
		}

		private static LiveContextDay ReadDay()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new LiveContextDay(TimeManager.ElapsedDays, ((object)TimeManager.CurrentDay/*cast due to .constrained prefix*/).ToString());
		}
	}
	internal sealed class S1ApiLiveFactSource : ILiveFactSource
	{
		public LiveRankReading ReadRank()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelManager.Exists)
			{
				throw new InvalidOperationException("LevelManager unavailable.");
			}
			return new LiveRankReading(((object)LevelManager.Rank/*cast due to .constrained prefix*/).ToString(), LevelManager.Tier, LevelManager.XP, LevelManager.TotalXP);
		}

		public LiveMoneyReading ReadMoney()
		{
			return new LiveMoneyReading(Money.GetCashBalance(), Money.GetOnlineBalance(), Money.GetNetWorth());
		}

		public LivePropertiesReading ReadProperties()
		{
			List<string> list = new List<string>();
			foreach (PropertyWrapper ownedProperty in PropertyManager.GetOwnedProperties())
			{
				list.Add(((BaseProperty)ownedProperty).PropertyCode);
			}
			List<string> list2 = new List<string>();
			foreach (BusinessWrapper ownedBusiness in BusinessManager.GetOwnedBusinesses())
			{
				list2.Add(((BaseProperty)ownedBusiness).PropertyCode);
			}
			return new LivePropertiesReading(list, list2);
		}

		public int ReadElapsedDays()
		{
			return TimeManager.ElapsedDays;
		}
	}
	internal sealed class SaveCompleteLifecycleSubscription : IDisposable
	{
		private readonly Action<Action> _unsubscribe;

		private Action? _handler;

		public SaveCompleteLifecycleSubscription(Action<Action> subscribe, Action<Action> unsubscribe, Action handler)
		{
			_unsubscribe = unsubscribe;
			_handler = handler;
			subscribe(handler);
		}

		public void Dispose()
		{
			Action handler = _handler;
			if (handler != null)
			{
				_handler = null;
				_unsubscribe(handler);
			}
		}
	}
	internal enum SyncNowRequestSource
	{
		SaveComplete,
		Manual
	}
	internal sealed record SyncNowFlushResult(string RequestId, SyncNowRequestSource Source);
	internal sealed class SaveCompleteSyncCoordinator
	{
		private readonly object _gate = new object();

		private readonly BridgeCommandFileWriter _writer;

		private readonly Func<DateTimeOffset> _clock;

		private readonly TimeSpan _debounceWindow;

		private DateTimeOffset _nextAllowed = DateTimeOffset.MinValue;

		private string? _pendingRequestId;

		private string? _pendingRequestedAt;

		private string? _pendingSaveFingerprint;

		private SyncNowRequestSource _pendingSource;

		public bool Pending
		{
			get
			{
				lock (_gate)
				{
					return _pendingRequestId != null;
				}
			}
		}

		public SaveCompleteSyncCoordinator(BridgeCommandFileWriter writer, Func<DateTimeOffset> clock, TimeSpan debounceWindow)
		{
			_writer = writer;
			_clock = clock;
			_debounceWindow = debounceWindow;
		}

		public bool HandleSaveComplete(string? activeSaveFingerprint)
		{
			lock (_gate)
			{
				if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint))
				{
					return false;
				}
				DateTimeOffset dateTimeOffset = _clock();
				if (_pendingRequestId != null || dateTimeOffset < _nextAllowed)
				{
					return false;
				}
				SetPending(dateTimeOffset, SyncNowRequestSource.SaveComplete, activeSaveFingerprint);
				return true;
			}
		}

		public bool TryRequestManual(string? activeSaveFingerprint, out string requestId)
		{
			lock (_gate)
			{
				requestId = "";
				if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint))
				{
					return false;
				}
				if (_pendingRequestId != null)
				{
					if (!string.Equals(_pendingSaveFingerprint, activeSaveFingerprint, StringComparison.Ordinal))
					{
						ClearPending();
						return false;
					}
					requestId = _pendingRequestId;
					return true;
				}
				SetPending(_clock(), SyncNowRequestSource.Manual, activeSaveFingerprint);
				requestId = _pendingRequestId;
				return true;
			}
		}

		public bool TryFlush(string? activeSaveFingerprint, out SyncNowFlushResult? result)
		{
			lock (_gate)
			{
				result = null;
				if (_pendingRequestId == null)
				{
					return false;
				}
				if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint) || !string.Equals(_pendingSaveFingerprint, activeSaveFingerprint, StringComparison.Ordinal))
				{
					ClearPending();
					return false;
				}
				string pendingRequestId = _pendingRequestId;
				SyncNowRequestSource pendingSource = _pendingSource;
				var command = new
				{
					command = "syncNow",
					version = 1,
					saveFingerprint = _pendingSaveFingerprint,
					requestId = pendingRequestId,
					requestedAt = _pendingRequestedAt
				};
				if (!_writer.TryWrite(command))
				{
					return false;
				}
				ClearPending();
				_nextAllowed = _clock().Add(_debounceWindow);
				result = new SyncNowFlushResult(pendingRequestId, pendingSource);
				return true;
			}
		}

		private void SetPending(DateTimeOffset now, SyncNowRequestSource source, string saveFingerprint)
		{
			_pendingRequestId = Guid.NewGuid().ToString("N");
			_pendingRequestedAt = now.UtcDateTime.ToString("O", CultureInfo.InvariantCulture);
			_pendingSaveFingerprint = saveFingerprint;
			_pendingSource = source;
		}

		private void ClearPending()
		{
			_pendingRequestId = null;
			_pendingRequestedAt = null;
			_pendingSaveFingerprint = null;
		}
	}
	public sealed class ScheduleINotificationSink : IAdvisorDispatchNotificationSink
	{
		public bool TryShow(string text)
		{
			try
			{
				if (!Singleton<NotificationsManager>.InstanceExists)
				{
					return false;
				}
				Singleton<NotificationsManager>.Instance.SendNotification(text, "", (Sprite)null, 5f, false);
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class ScopedSaveTrackCommand
	{
		internal static object Create(string? activeSaveFingerprint, LocalMix mix, string requestId, DateTimeOffset capturedAt)
		{
			if (!SaveGenerationIdentity.IsV2Fingerprint(activeSaveFingerprint))
			{
				throw new ArgumentException("A validated save generation is required.", "activeSaveFingerprint");
			}
			if (mix == null)
			{
				throw new ArgumentNullException("mix");
			}
			if (!IsSafeRequestId(requestId))
			{
				throw new ArgumentException("The request id is invalid.", "requestId");
			}
			string productId = (string.IsNullOrWhiteSpace(mix.ProductId) ? mix.Name : mix.ProductId);
			string name = (string.IsNullOrWhiteSpace(mix.GameName) ? mix.Name : mix.GameName);
			return new
			{
				command = "saveMix",
				saveFingerprint = activeSaveFingerprint,
				requestId = requestId,
				mix = new
				{
					productId = productId,
					ingredientIds = mix.Ingredients,
					name = name,
					capturedAt = capturedAt.UtcDateTime.ToString("O", CultureInfo.InvariantCulture),
					source = "inGameTile",
					steps = mix.Steps.ConvertAll((LocalMixStep step) => new
					{
						ingredientId = step.IngredientId,
						outputProductId = step.OutputProductId,
						outputEffects = step.OutputEffects
					})
				}
			};
		}

		private static bool IsSafeRequestId(string? requestId)
		{
			if (requestId == null || requestId.Length != 32)
			{
				return false;
			}
			for (int i = 0; i < requestId.Length; i++)
			{
				if (!char.IsLetterOrDigit(requestId[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class ScreenActivityProjection
	{
		internal static ScreenActivityScreen? Project(bool containerVisible, bool isPhoneRecipes, bool isAdvisorDispatches)
		{
			if (containerVisible)
			{
				if (!isPhoneRecipes)
				{
					if (!isAdvisorDispatches)
					{
						return null;
					}
					return ScreenActivityScreen.AdvisorDispatches;
				}
				return ScreenActivityScreen.PhoneRecipes;
			}
			return null;
		}
	}
	internal sealed class ScreenActivityWriter
	{
		internal static readonly TimeSpan KeepaliveInterval = TimeSpan.FromSeconds(15.0);

		private readonly Func<string?> _runtimeSession;

		private readonly Func<string?> _generation;

		private readonly string _path;

		private readonly Action<string, byte[]> _writeAtomic;

		private ScreenActivityScreen? _lastScreen;

		private string? _lastSession;

		private string? _lastGeneration;

		private DateTimeOffset _lastWrite;

		private long _sequence;

		private bool _written;

		internal static string DefaultPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "TVGS", "Schedule I", "HylandHelper", "bridge-screen-activity.json");

		internal string TileInstanceId { get; }

		internal ScreenActivityWriter(Func<string?> runtimeSession, Func<string?> playthroughGeneration, string? path = null, Action<string, byte[]>? writeAtomic = null)
		{
			_runtimeSession = runtimeSession;
			_generation = playthroughGeneration;
			_path = path ?? DefaultPath;
			_writeAtomic = writeAtomic ?? new Action<string, byte[]>(WriteAtomic);
			TileInstanceId = Guid.NewGuid().ToString("N");
		}

		internal void Tick(ScreenActivityScreen? visibleScreen, DateTimeOffset now)
		{
			string text = _runtimeSession();
			string text2 = _generation();
			if (string.IsNullOrWhiteSpace(text) || !SaveGenerationIdentity.IsV2Fingerprint(text2))
			{
				return;
			}
			bool flag = !_written || text != _lastSession || text2 != _lastGeneration;
			bool flag2 = !_written || visibleScreen != _lastScreen;
			bool flag3 = visibleScreen.HasValue && now - _lastWrite >= KeepaliveInterval;
			if (!flag && !flag2 && !flag3)
			{
				return;
			}
			if (flag)
			{
				_sequence = 0L;
			}
			ScreenActivityDocument screenActivityDocument = new ScreenActivityDocument();
			screenActivityDocument.PlaythroughGeneration = text2;
			screenActivityDocument.RuntimeSession = text;
			screenActivityDocument.TileInstanceId = TileInstanceId;
			screenActivityDocument.Sequence = _sequence + 1;
			screenActivityDocument.UpdatedAt = now.UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'");
			ScreenActivityDocument screenActivityDocument2 = screenActivityDocument;
			string reason = (screenActivityDocument2.VisibleScreen = visibleScreen switch
			{
				ScreenActivityScreen.PhoneRecipes => "phoneRecipes", 
				ScreenActivityScreen.AdvisorDispatches => "advisorDispatches", 
				_ => null, 
			});
			if (ScreenActivitySerializer.TrySerialize(screenActivityDocument, out byte[] utf, out reason))
			{
				try
				{
					_writeAtomic(_path, utf);
				}
				catch
				{
					return;
				}
				_sequence++;
				_lastScreen = visibleScreen;
				_lastSession = text;
				_lastGeneration = text2;
				_lastWrite = now;
				_written = true;
			}
		}

		private static void WriteAtomic(string path, byte[] bytes)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
			try
			{
				File.WriteAllBytes(text, bytes);
				File.Move(text, path, overwrite: true);
			}
			finally
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch
				{
				}
			}
		}
	}
	public enum TileChallengeSyncState
	{
		NoCurrentChallenge,
		Echoed,
		Unchanged,
		Withdrawn
	}
	public sealed record TileChallengeSyncResult(TileChallengeSyncState State, string? Challenge, bool HandshakePresent);
	public sealed class TileChallengeHandshakeWriter
	{
		private sealed class HandshakeDocument
		{
			public int version { get; set; }

			public string challenge { get; set; } = "";

			public string tileBuild { get; set; } = "";

			public int protocolVersion { get; set; }
		}

		public const int ProtocolVersion = 1;

		public const int MaxChallengeLength = 128;

		public const int MaxTileBuildLength = 128;

		public const int MaxStatusBytes = 65536;

		public const int MaxHandshakeBytes = 4096;

		private static readonly HashSet<string> ChallengeFields = new HashSet<string>(StringComparer.Ordinal) { "version", "challenge", "protocolVersion" };

		private readonly string _statusPath;

		private readonly string _handshakePath;

		private readonly string _tileBuild;

		private readonly Action<string, string> _replaceFile;

		private readonly Action<string> _deleteFile;

		public TileChallengeHandshakeWriter(string statusPath, string handshakePath, string tileBuild)
			: this(statusPath, handshakePath, tileBuild, null, null)
		{
		}

		internal TileChallengeHandshakeWriter(string statusPath, string handshakePath, string tileBuild, Action<string, string>? replaceFile, Action<string>? deleteFile)
		{
			_statusPath = statusPath;
			_handshakePath = handshakePath;
			_tileBuild = tileBuild;
			_replaceFile = replaceFile ?? ((Action<string, string>)delegate(string source, string destination)
			{
				File.Move(source, destination, overwrite: true);
			});
			_deleteFile = deleteFile ?? new Action<string>(File.Delete);
		}

		public TileChallengeSyncResult Sync()
		{
			if (!IsBounded(_tileBuild, 128))
			{
				return Withdraw();
			}
			if (!File.Exists(_statusPath))
			{
				return Withdraw();
			}
			try
			{
				FileInfo fileInfo = new FileInfo(_statusPath);
				if (fileInfo.Length <= 0 || fileInfo.Length > 65536)
				{
					return Withdraw();
				}
				byte[] array = File.ReadAllBytes(_statusPath);
				if (array.Length == 0 || array.Length > 65536)
				{
					return Withdraw();
				}
				using JsonDocument jsonDocument = JsonDocument.Parse(array);
				if (!TryReadChallenge(jsonDocument.RootElement, out string challenge))
				{
					return Withdraw();
				}
				return Sync(challenge);
			}
			catch
			{
				return Withdraw();
			}
		}

		public TileChallengeSyncResult Sync(string? acceptedChallenge)
		{
			if (!IsBounded(_tileBuild, 128) || !IsBounded(acceptedChallenge, 128))
			{
				return Withdraw();
			}
			try
			{
				byte[] array = JsonSerializer.SerializeToUtf8Bytes(new HandshakeDocument
				{
					version = 1,
					challenge = acceptedChallenge,
					tileBuild = _tileBuild,
					protocolVersion = 1
				});
				if (array.Length > 4096)
				{
					return Withdraw();
				}
				if (File.Exists(_handshakePath) && File.ReadAllBytes(_handshakePath).SequenceEqual(array))
				{
					return new TileChallengeSyncResult(TileChallengeSyncState.Unchanged, acceptedChallenge, HandshakePresent: true);
				}
				if (!TryWriteAtomic(array))
				{
					return new TileChallengeSyncResult(TileChallengeSyncState.Withdrawn, acceptedChallenge, File.Exists(_handshakePath));
				}
				return new TileChallengeSyncResult(TileChallengeSyncState.Echoed, acceptedChallenge, HandshakePresent: true);
			}
			catch
			{
				return Withdraw();
			}
		}

		private static bool TryReadChallenge(JsonElement root, out string challenge)
		{
			challenge = "";
			if (root.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			JsonElement jsonElement = default(JsonElement);
			int num = 0;
			foreach (JsonProperty item in root.EnumerateObject())
			{
				if (string.Equals(item.Name, "tileChallenge", StringComparison.Ordinal))
				{
					jsonElement = item.Value;
					num++;
				}
			}
			if (num != 1 || jsonElement.ValueKind != JsonValueKind.Object)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item2 in jsonElement.EnumerateObject())
			{
				if (!ChallengeFields.Contains(item2.Name) || !hashSet.Add(item2.Name))
				{
					return false;
				}
			}
			if (!hashSet.SetEquals(ChallengeFields) || !jsonElement.TryGetProperty("version", out var value) || value.ValueKind != JsonValueKind.Number || value.GetInt32() != 1 || !jsonElement.TryGetProperty("protocolVersion", out var value2) || value2.ValueKind != JsonValueKind.Number || value2.GetInt32() != 1 || !jsonElement.TryGetProperty("challenge", out var value3) || value3.ValueKind != JsonValueKind.String)
			{
				return false;
			}
			challenge = value3.GetString() ?? "";
			return IsBounded(challenge, 128);
		}

		private bool TryWriteAtomic(byte[] bytes)
		{
			string text = null;
			try
			{
				string directoryName = Path.GetDirectoryName(_handshakePath);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				text = $"{_handshakePath}.{Guid.NewGuid():N}.tmp";
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(bytes, 0, bytes.Length);
					fileStream.Flush(flushToDisk: true);
				}
				_replaceFile(text, _handshakePath);
				text = null;
				return true;
			}
			catch
			{
				return false;
			}
			finally
			{
				if (!string.IsNullOrEmpty(text))
				{
					try
					{
						File.Delete(text);
					}
					catch
					{
					}
				}
			}
		}

		private TileChallengeSyncResult Withdraw()
		{
			try
			{
				if (File.Exists(_handshakePath))
				{
					_deleteFile(_handshakePath);
				}
			}
			catch
			{
			}
			return new TileChallengeSyncResult(File.Exists(_statusPath) ? TileChallengeSyncState.Withdrawn : TileChallengeSyncState.NoCurrentChallenge, null, File.Exists(_handshakePath));
		}

		private static bool IsBounded(string? value, int maxLength)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value.Length <= maxLength;
			}
			return false;
		}
	}
	public static class UnlinkAvailability
	{
		public static bool IsAvailable(BridgeStatus status)
		{
			if (status.CanUnlink.HasValue)
			{
				return status.CanUnlink.Value;
			}
			if (!string.IsNullOrEmpty(status.PairingCode))
			{
				return false;
			}
			string text = status.Status ?? "";
			if (!text.Contains("synced", StringComparison.OrdinalIgnoreCase))
			{
				return text.Contains("Paired", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
}