using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Forteca_ServerRewards;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using fastJSON;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("304AA6D2-0783-4A5A-B05B-87001CDAF792")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyProduct("Forteca_ServerRewards")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Forteca_ServerRewards")]
[assembly: AssemblyCompany("")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 ServerSync
{
	[PublicAPI]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> list = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							SendAdmin(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
							SendAdmin(list, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ISocket
			{
				public volatile bool finished;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsServer())
				{
					BufferingSocket value = new BufferingSocket(rpc.GetSocket());
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (val != null && (int)ZNet.m_onlineBackend != 0)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
					}
					if (__state == null)
					{
						__state = new Dictionary<Assembly, BufferingSocket>();
					}
					__state[Assembly.GetExecutingAssembly()] = value;
				}
			}

			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(ZNetPeer), "m_socket");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(ZPlayFabSocket), "m_remotePlayerId");
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Isinst, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null)
				});
				if (val.IsInvalid)
				{
					return instructions;
				}
				val.SetAndAdvance(OpCodes.Ldstr, (object)"none");
				val.SetOpcodeAndAdvance(OpCodes.Nop);
				val.SetOpcodeAndAdvance(OpCodes.Nop);
				val.SetOpcodeAndAdvance(OpCodes.Nop);
				return val.InstructionEnumeration();
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					//IL_008b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0091: Expected O, but got Unknown
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> list = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							list.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						list.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)methodInfo == null) ? ((object)val.Contains(rpc.GetSocket().GetHostName())) : methodInfo.Invoke(ZNet.instance, new object[2]
							{
								val,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, list, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool flag2;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0051;
					}
					flag2 = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					flag2 = flag == true;
				}
				if (flag2)
				{
					return !lockExempt;
				}
				goto IL_0051;
				IL_0051:
				return false;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin
		{
			get
			{
				if (!lockExempt)
				{
					return isSourceOfTruth;
				}
				return true;
			}
		}

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			CustomSyncedValueBase customSyncedValueBase = customValue;
			customSyncedValueBase.ValueChanged = (Action)Delegate.Combine(customSyncedValueBase.ValueChanged, (Action)delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			});
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					MemoryStream stream = new MemoryStream(package.ReadByteArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			if (!configSync.IsSourceOfTruth && config.SynchronizedConfig && config.LocalBaseValue != null)
			{
				if (!configSync.IsLocked)
				{
					if (config == configSync.lockedConfig)
					{
						return lockExempt;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage val = new ZPackage();
						val.Write((byte)2);
						val.Write(packageIdentifier);
						val.Write(fragment);
						val.Write(fragments);
						val.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(val);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { 5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!ValheimCompat.Exists((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = ValheimCompat.GetPeers();
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!ValheimCompat.Exists((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] array = package.GetArray();
			if (array != null && array.LongLength > 10000)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)4);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
				{
					deflateStream.Write(array, 0, array.Length);
				}
				val.Write(memoryStream.ToArray());
				package = val;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if ((Object)(object)instance != (Object)null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if ((Object)(object)instance != (Object)null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write(partial ? ((byte)1) : ((byte)0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public void Update()
		{
			ValueChanged?.Invoke();
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public Action? ValueChanged;

		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				ValueChanged?.Invoke();
			}
		}

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				string text = minimumRequiredVersion;
				if (text == null)
				{
					if (!ModRequired)
					{
						return "0.0.0";
					}
					text = CurrentVersion;
				}
				return text;
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool num = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return num && flag;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			if (!(new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)))
			{
				return DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".";
			}
			return DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".";
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			if (rpc != null)
			{
				return ErrorServer(rpc);
			}
			return ErrorClient();
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			ValheimCompat.SetZNetConnectionStatus(3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Debug.LogWarning((object)array2[i].Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace fastJSON
{
	internal class DataMemberAttribute : Attribute
	{
		public string Name { get; set; }
	}
	internal sealed class DatasetSchema
	{
		public List<string> Info;

		public string Name;
	}
	internal class deserializer
	{
		private JSONParameters _params;

		private bool _usingglobals;

		private Dictionary<object, int> _circobj;

		private Dictionary<int, object> _cirrev = new Dictionary<int, object>();

		public deserializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_circobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_circobj = new Dictionary<object, int>();
			}
			param.FixValues();
			_params = param.MakeCopy();
		}

		public T ToObject<T>(string json)
		{
			Type typeFromHandle = typeof(T);
			object obj = ToObject(json, typeFromHandle);
			if (typeFromHandle.IsArray)
			{
				if ((obj as ICollection).Count == 0)
				{
					return (T)(object)Array.CreateInstance(typeFromHandle.GetElementType(), 0);
				}
				return (T)obj;
			}
			return (T)obj;
		}

		public object ToObject(string json)
		{
			return ToObject(json, null);
		}

		public object ToObject(string json, Type type)
		{
			Type type2 = null;
			if (type != null && type.IsGenericType)
			{
				type2 = Reflection.Instance.GetGenericTypeDefinition(type);
			}
			_usingglobals = _params.UsingGlobalTypes;
			if (typeof(IDictionary).IsAssignableFrom(type2) || typeof(List<>).IsAssignableFrom(type2))
			{
				_usingglobals = false;
			}
			object obj = new JsonParser(json, _params.AllowNonQuotedKeys).Decode(type);
			if (obj == null)
			{
				return null;
			}
			if (obj is IDictionary)
			{
				if (type != null && typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				return ParseDictionary(obj as Dictionary<string, object>, null, type, null);
			}
			if (obj is List<object>)
			{
				if (!(type != null))
				{
					List<object> list = (List<object>)obj;
					if (list.Count > 0 && list[0].GetType() == typeof(Dictionary<string, object>))
					{
						Dictionary<string, object> globaltypes = new Dictionary<string, object>();
						List<object> list2 = new List<object>();
						{
							foreach (object item in list)
							{
								list2.Add(ParseDictionary((Dictionary<string, object>)item, globaltypes, null, null));
							}
							return list2;
						}
					}
					return list.ToArray();
				}
				if (typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				if (type2 == typeof(List<>))
				{
					return RootList(obj, type);
				}
				if (type.IsArray)
				{
					return RootArray(obj, type);
				}
				if (type == typeof(Hashtable))
				{
					return RootHashTable((List<object>)obj);
				}
			}
			else if (type != null && obj.GetType() != type)
			{
				return ChangeType(obj, type);
			}
			return obj;
		}

		private object RootHashTable(List<object> o)
		{
			Hashtable hashtable = new Hashtable();
			foreach (Dictionary<string, object> item in o)
			{
				object obj2 = item["k"];
				object obj3 = item["v"];
				if (obj2 is Dictionary<string, object>)
				{
					obj2 = ParseDictionary((Dictionary<string, object>)obj2, null, typeof(object), null);
				}
				if (obj3 is Dictionary<string, object>)
				{
					obj3 = ParseDictionary((Dictionary<string, object>)obj3, null, typeof(object), null);
				}
				hashtable.Add(obj2, obj3);
			}
			return hashtable;
		}

		private object ChangeType(object value, Type conversionType)
		{
			if (conversionType == typeof(object))
			{
				return value;
			}
			if (conversionType == typeof(int))
			{
				if (!(value is string text))
				{
					return (int)(long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateInteger(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(long))
			{
				if (!(value is string text2))
				{
					return (long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateLong(text2, 0, text2.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(string))
			{
				return (string)value;
			}
			if (conversionType.IsEnum)
			{
				return Helper.CreateEnum(conversionType, value);
			}
			if (conversionType == typeof(DateTime))
			{
				return Helper.CreateDateTime((string)value, _params.UseUTCDateTime);
			}
			if (conversionType == typeof(DateTimeOffset))
			{
				return Helper.CreateDateTimeOffset((string)value);
			}
			if (Reflection.Instance.IsTypeRegistered(conversionType))
			{
				return Reflection.Instance.CreateCustom((string)value, conversionType);
			}
			if (Helper.IsNullable(conversionType))
			{
				if (value == null)
				{
					return value;
				}
				conversionType = Helper.UnderlyingTypeOf(conversionType);
			}
			if (conversionType == typeof(Guid))
			{
				return Helper.CreateGuid((string)value);
			}
			if (conversionType == typeof(byte[]))
			{
				return Convert.FromBase64String((string)value);
			}
			if (conversionType == typeof(TimeSpan))
			{
				return new TimeSpan((long)value);
			}
			return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
		}

		private object RootList(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			IList list = (IList)Reflection.Instance.FastCreateList(type, ((IList)parse).Count);
			DoParseList((IList)parse, genericArguments[0], list);
			return list;
		}

		private void DoParseList(IList parse, Type it, IList o)
		{
			Dictionary<string, object> globaltypes = new Dictionary<string, object>();
			foreach (object item in parse)
			{
				_usingglobals = false;
				object obj = item;
				obj = ((!(item is Dictionary<string, object> d)) ? ChangeType(item, it) : ParseDictionary(d, globaltypes, it, null));
				o.Add(obj);
			}
		}

		private object RootArray(object parse, Type type)
		{
			Type elementType = type.GetElementType();
			IList list = (IList)Reflection.Instance.FastCreateInstance(typeof(List<>).MakeGenericType(elementType));
			DoParseList((IList)parse, elementType, list);
			Array array = Array.CreateInstance(elementType, list.Count);
			list.CopyTo(array, 0);
			return array;
		}

		private object RootDictionary(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			Type type2 = null;
			Type type3 = null;
			bool flag = false;
			if (genericArguments != null)
			{
				type2 = genericArguments[0];
				type3 = genericArguments[1];
				if (type3 != null)
				{
					flag = type3.Name.StartsWith("Dictionary");
				}
			}
			Type elementType = type3.GetElementType();
			if (parse is Dictionary<string, object>)
			{
				IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(type);
				{
					foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)parse)
					{
						object key = ChangeType(item.Key, type2);
						object value = ((!flag) ? ((!(item.Value is Dictionary<string, object>)) ? ((type3.IsArray && type3 != typeof(byte[])) ? CreateArray((List<object>)item.Value, type3, elementType, null) : ((!(item.Value is IList)) ? ChangeType(item.Value, type3) : CreateGenericList((List<object>)item.Value, type3, type2, null))) : ParseDictionary(item.Value as Dictionary<string, object>, null, type3, null)) : RootDictionary(item.Value, type3));
						dictionary.Add(key, value);
					}
					return dictionary;
				}
			}
			if (parse is List<object>)
			{
				return CreateDictionary(parse as List<object>, type, genericArguments, null);
			}
			return null;
		}

		internal object ParseDictionary(Dictionary<string, object> d, Dictionary<string, object> globaltypes, Type type, object input)
		{
			object value = "";
			if (type == typeof(NameValueCollection))
			{
				return Helper.CreateNV(d);
			}
			if (type == typeof(StringDictionary))
			{
				return Helper.CreateSD(d);
			}
			if (d.TryGetValue("$i", out value))
			{
				object value2 = null;
				_cirrev.TryGetValue((int)(long)value, out value2);
				return value2;
			}
			if (d.TryGetValue("$types", out value))
			{
				_usingglobals = true;
				if (globaltypes == null)
				{
					globaltypes = new Dictionary<string, object>();
				}
				foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)value)
				{
					globaltypes.Add((string)item.Value, item.Key);
				}
			}
			if (globaltypes != null)
			{
				_usingglobals = true;
			}
			bool flag = d.TryGetValue("$type", out value);
			if (!flag && type == typeof(object))
			{
				return d;
			}
			if (flag)
			{
				if (_usingglobals)
				{
					object value3 = "";
					if (globaltypes != null && globaltypes.TryGetValue((string)value, out value3))
					{
						value = value3;
					}
				}
				type = Reflection.Instance.GetTypeFromCache((string)value, _params.BadListTypeChecking);
			}
			if (type == null)
			{
				throw new Exception("Cannot determine type : " + value);
			}
			string fullName = type.FullName;
			object obj = input;
			if (obj == null)
			{
				obj = ((!_params.ParametricConstructorOverride) ? Reflection.Instance.FastCreateInstance(type) : FormatterServices.GetUninitializedObject(type));
			}
			int value4 = 0;
			if (!_circobj.TryGetValue(obj, out value4))
			{
				value4 = _circobj.Count + 1;
				_circobj.Add(obj, value4);
				_cirrev.Add(value4, obj);
			}
			Dictionary<string, myPropInfo> dictionary = Reflection.Instance.Getproperties(type, fullName, _params.ShowReadOnlyProperties);
			foreach (KeyValuePair<string, object> item2 in d)
			{
				string key = item2.Key;
				object value5 = item2.Value;
				string text = key;
				if (text == "$map")
				{
					ProcessMap(obj, dictionary, (Dictionary<string, object>)d[text]);
				}
				else
				{
					if ((!dictionary.TryGetValue(text, out var value6) && !dictionary.TryGetValue(text.ToLowerInvariant(), out value6)) || !value6.CanWrite)
					{
						continue;
					}
					object value7 = null;
					if (value5 != null)
					{
						switch (value6.Type)
						{
						case myPropInfoType.Int:
							value7 = (int)Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.Long:
							value7 = Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.String:
							value7 = value5.ToString();
							break;
						case myPropInfoType.Bool:
							value7 = Helper.BoolConv(value5);
							break;
						case myPropInfoType.DateTime:
							value7 = Helper.CreateDateTime((string)value5, _params.UseUTCDateTime);
							break;
						case myPropInfoType.Enum:
							value7 = Helper.CreateEnum(value6.pt, value5);
							break;
						case myPropInfoType.Guid:
							value7 = Helper.CreateGuid((string)value5);
							break;
						case myPropInfoType.Array:
							if (!value6.IsValueType)
							{
								value7 = CreateArray((List<object>)value5, value6.pt, value6.bt, globaltypes);
							}
							break;
						case myPropInfoType.ByteArray:
							value7 = Convert.FromBase64String((string)value5);
							break;
						case myPropInfoType.Dictionary:
							value7 = CreateDictionary((List<object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.StringKeyDictionary:
							value7 = CreateStringKeyDictionary((Dictionary<string, object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.NameValue:
							value7 = Helper.CreateNV((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.StringDictionary:
							value7 = Helper.CreateSD((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.Custom:
							value7 = Reflection.Instance.CreateCustom((string)value5, value6.pt);
							break;
						default:
							value7 = ((value6.IsGenericType && !value6.IsValueType && value5 is List<object>) ? CreateGenericList((List<object>)value5, value6.pt, value6.bt, globaltypes) : (((value6.IsClass || value6.IsStruct || value6.IsInterface) && value5 is Dictionary<string, object>) ? ParseDictionary((Dictionary<string, object>)value5, globaltypes, value6.pt, null) : ((value5 is List<object>) ? CreateArray((List<object>)value5, value6.pt, typeof(object), globaltypes) : ((!value6.IsValueType) ? value5 : ChangeType(value5, value6.changeType)))));
							break;
						}
					}
					obj = value6.setter(obj, value7);
				}
			}
			return obj;
		}

		private static void ProcessMap(object obj, Dictionary<string, myPropInfo> props, Dictionary<string, object> dic)
		{
			foreach (KeyValuePair<string, object> item in dic)
			{
				myPropInfo myPropInfo2 = props[item.Key];
				object obj2 = myPropInfo2.getter(obj);
				if (Reflection.Instance.GetTypeFromCache((string)item.Value, badlistChecking: true) == typeof(Guid))
				{
					myPropInfo2.setter(obj, Helper.CreateGuid((string)obj2));
				}
			}
		}

		private object CreateArray(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (bt == null)
			{
				bt = typeof(object);
			}
			Array array = Array.CreateInstance(bt, data.Count);
			Type elementType = bt.GetElementType();
			for (int i = 0; i < data.Count; i++)
			{
				object obj = data[i];
				if (obj != null)
				{
					if (obj is IDictionary)
					{
						array.SetValue(ParseDictionary((Dictionary<string, object>)obj, globalTypes, bt, null), i);
					}
					else if (obj is ICollection)
					{
						array.SetValue(CreateArray((List<object>)obj, bt, elementType, globalTypes), i);
					}
					else
					{
						array.SetValue(ChangeType(obj, bt), i);
					}
				}
			}
			return array;
		}

		private object CreateGenericList(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (pt != typeof(object))
			{
				IList list = (IList)Reflection.Instance.FastCreateList(pt, data.Count);
				Type type = Reflection.Instance.GetGenericArguments(pt)[0];
				{
					foreach (object datum in data)
					{
						if (datum is IDictionary)
						{
							list.Add(ParseDictionary((Dictionary<string, object>)datum, globalTypes, type, null));
						}
						else if (datum is List<object>)
						{
							if (bt.IsGenericType)
							{
								list.Add((List<object>)datum);
							}
							else
							{
								list.Add(((List<object>)datum).ToArray());
							}
						}
						else
						{
							list.Add(ChangeType(datum, type));
						}
					}
					return list;
				}
			}
			return data;
		}

		private object CreateStringKeyDictionary(Dictionary<string, object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			if (types != null)
			{
				type2 = types[1];
			}
			Type bt = null;
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
			if (genericArguments.Length != 0)
			{
				bt = genericArguments[0];
			}
			type = type2.GetElementType();
			foreach (KeyValuePair<string, object> item in reader)
			{
				string key = item.Key;
				object obj = null;
				obj = ((!(item.Value is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? ((!(item.Value is Array)) ? CreateArray((List<object>)item.Value, type2, type, globalTypes) : item.Value) : ((!(item.Value is IList)) ? ChangeType(item.Value, type2) : CreateGenericList((List<object>)item.Value, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)item.Value, globalTypes, type2, null));
				dictionary.Add(key, obj);
			}
			return dictionary;
		}

		private object CreateDictionary(List<object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			Type bt = null;
			if (types != null)
			{
				type = types[0];
				type2 = types[1];
			}
			Type bt2 = type2;
			if (type2 != null)
			{
				Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
				if (genericArguments.Length != 0)
				{
					bt = genericArguments[0];
				}
				bt2 = type2.GetElementType();
			}
			bool flag = typeof(IDictionary).IsAssignableFrom(type2);
			foreach (Dictionary<string, object> item in reader)
			{
				object obj2 = item["k"];
				object obj3 = item["v"];
				obj2 = ((!(obj2 is Dictionary<string, object>)) ? ChangeType(obj2, type) : ParseDictionary((Dictionary<string, object>)obj2, globalTypes, type, null));
				obj3 = ((!flag) ? ((!(obj3 is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? CreateArray((List<object>)obj3, type2, bt2, globalTypes) : ((!(obj3 is IList)) ? ChangeType(obj3, type2) : CreateGenericList((List<object>)obj3, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)obj3, globalTypes, type2, null)) : RootDictionary(obj3, type2));
				dictionary.Add(obj2, obj3);
			}
			return dictionary;
		}
	}
	internal class DynamicJson : DynamicObject, IEnumerable
	{
		private IDictionary<string, object> _dictionary { get; set; }

		private List<object> _list { get; set; }

		public DynamicJson(string json)
		{
			object obj = JSON.Parse(json);
			if (obj is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)obj;
			}
			else
			{
				_list = (List<object>)obj;
			}
		}

		private DynamicJson(object dictionary)
		{
			if (dictionary is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)dictionary;
			}
		}

		public override IEnumerable<string> GetDynamicMemberNames()
		{
			return _dictionary.Keys.ToList();
		}

		public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
		{
			object obj = indexes[0];
			if (obj is int)
			{
				result = _list[(int)obj];
			}
			else
			{
				result = _dictionary[(string)obj];
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			return true;
		}

		public override bool TryGetMember(GetMemberBinder binder, out object result)
		{
			if (!_dictionary.TryGetValue(binder.Name, out result) && !_dictionary.TryGetValue(binder.Name.ToLowerInvariant(), out result))
			{
				return false;
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			else if (result is List<object>)
			{
				List<object> list = new List<object>();
				foreach (object item in (List<object>)result)
				{
					if (item is IDictionary<string, object>)
					{
						list.Add(new DynamicJson(item as IDictionary<string, object>));
					}
					else
					{
						list.Add(item);
					}
				}
				result = list;
			}
			return _dictionary.ContainsKey(binder.Name);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			foreach (object item in _list)
			{
				yield return new DynamicJson(item as IDictionary<string, object>);
			}
		}
	}
	internal static class Formatter
	{
		private static void AppendIndent(StringBuilder sb, int count, string indent)
		{
			while (count > 0)
			{
				sb.Append(indent);
				count--;
			}
		}

		public static string PrettyPrint(string input)
		{
			return PrettyPrint(input, new string(' ', JSON.Parameters.FormatterIndentSpaces));
		}

		public static string PrettyPrint(string input, string spaces)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int length = input.Length;
			char[] array = input.ToCharArray();
			for (int i = 0; i < length; i++)
			{
				char c = array[i];
				if (c == '"')
				{
					bool flag = true;
					while (flag)
					{
						stringBuilder.Append(c);
						c = array[++i];
						switch (c)
						{
						case '\\':
							stringBuilder.Append(c);
							c = array[++i];
							break;
						case '"':
							flag = false;
							break;
						}
					}
				}
				switch (c)
				{
				case '[':
				case '{':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, ++num, spaces);
					break;
				case ']':
				case '}':
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, --num, spaces);
					stringBuilder.Append(c);
					break;
				case ',':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, num, spaces);
					break;
				case ':':
					stringBuilder.Append(" : ");
					break;
				default:
					if (!char.IsWhiteSpace(c))
					{
						stringBuilder.Append(c);
					}
					break;
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal struct Getters
	{
		public string Name;

		public string lcName;

		public string memberName;

		public Reflection.GenericGetter Getter;

		public bool ReadOnly;
	}
	internal class Helper
	{
		public static bool IsNullable(Type t)
		{
			if (!t.IsGenericType)
			{
				return false;
			}
			return t.GetGenericTypeDefinition().Equals(typeof(Nullable<>));
		}

		public static Type UnderlyingTypeOf(Type t)
		{
			return Reflection.Instance.GetGenericArguments(t)[0];
		}

		public static DateTimeOffset CreateDateTimeOffset(int year, int month, int day, int hour, int min, int sec, int milli, int extraTicks, TimeSpan offset)
		{
			DateTimeOffset dateTimeOffset = new DateTimeOffset(year, month, day, hour, min, sec, milli, offset);
			if (extraTicks > 0)
			{
				return dateTimeOffset + TimeSpan.FromTicks(extraTicks);
			}
			return dateTimeOffset;
		}

		public static bool BoolConv(object v)
		{
			bool result = false;
			if (v is bool)
			{
				result = (bool)v;
			}
			else if (v is long)
			{
				result = (long)v > 0;
			}
			else if (v is string)
			{
				switch (((string)v).ToLowerInvariant())
				{
				case "1":
				case "true":
				case "yes":
				case "on":
					result = true;
					break;
				}
			}
			return result;
		}

		public static long AutoConv(object value, JSONParameters param)
		{
			if (value is string)
			{
				if (param.AutoConvertStringToNumbers)
				{
					string text = (string)value;
					return CreateLong(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (value is long)
			{
				return (long)value;
			}
			return Convert.ToInt64(value);
		}

		public unsafe static long CreateLong(string s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static long CreateLong(char[] s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static int CreateInteger(string s, int index, int count)
		{
			int num = 0;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public static object CreateEnum(Type pt, object v)
		{
			return Enum.Parse(pt, v.ToString(), ignoreCase: true);
		}

		public static Guid CreateGuid(string s)
		{
			if (s.Length > 30)
			{
				return new Guid(s);
			}
			return new Guid(Convert.FromBase64String(s));
		}

		public static StringDictionary CreateSD(Dictionary<string, object> d)
		{
			StringDictionary stringDictionary = new StringDictionary();
			foreach (KeyValuePair<string, object> item in d)
			{
				stringDictionary.Add(item.Key, (string)item.Value);
			}
			return stringDictionary;
		}

		public static NameValueCollection CreateNV(Dictionary<string, object> d)
		{
			NameValueCollection nameValueCollection = new NameValueCollection();
			foreach (KeyValuePair<string, object> item in d)
			{
				nameValueCollection.Add(item.Key, (string)item.Value);
			}
			return nameValueCollection;
		}

		public static object CreateDateTimeOffset(string value)
		{
			int milli = 0;
			int extraTicks = 0;
			int num = 0;
			int num2 = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int min = CreateInteger(value, 14, 2);
			int sec = CreateInteger(value, 17, 2);
			int num3 = 20;
			if (value.Length > 21 && value[19] == '.')
			{
				milli = CreateInteger(value, num3, 3);
				num3 = 23;
				if (value.Length > 25 && char.IsDigit(value[num3]))
				{
					extraTicks = CreateInteger(value, num3, 4);
					num3 = 27;
				}
			}
			if (value[num3] == 'Z')
			{
				return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, TimeSpan.Zero);
			}
			if (value[num3] == ' ')
			{
				num3++;
			}
			num = CreateInteger(value, num3 + 1, 2);
			num2 = CreateInteger(value, num3 + 1 + 2 + 1, 2);
			if (value[num3] == '-')
			{
				num = -num;
			}
			return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, new TimeSpan(num, num2, 0));
		}

		public static DateTime CreateDateTime(string value, bool UseUTCDateTime)
		{
			if (value.Length < 19)
			{
				return DateTime.MinValue;
			}
			bool flag = false;
			int millisecond = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int minute = CreateInteger(value, 14, 2);
			int second = CreateInteger(value, 17, 2);
			if (value.Length > 21 && value[19] == '.')
			{
				millisecond = CreateInteger(value, 20, 3);
			}
			if (value[value.Length - 1] == 'Z')
			{
				flag = true;
			}
			if (!UseUTCDateTime && !flag)
			{
				return new DateTime(year, month, day, hour, minute, second, millisecond);
			}
			return new DateTime(year, month, day, hour, minute, second, millisecond, DateTimeKind.Utc).ToLocalTime();
		}
	}
	internal static class JSON
	{
		public static JSONParameters Parameters = new JSONParameters();

		public static string ToNiceJSON(object obj)
		{
			return Beautify(ToJSON(obj, Parameters));
		}

		public static string ToNiceJSON(object obj, JSONParameters param)
		{
			return Beautify(ToJSON(obj, param), param.FormatterIndentSpaces);
		}

		public static string ToJSON(object obj)
		{
			return ToJSON(obj, Parameters);
		}

		public static string ToJSON(object obj, JSONParameters param)
		{
			param.FixValues();
			param = param.MakeCopy();
			Type c = null;
			if (obj == null)
			{
				return "null";
			}
			if (obj.GetType().IsGenericType)
			{
				c = Reflection.Instance.GetGenericTypeDefinition(obj.GetType());
			}
			if (typeof(IDictionary).IsAssignableFrom(c) || typeof(List<>).IsAssignableFrom(c))
			{
				param.UsingGlobalTypes = false;
			}
			if (param.EnableAnonymousTypes)
			{
				param.UseExtensions = false;
				param.UsingGlobalTypes = false;
			}
			return new JSONSerializer(param).ConvertToJSON(obj);
		}

		public static object Parse(string json)
		{
			return new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(null);
		}

		public static dynamic ToDynamic(string json)
		{
			return new DynamicJson(json);
		}

		public static T ToObject<T>(string json)
		{
			return new deserializer(Parameters).ToObject<T>(json);
		}

		public static T ToObject<T>(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject<T>(json);
		}

		public static object ToObject(string json)
		{
			return new deserializer(Parameters).ToObject(json, null);
		}

		public static object ToObject(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject(json, null);
		}

		public static object ToObject(string json, Type type)
		{
			return new deserializer(Parameters).ToObject(json, type);
		}

		public static object ToObject(string json, Type type, JSONParameters par)
		{
			return new deserializer(par).ToObject(json, type);
		}

		public static object FillObject(object input, string json)
		{
			if (!(new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(input.GetType()) is Dictionary<string, object> d))
			{
				return null;
			}
			return new deserializer(Parameters).ParseDictionary(d, null, input.GetType(), input);
		}

		public static object DeepCopy(object obj)
		{
			return new deserializer(Parameters).ToObject(ToJSON(obj));
		}

		public static T DeepCopy<T>(T obj)
		{
			return new deserializer(Parameters).ToObject<T>(ToJSON(obj));
		}

		public static string Beautify(string input)
		{
			string spaces = new string(' ', Parameters.FormatterIndentSpaces);
			return Formatter.PrettyPrint(input, spaces);
		}

		public static string Beautify(string input, byte spaces)
		{
			string spaces2 = new string(' ', spaces);
			return Formatter.PrettyPrint(input, spaces2);
		}

		public static void RegisterCustomType(Type type, Reflection.Serialize serializer, Reflection.Deserialize deserializer)
		{
			Reflection.Instance.RegisterCustomType(type, serializer, deserializer);
		}

		public static void ClearReflectionCache()
		{
			Reflection.Instance.ClearReflectionCache();
		}
	}
	internal sealed class JSONParameters
	{
		public bool UseOptimizedDatasetSchema = true;

		public bool UseFastGuid = true;

		public bool SerializeNullValues = true;

		public bool UseUTCDateTime = true;

		public bool ShowReadOnlyProperties;

		public bool UsingGlobalTypes = true;

		[Obsolete("Not needed anymore and will always match")]
		public bool IgnoreCaseOnDeserialize;

		public bool EnableAnonymousTypes;

		public bool UseExtensions = true;

		public bool UseEscapedUnicode = true;

		public bool KVStyleStringDictionary;

		public bool UseValuesOfEnums;

		public List<Type> IgnoreAttributes = new List<Type>
		{
			typeof(XmlIgnoreAttribute),
			typeof(NonSerializedAttribute)
		};

		public bool ParametricConstructorOverride;

		public bool DateTimeMilliseconds;

		public byte SerializerMaxDepth = 20;

		public bool InlineCircularReferences;

		public bool SerializeToLowerCaseNames;

		public byte FormatterIndentSpaces = 3;

		public bool AllowNonQuotedKeys;

		public bool AutoConvertStringToNumbers = true;

		public bool OverrideObjectHashCodeChecking;

		[Obsolete("Racist term removed, please use BadListTypeChecking")]
		public bool BlackListTypeChecking = true;

		public bool BadListTypeChecking = true;

		public bool FullyQualifiedDataSetSchema;

		public void FixValues()
		{
			if (!UseExtensions)
			{
				UsingGlobalTypes = false;
				InlineCircularReferences = true;
			}
			if (EnableAnonymousTypes)
			{
				ShowReadOnlyProperties = true;
			}
		}

		public JSONParameters MakeCopy()
		{
			return new JSONParameters
			{
				AllowNonQuotedKeys = AllowNonQuotedKeys,
				DateTimeMilliseconds = DateTimeMilliseconds,
				EnableAnonymousTypes = EnableAnonymousTypes,
				FormatterIndentSpaces = FormatterIndentSpaces,
				IgnoreAttributes = new List<Type>(IgnoreAttributes),
				InlineCircularReferences = InlineCircularReferences,
				KVStyleStringDictionary = KVStyleStringDictionary,
				ParametricConstructorOverride = ParametricConstructorOverride,
				SerializeNullValues = SerializeNullValues,
				SerializerMaxDepth = SerializerMaxDepth,
				SerializeToLowerCaseNames = SerializeToLowerCaseNames,
				ShowReadOnlyProperties = ShowReadOnlyProperties,
				UseEscapedUnicode = UseEscapedUnicode,
				UseExtensions = UseExtensions,
				UseFastGuid = UseFastGuid,
				UseOptimizedDatasetSchema = UseOptimizedDatasetSchema,
				UseUTCDateTime = UseUTCDateTime,
				UseValuesOfEnums = UseValuesOfEnums,
				UsingGlobalTypes = UsingGlobalTypes,
				AutoConvertStringToNumbers = AutoConvertStringToNumbers,
				OverrideObjectHashCodeChecking = OverrideObjectHashCodeChecking,
				FullyQualifiedDataSetSchema = FullyQualifiedDataSetSchema,
				BadListTypeChecking = BadListTypeChecking
			};
		}
	}
	internal sealed class JsonParser
	{
		private enum Token
		{
			None = -1,
			Curly_Open,
			Curly_Close,
			Squared_Open,
			Squared_Close,
			Colon,
			Comma,
			String,
			Number,
			True,
			False,
			Null,
			PosInfinity,
			NegInfinity,
			NaN
		}

		private readonly char[] json;

		private readonly StringBuilder s = new StringBuilder();

		private Token lookAheadToken = Token.None;

		private int index;

		private bool allownonquotedkey;

		private int _len;

		private SafeDictionary<string, bool> _lookup;

		private SafeDictionary<Type, bool> _seen;

		private bool _parseJsonType;

		private bool _parseType;

		internal JsonParser(string json, bool AllowNonQuotedKeys)
		{
			allownonquotedkey = AllowNonQuotedKeys;
			this.json = json.ToCharArray();
			_len = json.Length;
		}

		private void SetupLookup()
		{
			_lookup = new SafeDictionary<string, bool>();
			_seen = new SafeDictionary<Type, bool>();
			_lookup.Add("$types", value: true);
			_lookup.Add("$type", value: true);
			_lookup.Add("$i", value: true);
			_lookup.Add("$map", value: true);
			_lookup.Add("$schema", value: true);
			_lookup.Add("k", value: true);
			_lookup.Add("v", value: true);
		}

		public unsafe object Decode(Type objtype)
		{
			fixed (char* p = json)
			{
				if (objtype != null && !CheckForTypeInJson(p))
				{
					_parseJsonType = true;
					SetupLookup();
					BuildLookup(objtype);
					if (!_parseJsonType || _lookup.Count() == 7)
					{
						_lookup = null;
					}
				}
				return ParseValue(p);
			}
		}

		private unsafe bool CheckForTypeInJson(char* p)
		{
			int i = 0;
			for (int num = ((_len > 1000) ? 1000 : _len); i < num; i++)
			{
				if (p[i] == '$' && p[i + 1] == 't' && p[i + 2] == 'y' && p[i + 3] == 'p' && p[i + 4] == 'e' && p[i + 5] == 's')
				{
					return true;
				}
			}
			return false;
		}

		private void BuildGenericTypeLookup(Type t)
		{
			if (_seen.TryGetValue(t, out var _))
			{
				return;
			}
			Type[] genericArguments = t.GetGenericArguments();
			foreach (Type type in genericArguments)
			{
				if (!type.IsPrimitive)
				{
					bool flag = type.IsValueType && !type.IsEnum;
					if ((type.IsClass || flag || type.IsAbstract) && type != typeof(string) && type != typeof(DateTime) && type != typeof(Guid))
					{
						BuildLookup(type);
					}
				}
			}
		}

		private void BuildArrayTypeLookup(Type t)
		{
			if (!_seen.TryGetValue(t, out var _))
			{
				bool flag = t.IsValueType && !t.IsEnum;
				if ((t.IsClass || flag) && t != typeof(string) && t != typeof(DateTime) && t != typeof(Guid))
				{
					BuildLookup(t.GetElementType());
				}
			}
		}

		private void BuildLookup(Type objtype)
		{
			if (objtype == null || objtype == typeof(NameValueCollection) || objtype == typeof(StringDictionary) || typeof(IDictionary).IsAssignableFrom(objtype) || _seen.TryGetValue(objtype, out var _))
			{
				return;
			}
			if (objtype.IsGenericType)
			{
				BuildGenericTypeLookup(objtype);
				return;
			}
			if (objtype.IsArray)
			{
				BuildArrayTypeLookup(objtype);
				return;
			}
			_seen.Add(objtype, value: true);
			foreach (KeyValuePair<string, myPropInfo> item in Reflection.Instance.Getproperties(objtype, objtype.FullName, ShowReadOnlyProperties: true))
			{
				Type pt = item.Value.pt;
				_lookup.Add(item.Key, value: true);
				if (pt.IsArray)
				{
					BuildArrayTypeLookup(pt);
				}
				if (pt.IsGenericType)
				{
					if (typeof(IDictionary).IsAssignableFrom(pt))
					{
						_parseJsonType = false;
						break;
					}
					BuildGenericTypeLookup(pt);
				}
				if (pt.FullName.IndexOf("System.") == -1)
				{
					BuildLookup(pt);
				}
			}
		}

		private bool InLookup(string name)
		{
			if (_lookup == null)
			{
				return true;
			}
			bool value;
			return _lookup.TryGetValue(name.ToLowerInvariant(), out value);
		}

		private unsafe Dictionary<string, object> ParseObject(char* p)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return dictionary;
				}
				string text = ParseKey(p);
				if (NextToken(p) != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				if (_parseJsonType)
				{
					if (text == "$types")
					{
						_parseType = true;
						Dictionary<string, object> dictionary2 = (Dictionary<string, object>)ParseValue(p);
						_parseType = false;
						if (_lookup == null)
						{
							SetupLookup();
						}
						foreach (string key in dictionary2.Keys)
						{
							BuildLookup(Reflection.Instance.GetTypeFromCache(key, badlistChecking: true));
						}
						dictionary[text] = dictionary2;
					}
					else if (text == "$schema")
					{
						_parseType = true;
						object value = ParseValue(p);
						_parseType = false;
						dictionary[text] = value;
					}
					else if (_parseType || InLookup(text))
					{
						dictionary[text] = ParseValue(p);
					}
					else
					{
						SkipValue(p);
					}
				}
				else
				{
					dictionary[text] = ParseValue(p);
				}
			}
		}

		private unsafe void SkipValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				ParseNumber(p, skip: true);
				break;
			case Token.String:
				SkipString(p);
				break;
			case Token.Curly_Open:
				SkipObject(p);
				break;
			case Token.Squared_Open:
				SkipArray(p);
				break;
			case Token.True:
			case Token.False:
			case Token.Null:
			case Token.PosInfinity:
			case Token.NegInfinity:
			case Token.NaN:
				ConsumeToken();
				break;
			case Token.Curly_Close:
			case Token.Squared_Close:
			case Token.Colon:
			case Token.Comma:
				break;
			}
		}

		private unsafe void SkipObject(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return;
				}
				SkipString(p);
				if (NextToken(p) != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				SkipValue(p);
			}
		}

		private unsafe void SkipArray(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return;
				default:
					SkipValue(p);
					break;
				}
			}
		}

		private unsafe void SkipString(char* p)
		{
			ConsumeToken();
			int len = _len;
			while (index < len)
			{
				switch (p[index++])
				{
				case '"':
					return;
				case '\\':
					if (p[index++] == 'u')
					{
						index += 4;
					}
					break;
				}
			}
		}

		private unsafe List<object> ParseArray(char* p)
		{
			List<object> list = new List<object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return list;
				default:
					list.Add(ParseValue(p));
					break;
				}
			}
		}

		private unsafe object ParseValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				return ParseNumber(p, skip: false);
			case Token.String:
				return ParseString(p);
			case Token.Curly_Open:
				return ParseObject(p);
			case Token.Squared_Open:
				return ParseArray(p);
			case Token.True:
				ConsumeToken();
				return true;
			case Token.False:
				ConsumeToken();
				return false;
			case Token.Null:
				ConsumeToken();
				return null;
			case Token.PosInfinity:
				ConsumeToken();
				return double.PositiveInfinity;
			case Token.NegInfinity:
				ConsumeToken();
				return double.NegativeInfinity;
			case Token.NaN:
				ConsumeToken();
				return double.NaN;
			default:
				throw new Exception("Unrecognized token at index " + index);
			}
		}

		private unsafe string ParseKey(char* p)
		{
			if (!allownonquotedkey || p[index - 1] == '"')
			{
				return ParseString(p);
			}
			ConsumeToken();
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				if (p[index + num++] == ':')
				{
					string result = UnsafeSubstring(p, index, num - 1).Trim();
					index += num - 1;
					return result;
				}
			}
			throw new Exception("Unable to read key");
		}

		private unsafe string ParseString(char* p)
		{
			char c = p[index - 1];
			ConsumeToken();
			if (s.Length > 0)
			{
				s.Length = 0;
			}
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				char c2 = p[index + num++];
				if (c2 == '\\')
				{
					break;
				}
				if (c2 == c)
				{
					string result = UnsafeSubstring(p, index, num - 1);
					index += num;
					return result;
				}
			}
			while (index < len)
			{
				char c3 = p[index++];
				if (c3 == c)
				{
					return s.ToString();
				}
				if (c3 != '\\')
				{
					s.Append(c3);
					continue;
				}
				c3 = p[index++];
				switch (c3)
				{
				case 'b':
					s.Append('\b');
					continue;
				case 'f':
					s.Append('\f');
					continue;
				case 'n':
					s.Append('\n');
					continue;
				case 'r':
					s.Append('\r');
					continue;
				case 't':
					s.Append('\t');
					continue;
				case 'u':
				{
					uint num2 = ParseUnicode(p[index], p[index + 1], p[index + 2], p[index + 3]);
					s.Append((char)num2);
					index += 4;
					continue;
				}
				}
				if (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
				{
					while (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
					{
						index++;
						c3 = p[index];
						if (c3 == '\r' || c3 == '\n')
						{
							c3 = p[index + 1];
							if (c3 == '\r' || c3 == '\n')
							{
								index += 2;
								c3 = p[index];
							}
							break;
						}
					}
				}
				else
				{
					s.Append(c3);
				}
			}
			return s.ToString();
		}

		private unsafe string ParseJson5String(char* p)
		{
			throw new NotImplementedException();
		}

		private uint ParseSingleChar(char c1, uint multipliyer)
		{
			uint result = 0u;
			if (c1 >= '0' && c1 <= '9')
			{
				result = (uint)(c1 - 48) * multipliyer;
			}
			else if (c1 >= 'A' && c1 <= 'F')
			{
				result = (uint)(c1 - 65 + 10) * multipliyer;
			}
			else if (c1 >= 'a' && c1 <= 'f')
			{
				result = (uint)(c1 - 97 + 10) * multipliyer;
			}
			return result;
		}

		private uint ParseUnicode(char c1, char c2, char c3, char c4)
		{
			uint num = ParseSingleChar(c1, 4096u);
			uint num2 = ParseSingleChar(c2, 256u);
			uint num3 = ParseSingleChar(c3, 16u);
			uint num4 = ParseSingleChar(c4, 1u);
			return num + num2 + num3 + num4;
		}

		private unsafe object ParseNumber(char* p, bool skip)
		{
			ConsumeToken();
			int num = index - 1;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = true;
			if (p[num] == '.')
			{
				flag = true;
			}
			while (index != _len)
			{
				switch (p[index])
				{
				case 'X':
				case 'x':
					index++;
					return ReadHexNumber(p);
				case '+':
				case '-':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					break;
				case 'E':
				case 'e':
					flag2 = true;
					index++;
					break;
				case '.':
					index++;
					flag = true;
					break;
				case 'N':
				case 'n':
					index += 3;
					return double.NaN;
				default:
					flag3 = false;
					break;
				}
				if (index == _len)
				{
					flag3 = false;
				}
				if (!flag3)
				{
					break;
				}
			}
			if (skip)
			{
				return 0;
			}
			int num2 = index - num;
			if (flag2 || num2 > 31)
			{
				return double.Parse(UnsafeSubstring(p, num, num2), NumberFormatInfo.InvariantInfo);
			}
			if (!flag && num2 < 20)
			{
				return Helper.CreateLong(json, num, num2);
			}
			return decimal.Parse(UnsafeSubstring(p, num, num2), NumberFormatInfo.InvariantInfo);
		}

		private unsafe object ReadHexNumber(char* p)
		{
			long num = 0L;
			bool flag = true;
			while (flag && index < _len)
			{
				char c = p[index];
				switch (c)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					num = (num << 4) + (c - 48);
					break;
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					index++;
					num = (num << 4) + (c - 97) + 10;
					break;
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
					index++;
					num = (num << 4) + (c - 65) + 10;
					break;
				default:
					flag = false;
					break;
				}
			}
			return num;
		}

		private unsafe Token LookAhead(char* p)
		{
			if (lookAheadToken != Token.None)
			{
				return lookAheadToken;
			}
			return lookAheadToken = NextTokenCore(p);
		}

		private void ConsumeToken()
		{
			lookAheadToken = Token.None;
		}

		private unsafe Token NextToken(char* p)
		{
			Token result = ((lookAheadToken != Token.None) ? lookAheadToken : NextTokenCore(p));
			lookAheadToken = Token.None;
			return result;
		}

		private unsafe void SkipWhitespace(char* p)
		{
			char c;
			do
			{
				c = p[index];
				if (c == '/' && p[index + 1] == '/')
				{
					index++;
					index++;
					do
					{
						c = p[index];
					}
					while (c != '\r' && c != '\n' && ++index < _len);
				}
				if (c != '/' || p[index + 1] != '*')
				{
					continue;
				}
				index++;
				index++;
				do
				{
					c = p[index];
					if (c == '*' && p[index + 1] == '/')
					{
						index += 2;
						c = p[index];
						break;
					}
				}
				while (++index < _len);
			}
			while ((c == ' ' || c == '\t' || c == '\n' || c == '\r') && ++index < _len);
		}

		private unsafe Token NextTokenCore(char* p)
		{
			int len = _len;
			SkipWhitespace(p);
			if (index == len)
			{
				throw new Exception("Reached end of string unexpectedly");
			}
			char c = p[index];
			index++;
			switch (c)
			{
			case '{':
				return Token.Curly_Open;
			case '}':
				return Token.Curly_Close;
			case '[':
				return Token.Squared_Open;
			case ']':
				return Token.Squared_Close;
			case ',':
				return Token.Comma;
			case '"':
			case '\'':
				return Token.String;
			case '-':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.NegInfinity;
				}
				return Token.Number;
			case '+':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.PosInfinity;
				}
				return Token.Number;
			case '.':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return Token.Number;
			case ':':
				return Token.Colon;
			case 'I':
			case 'i':
				index += 7;
				return Token.PosInfinity;
			case 'f':
				if (len - index >= 4 && p[index] == 'a' && p[index + 1] == 'l' && p[index + 2] == 's' && p[index + 3] == 'e')
				{
					index += 4;
					return Token.False;
				}
				break;
			case 't':
				if (len - index >= 3 && p[index] == 'r' && p[index + 1] == 'u' && p[index + 2] == 'e')
				{
					index += 3;
					return Token.True;
				}
				break;
			case 'N':
			case 'n':
				if (len - index >= 3 && p[index] == 'u' && p[index + 1] == 'l' && p[index + 2] == 'l')
				{
					index += 3;
					return Token.Null;
				}
				if (len - index >= 2 && p[index] == 'a' && (p[index + 1] == 'n' || p[index + 1] == 'N'))
				{
					index += 2;
					return Token.NaN;
				}
				break;
			}
			if (allownonquotedkey)
			{
				index--;
				return Token.String;
			}
			string[] obj = new string[5] { "Could not find token at index ", null, null, null, null };
			obj[1] = (--index).ToString();
			obj[2] = " got '";
			obj[3] = p[index].ToString();
			obj[4] = "'";
			throw new Exception(string.Concat(obj));
		}

		private unsafe static string UnsafeSubstring(char* p, int startIndex, int length)
		{
			return new string(p, startIndex, length);
		}
	}
	internal sealed class JSONSerializer
	{
		private StringBuilder _output = new StringBuilder();

		private int _before;

		private int _MAX_DEPTH = 20;

		private int _current_depth;

		private Dictionary<string, int> _globalTypes = new Dictionary<string, int>();

		private Dictionary<object, int> _cirobj;

		private JSONParameters _params;

		private bool _useEscapedUnicode;

		private bool _TypesWritten;

		internal JSONSerializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_cirobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_cirobj = new Dictionary<object, int>();
			}
			_params = param;
			_useEscapedUnicode = _params.UseEscapedUnicode;
			_MAX_DEPTH = _params.SerializerMaxDepth;
		}

		internal string ConvertToJSON(object obj)
		{
			WriteValue(obj);
			if (_params.UsingGlobalTypes && _globalTypes != null && _globalTypes.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("\"$types\":{");
				bool flag = false;
				foreach (KeyValuePair<string, int> globalType in _globalTypes)
				{
					if (flag)
					{
						stringBuilder.Append(',');
					}
					flag = true;
					stringBuilder.Append('"');
					stringBuilder.Append(globalType.Key);
					stringBuilder.Append("\":\"");
					stringBuilder.Append(globalType.Value);
					stringBuilder.Append('"');
				}
				stringBuilder.Append("},");
				_output.Insert(_before, stringBuilder.ToString());
			}
			return _output.ToString();
		}

		private void WriteValue(object obj)
		{
			if (obj == null || obj is DBNull)
			{
				_output.Append("null");
			}
			else if (obj is string || obj is char)
			{
				WriteString(obj.ToString());
			}
			else if (obj is Guid)
			{
				WriteGuid((Guid)obj);
			}
			else if (obj is bool)
			{
				_output.Append(((bool)obj) ? "true" : "false");
			}
			else if (obj is int || obj is long || obj is decimal || obj is byte || obj is short || obj is sbyte || obj is ushort || obj is uint || obj is ulong)
			{
				_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
			}
			else if (obj is double || obj is double)
			{
				double d = (double)obj;
				if (double.IsNaN(d))
				{
					_output.Append("\"NaN\"");
				}
				else if (double.IsInfinity(d))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is float || obj is float)
			{
				float f = (float)obj;
				if (float.IsNaN(f))
				{
					_output.Append("\"NaN\"");
				}
				else if (float.IsInfinity(f))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is DateTime)
			{
				WriteDateTime((DateTime)obj);
			}
			else if (obj is DateTimeOffset)
			{
				WriteDateTimeOffset((DateTimeOffset)obj);
			}
			else if (obj is TimeSpan)
			{
				_output.Append(((TimeSpan)obj).Ticks);
			}
			else if (!_params.KVStyleStringDictionary && obj is IEnumerable<KeyValuePair<string, object>>)
			{
				WriteStringDictionary((IEnumerable<KeyValuePair<string, object>>)obj);
			}
			else if (!_params.KVStyleStringDictionary && obj is IDictionary && obj.GetType().IsGenericType && Reflection.Instance.GetGenericArguments(obj.GetType())[0] == typeof(string))
			{
				WriteStringDictionary((IDictionary)obj);
			}
			else if (obj is IDictionary)
			{
				WriteDictionary((IDictionary)obj);
			}
			else if (obj is byte[])
			{
				WriteBytes((byte[])obj);
			}
			else if (obj is StringDictionary)
			{
				WriteSD((StringDictionary)obj);
			}
			else if (obj is NameValueCollection)
			{
				WriteNV((NameValueCollection)obj);
			}
			else if (obj is Array)
			{
				WriteArrayRanked((Array)obj);
			}
			else if (obj is IEnumerable)
			{
				WriteArray((IEnumerable)obj);
			}
			else if (obj is Enum)
			{
				WriteEnum((Enum)obj);
			}
			else if (Reflection.Instance.IsTypeRegistered(obj.GetType()))
			{
				WriteCustom(obj);
			}
			else
			{
				WriteObject(obj);
			}
		}

		private void WriteDateTimeOffset(DateTimeOffset d)
		{
			DateTime dt = (_params.UseUTCDateTime ? d.UtcDateTime : d.DateTime);
			write_date_value(dt);
			long num = dt.Ticks % 10000000;
			_output.Append('.');
			_output.Append(num.ToString("0000000", NumberFormatInfo.InvariantInfo));
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			else
			{
				if (d.Offset.Hours > 0)
				{
					_output.Append('+');
				}
				else
				{
					_output.Append('-');
				}
				_output.Append(d.Offset.Hours.ToString("00", NumberFormatInfo.InvariantInfo));
				_output.Append(':');
				_output.Append(d.Offset.Minutes.ToString("00", NumberFormatInfo.InvariantInfo));
			}
			_output.Append('"');
		}

		private void WriteNV(NameValueCollection nameValueCollection)
		{
			_output.Append('{');
			bool flag = false;
			foreach (string item in nameValueCollection)
			{
				if (_params.SerializeNullValues || nameValueCollection[item] != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(item.ToLowerInvariant(), nameValueCollection[item]);
					}
					else
					{
						WritePair(item, nameValueCollection[item]);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteSD(StringDictionary stringDictionary)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in stringDictionary)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteCustom(object obj)
		{
			Reflection.Instance._customSerializer.TryGetValue(obj.GetType(), out var value);
			WriteStringFast(value(obj));
		}

		private void WriteEnum(Enum e)
		{
			if (_params.UseValuesOfEnums)
			{
				WriteValue(Convert.ToInt32(e));
			}
			else
			{
				WriteStringFast(e.ToString());
			}
		}

		private void WriteGuid(Guid g)
		{
			if (!_params.UseFastGuid)
			{
				WriteStringFast(g.ToString());
			}
			else
			{
				WriteBytes(g.ToByteArray());
			}
		}

		private void WriteBytes(byte[] bytes)
		{
			WriteStringFast(Convert.ToBase64String(bytes, 0, bytes.Length, Base64FormattingOptions.None));
		}

		private void WriteDateTime(DateTime dateTime)
		{
			DateTime dt = dateTime;
			if (_params.UseUTCDateTime)
			{
				dt = dateTime.ToUniversalTime();
			}
			write_date_value(dt);
			if (_params.DateTimeMilliseconds)
			{
				_output.Append('.');
				_output.Append(dt.Millisecond.ToString("000", NumberFormatInfo.InvariantInfo));
			}
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			_output.Append('"');
		}

		private void write_date_value(DateTime dt)
		{
			_output.Append('"');
			_output.Append(dt.Year.ToString("0000", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Month.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Day.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('T');
			_output.Append(dt.Hour.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Minute.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Second.ToString("00", NumberFormatInfo.InvariantInfo));
		}

		private void WriteObject(object obj)
		{
			int value = 0;
			if (!_cirobj.TryGetValue(obj, out value))
			{
				_cirobj.Add(obj, _cirobj.Count + 1);
			}
			else if (_current_depth > 0 && !_params.InlineCircularReferences)
			{
				_output.Append("{\"$i\":");
				_output.Append(value.ToString());
				_output.Append('}');
				return;
			}
			if (!_params.UsingGlobalTypes)
			{
				_output.Append('{');
			}
			else if (!_TypesWritten)
			{
				_output.Append('{');
				_before = _output.Length;
			}
			else
			{
				_output.Append('{');
			}
			_TypesWritten = true;
			_current_depth++;
			if (_current_depth > _MAX_DEPTH)
			{
				throw new Exception("Serializer encountered maximum depth of " + _MAX_DEPTH);
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			Type type = obj.GetType();
			bool flag = false;
			if (_params.UseExtensions)
			{
				if (!_params.UsingGlobalTypes)
				{
					WritePairFast("$type", Reflection.Instance.GetTypeAssemblyName(type));
				}
				else
				{
					int value2 = 0;
					string typeAssemblyName = Reflection.Instance.GetTypeAssemblyName(type);
					if (!_globalTypes.TryGetValue(typeAssemblyName, out value2))
					{
						value2 = _globalTypes.Count + 1;
						_globalTypes.Add(typeAssemblyName, value2);
					}
					WritePairFast("$type", value2.ToString());
				}
				flag = true;
			}
			Getters[] getters = Reflection.Instance.GetGetters(type, _params.IgnoreAttributes);
			int num = getters.Length;
			for (int i = 0; i < num; i++)
			{
				Getters getters2 = getters[i];
				if (!_params.ShowReadOnlyProperties && getters2.ReadOnly)
				{
					continue;
				}
				object obj2 = getters2.Getter(obj);
				if (!_params.SerializeNullValues && (obj2 == null || obj2 is DBNull))
				{
					continue;
				}
				if (flag)
				{
					_output.Append(',');
				}
				if (getters2.memberName != null)
				{
					WritePair(getters2.memberName, obj2);
				}
				else if (_params.SerializeToLowerCaseNames)
				{
					WritePair(getters2.lcName, obj2);
				}
				else
				{
					WritePair(getters2.Name, obj2);
				}
				if (obj2 != null && _params.UseExtensions)
				{
					Type type2 = obj2.GetType();
					if (type2 == typeof(object))
					{
						dictionary.Add(getters2.Name, type2.ToString());
					}
				}
				flag = true;
			}
			if (dictionary.Count > 0 && _params.UseExtensions)
			{
				_output.Append(",\"$map\":");
				WriteStringDictionary(dictionary);
			}
			_output.Append('}');
			_current_depth--;
		}

		private void WritePairFast(string name, string value)
		{
			WriteStringFast(name);
			_output.Append(':');
			WriteStringFast(value);
		}

		private void WritePair(string name, object value)
		{
			WriteString(name);
			_output.Append(':');
			WriteValue(value);
		}

		private void WriteArray(IEnumerable array)
		{
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteArrayRanked(Array array)
		{
			if (array.Rank == 1)
			{
				WriteArray(array);
				return;
			}
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringDictionary(IDictionary dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteStringDictionary(IEnumerable<KeyValuePair<string, object>> dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (KeyValuePair<string, object> item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string key = item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(key.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(key, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteDictionary(IDictionary dic)
		{
			_output.Append('[');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (flag)
				{
					_output.Append(',');
				}
				_output.Append('{');
				WritePair("k", item.Key);
				_output.Append(',');
				WritePair("v", item.Value);
				_output.Append('}');
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringFast(string s)
		{
			_output.Append('"');
			_output.Append(s);
			_output.Append('"');
		}

		private void WriteString(string s)
		{
			_output.Append('"');
			int num = -1;
			int length = s.Length;
			for (int i = 0; i < length; i++)
			{
				char c = s[i];
				if (_useEscapedUnicode)
				{
					if (c >= ' ' && c < '\u0080' && c != '"' && c != '\\')
					{
						if (num == -1)
						{
							num = i;
						}
						continue;
					}
				}
				else if (c != '\t' && c != '\n' && c != '\r' && c != '"' && c != '\\' && c != 0)
				{
					if (num == -1)
					{
						num = i;
					}
					continue;
				}
				if (num != -1)
				{
					_output.Append(s, num, i - num);
					num = -1;
				}
				switch (c)
				{
				case '\t':
					_output.Append('\\').Append('t');
					continue;
				case '\r':
					_output.Append('\\').Append('r');
					continue;
				case '\n':
					_output.Append('\\').Append('n');
					continue;
				case '"':
				case '\\':
					_output.Append('\\');
					_output.Append(c);
					continue;
				case '\0':
					_output.Append("\\u0000");
					continue;
				}
				if (_useEscapedUnicode)
				{
					_output.Append("\\u");
					StringBuilder output = _output;
					int num2 = c;
					output.Append(num2.ToString("X4", NumberFormatInfo.InvariantInfo));
				}
				else
				{
					_output.Append(c);
				}
			}
			if (num != -1)
			{
				_output.Append(s, num, s.Length - num);
			}
			_output.Append('"');
		}
	}
	internal class myPropInfo
	{
		public Type pt;

		public Type bt;

		public Type changeType;

		public Reflection.GenericSetter setter;

		public Reflection.GenericGetter getter;

		public Type[] GenericTypes;

		public string Name;

		public string memberName;

		public myPropInfoType Type;

		public bool CanWrite;

		public bool IsClass;

		public bool IsValueType;

		public bool IsGenericType;

		public bool IsStruct;

		public bool IsInterface;
	}
	internal enum myPropInfoType
	{
		Int,
		Long,
		String,
		Bool,
		DateTime,
		Enum,
		Guid,
		Array,
		ByteArray,
		Dictionary,
		StringKeyDictionary,
		NameValue,
		StringDictionary,
		Hashtable,
		DataSet,
		DataTable,
		Custom,
		Unknown
	}
	internal class ReferenceEqualityComparer : IEqualityComparer, IEqualityComparer<object>
	{
		public static ReferenceEqualityComparer Default { get; } = new ReferenceEqualityComparer();

		public new bool Equals(object x, object y)
		{
			return x.Equals(y);
		}

		public int GetHashCode(object obj)
		{
			return RuntimeHelpers.GetHashCode(obj);
		}
	}
	internal sealed class Reflection
	{
		public delegate string Serialize(object data);

		public delegate object Deserialize(string data);

		public delegate object GenericSetter(object target, object value);

		public delegate object GenericGetter(object obj);

		private delegate object CreateObject();

		private delegate object CreateList(int capacity);

		private static readonly Reflection instance;

		public static bool RDBMode;

		private SafeDictionary<Type, string> _tyname = new SafeDictionary<Type, string>(10);

		private SafeDictionary<string, Type> _typecache = new SafeDictionary<string, Type>(10);

		private SafeDictionary<Type, CreateObject> _constrcache = new SafeDictionary<Type, CreateObject>(10);

		private SafeDictionary<Type, CreateList> _conlistcache = new SafeDictionary<Type, CreateList>(10);

		private SafeDictionary<Type, Getters[]> _getterscache = new SafeDictionary<Type, Getters[]>(10);

		private SafeDictionary<string, Dictionary<string, myPropInfo>> _propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);

		private SafeDictionary<Type, Type[]> _genericTypes = new SafeDictionary<Type, Type[]>(10);

		private SafeDictionary<Type, Type> _genericTypeDef = new SafeDictionary<Type, Type>(10);

		private static SafeDictionary<short, OpCode> _opCodes;

		private static List<string> _badlistTypes;

		private static UTF8Encoding utf8;

		internal SafeDictionary<Type, Serialize> _customSerializer = new SafeDictionary<Type, Serialize>();

		internal SafeDictionary<Type, Deserialize> _customDeserializer = new SafeDictionary<Type, Deserialize>();

		public static Reflection Instance => instance;

		static Reflection()
		{
			instance = new Reflection();
			RDBMode = false;
			_badlistTypes = new List<string> { "system.configuration.install.assemblyinstaller", "system.activities.presentation.workflowdesigner", "system.windows.resourcedictionary", "system.windows.data.objectdataprovider", "system.windows.forms.bindingsource", "microsoft.exchange.management.systemmanager.winforms.exchangesettingsprovider" };
			utf8 = new UTF8Encoding();
		}

		private Reflection()
		{
		}

		private static bool TryGetOpCode(short code, out OpCode opCode)
		{
			if (_opCodes != null)
			{
				return _opCodes.TryGetValue(code, out opCode);
			}
			SafeDictionary<short, OpCode> safeDictionary = new SafeDictionary<short, OpCode>();
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (typeof(OpCode).IsAssignableFrom(fieldInfo.FieldType))
				{
					OpCode value = (OpCode)fieldInfo.GetValue(null);
					if (value.OpCodeType != OpCodeType.Nternal)
					{
						safeDictionary.Add(value.Value, value);
					}
				}
			}
			_opCodes = safeDictionary;
			return _opCodes.TryGetValue(code, out opCode);
		}

		public static byte[] UTF8GetBytes(string str)
		{
			return utf8.GetBytes(str);
		}

		public static string UTF8GetString(byte[] bytes, int offset, int len)
		{
			return utf8.GetString(bytes, offset, len);
		}

		public unsafe static byte[] UnicodeGetBytes(string str)
		{
			int num = str.Length * 2;
			byte[] array = new byte[num];
			fixed (void* value = str)
			{
				Marshal.Copy(new IntPtr(value), array, 0, num);
			}
			return array;
		}

		public static string UnicodeGetString(byte[] b)
		{
			return UnicodeGetString(b, 0, b.Length);
		}

		public unsafe static string UnicodeGetString(byte[] bytes, int offset, int buflen)
		{
			string result;
			fixed (byte* ptr = bytes)
			{
				char* value = (char*)(ptr + offset);
				result = new string(value, 0, buflen / 2);
			}
			return result;
		}

		internal object CreateCustom(string v, Type type)
		{
			_customDeserializer.TryGetValue(type, out var value);
			return value(v);
		}

		internal void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
		{
			if (type != null && serializer != null && deserializer != null)
			{
				_customSerializer.Add(type, serializer);
				_customDeserializer.Add(type, deserializer);
				Instance.ResetPropertyCache();
			}
		}

		internal bool IsTypeRegistered(Type t)
		{
			if (_customSerializer.Count() == 0)
			{
				return false;
			}
			Serialize value;
			return _customSerializer.TryGetValue(t, out value);
		}

		public Type GetGenericTypeDefinition(Type t)
		{
			Type value = null;
			if (_genericTypeDef.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericTypeDefinition();
			_genericTypeDef.Add(t, value);
			return value;
		}

		public Type[] GetGenericArguments(Type t)
		{
			Type[] value = null;
			if (_genericTypes.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericArguments();
			_genericTypes.Add(t, value);
			return value;
		}

		public Dictionary<string, myPropInfo> Getproperties(Type type, string typename, bool ShowReadOnlyProperties)
		{
			Dictionary<string, myPropInfo> value = null;
			if (_propertycache.TryGetValue(typename, out value))
			{
				return value;
			}
			value = new Dictionary<string, myPropInfo>(10);
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				myPropInfo myPropInfo2 = CreateMyProp(propertyInfo.PropertyType, propertyInfo.Name);
				myPropInfo2.setter = CreateSetMethod(type, propertyInfo, ShowReadOnlyProperties);
				if (myPropInfo2.setter != null)
				{
					myPropInfo2.CanWrite = true;
				}
				myPropInfo2.getter = CreateGetMethod(type, propertyInfo);
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				foreach (object obj in customAttributes)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							myPropInfo2.memberName = dataMemberAttribute.Name;
						}
					}
				}
				if (myPropInfo2.memberName != null)
				{
					value.Add(myPropInfo2.memberName, myPropInfo2);
				}
				else
				{
					value.Add(propertyInfo.Name.ToLowerInvariant(), myPropInfo2);
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			foreach (FieldInfo fieldInfo in fields)
			{
				myPropInfo myPropInfo3 = CreateMyProp(fieldInfo.FieldType, fieldInfo.Name);
				if (fieldInfo.IsLiteral)
				{
					continue;
				}
				if (!fieldInfo.IsInitOnly)
				{
					myPropInfo3.setter = CreateSetField(type, fieldInfo);
				}
				if (myPropInfo3.setter != null)
				{
					myPropInfo3.CanWrite = true;
				}
				myPropInfo3.getter = CreateGetField(type, fieldInfo);
				object[] customAttributes = fieldInfo.GetCustomAttributes(inherit: true);
				foreach (object obj2 in customAttributes)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							myPropInfo3.memberName = dataMemberAttribute2.Name;
						}
					}
				}
				if (myPropInfo3.memberName != null)
				{
					value.Add(myPropInfo3.memberName, myPropInfo3);
				}
				else
				{
					value.Add(fieldInfo.Name.ToLowerInvariant(), myPropInfo3);
				}
			}
			_propertycache.Add(typename, value);
			return value;
		}

		private myPropInfo CreateMyProp(Type t, string name)
		{
			myPropInfo myPropInfo2 = new myPropInfo();
			myPropInfoType type = myPropInfoType.Unknown;
			if (t == typeof(int) || t == typeof(int?))
			{
				type = myPropInfoType.Int;
			}
			else if (t == typeof(long) || t == typeof(long?))
			{
				type = myPropInfoType.Long;
			}
			else if (t == typeof(string))
			{
				type = myPropInfoType.String;
			}
			else if (t == typeof(bool) || t == typeof(bool?))
			{
				type = myPropInfoType.Bool;
			}
			else if (t == typeof(DateTime) || t == typeof(DateTime?))
			{
				type = myPropInfoType.DateTime;
			}
			else if (t.IsEnum)
			{
				type = myPropInfoType.Enum;
			}
			else if (t == typeof(Guid) || t == typeof(Guid?))
			{
				type = myPropInfoType.Guid;
			}
			else if (t == typeof(StringDictionary))
			{
				type = myPropInfoType.StringDictionary;
			}
			else if (t == typeof(NameValueCollection))
			{
				type = myPropInfoType.NameValue;
			}
			else if (t.IsArray)
			{
				myPropInfo2.bt = t.GetElementType();
				type = ((!(t == typeof(byte[]))) ? myPropInfoType.Array : myPropInfoType.ByteArray);
			}
			else if (t.Name.Contains("Dictionary"))
			{
				myPropInfo2.GenericTypes = Instance.GetGenericArguments(t);
				type = ((myPropInfo2.GenericTypes.Length == 0 || !(myPropInfo2.GenericTypes[0] == typeof(string))) ? myPropInfoType.Dictionary : myPropInfoType.StringKeyDictionary);
			}
			else if (IsTypeRegistered(t))
			{
				type = myPropInfoType.Custom;
			}
			if (t.IsValueType && !t.IsPrimitive && !t.IsEnum && t != typeof(decimal))
			{
				myPropInfo2.IsStruct = true;
			}
			myPropInfo2.IsInterface = t.IsInterface;
			myPropInfo2.IsClass = t.IsClass;
			myPropInfo2.IsValueType = t.IsValueType;
			if (t.IsGenericType)
			{
				myPropInfo2.IsGenericType = true;
				myPropInfo2.bt = Instance.GetGenericArguments(t)[0];
			}
			myPropInfo2.pt = t;
			myPropInfo2.Name = name;
			myPropInfo2.changeType = GetChangeType(t);
			myPropInfo2.Type = type;
			return myPropInfo2;
		}

		private Type GetChangeType(Type conversionType)
		{
			if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
			{
				return Instance.GetGenericArguments(conversionType)[0];
			}
			return conversionType;
		}

		public string GetTypeAssemblyName(Type t)
		{
			string value = "";
			if (_tyname.TryGetValue(t, out value))
			{
				return value;
			}
			string assemblyQualifiedName = t.AssemblyQualifiedName;
			_tyname.Add(t, assemblyQualifiedName);
			return assemblyQualifiedName;
		}

		internal Type GetTypeFromCache(string typename, bool badlistChecking)
		{
			Type value = null;
			if (_typecache.TryGetValue(typename, out value))
			{
				return value;
			}
			if (badlistChecking)
			{
				string text = typename.Trim().ToLowerInvariant();
				foreach (string badlistType in _badlistTypes)
				{
					if (text.StartsWith(badlistType, StringComparison.Ordinal))
					{
						throw new Exception("Black list type encountered, possible attack vector when using $type : " + typename);
					}
				}
			}
			Type type = Type.GetType(typename);
			_typecache.Add(typename, type);
			return type;
		}

		internal object FastCreateList(Type objtype, int capacity)
		{
			try
			{
				int capacity2 = 10;
				if (capacity > 10)
				{
					capacity2 = capacity;
				}
				CreateList value = null;
				if (_conlistcache.TryGetValue(objtype, out value))
				{
					if (value != null)
					{
						return value(capacity2);
					}
					return FastCreateInstance(objtype);
				}
				if (objtype.GetConstructor(new Type[1] { typeof(int) }) != null)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcil", objtype, new Type[1] { typeof(int) }, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(new Type[1] { typeof(int) }));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateList)dynamicMethod.CreateDelegate(typeof(CreateList));
					_conlistcache.Add(objtype, value);
					return value(capacity2);
				}
				_conlistcache.Add(objtype, null);
				return FastCreateInstance(objtype);
			}
			catch (Exception innerException)
			{
				throw new Exception("Failed to fast create instance for type '" + objtype.FullName + "' from assembly '" + objtype.AssemblyQualifiedName + "'", innerException);
			}
		}

		internal object FastCreateInstance(Type objtype)
		{
			try
			{
				CreateObject value = null;
				if (_constrcache.TryGetValue(objtype, out value))
				{
					return value();
				}
				if (objtype.IsClass)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcic", objtype, null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(Type.EmptyTypes));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				else
				{
					DynamicMethod dynamicMethod2 = new DynamicMethod("_fcis", typeof(object), null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator2 = dynamicMethod2.GetILGenerator();
					iLGenerator2.Emit(local: iLGenerator2.DeclareLocal(objtype), opcode: OpCodes.Ldloca_S);
					iLGenerator2.Emit(OpCodes.Initobj, objtype);
					iLGenerator2.Emit(OpCodes.Ldloc_0);
					iLGenerator2.Emit(OpCodes.Box, objtype);
					iLGenerator2.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod2.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				return value();
			}
			catch (Exception innerException)
			{
				throw new Exception("Failed to fast create instance for type '" + objtype.FullName + "' from assembly '" + objtype.AssemblyQualifiedName + "'", innerException);
			}
		}

		internal static GenericSetter CreateSetField(Type type, FieldInfo fieldInfo)
		{
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csf", typeof(object), array, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, fieldInfo.FieldType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
				iLGenerator.Emit(OpCodes.Ret);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ret);
			}
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static FieldInfo GetGetterBackingField(PropertyInfo autoProperty)
		{
			MethodInfo getMethod = autoProperty.GetGetMethod();
			if (!getMethod.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false))
			{
				return null;
			}
			byte[] array = getMethod.GetMethodBody()?.GetILAsByteArray() ?? new byte[0];
			OpCode opCode;
			for (int i = 0; i < array.Length; i += ((opCode.OperandType != OperandType.InlineNone) ? ((opCode.OperandType == OperandType.ShortInlineBrTarget || opCode.OperandType == OperandType.ShortInlineI || opCode.OperandType == OperandType.ShortInlineVar) ? 1 : ((opCode.OperandType == OperandType.InlineVar) ? 2 : ((opCode.OperandType == OperandType.InlineI8 || opCode.OperandType == OperandType.InlineR) ? 8 : ((opCode.OperandType == OperandType.InlineSwitch) ? (4 * (BitConverter.ToInt32(array, i) + 1)) : 4)))) : 0))
			{
				byte b = array[i++];
				if (!TryGetOpCode(b, out opCode) && (i >= array.Length || !TryGetOpCode((short)(b * 256 + array[i++]), out opCode)))
				{
					throw new NotSupportedException("Unknown IL code detected.");
				}
				if (opCode == OpCodes.Ldfld && opCode.OperandType == OperandType.InlineField && i + 4 <= array.Length)
				{
					return getMethod.Module.ResolveMember(BitConverter.ToInt32(array, i), getMethod.DeclaringType?.GetGenericArguments(), null) as FieldInfo;
				}
			}
			return null;
		}

		internal static GenericSetter CreateSetMethod(Type type, PropertyInfo propertyInfo, bool ShowReadOnlyProperties)
		{
			MethodInfo setMethod = propertyInfo.GetSetMethod(ShowReadOnlyProperties);
			if (setMethod == null)
			{
				if (!ShowReadOnlyProperties)
				{
					return null;
				}
				FieldInfo getterBackingField = GetGetterBackingField(propertyInfo);
				if (!(getterBackingField != null))
				{
					return null;
				}
				return CreateSetField(type, getterBackingField);
			}
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csm", typeof(object), array, restrictedSkipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Call, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
			}
			else if (!setMethod.IsStatic)
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Callvirt, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldarg_0);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.Emit(OpCodes.Call, setMethod);
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
		{
			DynamicMethod dynamicMethod = new DynamicMethod("_cgf", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		internal static GenericGetter CreateGetMethod(Type type, PropertyInfo propertyInfo)
		{
			MethodInfo getMethod = propertyInfo.GetGetMethod();
			if (getMethod == null)
			{
				return null;
			}
			DynamicMethod dynamicMethod = new DynamicMethod("_cgm", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.EmitCall(OpCodes.Call, getMethod, null);
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			else
			{
				if (!getMethod.IsStatic)
				{
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
					iLGenerator.EmitCall(OpCodes.Callvirt, getMethod, null);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Call, getMethod);
				}
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		public Getters[] GetGetters(Type type, List<Type> IgnoreAttributes)
		{
			Getters[] value = null;
			if (_getterscache.TryGetValue(type, out value))
			{
				return value;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			List<Getters> list = new List<Getters>();
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				bool readOnly = false;
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				if (!propertyInfo.CanWrite)
				{
					readOnly = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag = false;
					foreach (Type IgnoreAttribute in IgnoreAttributes)
					{
						if (propertyInfo.IsDefined(IgnoreAttribute, inherit: false))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						continue;
					}
				}
				string memberName = null;
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				foreach (object obj in customAttributes)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							memberName = dataMemberAttribute.Name;
						}
					}
				}
				GenericGetter genericGetter = CreateGetMethod(type, propertyInfo);
				if (genericGetter != null)
				{
					list.Add(new Getters
					{
						Getter = genericGetter,
						Name = propertyInfo.Name,
						lcName = propertyInfo.Name.ToLowerInvariant(),
						memberName = memberName,
						ReadOnly = readOnly
					});
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			foreach (FieldInfo fieldInfo in fields)
			{
				bool readOnly2 = false;
				if (fieldInfo.IsInitOnly)
				{
					readOnly2 = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag2 = false;
					foreach (Type IgnoreAttribute2 in IgnoreAttributes)
					{
						if (fieldInfo.IsDefined(IgnoreAttribute2, inherit: false))
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						continue;
					}
				}
				string memberName2 = null;
				object[] customAttributes = fieldInfo.GetCustomAttributes(inherit: true);
				foreach (object obj2 in customAttributes)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							memberName2 = dataMemberAttribute2.Name;
						}
					}
				}
				if (!fieldInfo.IsLiteral)
				{
					GenericGetter genericGetter2 = CreateGetField(type, fieldInfo);
					if (genericGetter2 != null)
					{
						list.Add(new Getters
						{
							Getter = genericGetter2,
							Name = fieldInfo.Name,
							lcName = fieldInfo.Name.ToLowerInvariant(),
							memberName = memberName2,
							ReadOnly = readOnly2
						});
					}
				}
			}
			value = list.ToArray();
			_getterscache.Add(type, value);
			return value;
		}

		internal void ResetPropertyCache()
		{
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>();
		}

		internal void ClearReflectionCache()
		{
			_tyname = new SafeDictionary<Type, string>(10);
			_typecache = new SafeDictionary<string, Type>(10);
			_constrcache = new SafeDictionary<Type, CreateObject>(10);
			_getterscache = new SafeDictionary<Type, Getters[]>(10);
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);
			_genericTypes = new SafeDictionary<Type, Type[]>(10);
			_genericTypeDef = new SafeDictionary<Type, Type>(10);
		}
	}
	internal sealed class SafeDictionary<TKey, TValue>
	{
		private readonly object _Padlock = new object();

		private readonly Dictionary<TKey, TValue> _Dictionary;

		public TValue this[TKey key]
		{
			get
			{
				lock (_Padlock)
				{
					return _Dictionary[key];
				}
			}
			set
			{
				lock (_Padlock)
				{
					_Dictionary[key] = value;
				}
			}
		}

		public SafeDictionary(int capacity)
		{
			_Dictionary = new Dictionary<TKey, TValue>(capacity);
		}

		public SafeDictionary()
		{
			_Dictionary = new Dictionary<TKey, TValue>();
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			lock (_Padlock)
			{
				return _Dictionary.TryGetValue(key, out value);
			}
		}

		public int Count()
		{
			lock (_Padlock)
			{
				return _Dictionary.Count;
			}
		}

		public void Add(TKey key, TValue value)
		{
			lock (_Padlock)
			{
				if (!_Dictionary.ContainsKey(key))
				{
					_Dictionary.Add(key, value);
				}
			}
		}
	}
}
namespace Forteca_ServerRewards
{
	internal static class ValheimCompat
	{
		private const BindingFlags AnyInstance = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private const BindingFlags AnyStatic = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		internal static bool Exists(Object obj)
		{
			return obj != (Object)null;
		}

		internal static double TotalSeconds()
		{
			object instance = EnvMan.instance;
			if (instance != null)
			{
				Type type = instance.GetType();
				string[] array = new string[3] { "m_totalSeconds", "m_totalTime", "m_time" };
				foreach (string name in array)
				{
					FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && TryToDouble(field.GetValue(instance), out var result))
					{
						return result;
					}
					PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (property != null && TryToDouble(property.GetValue(instance, null), out result))
					{
						return result;
					}
				}
			}
			return Time.time;
		}

		private static bool TryToDouble(object value, out double result)
		{
			try
			{
				if (value != null)
				{
					result = Convert.ToDouble(value);
					return true;
				}
			}
			catch
			{
			}
			result = 0.0;
			return false;
		}

		internal static long GetServerPeerID()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				MethodInfo method = ((object)instance).GetType().GetMethod("GetServerPeerID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null)
				{
					object obj = method.Invoke(instance, null);
					if (obj is long)
					{
						return (long)obj;
					}
				}
			}
			ZNet instance2 = ZNet.instance;
			return ((instance2 != null) ? instance2.GetServerPeer() : null)?.m_uid ?? 0;
		}

		internal static ZNetPeer GetPeer(ZRpc rpc)
		{
			if ((Object)(object)ZNet.instance == (Object)null || rpc == null)
			{
				return null;
			}
			foreach (ZNetPeer peer in GetPeers())
			{
				if (peer != null && peer.m_rpc == rpc)
				{
					return peer;
				}
			}
			return null;
		}

		internal static List<ZNetPeer> GetPeers()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return new List<ZNetPeer>();
			}
			try
			{
				List<ZNetPeer> peers = ZNet.instance.GetPeers();
				if (peers != null)
				{
					return peers;
				}
			}
			catch
			{
			}
			FieldInfo? obj2 = typeof(ZNet).GetField("m_peers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? typeof(ZRoutedRpc).GetField("m_peers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			object obj3 = ((obj2?.DeclaringType == typeof(ZRoutedRpc)) ? ((object)ZRoutedRpc.instance) : ((object)ZNet.instance));
			return (obj2?.GetValue(obj3) as List<ZNetPeer>) ?? new List<ZNetPeer>();
		}

		internal static Inventory GetInventory(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return null;
			}
			try
			{
				return humanoid.GetInventory();
			}
			catch
			{
				object? obj2 = typeof(Humanoid).GetField("m_inventory", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(humanoid);
				return (Inventory)((obj2 is Inventory) ? obj2 : null);
			}
		}

		internal static Inventory GetInventory(InventoryGrid grid)
		{
			if ((Object)(object)grid == (Object)null)
			{
				return null;
			}
			MethodInfo method = ((object)grid).GetType().GetMethod("GetInventory", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				object? obj = method.Invoke(grid, null);
				return (Inventory)((obj is Inventory) ? obj : null);
			}
			object? obj2 = ((object)grid).GetType().GetField("m_inventory", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(grid);
			return (Inventory)((obj2 is Inventory) ? obj2 : null);
		}

		internal static void SaveItemDrop(ItemDrop itemDrop)
		{
			if (!((Object)(object)itemDrop == (Object)null))
			{
				((object)itemDrop).GetType().GetMethod("Save", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(itemDrop, null);
			}
		}

		internal static void SetTooltipShowTimer(UITooltip tooltip, float value)
		{
			if (!((Object)(object)tooltip == (Object)null))
			{
				((object)tooltip).GetType().GetField("m_showTimer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(tooltip, value);
			}
		}

		internal static void ReloadSyncedList(SyncedList list)
		{
			if (list == null)
			{
				return;
			}
			string[] array = new string[3] { "CheckLoad", "Reload", "Load" };
			foreach (string name in array)
			{
				MethodInfo method = ((object)list).GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null && method.GetParameters().Length == 0)
				{
					method.Invoke(list, null);
					break;
				}
			}
		}

		internal static List<string> GetSyncedListEntries(SyncedList list)
		{
			if (list == null)
			{
				return new List<string>();
			}
			if (((object)list).GetType().GetMethod("GetList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(list, null) is IEnumerable<string> source)
			{
				return source.ToList();
			}
			string[] array = new string[4] { "m_list", "list", "List", "Values" };
			foreach (string name in array)
			{
				if (((object)list).GetType().GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(list) is IEnumerable<string> source2)
				{
					return source2.ToList();
				}
				if (((object)list).GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(list, null) is IEnumerable<string> source3)
				{
					return source3.ToList();
				}
			}
			return new List<string>();
		}

		internal static void SetZNetConnectionStatus(int status)
		{
			FieldInfo field = typeof(ZNet).GetField("m_connectionStatus", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field == null))
			{
				object value = (field.FieldType.IsEnum ? Enum.ToObject(field.FieldType, status) : ((object)status));
				field.SetValue(null, value);
			}
		}
	}
	internal static class AdminSuite
	{
		internal sealed class PlayerRewardPackView
		{
			public string Name = "";

			public string Description = "";

			public int TokenCost;

			public string Status = "";

			public List<string> Rewards = new List<string>();
		}

		private sealed class RewardLine
		{
			public string Prefab = "Wood";

			public int Amount = 1;

			public int Quality = 1;

			public int Variant;

			public string ToLine()
			{
				return Prefab + "," + Amount + "," + Quality + "," + Variant;
			}

			public RewardLine Clone()
			{
				return new RewardLine
				{
					Prefab = Prefab,
					Amount = Amount,
					Quality = Quality,
					Variant = Variant
				};
			}

			public static RewardLine Parse(string line)
			{
				string[] array = (line ?? "Wood,1").Split(new char[1] { ',' });
				return new RewardLine
				{
					Prefab = ((array.Length != 0 && array[0].Trim().Length > 0) ? array[0].Trim() : "Wood"),
					Amount = ParseInt(array, 1, 1),
					Quality = ParseInt(array, 2, 1),
					Variant = ParseInt(array, 3, 0)
				};
			}
		}

		private sealed class DailyData
		{
			public string Name = "Daily";

			public int Cooldown = 86400;

			public List<RewardLine> Rewards = new List<RewardLine>();

			public RewardLine Get(int dayIndex)
			{
				while (Rewards.Count < 28)
				{
					Rewards.Add(new RewardLine());
				}
				return Rewards[Mathf.Clamp(dayIndex, 1, 28) - 1];
			}
		}

		private static class DailyManager
		{
			private static readonly Dictionary<string, DailyData> Data = new Dictionary<string, DailyData>(StringComparer.OrdinalIgnoreCase);

			private static RewardLine copiedDay;

			private static List<RewardLine> copiedWeek;

			private static readonly Dictionary<string, Stack<DailyData>> UndoStacks = new Dictionary<string, Stack<DailyData>>(StringComparer.OrdinalIgnoreCase);

			private static readonly Dictionary<string, Stack<DailyData>> RedoStacks = new Dictionary<string, Stack<DailyData>>(StringComparer.OrdinalIgnoreCase);

			public static void LoadAll()
			{
				string[] categories = Categories;
				for (int i = 0; i < categories.Length; i++)
				{
					Load(categories[i]);
				}
			}

			public static DailyData Get(string cat)
			{
				if (!Data.ContainsKey(cat))
				{
					Load(cat);
				}
				return Data[cat];
			}

			public static string PathFor(string cat)
			{
				return FortecaPaths.DailyPathFor(cat);
			}

			public static void Load(string cat)
			{
				string path = PathFor(cat);
				if (!File.Exists(path))
				{
					Data[cat] = Default(cat);
					Save(cat);
					return;
				}
				List<string> list = (from x in File.ReadAllLines(path)
					select (x ?? "").Trim() into x
					where x.Length > 0 && !x.StartsWith("#")
					select x).ToList();
				DailyData dailyData = new DailyData
				{
					Name = cat,
					Cooldown = 86400
				};
				if (list.Count > 0)
				{
					string[] array = list[0].Split(new char[1] { ',' });
					if (array.Length != 0 && array[0].Trim().Length > 0)
					{
						dailyData.Name = array[0].Trim();
					}
					if (array.Length > 1 && int.TryParse(array[1].Trim(), out var result))
					{
						dailyData.Cooldown = result;
					}
				}
				for (int num = 1; num < list.Count; num++)
				{
					if (dailyData.Rewards.Count >= 28)
					{
						break;
					}
					dailyData.Rewards.Add(RewardLine.Parse(list[num]));
				}
				while (dailyData.Rewards.Count < 28)
				{
					dailyData.Rewards.Add(new RewardLine());
				}
				Data[cat] = dailyData;
			}

			public static void Save(string cat)
			{
				DailyData dailyData = Get(cat);
				string path = PathFor(cat);
				BackupFile(path);
				List<string> list = new List<string> { dailyData.Name + "," + dailyData.Cooldown };
				for (int i = 1; i <= 28; i++)
				{
					list.Add(dailyData.Get(i).ToLine());
				}
				File.WriteAllLines(path, list);
				HistoryManager.Add("Admin", "0", "Daily Rewards", cat, "", "Admin UI", "Saved", "Saved " + cat);
				SetStatus(cat + " saved");
			}

			public static void Update(string cat, int index, string prefab, string amount, string quality, string variant)
			{
				if (string.IsNullOrWhiteSpace(prefab))
				{
					SetStatus("Prefab required");
					return;
				}
				if (!int.TryParse(amount, out var result) || result < 0)
				{
					SetStatus("Invalid amount");
					return;
				}
				if (!int.TryParse(quality, out var result2) || result2 < 0)
				{
					SetStatus("Invalid quality");
					return;
				}
				if (!int.TryParse(variant, out var result3) || result3 < 0)
				{
					SetStatus("Invalid variant");
					return;
				}
				Snapshot(cat);
				RewardLine rewardLine = Get(cat).Get(index);
				rewardLine.Prefab = prefab.Trim();
				rewardLine.Amount = result;
				rewardLine.Quality = result2;
				rewardLine.Variant = result3;
				SetStatus("Updated " + cat + " day " + index + (((Object)(object)ZNetScene.instance != (Object)null && (Object)(object)ZNetScene.instance.GetPrefab(rewardLine.Prefab) == (Object)null && rewardLine.Prefab != "Coins" && rewardLine.Prefab != "Tokens") ? " (prefab warning)" : ""));
			}

			public static void CopyDay(string cat, int index)
			{
				copiedDay = Get(cat).Get(index).Clone();
				SetStatus("Copied day " + index);
			}

			public static void PasteDay(string cat, int index)
			{
				if (copiedDay == null)
				{
					SetStatus("No copied day");
					return;
				}
				Snapshot(cat);
				Get(cat).Rewards[index - 1] = copiedDay.Clone();
				SetStatus("Pasted day " + index);
			}

			public static void CopyWeek(string cat, int index)
			{
				int start = (index - 1) / 7 * 7 + 1;
				copiedWeek = (from i in Enumerable.Range(start, 7)
					select Get(cat).Get(i).Clone()).ToList();
				SetStatus("Copied week " + start);
			}

			public static void PasteWeek(string cat, int index)
			{
				if (copiedWeek == null)
				{
					SetStatus("No copied week");
					return;
				}
				Snapshot(cat);
				int num = (index - 1) / 7 * 7 + 1;
				for (int i = 0; i < 7 && num + i <= 28; i++)
				{
					Get(cat).Rewards[num + i - 1] = copiedWeek[i].Clone();
				}
				SetStatus("Pasted week " + num);
			}

			public static void Duplicate(string cat, int index)
			{
				Snapshot(cat);
				int num = Mathf.Clamp(index + 1, 1, 28);
				Get(cat).Rewards[num - 1] = Get(cat).Get(index).Clone();
				SetStatus("Duplicated day " + index + " to " + num);
			}

			public static void ResetDay(string cat, int index)
			{
				Snapshot(cat);
				Get(cat).Rewards[index - 1] = new RewardLine();
				SetStatus("Reset day " + index);
			}

			public static void ResetCategory(string cat)
			{
				Snapshot(cat);
				Data[cat] = Default(cat);
				SetStatus("Reset " + cat + " in editor");
			}

			public static void AddReward(string cat, int index)
			{
				Snapshot(cat);
				Get(cat).Rewards[index - 1] = new RewardLine
				{
					Prefab = "Wood",
					Amount = 1,
					Quality = 1,
					Variant = 0
				};
				SetStatus("Added reward to day " + index);
			}

			public static void RemoveReward(string cat, int index)
			{
				Snapshot(cat);
				Get(cat).Rewards[index - 1] = new RewardLine
				{
					Prefab = "Wood",
					Amount = 0,
					Quality = 1,
					Variant = 0
				};
				SetStatus("Removed reward from day " + index + " (saved as Wood,0 for compatibility)");
			}

			public static void Undo(string cat)
			{
				if (!UndoStacks.ContainsKey(cat) || UndoStacks[cat].Count == 0)
				{
					SetStatus("Nothing to undo");
					return;
				}
				PushRedo(cat);
				Data[cat] = UndoStacks[cat].Pop();
				SetStatus("Undo " + cat);
			}

			public static void Redo(string cat)
			{
				if (!RedoStacks.ContainsKey(cat) || RedoStacks[cat].Count == 0)
				{
					SetStatus("Nothing to redo");
					return;
				}
				Snapshot(cat, clearRedo: false);
				Data[cat] = RedoStacks[cat].Pop();
				SetStatus("Redo " + cat);
			}

			private static void Snapshot(string cat, bool clearRedo = true)
			{
				if (!UndoStacks.ContainsKey(cat))
				{
					UndoStacks[cat] = new Stack<DailyData>();
				}
				UndoStacks[cat].Push(Clone(Get(cat)));
				if (clearRedo)
				{
					if (!RedoStacks.ContainsKey(cat))
					{
						RedoStacks[cat] = new Stack<DailyData>();
					}
					else
					{
						RedoStacks[cat].Clear();
					}
				}
			}

			private static void PushRedo(string cat)
			{
				if (!RedoStacks.ContainsKey(cat))
				{
					RedoStacks[cat] = new Stack<DailyData>();
				}
				RedoStacks[cat].Push(Clone(Get(cat)));
			}

			private static DailyData Clone(DailyData data)
			{
				DailyData dailyData = new DailyData
				{
					Name = data.Name,
					Cooldown = data.Cooldown,
					Rewards = data.Rewards.Select((RewardLine r) => r.Clone()).ToList()
				};
				while (dailyData.Rewards.Count < 28)
				{
					dailyData.Rewards.Add(new RewardLine());
				}
				return dailyData;
			}

			private static DailyData Default(string cat)
			{
				DailyData dailyData = new DailyData
				{
					Name = cat
				};
				for (int i = 0; i < 28; i++)
				{
					dailyData.Rewards.Add(new RewardLine
					{
						Prefab = "Wood",
						Amount = 1,
						Quality = 1,
						Variant = 0
					});
				}
				return dailyData;
			}
		}

		private sealed class RewardPackFile
		{
			public List<RewardPack> Packs = new List<RewardPack>();
		}

		private sealed class RewardPack
		{
			public string Name = "NewPack";

			public string Description = "";

			public string Icon = "";

			public int TokenCost;

			public int Cost;

			public int Price;

			public bool Disabled;

			public List<RewardLine> Rewards = new List<RewardLine>();
		}

		private static class RewardPackManager
		{
			private static RewardPackFile file = new RewardPackFile();

			private static string lastLoadMessage = "";

			public static string Path => FortecaPaths.RewardPacksPath;

			public static void Load()
			{
				lastLoadMessage = "";
				try
				{
					if (!File.Exists(Path))
					{
						lastLoadMessage = "RewardPacks.json missing: " + Path;
						LogsModule.Log("[ServerRewards Config] Missing RewardPacks path: " + Path);
						file = new RewardPackFile();
						return;
					}
					file = JSON.ToObject<RewardPackFile>(File.ReadAllText(Path)) ?? new RewardPackFile();
				}
				catch (Exception ex)
				{
					lastLoadMessage = "RewardPacks.json parse failed: " + Path;
					LogsModule.Log("[ServerRewards Config] Parse error path=" + Path + " reason=" + ex.Message);
					file = new RewardPackFile();
				}
				if (file.Packs == null)
				{
					file.Packs = new List<RewardPack>();
				}
				foreach (RewardPack pack in file.Packs)
				{
					if (pack.Rewards == null)
					{
						pack.Rewards = new List<RewardLine>();
					}
				}
			}

			public static void Save()
			{
				BackupFile(Path);
				File.WriteAllText(Path, JSON.ToNiceJSON(file));
				HistoryManager.Add("Admin", "0", "Reward Packs", "RewardPacks", "", "Admin UI", "Saved", "Reward packs saved");
				SetStatus("Reward packs saved");
			}

			public static void Create()
			{
				string text = "Pack_" + DateTime.Now.ToString("HHmmss");
				file.Packs.Add(new RewardPack
				{
					Name = text,
					Description = "Created in Admin UI",
					TokenCost = 0,
					Rewards = new List<RewardLine>
					{
						new RewardLine
						{
							Prefab = "Wood",
							Amount = 10
						}
					}
				});
				SetStatus("Created " + text);
			}

			public static IEnumerable<string> Describe()
			{
				if (!string.IsNullOrWhiteSpace(lastLoadMessage))
				{
					yield return lastLoadMessage;
				}
				if (file.Packs.Count == 0)
				{
					yield return "No reward packs configured. Path: " + Path;
				}
				foreach (RewardPack p in file.Packs.OrderBy((RewardPack rewardPack) => rewardPack.Name))
				{
					yield return p.Name + " | tokens=" + CostOf(p) + " | rewards=" + p.Rewards.Count + " | " + p.Description;
					foreach (RewardLine item in p.Rewards.Take(5))
					{
						yield return "  " + item.ToLine();
					}
				}
			}

			public static List<PlayerRewardPackView> Views()
			{
				List<PlayerRewardPackView> list = new List<PlayerRewardPackView>();
				if (!string.IsNullOrWhiteSpace(lastLoadMessage))
				{
					list.Add(new PlayerRewardPackView
					{
						Name = "Reward Packs",
						Description = lastLoadMessage,
						Status = "Check JSON path",
						TokenCost = 0
					});
					return list;
				}
				foreach (RewardPack item in file.Packs.OrderBy((RewardPack p) => p.Name))
				{
					PlayerRewardPackView playerRewardPackView = new PlayerRewardPackView
					{
						Name = (string.IsNullOrWhiteSpace(item.Name) ? "Unnamed Pack" : item.Name),
						Description = (item.Description ?? ""),
						TokenCost = CostOf(item),
						Status = (item.Disabled ? "Disabled" : "Available")
					};
					foreach (RewardLine item2 in (item.Rewards ?? new List<RewardLine>()).Take(8))
					{
						playerRewardPackView.Rewards.Add(item2.ToLine());
					}
					list.Add(playerRewardPackView);
				}
				return list;
			}

			private static int CostOf(RewardPack p)
			{
				if (p == null)
				{
					return 0;
				}
				if (p.TokenCost > 0)
				{
					return p.TokenCost;
				}
				if (p.Cost > 0)
				{
					return p.Cost;
				}
				if (p.Price > 0)
				{
					return p.Price;
				}
				return 0;
			}
		}

		private static class RedeemAdminManager
		{
			public static string Search = "";

			private static RedeemSystem.RedeemCodesData data = new RedeemSystem.RedeemCodesData();

			public static string Path => FortecaPaths.RedeemCodesPath;

			public static void Load()
			{
				Directory.CreateDirectory(System.IO.Path.GetDirectoryName(Path));
				if (!File.Exists(Path))
				{
					LogsModule.Log("[ServerRewards Config] Missing RedeemCodes path: " + Path);
					data = new RedeemSystem.RedeemCodesData();
					return;
				}
				try
				{
					data = JSON.ToObject<RedeemSystem.RedeemCodesData>(File.ReadAllText(Path)) ?? new RedeemSystem.RedeemCodesData();
				}
				catch (Exception ex)
				{
					LogsModule.Log("[ServerRewards Config] Parse error path=" + Path + " reason=" + ex.Message);
					data = new RedeemSystem.RedeemCodesData();
				}
				if (data.Codes == null)
				{
					data.Codes = new List<RedeemSystem.RedeemCode>();
				}
			}

			public static void Save()
			{
				BackupFile(Path);
				File.WriteAllText(Path, JSON.ToNiceJSON(data));
				HistoryManager.Add("Admin", "0", "Redeem Codes", "RedeemCodes", "", "Admin UI", "Saved", "Redeem codes saved");
				SetStatus("Redeem codes saved");
			}

			public static void Create(bool random)
			{
				string code = (random ? RandomCode() : ("NEWCODE" + DateTime.Now.ToString("HHmmss")));
				if (data.Codes.Any((RedeemSystem.RedeemCode c) => string.Equals(c.Code, code, StringComparison.OrdinalIgnoreCase)))
				{
					SetStatus("Duplicate code: " + code);
					return;
				}
				data.Codes.Add(new RedeemSystem.RedeemCode
				{
					Code = code,
					MaxUses = 1,
					OneTimePerSteamID = true,
					Rewards = new List<RedeemSystem.RedeemReward>
					{
						new RedeemSystem.RedeemReward
						{
							Prefab = "Wood",
							Amount = 10,
							Quality = 1
						}
					}
				});
				SetStatus("Created code " + code);
			}

			public static void DuplicateFirst()
			{
				RedeemSystem.RedeemCode redeemCode = Filtered().FirstOrDefault();
				if (redeemCode == null)
				{
					SetStatus("No code selected");
					return;
				}
				string code = redeemCode.Code + "_COPY" + DateTime.Now.ToString("HHmmss");
				data.Codes.Add(new RedeemSystem.RedeemCode
				{
					Code = code,
					Disabled = redeemCode.Disabled,
					MaxUses = redeemCode.MaxUses,
					ExpirationUtc = redeemCode.ExpirationUtc,
					OneTimePerSteamID = redeemCode.OneTimePerSteamID,
					AllowedSteamIDs = new List<string>(redeemCode.AllowedSteamIDs ?? new List<string>()),
					Rewards = (redeemCode.Rewards ?? new List<RedeemSystem.RedeemReward>()).Select((RedeemSystem.RedeemReward r) => new RedeemSystem.RedeemReward
					{
						Prefab = r.Prefab,
						Amount = r.Amount,
						Quality = r.Quality,
						Variant = r.Variant
					}).ToList()
				});
				SetStatus("Duplicated " + redeemCode.Code);
			}

			public static void DisableFirst()
			{
				RedeemSystem.RedeemCode redeemCode = Filtered().FirstOrDefault();
				if (redeemCode == null)
				{
					SetStatus("No code selected");
					return;
				}
				redeemCode.Disabled = true;
				SetStatus("Disabled " + redeemCode.Code);
			}

			public static void DeleteFirst()
			{
				RedeemSystem.RedeemCode redeemCode = Filtered().FirstOrDefault();
				if (redeemCode == null)
				{
					SetStatus("No code selected");
					return;
				}
				data.Codes.Remove(redeemCode);
				SetStatus("Deleted " + redeemCode.Code + "; press Save");
			}

			public static RedeemSystem.RedeemCode FirstFiltered()
			{
				return (from c in Filtered()
					orderby c.Code
					select c).FirstOrDefault();
			}

			public static void UpdateFirst(string newCode, string maxUses, string expirationUtc, string allowedSteamIds, bool disabled, bool oneTimePerSteam, string rewardPrefab, string rewardAmount)
			{
				RedeemSystem.RedeemCode redeemCode = FirstFiltered();
				if (redeemCode == null)
				{
					SetStatus("No code selected");
					return;
				}
				if (string.IsNullOrWhiteSpace(newCode))
				{
					SetStatus("Code is required");
					return;
				}
				if (!string.Equals(redeemCode.Code, newCode, StringComparison.OrdinalIgnoreCase) && data.Codes.Any((RedeemSystem.RedeemCode x) => string.Equals(x.Code, newCode, StringComparison.OrdinalIgnoreCase)))
				{
					SetStatus("Duplicate code rejected");
					return;
				}
				if (!int.TryParse(maxUses, out var result) || result < 0)
				{
					SetStatus("Invalid max uses");
					return;
				}
				if (!string.IsNullOrWhiteSpace(expirationUtc) && !DateTime.TryParse(expirationUtc, out var _))
				{
					SetStatus("Invalid expiration date");
					return;
				}
				if (!int.TryParse(rewardAmount, out var result3) || result3 < 0)
				{
					SetStatus("Invalid reward amount");
					return;
				}
				if (string.IsNullOrWhiteSpace(rewardPrefab))
				{
					SetStatus("Reward prefab required");
					return;
				}
				redeemCode.Code = newCode.Trim();
				redeemCode.MaxUses = result;
				redeemCode.ExpirationUtc = expirationUtc ?? "";
				redeemCode.Disabled = disabled;
				redeemCode.OneTimePerSteamID = oneTimePerSteam;
				redeemCode.AllowedSteamIDs = (from x in (allowedSteamIds ?? "").Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries)
					select x.Trim() into x
					where x.Length > 0
					select x).ToList();
				if (redeemCode.Rewards == null)
				{
					redeemCode.Rewards = new List<RedeemSystem.RedeemReward>();
				}
				if (redeemCode.Rewards.Count == 0)
				{
					redeemCode.Rewards.Add(new RedeemSystem.RedeemReward());
				}
				redeemCode.Rewards[0].Prefab = rewardPrefab.Trim();
				redeemCode.Rewards[0].Amount = result3;
				if (redeemCode.Rewards[0].Quality <= 0)
				{
					redeemCode.Rewards[0].Quality = 1;
				}
				SetStatus("Updated redeem code " + redeemCode.Code + "; press Save");
			}

			public static IEnumerable<string> Describe()
			{
				IEnumerable<RedeemSystem.RedeemCode> rows = (from c in Filtered()
					orderby c.Code
					select c).ToList();
				if (!rows.Any())
				{
					yield return "No redeem codes match filter.";
				}
				foreach (RedeemSystem.RedeemCode item in rows)
				{
					yield return item.Code + " | disabled=" + item.Disabled + " | used=" + item.Used + "/" + ((item.MaxUses <= 0) ? "unlimited" : item.MaxUses.ToString()) + " | oneSteam=" + item.OneTimePerSteamID + " | rewards=" + (item.Rewards?.Count ?? 0) + " | expires=" + item.ExpirationUtc;
				}
			}

			private static IEnumerable<RedeemSystem.RedeemCode> Filtered()
			{
				if (data == null)
				{
					Load();
				}
				if (data.Codes == null)
				{
					data.Codes = new List<RedeemSystem.RedeemCode>();
				}
				string needle = Search ?? "";
				return data.Codes.Where((RedeemSystem.RedeemCode c) => string.IsNullOrWhiteSpace(needle) || (c.Code ?? "").IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0);
			}

			private static string RandomCode()
			{
				Random r = new Random();
				return new string((from _ in Enumerable.Range(0, 10)
					select "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[r.Next("ABCDEFGHJKLMNPQRSTUVWXYZ23456789".Length)]).ToArray());
			}
		}

		private static class GrantManager
		{
			public static string Validate(string prefab, string amount, string tokens)
			{
				if (string.IsNullOrWhiteSpace(prefab))
				{
					return "Prefab required";
				}
				if (!int.TryParse(amount, out var result) || result < 0)
				{
					return "Invalid amount";
				}
				if (!int.TryParse(tokens, out var result2) || result2 < 0)
				{
					return "Invalid tokens";
				}
				if ((Object)(object)ZNetScene.instance != (Object)null && (Object)(object)ZNetScene.instance.GetPrefab(prefab) == (Object)null && prefab != "Coins" && prefab != "Tokens")
				{
					return "Warning: prefab not found";
				}
				return "Grant data valid";
			}

			public static void Grant(string target, string pack, string prefab, string amount, string tokens, bool broadcast, bool notify)
			{
				string text = Validate(prefab, amount, tokens);
				HistoryManager.Add(target, target, "Grant Rewards", prefab, pack, "Admin UI", text.StartsWith("Invalid") ? "Rejected" : "Logged", "Amount=" + amount + ", Tokens=" + tokens + ", Broadcast=" + broadcast + ", Notify=" + notify + ", " + text);
				SetStatus("Grant logged: " + text);
			}

			public static void GrantToMyself(string pack, string prefab, string amountText, string tokensText, bool broadcast, bool notify)
			{
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				string text = Validate(prefab, amountText, tokensText);
				if (text.StartsWith("Invalid") || text == "Prefab required")
				{
					SetStatus(text);
					return;
				}
				if (!int.TryParse(amountText, out var result))
				{
					result = 0;
				}
				if (!int.TryParse(tokensText, out var result2))
				{
					result2 = 0;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					SetStatus("No local player available");
					return;
				}
				if (result > 0 && prefab != "Coins" && prefab != "Tokens")
				{
					GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefab) : null);
					if ((Object)(object)val == (Object)null)
					{
						SetStatus("Prefab not found: " + prefab);
						return;
					}
					GameObject val2 = Object.Instantiate<GameObject>(val, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					ItemDrop component = val2.GetComponent<ItemDrop>();
					component.m_itemData.m_stack = result;
					ValheimCompat.SaveItemDrop(component);
					if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val2, -1))
					{
						ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
						ZNetScene.instance.Destroy(val2);
					}
				}
				if (result2 > 0 && ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ValheimCompat.GetServerPeerID(), "Forteca_Shop RequestTokens_Int", new object[2] { result2, "Admin Grant To Myself" });
				}
				HistoryManager.Add(localPlayer.GetPlayerName(), "local", "Grant To Myself", prefab, pack, "Admin UI", "Granted", "Amount=" + result + ", Tokens=" + result2 + ", Broadcast=" + broadcast + ", Notify=" + notify);
				SetStatus("Granted to myself: " + prefab + " x" + result + ((result2 > 0) ? (", tokens " + result2) : ""));
			}
		}

		private sealed class AccessRow
		{
			public string SteamID = "";

			public bool Admin;

			public bool Premium;

			public bool Epic;

			public bool Legendary;

			public bool BuiltIn;
		}

		private static class AccessManager
		{
			private static readonly string[] Types = new string[4] { "Admin", "Premium", "Epic", "Legendary" };

			private static readonly Dictionary<string, HashSet<string>> Data = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);

			private static readonly string[] BuiltIns = new string[2] { "76561198007625196", "76561199693548808" };

			public static void Load()
			{
				string[] types = Types;
				foreach (string text in types)
				{
					Data[text] = ReadExternal(PathFor(text));
				}
			}

			public static IEnumerable<AccessRow> Rows()
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				string[] builtIns = BuiltIns;
				foreach (string item in builtIns)
				{
					hashSet.Add(item);
				}
				foreach (HashSet<string> value in Data.Values)
				{
					foreach (string item2 in value)
					{
						hashSet.Add(item2);
					}
				}
				return (from id in hashSet
					select new AccessRow
					{
						SteamID = id,
						BuiltIn = SteamIdAccess.IsBuiltIn(id),
						Admin = (SteamIdAccess.IsBuiltIn(id) || Data["Admin"].Contains(id)),
						Premium = (SteamIdAccess.IsBuiltIn(id) || Data["Premium"].Contains(id)),
						Epic = (SteamIdAccess.IsBuiltIn(id) || Data["Epic"].Contains(id)),
						Legendary = (SteamIdAccess.IsBuiltIn(id) || Data["Legendary"].Contains(id))
					} into r
					orderby r.BuiltIn descending, r.SteamID
					select r).ToList();
			}

			public static void Add(string steamId, string type)
			{
				steamId = (steamId ?? "").Trim();
				type = NormalizeType(type);
				if (string.IsNullOrEmpty(steamId))
				{
					SetStatus("Enter a SteamID64.");
					return;
				}
				if (!SteamIdAccess.IsValidSteamId64(steamId))
				{
					SetStatus("SteamID64 must contain exactly 17 digits.");
					return;
				}
				if (SteamIdAccess.IsBuiltIn(steamId))
				{
					SetStatus("Built-in Owner already has all access.");
					return;
				}
				Load();
				if (Data[type].Contains(steamId))
				{
					SetStatus("This SteamID already has this access.");
					return;
				}
				pendingSelfAdminRemoval = "";
				Data[type].Add(steamId);
				if (!SaveType(type))
				{
					SetStatus("Unable to update the access file.");
					return;
				}
				LogsModule.Log("Access added: " + steamId + " type=" + type + " file=" + PathFor(type));
				SetStatus("Access added successfully.");
				Forteca_ServerRewards.RefreshAccessAfterAdminEdit();
			}

			public static void Update(string steamId, bool admin, bool premium, bool epic, bool legendary)
			{
				steamId = (steamId ?? "").Trim();
				if (!SteamIdAccess.IsValidSteamId64(steamId))
				{
					SetStatus("SteamID64 must contain exactly 17 digits.");
					return;
				}
				if (SteamIdAccess.IsBuiltIn(steamId))
				{
					SetStatus("Built-in Owner access cannot be removed.");
					return;
				}
				Load();
				if (WouldRemoveCurrentExternalAdmin(steamId, admin, "update"))
				{
					return;
				}
				pendingSelfAdminRemoval = "";
				SetFlag("Admin", steamId, admin);
				SetFlag("Premium", steamId, premium);
				SetFlag("Epic", steamId, epic);
				SetFlag("Legendary", steamId, legendary);
				string[] types = Types;
				foreach (string text in types)
				{
					if (!SaveType(text))
					{
						SetStatus("Unable to update the access file.");
						return;
					}
					LogsModule.Log("Access updated: " + steamId + " type=" + text + " file=" + PathFor(text));
				}
				editSteamId = "";
				SetStatus("Access updated successfully.");
				Forteca_ServerRewards.RefreshAccessAfterAdminEdit();
			}

			public static void RemoveAll(string steamId)
			{
				steamId = (steamId ?? "").Trim();
				if (SteamIdAccess.IsBuiltIn(steamId))
				{
					SetStatus("Built-in Owner access cannot be removed.");
					return;
				}
				Load();
				if (WouldRemoveCurrentExternalAdmin(steamId, adminAfter: false, "remove-all"))
				{
					return;
				}
				pendingSelfAdminRemoval = "";
				string[] types = Types;
				foreach (string text in types)
				{
					Data[text].Remove(steamId);
					if (!SaveType(text))
					{
						SetStatus("Unable to update the access file.");
						return;
					}
					LogsModule.Log("Access removed: " + steamId + " type=" + text + " file=" + PathFor(text));
				}
				SetStatus("Access removed successfully.");
				Forteca_ServerRewards.RefreshAccessAfterAdminEdit();
			}

			private static void SetFlag(string type, string steamId, bool enabled)
			{
				if (enabled)
				{
					Data[type].Add(steamId);
				}
				else
				{
					Data[type].Remove(steamId);
				}
			}

			private static bool WouldRemoveCurrentExternalAdmin(string steamId, bool adminAfter, string action)
			{
				string text = (Forteca_ServerRewards.CurrentUserID ?? "").Trim();
				if (adminAfter || string.IsNullOrEmpty(text) || text == "ERROR")
				{
					return false;
				}
				if (!string.Equals(text, steamId, StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				if (SteamIdAccess.IsBuiltIn(text))
				{
					return false;
				}
				if (!Data["Admin"].Contains(steamId))
				{
					return false;
				}
				string text2 = action + ":" + steamId;
				if (pendingSelfAdminRemoval == text2)
				{
					return false;
				}
				pendingSelfAdminRemoval = text2;
				SetStatus("You are removing your own Admin access. Click again to confirm.");
				return true;
			}

			private static string NormalizeType(string type)
			{
				string[] types = Types;
				foreach (string text in types)
				{
					if (string.Equals(text, type, StringComparison.OrdinalIgnoreCase))
					{
						return text;
					}
				}
				return "Admin";
			}

			private static string PathFor(string type)
			{
				return type switch
				{
					"Premium" => FortecaPaths.PremiumUsersPath, 
					"Epic" => FortecaPaths.EpicUsersPath, 
					"Legendary" => FortecaPaths.LegendaryUsersPath, 
					_ => FortecaPaths.AdminUsersPath, 
				};
			}

			private static HashSet<string> ReadExternal(string path)
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				try
				{
					FortecaPaths.EnsureTextFile(path, "# One SteamID64 per line." + Environment.NewLine);
					string[] array = File.ReadAllLines(path);
					for (int i = 0; i < array.Length; i++)
					{
						string text = (array[i] ?? "").Trim();
						if (text.Length != 0 && !text.StartsWith("#") && SteamIdAccess.IsValidSteamId64(text) && !SteamIdAccess.IsBuiltIn(text))
						{
							hashSet.Add(text);
						}
					}
				}
				catch (Exception ex)
				{
					LogsModule.Log("Failed to read access file " + path + ": " + ex.Message);
				}
				return hashSet;
			}

			private static bool SaveType(string type)
			{
				string text = PathFor(type);
				try
				{
					Directory.CreateDirectory(Path.GetDirectoryName(text));
					object source = (File.Exists(text) ? ((object)File.ReadAllLines(text)) : ((object)new string[0]));
					List<string> list = ((IEnumerable<string>)source).Where((string line) => (line ?? "").TrimStart(Array.Empty<char>()).StartsWith("#")).ToList();
					if (list.Count == 0)
					{
						list.Add("# One SteamID64 per line.");
					}
					HashSet<string> hashSet = new HashSet<string>(((IEnumerable<string>)source).Select((string line) => (line ?? "").Trim()).Where(SteamIdAccess.IsBuiltIn), StringComparer.OrdinalIgnoreCase);
					List<string> list2 = (from id in (from id in Data[type].Where(SteamIdAccess.IsValidSteamId64)
							where !SteamIdAccess.IsBuiltIn(id)
							select id).Distinct<string>(StringComparer.OrdinalIgnoreCase)
						orderby id
						select id).ToList();
					list2.InsertRange(0, from id in BuiltIns.Where(hashSet.Contains)
						orderby id
						select id);
					List<string> list3 = new List<string>();
					list3.AddRange(list);
					if (list3.Count > 0 && list3[list3.Count - 1].Length != 0)
					{
						list3.Add("");
					}
					list3.AddRange(list2);
					string text2 = text + ".tmp";
					File.WriteAllLines(text2, list3, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					if (File.Exists(text))
					{
						File.Replace(text2, text, null);
					}
					else
					{
						File.Move(text2, text);
					}
					return true;
				}
				catch (Exception ex)
				{
					LogsModule.Log("Unable to update access file " + text + ": " + ex.Message);
					return false;
				}
			}
		}

		private sealed class WebhookSettings
		{
			public string WebhookUrl = "";

			public bool EnableWebhook;

			public bool StorePurchases = true;

			public bool DailyClaims = true;

			public bool PremiumClaims = true;

			public bool EpicClaims = true;

			public bool LegendaryClaims = true;

			public bool RedeemSuccess = true;

			public bool RedeemFailed = true;

			public bool RewardGrants = true;

			public bool AdminActions = true;

			public bool Errors = true;

			public bool ServerStarted = true;

			public bool ServerStopped = true;

			public bool FutureEventRewards;

			public string LastSendStatus = "Never sent";

			public string LastHttpError = "";

			public string LastSendUtc = "";
		}

		private static class WebhookManager
		{
			private static readonly object Sync = new object();

			public static WebhookSettings Data = new WebhookSettings();

			public static string Path => FortecaPaths.WebhookSettingsPath;

			public static void Load()
			{
				lock (Sync)
				{
					try
					{
						FortecaPaths.EnsureFreshStructure();
						if (!File.Exists(Path))
						{
							MigrateLegacyJsonIfPossible();
							SaveNoStatus();
							return;
						}
						WebhookSettings webhookSettings = new WebhookSettings();
						string[] array = File.ReadAllLines(Path);
						for (int i = 0; i < array.Length; i++)
						{
							string text = (array[i] ?? "").Trim();
							if (text.Length != 0 && !text.StartsWith("#"))
							{
								int num = text.IndexOf('=');
								if (num > 0)
								{
									Apply(webhookSettings, text.Substring(0, num).Trim(), text.Substring(num + 1).Trim());
								}
							}
						}
						Data = webhookSettings;
					}
					catch (Exception ex)
					{
						LogsModule.Log("Failed to parse webhook settings: " + ex.Message);
						Data = new WebhookSettings();
					}
				}
			}

			public static void Save()
			{
				lock (Sync)
				{
					BackupFile(Path);
					SaveNoStatus();
					SetStatus("Webhook saved");
				}
			}

			private static void SaveNoStatus()
			{
				string directoryName = System.IO.Path.GetDirectoryName(Path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.WriteAllLines(Path, Lines(Data), Encoding.UTF8);
			}

			public static void Update(string url, bool enabled, bool store, bool daily, bool premium, bool epic, bool legendary, bool redeemOk, bool redeemFail, bool grants, bool admin, bool errors, bool started, bool stopped, bool future)
			{
				Load();
				string text = (url ?? "").Trim();
				if (!string.IsNullOrWhiteSpace(text) && text.IndexOf("***", StringComparison.OrdinalIgnoreCase) < 0)
				{
					Data.WebhookUrl = text;
				}
				Data.EnableWebhook = enabled;
				Data.StorePurchases = store;
				Data.DailyClaims = daily;
				Data.PremiumClaims = premium;
				Data.EpicClaims = epic;
				Data.LegendaryClaims = legendary;
				Data.RedeemSuccess = redeemOk;
				Data.RedeemFailed = redeemFail;
				Data.RewardGrants = grants;
				Data.AdminActions = admin;
				Data.Errors = errors;
				Data.ServerStarted = started;
				Data.ServerStopped = stopped;
				Data.FutureEventRewards = future;
				Save();
			}

			public static void Clear()
			{
				Load();
				Data.WebhookUrl = "";
				Data.LastSendStatus = "URL cleared";
				Data.LastHttpError = "";
				Save();
			}

			public static void Test()
			{
				Load();
				bool flag = SendNow("Test Webhook", "Forteca_ServerRewards test webhook from Admin Suite.");
				HistoryManager.Add("Admin", "0", "Webhook", "Test", "", "Admin UI", flag ? "Sent" : "Failed", Data.LastSendStatus + " " + Data.LastHttpError);
				Save();
				SetStatus(flag ? "Webhook test sent" : ("Webhook test failed: " + Data.LastHttpError));
			}

			public static void SendEvent(string eventName, string message)
			{
				try
				{
					Load();
					if (!ShouldSend(eventName))
					{
						return;
					}
					ThreadPool.QueueUserWorkItem(delegate
					{
						try
						{
							SendNow(eventName, message);
							lock (Sync)
							{
								SaveNoStatus();
							}
						}
						catch (Exception ex2)
						{
							try
							{
								LogsModule.Log("Webhook event failed without blocking reward: " + ex2.Message);
							}
							catch
							{
							}
						}
					});
				}
				catch (Exception ex)
				{
					LogsModule.Log("Webhook event skipped without blocking reward: " + ex.Message);
				}
			}

			public static string MaskedUrl()
			{
				string text = ((Data != null) ? (Data.WebhookUrl ?? "") : "");
				if (string.IsNullOrWhiteSpace(text))
				{
					return "not configured";
				}
				if (text.Length <= 16)
				{
					return "***";
				}
				return text.Substring(0, Math.Min(28, text.Length)) + "...***";
			}

			private static bool ShouldSend(string eventName)
			{
				if (Data == null || !Data.EnableWebhook || string.IsNullOrWhiteSpace(Data.WebhookUrl))
				{
					return false;
				}
				string text = (eventName ?? "").ToLowerInvariant();
				if (text.Contains("kit") || text.Contains("store"))
				{
					return Data.StorePurchases;
				}
				if (text.Contains("daily claim"))
				{
					return Data.DailyClaims;
				}
				if (text.Contains("premium"))
				{
					return Data.PremiumClaims;
				}
				if (text.Contains("epic"))
				{
					return Data.EpicClaims;
				}
				if (text.Contains("legendary"))
				{
					return Data.LegendaryClaims;
				}
				if (text.Contains("redeem success"))
				{
					return Data.RedeemSuccess;
				}
				if (text.Contains("redeem fail") || text.Contains("redeem failure"))
				{
					return Data.RedeemFailed;
				}
				if (text.Contains("redeem"))
				{
					return Data.RedeemSuccess;
				}
				if (text.Contains("grant"))
				{
					return Data.RewardGrants;
				}
				if (text.Contains("admin"))
				{
					return Data.AdminActions;
				}
				if (text.Contains("error"))
				{
					return Data.Errors;
				}
				if (text.Contains("started"))
				{
					return Data.ServerStarted;
				}
				if (text.Contains("stopped"))
				{
					return Data.ServerStopped;
				}
				if (text.Contains("future"))
				{
					return Data.FutureEventRewards;
				}
				return true;
			}

			private static bool SendNow(string eventName, string message)
			{
				try
				{
					if (Data == null)
					{
						Data = new WebhookSettings();
					}
					if (!Data.EnableWebhook)
					{
						Data.LastSendStatus = "Skipped: disabled";
						Data.LastHttpError = "";
						return false;
					}
					if (string.IsNullOrWhiteSpace(Data.WebhookUrl))
					{
						Data.LastSendStatus = "Skipped: missing URL";
						Data.LastHttpError = "Webhook URL is empty";
						return false;
					}
					string s = "{\"content\":\"" + JsonEscape("**Forteca ServerRewards**\n" + eventName + "\n" + message) + "\"}";
					byte[] bytes = Encoding.UTF8.GetBytes(s);
					HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(Data.WebhookUrl);
					httpWebRequest.Method = "POST";
					httpWebRequest.ContentType = "application/json";
					httpWebRequest.Timeout = 8000;
					httpWebRequest.ReadWriteTimeout = 8000;
					httpWebRequest.ContentLength = bytes.Length;
					using (Stream stream = httpWebRequest.GetRequestStream())
					{
						stream.Write(bytes, 0, bytes.Length);
					}
					using HttpWebResponse httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
					int statusCode = (int)httpWebResponse.StatusCode;
					Data.LastSendUtc = DateTime.UtcNow.ToString("o");
					Data.LastSendStatus = "HTTP " + statusCode + " " + httpWebResponse.StatusDescription;
					Data.LastHttpError = ((statusCode >= 200 && statusCode < 300) ? "" : Data.LastSendStatus);
					return statusCode >= 200 && statusCode < 300;
				}
				catch (WebException ex)
				{
					Data.LastSendUtc = DateTime.UtcNow.ToString("o");
					Data.LastSendStatus = "Failed";
					Data.LastHttpError = ReadWebException(ex);
					LogsModule.Log("Webhook send failed: " + Data.LastHttpError);
					return false;
				}
				catch (Exception ex2)
				{
					Data.LastSendUtc = DateTime.UtcNow.ToString("o");
					Data.LastSendStatus = "Failed";
					Data.LastHttpError = ex2.Message;
					LogsModule.Log("Webhook send failed: " + ex2.Message);
					return false;
				}
			}

			private static string ReadWebException(WebException ex)
			{
				try
				{
					if (ex.Response is HttpWebResponse httpWebResponse)
					{
						using (httpWebResponse)
						{
							using StreamReader streamReader = new StreamReader(httpWebResponse.GetResponseStream() ?? Stream.Null);
							string text = streamReader.ReadToEnd();
							return "HTTP " + (int)httpWebResponse.StatusCode + " " + httpWebResponse.StatusDescription + (string.IsNullOrWhiteSpace(text) ? "" : (": " + text));
						}
					}
				}
				catch
				{
				}
				return ex.Message;
			}

			private static string JsonEscape(string value)
			{
				return (value ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "")
					.Replace("\n", "\\n");
			}

			private static void Apply(WebhookSettings s, string key, string value)
			{
				bool flag = Bool(value);
				string text = (key ?? "").Trim().ToLowerInvariant();
				if (text == null)
				{
					return;
				}
				switch (text.Length)
				{
				case 10:
					switch (text[0])
					{
					case 'w':
						if (text == "webhookurl")
						{
							s.WebhookUrl = value ?? "";
						}
						break;
					case 'e':
						if (text == "epicclaims")
						{
							s.EpicClaims = flag;
						}
						break;
					}
					break;
				case 13:
					switch (text[8])
					{
					case 'b':
						if (text == "enablewebhook")
						{
							s.EnableWebhook = flag;
						}
						break;
					case 'l':
						if (text == "premiumclaims")
						{
							s.PremiumClaims = flag;
						}
						break;
					case 'c':
						if (text == "redeemsuccess")
						{
							s.RedeemSuccess = flag;
						}
						break;
					case 'a':
						if (text == "serverstarted")
						{
							s.ServerStarted = flag;
						}
						break;
					case 'o':
						if (text == "serverstopped")
						{
							s.ServerStopped = flag;
						}
						break;
					case 'e':
						if (text == "lasthttperror")
						{
							s.LastHttpError = value ?? "";
						}
						break;
					}
					break;
				case 14:
					switch (text[0])
					{
					case 's':
						if (text == "storepurchases")
						{
							s.StorePurchases = flag;
						}
						break;
					case 'l':
						if (text == "lastsendstatus")
						{
							s.LastSendStatus = value ?? "";
						}
						break;
					}
					break;
				case 11:
					switch (text[0])
					{
					case 'd':
						if (text == "dailyclaims")
						{
							s.DailyClaims = flag;
						}
						break;
					case 'l':
						if (text == "lastsendutc")
						{
							s.LastSendUtc = value ?? "";
						}
						break;
					}
					break;
				case 12:
					switch (text[2])
					{
					case 'd':
						if (text == "redeemfailed")
						{
							s.RedeemFailed = flag;
						}
						break;
					case 'w':
						if (text == "rewardgrants")
						{
							s.RewardGrants = flag;
						}
						break;
					case 'm':
						if (text == "adminactions")
						{
							s.AdminActions = flag;
						}
						break;
					}
					break;
				case 15:
					if (text == "legendaryclaims")
					{
						s.LegendaryClaims = flag;
					}
					break;
				case 6:
					if (text == "errors")
					{
						s.Errors = flag;
					}
					break;
				case 18:
					if (text == "futureeventrewards")
					{
						s.FutureEventRewards = flag;
					}
					break;
				case 7:
				case 8:
				case 9:
				case 16:
				case 17:
					break;
				}
			}

			private static bool Bool(string value)
			{
				if (!string.Equals(value, "true", StringComparison.OrdinalIgnoreCase) && !(value == "1"))
				{
					return string.Equals(value, "yes", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}

			private static IEnumerable<string> Lines(WebhookSettings s)
			{
				yield return "# Forteca_ServerRewards Discord webhook settings";
				yield return "# URL is stored here for server-side delivery. The Admin UI masks the saved URL.";
				yield return "EnableWebhook=" + s.EnableWebhook;
				yield return "WebhookUrl=" + s.WebhookUrl;
				yield return "StorePurchases=" + s.StorePurchases;
				yield return "DailyClaims=" + s.DailyClaims;
				yield return "PremiumClaims=" + s.PremiumClaims;
				yield return "EpicClaims=" + s.EpicClaims;
				yield return "LegendaryClaims=" + s.LegendaryClaims;
				yield return "RedeemSuccess=" + s.RedeemSuccess;
				yield return "RedeemFailed=" + s.RedeemFailed;
				yield return "RewardGrants=" + s.RewardGrants;
				yield return "AdminActions=" + s.AdminActions;
				yield return "Errors=" + s.Errors;
				yield return "ServerStarted=" + s.ServerStarted;
				yield return "ServerStopped=" + s.ServerStopped;
				yield return "FutureEventRewards=" + s.FutureEventRewards;
				yield return "LastSendStatus=" + s.LastSendStatus;
				yield return "LastHttpError=" + (s.LastHttpError ?? "").Replace(Environment.NewLine, " ");
				yield return "LastSendUtc=" + s.LastSendUtc;
			}

			private static void MigrateLegacyJsonIfPossible()
			{
				try
				{
					if (File.Exists(FortecaPaths.WebhookPath))
					{
						WebhookSettings webhookSettings = JSON.ToObject<WebhookSettings>(File.ReadAllText(FortecaPaths.WebhookPath));
						if (webhookSettings != null)
						{
							Data = webhookSettings;
						}
					}
				}
				catch
				{
				}
			}
		}

		private sealed class HistoryFile
		{
			public List<HistoryEntry> Entries = new List<HistoryEntry>();
		}

		private sealed class HistoryEntry
		{
			public string Player = "";

			public string SteamID = "";

			public string RewardType = "";

			public string RewardName = "";

			public string RewardPack = "";

			public string RedeemCode = "";

			public string GrantedBy = "";

			public string DateUtc = "";

			public string Status = "";

			public string Result = "";
		}

		private static class HistoryManager
		{
			public static string Search = "";

			public static string Filter = "All";

			private static HistoryFile file = new HistoryFile();

			public static string Path => FortecaPaths.ClaimHistoryPath;

			public static void Load()
			{
				try
				{
					if (!File.Exists(Path))
					{
						file = new HistoryFile();
						Save();
						return;
					}
					file = JSON.ToObject<HistoryFile>(File.ReadAllText(Path)) ?? new HistoryFile();
				}
				catch (Exception ex)
				{
					LogsModule.Log("Failed to parse claim history: " + ex.Message);
					file = new HistoryFile();
				}
				if (file.Entries == null)
				{
					file.Entries = new List<HistoryEntry>();
				}
			}

			public static void Save()
			{
				BackupFile(Path);
				File.WriteAllText(Path, JSON.ToNiceJSON(file));
			}

			public static void Add(string player, string steam, string type, string name, string pack, string by, string state, string result)
			{
				Load();
				file.Entries.Add(new HistoryEntry
				{
					Player = (player ?? ""),
					SteamID = (steam ?? ""),
					RewardType = (type ?? ""),
					RewardName = (name ?? ""),
					RewardPack = (pack ?? ""),
					GrantedBy = (by ?? ""),
					DateUtc = DateTime.UtcNow.ToString("o"),
					Status = (state ?? ""),
					Result = (result ?? "")
				});
				Save();
			}

			public static IEnumerable<string> Describe()
			{
				IEnumerable<HistoryEntry> rows = (from e in Filtered()
					orderby e.DateUtc descending
					select e).Take(120).ToList();
				if (!rows.Any())
				{
					yield return "No history entries match filter.";
				}
				foreach (HistoryEntry item in rows)
				{
					yield return item.DateUtc + " | " + item.Status + " | " + item.Player + " | " + item.SteamID + " | " + item.RewardType + " | " + item.RewardName + " | " + item.Result;
				}
			}

			private static IEnumerable<HistoryEntry> Filtered()
			{
				DateTime now = DateTime.UtcNow;
				return from e in file.Entries
					where DateOk(e, now)
					where string.IsNullOrWhiteSpace(Search) || (e.Player + " " + e.SteamID + " " + e.RedeemCode + " " + e.RewardPack + " " + e.RewardName).IndexOf(Search, StringComparison.OrdinalIgnoreCase) >= 0
					select e;
			}

			private static bool DateOk(HistoryEntry e, DateTime now)
			{
				if (!DateTime.TryParse(e.DateUtc, out var result))
				{
					return true;
				}
				if (Filter == "Today")
				{
					return result.Date == now.Date;
				}
				if (Filter == "Week")
				{
					return (now - result).TotalDays <= 7.0;
				}
				if (Filter == "Month")
				{
					return (now - result).TotalDays <= 31.0;
				}
				return true;
			}
		}

		private sealed class AdminSettings
		{
			public int TokensPerHour = 10;

			public bool RewardPopup = true;

			public float PopupDuration = 4f;

			public bool Animations = true;

			public bool RedeemEnabled = true;

			public bool WebhookEnabled;

			public bool AutoReload = true;

			public bool DebugLogging;

			public bool ConfigAutoBackup = true;
		}

		private static class SettingsManager
		{
			public static AdminSettings Data = new AdminSettings();

			public static string Path => FortecaPaths.SettingsPath;

			public static void Load()
			{
				try
				{
					if (!File.Exists(Path))
					{
						Save();
					}
					else
					{
						Data = JSON.ToObject<AdminSettings>(File.ReadAllText(Path)) ?? new AdminSettings();
					}
				}
				catch (Exception ex)
				{
					LogsModule.Log("Failed to parse internal settings: " + ex.Message);
					Data = new AdminSettings();
				}
			}

			public static void Save()
			{
				BackupFile(Path);
				File.WriteAllText(Path, JSON.ToNiceJSON(Data));
				SetStatus("Settings saved");
			}

			public static void Update(string tokens, bool popup, string duration, bool animations, bool redeem, bool webhook, bool reload, bool debug, bool backup)
			{
				if (int.TryParse(tokens, out var result) && result >= 0)
				{
					Data.TokensPerHour = result;
				}
				if (float.TryParse(duration, out var result2) && result2 >= 0f)
				{
					Data.PopupDuration = result2;
				}
				Data.RewardPopup = popup;
				Data.Animations = animations;
				Data.RedeemEnabled = redeem;
				Data.WebhookEnabled = webhook;
				Data.AutoReload = reload;
				Data.DebugLogging = debug;
				Data.ConfigAutoBackup = backup;
				Save();
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__24_2;

			public static UnityAction <>9__24_3;

			public static UnityAction <>9__24_4;

			public static UnityAction <>9__24_5;

			public static UnityAction <>9__24_6;

			public static UnityAction <>9__24_7;

			public static UnityAction <>9__24_8;

			public static UnityAction <>9__24_9;

			public static UnityAction <>9__24_10;

			public static UnityAction <>9__24_11;

			public static UnityAction <>9__24_12;

			public static UnityAction <>9__24_13;

			public static UnityAction <>9__24_14;

			public static UnityAction <>9__25_0;

			public static UnityAction <>9__25_1;

			public static UnityAction <>9__25_2;

			public static UnityAction <>9__25_3;

			public static UnityAction <>9__26_1;

			public static UnityAction <>9__26_2;

			public static UnityAction <>9__26_3;

			public static UnityAction <>9__26_4;

			public static UnityAction <>9__26_5;

			public static UnityAction <>9__26_6;

			public static UnityAction <>9__26_7;

			public static UnityAction <>9__26_8;

			public static UnityAction <>9__27_1;

			public static Func<AccessRow, bool> <>9__27_3;

			public static UnityAction <>9__27_5;

			public static UnityAction <>9__30_1;

			public static UnityAction <>9__30_2;

			public static UnityAction <>9__30_3;

			public static UnityAction <>9__31_1;

			public static UnityAction <>9__32_1;

			public static UnityAction <>9__32_2;

			public static UnityAction <>9__32_3;

			public static Func<string, string> <>9__55_1;

			internal void <RenderDaily>b__24_2()
			{
				DailyManager.AddReward(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_3()
			{
				DailyManager.RemoveReward(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_4()
			{
				DailyManager.CopyDay(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_5()
			{
				DailyManager.PasteDay(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_6()
			{
				DailyManager.CopyWeek(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_7()
			{
				DailyManager.PasteWeek(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_8()
			{
				DailyManager.ResetDay(category, day);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_9()
			{
				DailyManager.ResetCategory(category);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_10()
			{
				DailyManager.Undo(category);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_11()
			{
				DailyManager.Redo(category);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_12()
			{
				DailyManager.Save(category);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_13()
			{
				DailyManager.Load(category);
				SetStatus("Reloaded " + category);
				Render(root, header);
			}

			internal void <RenderDaily>b__24_14()
			{
				ExportFile(DailyManager.PathFor(category), category + "Rewards");
				Render(root, header);
			}

			internal void <RenderRewardPacks>b__25_0()
			{
				RewardPackManager.Create();
				Render(root, header);
			}

			internal void <RenderRewardPacks>b__25_1()
			{
				RewardPackManager.Save();
				Render(root, header);
			}

			internal void <RenderRewardPacks>b__25_2()
			{
				RewardPackManager.Load();
				SetStatus("Reward packs reloaded");
				Render(root, header);
			}

			internal void <RenderRewardPacks>b__25_3()
			{
				ExportFile(RewardPackManager.Path, "RewardPacks");
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_1()
			{
				RedeemAdminManager.Create(random: false);
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_2()
			{
				RedeemAdminManager.Create(random: true);
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_3()
			{
				RedeemAdminManager.DuplicateFirst();
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_4()
			{
				RedeemAdminManager.DisableFirst();
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_5()
			{
				RedeemAdminManager.DeleteFirst();
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_6()
			{
				RedeemAdminManager.Save();
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_7()
			{
				RedeemAdminManager.Load();
				SetStatus("Redeem codes reloaded");
				Render(root, header);
			}

			internal void <RenderRedeem>b__26_8()
			{
				ExportFile(RedeemAdminManager.Path, "RedeemCodes");
				Render(root, header);
			}

			internal void <RenderAccessManagement>b__27_1()
			{
				AccessManager.Load();
				SetStatus("Access lists reloaded");
				Render(root, header);
			}

			internal bool <RenderAccessManagement>b__27_3(AccessRow r)
			{
				return r.SteamID == editSteamId;
			}

			internal void <RenderAccessManagement>b__27_5()
			{
				editSteamId = "";
				Render(root, header);
			}

			internal void <RenderWebhook>b__30_1()
			{
				WebhookManager.Clear();
				Render(root, header);
			}

			internal void <RenderWebhook>b__30_2()
			{
				WebhookManager.Test();
				Render(root, header);
			}

			internal void <RenderWebhook>b__30_3()
			{
				ExportFile(WebhookManager.Path, "Webhook");
				Render(root, header);
			}

			internal void <RenderHistory>b__31_1()
			{
				ExportFile(HistoryManager.Path, "History");
				Render(root, header);
			}

			internal void <RenderSettings>b__32_1()
			{
				Forteca_ServerRewards.ReloadExternalAssetsFromAdmin();
				SetStatus("Custom Themes & Assets reloaded from " + ExternalAssetSystem.RootPath);
				Render(root, header);
			}

			internal void <RenderSettings>b__32_2()
			{
				ExportAll();
				Render(root, header);
			}

			internal void <RenderSettings>b__32_3()
			{
				SetStatus("Import prepared: place reviewed JSON/CFG files in " + exportPath + " and reload the relevant page.");
				Render(root, header);
			}

			internal string <GetPrefabNames>b__55_1(string n)
			{
				return n;
			}
		}

		private static readonly string[] Pages = new string[8] { "Daily Rewards", "Reward Packs", "Redeem Codes", "Grant Rewards", "Access Management", "Webhook", "History", "Settings" };

		private static readonly string[] Categories = new string[4] { "Daily", "Premium", "Epic", "Legendary" };

		private static string rootPath;

		private static string backupPath;

		private static string exportPath;

		private static string page = "Daily Rewards";

		private static string category = "Daily";

		private static int day = 1;

		private static string status = "Ready";

		private static string globalSearch = "";

		private static string prefabSearch = "";

		private static string accessSteamId = "";

		private static string accessType = "Admin";

		private static string editSteamId = "";

		private static string pendingSelfAdminRemoval = "";

		private static GameObject root;

		private static Text header;

		private static Font font;

		internal static void Init()
		{
			FortecaPaths.EnsureFreshStructure();
			rootPath = FortecaPaths.Root;
			backupPath = FortecaPaths.BackupsPath;
			exportPath = FortecaPaths.ExportsPath;
			Directory.CreateDirectory(rootPath);
			Directory.CreateDirectory(backupPath);
			Directory.CreateDirectory(exportPath);
			font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			DailyManager.LoadAll();
			RewardPackManager.Load();
			RedeemAdminManager.Load();
			WebhookManager.Load();
			HistoryManager.Load();
			SettingsManager.Load();
		}

		internal static void Render(GameObject container, Text headerText)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			Init();
			root = container;
			header = headerText;
			Clear(root.transform);
			root.SetActive(true);
			header.text = "Admin - " + page;
			GameObject val = Panel(root.transform, "AdminSuite", new Color(0.03f, 0.025f, 0.02f, 0.86f));
			((Graphic)val.GetComponent<Image>()).raycastTarget = false;
			Stretch(val.GetComponent<RectTransform>());
			GameObject val2 = NavGrid(val.transform, "Nav", 78f);
			string[] pages = Pages;
			foreach (string text in pages)
			{
				string capture = text;
				MakeButton(val2.transform, text, (text == page) ? Green() : Brown(), (UnityAction)delegate
				{
					page = capture;
					Render(root, header);
				});
			}
			GameObject val3 = Panel(val.transform, "Body", new Color(0f, 0f, 0f, 0.15f));
			((Graphic)val3.GetComponent<Image>()).raycastTarget = false;
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(8f, 34f);
			component.offsetMax = new Vector2(-8f, -92f);
			val3.AddComponent<RectMask2D>();
			try
			{
				if (page == "Daily Rewards")
				{
					RenderDaily(val3.transform);
				}
				else if (page == "Reward Packs")
				{
					RenderRewardPacks(val3.transform);
				}
				else if (page == "Redeem Codes")
				{
					RenderRedeem(val3.transform);
				}
				else if (page == "Grant Rewards")
				{
					RenderGrant(val3.transform);
				}
				else if (page == "Access Management")
				{
					RenderAccessManagement(val3.transform);
				}
				else if (page == "Webhook")
				{
					RenderWebhook(val3.transform);
				}
				else if (page == "History")
				{
					RenderHistory(val3.transform);
				}
				else
				{
					RenderSettings(val3.transform);
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("Admin section render failed: " + page + " - " + ex.Message);
				ShowAdminSectionError(val3.transform, page, ex);
			}
			val2.transform.SetAsLastSibling();
			RectTransform component2 = ((Component)MakeLabel(val.transform, status, 13, (TextAnchor)3, Color.yellow)).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 0f);
			component2.offsetMin = new Vector2(12f, 6f);
			component2.offsetMax = new Vector2(-12f, 30f);
		}

		private static void ShowAdminSectionError(Transform parent, string failedPage, Exception ex)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel(parent, "AdminSectionError", new Color(0.08f, 0.025f, 0.015f, 0.88f));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.12f, 0.35f);
			component.anchorMax = new Vector2(0.88f, 0.62f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Stretch(((Component)MakeLabel(obj.transform, failedPage + " could not be rendered.\nCheck the log and configuration, then reload.", 16, (TextAnchor)4, Color.yellow)).GetComponent<RectTransform>());
		}

		internal static List<PlayerRewardPackView> GetRewardPackViews()
		{
			RewardPackManager.Load();
			return RewardPackManager.Views();
		}

		private static void RenderGlobalSearch(Transform parent)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Form(parent, 0f, 0f, 1f, 1f);
			MakeLabel(val.transform, "Global Search: " + globalSearch, 16, (TextAnchor)3, Color.white);
			foreach (string item in BuildGlobalSearchResults(globalSearch).Take(120))
			{
				MakeLabel(val.transform, item, 12, (TextAnchor)3, Color.white);
			}
		}

		private static void RenderDaily(Transform parent)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_024f: 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_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Expected O, but got Unknown
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Expected O, but got Unknown
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Expected O, but got Unknown
			//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Expected O, but got Unknown
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_063f: Expected O, but got Unknown
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Expected O, but got Unknown
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Expected O, but got Unknown
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Expected O, but got Unknown
			//IL_0724: Unknown result type (might be due to invalid IL or missing references)
			//IL_0708: Unknown result type (might be due to invalid IL or missing references)
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0713: Expected O, but got Unknown
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_0748: Expected O, but got Unknown
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0772: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_077d: Expected O, but got Unknown
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b2: Expected O, but got Unknown
			//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Expected O, but got Unknown
			//IL_082d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0811: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Expected O, but got Unknown
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_0846: Unknown result type (might be due to invalid IL or missing references)
			//IL_084b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0851: Expected O, but got Unknown
			//IL_087a: Unknown result type (might be due to invalid IL or missing references)
			//IL_087f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0885: Expected O, but got Unknown
			DailyData dailyData = DailyManager.Get(category);
			GameObject val = AnchoredPanel(parent, "DailyCategoryBar", new Color(0f, 0f, 0f, 0.18f), new Vector2(0f, 0.89f), new Vector2(1f, 1f), new Vector2(8f, -38f), new Vector2(-8f, -4f));
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
			((LayoutGroup)obj).padding = new RectOffset(6, 6, 3, 3);
			string[] categories = Categories;
			foreach (string text in categories)
			{
				string capture = text;
				MakeButton(val.transform, text, (text == category) ? Green() : Brown(), (UnityAction)delegate
				{
					category = capture;
					day = 1;
					Render(root, header);
				});
			}
			GameObject val2 = AnchoredPanel(parent, "DailyDayGrid", new Color(0f, 0f, 0f, 0.16f), new Vector2(0f, 0.17f), new Vector2(0.43f, 0.88f), new Vector2(8f, 8f), new Vector2(-6f, -6f));
			GridLayoutGroup obj2 = val2.AddComponent<GridLayoutGroup>();
			obj2.cellSize = new Vector2(118f, 34f);
			obj2.spacing = new Vector2(6f, 6f);
			obj2.constraint = (Constraint)1;
			obj2.constraintCount = 3;
			((LayoutGroup)obj2).padding = new RectOffset(8, 8, 8, 8);
			for (int num = 1; num <= 28; num++)
			{
				int capture2 = num;
				RewardLine reward = dailyData.Get(num);
				MakeButton(val2.transform, CompactRewardLabel(num, reward), (Color)((num == day) ? new Color(0.45f, 0.18f, 0.08f, 0.95f) : Brown()), (UnityAction)delegate
				{
					day = capture2;
					Render(root, header);
				});
			}
			RewardLine rewardLine = dailyData.Get(day);
			GameObject val3 = AnchoredPanel(parent, "DailySelectedEditor", new Color(0.04f, 0.025f, 0.015f, 0.72f), new Vector2(0.45f, 0.17f), new Vector2(1f, 0.88f), new Vector2(6f, 8f), new Vector2(-8f, -6f));
			VerticalLayoutGroup obj3 = val3.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 6f;
			((LayoutGroup)obj3).padding = new RectOffset(12, 12, 10, 10);
			MakeLabel(val3.transform, category + " Daily Reward Editor", 17, (TextAnchor)3, Color.white);
			MakeReadOnlyField(val3.transform, "Day", day.ToString());
			MakeReadOnlyField(val3.transform, "Display Name", RewardDisplayName(rewardLine));
			GameObject obj4 = Row(val3.transform, "IconPreviewRow", 54f, topAnchored: false);
			MakeLabel(obj4.transform, "Icon Preview", 13, (TextAnchor)3, new Color(0.9f, 0.82f, 0.62f, 1f));
			MakeIconPreview(obj4.transform, rewardLine);
			InputField prefab = MakeLabeledInput(val3.transform, "Prefab", rewardLine.Prefab);
			InputField amount = MakeLabeledInput(val3.transform, "Amount", rewardLine.Amount.ToString());
			InputField quality = MakeLabeledInput(val3.transform, "Quality", rewardLine.Quality.ToString());
			InputField variant = MakeLabeledInput(val3.transform, "Variant", rewardLine.Variant.ToString());
			GameObject val4 = Row(val3.transform, "PrefabBrowser", 32f, topAnchored: false);
			MakeLabel(val4.transform, "Prefab Search", 13, (TextAnchor)3, Color.white);
			InputField prefabFilter = MakeInput(val4.transform, prefabSearch, "type prefab");
			MakeButton(val4.transform, "Filter", Brown(), (UnityAction)delegate
			{
				prefabSearch = prefabFilter.text;
				Render(root, header);
			});
			foreach (string item in GetPrefabNames(prefabSearch).Take(3))
			{
				string capturePrefab = item;
				MakeButton(val4.transform, Short(capturePrefab, 14), Brown(), (UnityAction)delegate
				{
					prefab.text = capturePrefab;
					prefabSearch = capturePrefab;
				});
			}
			MakeLabel(val3.transform, "Preview: " + RewardPreviewReadable(rewardLine), 12, (TextAnchor)3, Color.yellow);
			GameObject obj5 = AnchoredPanel(parent, "DailyActionBar", new Color(0f, 0f, 0f, 0.2f), new Vector2(0f, 0f), new Vector2(1f, 0.155f), new Vector2(8f, 8f), new Vector2(-8f, -8f));
			GridLayoutGroup obj6 = obj5.AddComponent<GridLayoutGroup>();
			obj6.cellSize = new Vector2(116f, 30f);
			obj6.spacing = new Vector2(6f, 6f);
			obj6.constraint = (Constraint)1;
			obj6.constraintCount = 6;
			((LayoutGroup)obj6).padding = new RectOffset(8, 8, 6, 6);
			MakeButton(obj5.transform, "Apply", Green(), (UnityAction)delegate
			{
				DailyManager.Update(category, day, prefab.text, amount.text, quality.text, variant.text);
				Render(root, header);
			});
			Transform transform = obj5.transform;
			Color color = Green();
			object obj7 = <>c.<>9__24_2;
			if (obj7 == null)
			{
				UnityAction val5 = delegate
				{
					DailyManager.AddReward(category, day);
					Render(root, header);
				};
				<>c.<>9__24_2 = val5;
				obj7 = (object)val5;
			}
			MakeButton(transform, "Add Reward", color, (UnityAction)obj7);
			Transform transform2 = obj5.transform;
			Color color2 = Danger();
			object obj8 = <>c.<>9__24_3;
			if (obj8 == null)
			{
				UnityAction val6 = delegate
				{
					DailyManager.RemoveReward(category, day);
					Render(root, header);
				};
				<>c.<>9__24_3 = val6;
				obj8 = (object)val6;
			}
			MakeButton(transform2, "Remove", color2, (UnityAction)obj8);
			Transform transform3 = obj5.transform;
			Color color3 = Brown();
			object obj9 = <>c.<>9__24_4;
			if (obj9 == null)
			{
				UnityAction val7 = delegate
				{
					DailyManager.CopyDay(category, day);
					Render(root, header);
				};
				<>c.<>9__24_4 = val7;
				obj9 = (object)val7;
			}
			MakeButton(transform3, "Copy Day", color3, (UnityAction)obj9);
			Transform transform4 = obj5.transform;
			Color color4 = Brown();
			object obj10 = <>c.<>9__24_5;
			if (obj10 == null)
			{
				UnityAction val8 = delegate
				{
					DailyManager.PasteDay(category, day);
					Render(root, header);
				};
				<>c.<>9__24_5 = val8;
				obj10 = (object)val8;
			}
			MakeButton(transform4, "Paste Day", color4, (UnityAction)obj10);
			Transform transform5 = obj5.transform;
			Color color5 = Brown();
			object obj11 = <>c.<>9__24_6;
			if (obj11 == null)
			{
				UnityAction val9 = delegate
				{
					DailyManager.CopyWeek(category, day);
					Render(root, header);
				};
				<>c.<>9__24_6 = val9;
				obj11 = (object)val9;
			}
			MakeButton(transform5, "Copy Week", color5, (UnityAction)obj11);
			Transform transform6 = obj5.transform;
			Color color6 = Brown();
			object obj12 = <>c.<>9__24_7;
			if (obj12 == null)
			{
				UnityAction val10 = delegate
				{
					DailyManager.PasteWeek(category, day);
					Render(root, header);
				};
				<>c.<>9__24_7 = val10;
				obj12 = (object)val10;
			}
			MakeButton(transform6, "Paste Week", color6, (UnityAction)obj12);
			Transform transform7 = obj5.transform;
			Color color7 = Danger();
			object obj13 = <>c.<>9__24_8;
			if (obj13 == null)
			{
				UnityAction val11 = delegate
				{
					DailyManager.ResetDay(category, day);
					Render(root, header);
				};
				<>c.<>9__24_8 = val11;
				obj13 = (object)val11;
			}
			MakeButton(transform7, "Reset Day", color7, (UnityAction)obj13);
			Transform transform8 = obj5.transform;
			Color color8 = Danger();
			object obj14 = <>c.<>9__24_9;
			if (obj14 == null)
			{
				UnityAction val12 = delegate
				{
					DailyManager.ResetCategory(category);
					Render(root, header);
				};
				<>c.<>9__24_9 = val12;
				obj14 = (object)val12;
			}
			MakeButton(transform8, "Reset Cat", color8, (UnityAction)obj14);
			Transform transform9 = obj5.transform;
			Color color9 = Brown();
			object obj15 = <>c.<>9__24_10;
			if (obj15 == null)
			{
				UnityAction val13 = delegate
				{
					DailyManager.Undo(category);
					Render(root, header);
				};
				<>c.<>9__24_10 = val13;
				obj15 = (object)val13;
			}
			MakeButton(transform9, "Undo", color9, (UnityAction)obj15);
			Transform transform10 = obj5.transform;
			Color color10 = Brown();
			object obj16 = <>c.<>9__24_11;
			if (obj16 == null)
			{
				UnityAction val14 = delegate
				{
					DailyManager.Redo(category);
					Render(root, header);
				};
				<>c.<>9__24_11 = val14;
				obj16 = (object)val14;
			}
			MakeButton(transform10, "Redo", color10, (UnityAction)obj16);
			Transform transform11 = obj5.transform;
			Color color11 = Green();
			object obj17 = <>c.<>9__24_12;
			if (obj17 == null)
			{
				UnityAction val15 = delegate
				{
					DailyManager.Save(category);
					Render(root, header);
				};
				<>c.<>9__24_12 = val15;
				obj17 = (object)val15;
			}
			MakeButton(transform11, "Save", color11, (UnityAction)obj17);
			Transform transform12 = obj5.transform;
			Color color12 = Brown();
			object obj18 = <>c.<>9__24_13;
			if (obj18 == null)
			{
				UnityAction val16 = delegate
				{
					DailyManager.Load(category);
					SetStatus("Reloaded " + category);
					Render(root, header);
				};
				<>c.<>9__24_13 = val16;
				obj18 = (object)val16;
			}
			MakeButton(transform12, "Reload", color12, (UnityAction)obj18);
			Transform transform13 = obj5.transform;
			Color color13 = Brown();
			object obj19 = <>c.<>9__24_14;
			if (obj19 == null)
			{
				UnityAction val17 = delegate
				{
					ExportFile(DailyManager.PathFor(category), category + "Rewards");
					Render(root, header);
				};
				<>c.<>9__24_14 = val17;
				obj19 = (object)val17;
			}
			MakeButton(transform13, "Export", color13, (UnityAction)obj19);
		}

		private static void RenderRewardPacks(Transform parent)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d9: 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)
			//IL_00e4: Expected O, but got Unknown
			RewardPackManager.Load();
			GameObject obj = Row(parent, "PacksTop", 34f, topAnchored: true);
			Transform transform = obj.transform;
			Color color = Green();
			object obj2 = <>c.<>9__25_0;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					RewardPackManager.Create();
					Render(root, header);
				};
				<>c.<>9__25_0 = val;
				obj2 = (object)val;
			}
			MakeButton(transform, "Create Pack", color, (UnityAction)obj2);
			Transform transform2 = obj.transform;
			Color color2 = Green();
			object obj3 = <>c.<>9__25_1;
			if (obj3 == null)
			{
				UnityAction val2 = delegate
				{
					RewardPackManager.Save();
					Render(root, header);
				};
				<>c.<>9__25_1 = val2;
				obj3 = (object)val2;
			}
			MakeButton(transform2, "Save", color2, (UnityAction)obj3);
			Transform transform3 = obj.transform;
			Color color3 = Brown();
			object obj4 = <>c.<>9__25_2;
			if (obj4 == null)
			{
				UnityAction val3 = delegate
				{
					RewardPackManager.Load();
					SetStatus("Reward packs reloaded");
					Render(root, header);
				};
				<>c.<>9__25_2 = val3;
				obj4 = (object)val3;
			}
			MakeButton(transform3, "Reload", color3, (UnityAction)obj4);
			Transform transform4 = obj.transform;
			Color color4 = Brown();
			object obj5 = <>c.<>9__25_3;
			if (obj5 == null)
			{
				UnityAction val4 = delegate
				{
					ExportFile(RewardPackManager.Path, "RewardPacks");
					Render(root, header);
				};
				<>c.<>9__25_3 = val4;
				obj5 = (object)val4;
			}
			MakeButton(transform4, "Export", color4, (UnityAction)obj5);
			TextList(parent, RewardPackManager.Describe(), 13);
			obj.transform.SetAsLastSibling();
		}

		private static void RenderRedeem(Transform parent)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0065: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01d8: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			RedeemAdminManager.Load();
			GameObject val = Row(parent, "RedeemTop", 34f, topAnchored: true);
			InputField search = MakeInput(val.transform, RedeemAdminManager.Search, "Search");
			MakeButton(val.transform, "Search", Brown(), (UnityAction)delegate
			{
				RedeemAdminManager.Search = search.text;
				Render(root, header);
			});
			Transform transform = val.transform;
			Color color = Green();
			object obj = <>c.<>9__26_1;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					RedeemAdminManager.Create(random: false);
					Render(root, header);
				};
				<>c.<>9__26_1 = val2;
				obj = (object)val2;
			}
			MakeButton(transform, "Create", color, (UnityAction)obj);
			Transform transform2 = val.transform;
			Color color2 = Green();
			object obj2 = <>c.<>9__26_2;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					RedeemAdminManager.Create(random: true);
					Render(root, header);
				};
				<>c.<>9__26_2 = val3;
				obj2 = (object)val3;
			}
			MakeButton(transform2, "Random", color2, (UnityAction)obj2);
			Transform transform3 = val.transform;
			Color color3 = Brown();
			object obj3 = <>c.<>9__26_3;
			if (obj3 == null)
			{
				UnityAction val4 = delegate
				{
					RedeemAdminManager.DuplicateFirst();
					Render(root, header);
				};
				<>c.<>9__26_3 = val4;
				obj3 = (object)val4;
			}
			MakeButton(transform3, "Duplicate", color3, (UnityAction)obj3);
			Transform transform4 = val.transform;
			Color color4 = Brown();
			object obj4 = <>c.<>9__26_4;
			if (obj4 == null)
			{
				UnityAction val5 = delegate
				{
					RedeemAdminManager.DisableFirst();
					Render(root, header);
				};
				<>c.<>9__26_4 = val5;
				obj4 = (object)val5;
			}
			MakeButton(transform4, "Disable", color4, (UnityAction)obj4);
			Transform transform5 = val.transform;
			Color color5 = Danger();
			object obj5 = <>c.<>9__26_5;
			if (obj5 == null)
			{
				UnityAction val6 = delegate
				{
					RedeemAdminManager.DeleteFirst();
					Render(root, header);
				};
				<>c.<>9__26_5 = val6;
				obj5 = (object)val6;
			}
			MakeButton(transform5, "Delete", color5, (UnityAction)obj5);
			Transform transform6 = val.transform;
			Color color6 = Green();
			object obj6 = <>c.<>9__26_6;
			if (obj6 == null)
			{
				UnityAction val7 = delegate
				{
					RedeemAdminManager.Save();
					Render(root, header);
				};
				<>c.<>9__26_6 = val7;
				obj6 = (object)val7;
			}
			MakeButton(transform6, "Save", color6, (UnityAction)obj6);
			Transform transform7 = val.transform;
			Color color7 = Brown();
			object obj7 = <>c.<>9__26_7;
			if (obj7 == null)
			{
				UnityAction val8 = delegate
				{
					RedeemAdminManager.Load();
					SetStatus("Redeem codes reloaded");
					Render(root, header);
				};
				<>c.<>9__26_7 = val8;
				obj7 = (object)val8;
			}
			MakeButton(transform7, "Reload", color7, (UnityAction)obj7);
			Transform transform8 = val.transform;
			Color color8 = Brown();
			object obj8 = <>c.<>9__26_8;
			if (obj8 == null)
			{
				UnityAction val9 = delegate
				{
					ExportFile(RedeemAdminManager.Path, "RedeemCodes");
					Render(root, header);
				};
				<>c.<>9__26_8 = val9;
				obj8 = (object)val9;
			}
			MakeButton(transform8, "Export", color8, (UnityAction)obj8);
			RedeemSystem.RedeemCode redeemCode = RedeemAdminManager.FirstFiltered();
			if (redeemCode != null)
			{
				GameObject val10 = Form(parent, 0f, 0f, 1f, 0.45f);
				MakeLabel(val10.transform, "Edit first filtered code: " + redeemCode.Code, 15, (TextAnchor)3, Color.white);
				InputField codeName = MakeInput(val10.transform, redeemCode.Code, "Code");
				InputField maxUses = MakeInput(val10.transform, redeemCode.MaxUses.ToString(), "Max Uses (0 unlimited)");
				InputField expires = MakeInput(val10.transform, redeemCode.ExpirationUtc ?? "", "Expiration UTC");
				InputField allowed = MakeInput(val10.transform, string.Join(";", redeemCode.AllowedSteamIDs ?? new List<string>()), "Allowed SteamIDs ; separated");
				Toggle disabled = MakeToggle(val10.transform, "Disabled", redeemCode.Disabled);
				Toggle oneSteam = MakeToggle(val10.transform, "One Claim Per SteamID", redeemCode.OneTimePerSteamID);
				RedeemSystem.RedeemReward redeemReward = ((redeemCode.Rewards != null && redeemCode.Rewards.Count > 0) ? redeemCode.Rewards[0] : new RedeemSystem.RedeemReward
				{
					Prefab = "Wood",
					Amount = 10,
					Quality = 1
				});
				InputField rewardPrefab = MakeInput(val10.transform, redeemReward.Prefab, "First reward prefab");
				InputField rewardAmount = MakeInput(val10.transform, redeemReward.Amount.ToString(), "First reward amount");
				MakeButton(Row(val10.transform, "RedeemEditActions", 34f, topAnchored: false).transform, "Apply Code", Green(), (UnityAction)delegate
				{
					RedeemAdminManager.UpdateFirst(codeName.text, maxUses.text, expires.text, allowed.text, disabled.isOn, oneSteam.isOn, rewardPrefab.text, rewardAmount.text);
					Render(root, header);
				});
			}
			TextList(parent, RedeemAdminManager.Describe(), 12);
		}

		private static void RenderAccessManagement(Transform parent)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Expected O, but got Unknown
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_051c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Expected O, but got Unknown
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Expected O, but got Unknown
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			AccessManager.Load();
			GameObject val = Form(parent, 0f, 0.58f, 1f, 1f);
			MakeLabel(val.transform, "Admin & Reward Access", 18, (TextAnchor)3, Color.white);
			MakeLabel(val.transform, "Manage SteamID64 access for Admin, Premium, Epic, and Legendary rewards.", 13, (TextAnchor)3, new Color(0.9f, 0.82f, 0.62f, 1f));
			MakeLabel(val.transform, "SteamID64", 14, (TextAnchor)3, Color.white);
			InputField steam = MakeInput(val.transform, accessSteamId, "76561198000000000");
			LayoutElement component = ((Component)steam).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.minWidth = 360f;
				component.preferredWidth = 420f;
			}
			MakeLabel(val.transform, "Access Type", 14, (TextAnchor)3, Color.white);
			GameObject val2 = Row(val.transform, "AccessType", 34f, topAnchored: false);
			string[] array = new string[4] { "Admin", "Premium", "Epic", "Legendary" };
			foreach (string text in array)
			{
				string capture = text;
				MakeButton(val2.transform, text, (text == accessType) ? Green() : Brown(), (UnityAction)delegate
				{
					accessSteamId = steam.text;
					accessType = capture;
					Render(root, header);
				});
			}
			GameObject obj = Row(val.transform, "AccessAdd", 34f, topAnchored: false);
			MakeButton(obj.transform, "Add Access", Green(), (UnityAction)delegate
			{
				accessSteamId = steam.text;
				AccessManager.Add(accessSteamId, accessType);
				Render(root, header);
			});
			Transform transform = obj.transform;
			Color color = Brown();
			object obj2 = <>c.<>9__27_1;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					AccessManager.Load();
					SetStatus("Access lists reloaded");
					Render(root, header);
				};
				<>c.<>9__27_1 = val3;
				obj2 = (object)val3;
			}
			MakeButton(transform, "Reload", color, (UnityAction)obj2);
			if (!string.IsNullOrWhiteSpace(editSteamId))
			{
				AccessRow accessRow = AccessManager.Rows().FirstOrDefault((AccessRow r) => r.SteamID == editSteamId);
				if (accessRow != null && !accessRow.BuiltIn)
				{
					GameObject val4 = Form(parent, 0f, 0.43f, 1f, 0.57f);
					MakeLabel(val4.transform, "Edit access: " + editSteamId, 14, (TextAnchor)3, Color.white);
					Toggle admin = MakeToggle(val4.transform, "Admin", accessRow.Admin);
					Toggle premium = MakeToggle(val4.transform, "Premium", accessRow.Premium);
					Toggle epic = MakeToggle(val4.transform, "Epic", accessRow.Epic);
					Toggle legendary = MakeToggle(val4.transform, "Legendary", accessRow.Legendary);
					GameObject obj3 = Row(val4.transform, "AccessEditActions", 34f, topAnchored: false);
					MakeButton(obj3.transform, "Save Changes", Green(), (UnityAction)delegate
					{
						AccessManager.Update(editSteamId, admin.isOn, premium.isOn, epic.isOn, legendary.isOn);
						Render(root, header);
					});
					Transform transform2 = obj3.transform;
					Color color2 = Brown();
					object obj4 = <>c.<>9__27_5;
					if (obj4 == null)
					{
						UnityAction val5 = delegate
						{
							editSteamId = "";
							Render(root, header);
						};
						<>c.<>9__27_5 = val5;
						obj4 = (object)val5;
					}
					MakeButton(transform2, "Cancel", color2, (UnityAction)obj4);
				}
			}
			GameObject obj5 = Form(parent, 0f, 0f, 1f, string.IsNullOrWhiteSpace(editSteamId) ? 0.57f : 0.42f);
			MakeLabel(obj5.transform, "SteamID64 | Admin | Premium | Epic | Legendary | Action", 13, (TextAnchor)3, Color.yellow);
			GameObject val6 = ScrollArea(obj5.transform, "AccessScroll");
			foreach (AccessRow item in AccessManager.Rows())
			{
				GameObject val7 = Row(val6.transform, "AccessRow_" + item.SteamID, 30f, topAnchored: false);
				MakeLabel(val7.transform, item.SteamID + " | " + Yes(item.Admin) + " | " + Yes(item.Premium) + " | " + Yes(item.Epic) + " | " + Yes(item.Legendary), 12, (TextAnchor)3, (Color)(item.BuiltIn ? new Color(0.9f, 0.75f, 0.35f, 1f) : Color.white));
				if (item.BuiltIn)
				{
					MakeLabel(val7.transform, "Built-in Owner", 12, (TextAnchor)4, new Color(0.9f, 0.75f, 0.35f, 1f));
					continue;
				}
				string capture2 = item.SteamID;
				MakeButton(val7.transform, "Edit", Brown(), (UnityAction)delegate
				{
					editSteamId = capture2;
					Render(root, header);
				});
				MakeButton(val7.transform, "Remove All", Danger(), (UnityAction)delegate
				{
					AccessManager.RemoveAll(capture2);
					if (editSteamId == capture2)
					{
						editSteamId = "";
					}
					Render(root, header);
				});
			}
		}

		private static string Yes(bool value)
		{
			if (!value)
			{
				return "NO";
			}
			return "YES";
		}

		private static void RenderGrant(Transform parent)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0153: 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)
			//IL_0169: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Form(parent, 0f, 0f, 1f, 1f);
			MakeLabel(val.transform, "Grant Rewards", 16, (TextAnchor)3, Color.white);
			InputField target = MakeInput(val.transform, "", "Online player / SteamID");
			InputField pack = MakeInput(val.transform, "", "Reward Pack");
			InputField prefab = MakeInput(val.transform, "Wood", "Prefab");
			InputField amount = MakeInput(val.transform, "1", "Amount");
			InputField tokens = MakeInput(val.transform, "0", "Tokens");
			Toggle broadcast = MakeToggle(val.transform, "Broadcast", value: false);
			Toggle notify = MakeToggle(val.transform, "Private notification", value: true);
			GameObject obj = Row(val.transform, "GrantActions", 34f, topAnchored: false);
			MakeButton(obj.transform, "Validate", Brown(), (UnityAction)delegate
			{
				SetStatus(GrantManager.Validate(prefab.text, amount.text, tokens.text));
				Render(root, header);
			});
			MakeButton(obj.transform, "Confirm Grant", Green(), (UnityAction)delegate
			{
				GrantManager.Grant(target.text, pack.text, prefab.text, amount.text, tokens.text, broadcast.isOn, notify.isOn);
				Render(root, header);
			});
			MakeButton(obj.transform, "Grant To Myself", Green(), (UnityAction)delegate
			{
				GrantManager.GrantToMyself(pack.text, prefab.text, amount.text, tokens.text, broadcast.isOn, notify.isOn);
				Render(root, header);
			});
			MakeLabel(val.transform, RewardPreview(new RewardLine
			{
				Prefab = prefab.text,
				Amount = ParseInt(new string[2] { "", amount.text }, 1, 1)
			}), 12, (TextAnchor)3, Color.yellow);
			MakeLabel(val.transform, "Remote/offline delivery is logged and prepared for future server RPC expansion; no existing gameplay RPCs were changed.", 12, (TextAnchor)3, Color.yellow);
		}

		private static void RenderWebhook(Transform parent)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Expected O, but got Unknown
			//IL_02e6: 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_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Expected O, but got Unknown
			//IL_034f: 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_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Expected O, but got Unknown
			WebhookManager.Load();
			WebhookSettings data = WebhookManager.Data;
			GameObject val = Form(parent, 0f, 0f, 1f, 1f);
			MakeLabel(val.transform, "Discord Webhook", 18, (TextAnchor)3, Color.white);
			MakeLabel(val.transform, "Saved URL: " + WebhookManager.MaskedUrl(), 12, (TextAnchor)3, new Color(0.9f, 0.82f, 0.62f, 1f));
			InputField url = MakeInput(val.transform, "", "Paste new Discord Webhook URL to replace saved URL");
			Toggle enabled = MakeToggle(val.transform, "Enable Webhook", data.EnableWebhook);
			Toggle store = MakeToggle(val.transform, "Kit Pack Purchase", data.StorePurchases);
			Toggle daily = MakeToggle(val.transform, "Daily Claim", data.DailyClaims);
			Toggle premium = MakeToggle(val.transform, "Premium Claim", data.PremiumClaims);
			Toggle epic = MakeToggle(val.transform, "Epic Claim", data.EpicClaims);
			Toggle legendary = MakeToggle(val.transform, "Legendary Claim", data.LegendaryClaims);
			Toggle redeemOk = MakeToggle(val.transform, "Redeem Success", data.RedeemSuccess);
			Toggle redeemFail = MakeToggle(val.transform, "Redeem Failed", data.RedeemFailed);
			Toggle grants = MakeToggle(val.transform, "Admin Grant", data.RewardGrants);
			Toggle admin = MakeToggle(val.transform, "Admin Actions", data.AdminActions);
			Toggle errors = MakeToggle(val.transform, "Errors", data.Errors);
			Toggle started = MakeToggle(val.transform, "Server Started", data.ServerStarted);
			Toggle stopped = MakeToggle(val.transform, "Server Stopped", data.ServerStopped);
			Toggle future = MakeToggle(val.transform, "Future Event Rewards", data.FutureEventRewards);
			MakeLabel(val.transform, "Last send status: " + (string.IsNullOrWhiteSpace(data.LastSendStatus) ? "Never sent" : data.LastSendStatus), 12, (TextAnchor)3, Color.yellow);
			MakeLabel(val.transform, "Last HTTP error: " + (string.IsNullOrWhiteSpace(data.LastHttpError) ? "None" : data.LastHttpError), 12, (TextAnchor)3, string.IsNullOrWhiteSpace(data.LastHttpError) ? Color.white : Color.red);
			GameObject obj = Row(val.transform, "WebhookActions", 34f, topAnchored: false);
			MakeButton(obj.transform, "Save", Green(), (UnityAction)delegate
			{
				WebhookManager.Update(url.text, enabled.isOn, store.isOn, daily.isOn, premium.isOn, epic.isOn, legendary.isOn, redeemOk.isOn, redeemFail.isOn, grants.isOn, admin.isOn, errors.isOn, started.isOn, stopped.isOn, future.isOn);
				Render(root, header);
			});
			Transform transform = obj.transform;
			Color color = Danger();
			object obj2 = <>c.<>9__30_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					WebhookManager.Clear();
					Render(root, header);
				};
				<>c.<>9__30_1 = val2;
				obj2 = (object)val2;
			}
			MakeButton(transform, "Clear", color, (UnityAction)obj2);
			Transform transform2 = obj.transform;
			Color color2 = Brown();
			object obj3 = <>c.<>9__30_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					WebhookManager.Test();
					Render(root, header);
				};
				<>c.<>9__30_2 = val3;
				obj3 = (object)val3;
			}
			MakeButton(transform2, "Test Webhook", color2, (UnityAction)obj3);
			Transform transform3 = obj.transform;
			Color color3 = Brown();
			object obj4 = <>c.<>9__30_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					ExportFile(WebhookManager.Path, "Webhook");
					Render(root, header);
				};
				<>c.<>9__30_3 = val4;
				obj4 = (object)val4;
			}
			MakeButton(transform3, "Export", color3, (UnityAction)obj4);
		}

		private static void RenderHistory(Transform parent)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			HistoryManager.Load();
			GameObject val = Row(parent, "HistoryTop", 34f, topAnchored: true);
			InputField search = MakeInput(val.transform, HistoryManager.Search, "Search");
			MakeButton(val.transform, "Search", Brown(), (UnityAction)delegate
			{
				HistoryManager.Search = search.text;
				Render(root, header);
			});
			string[] array = new string[4] { "Today", "Week", "Month", "All" };
			foreach (string text in array)
			{
				string capture = text;
				MakeButton(val.transform, text, (HistoryManager.Filter == text) ? Green() : Brown(), (UnityAction)delegate
				{
					HistoryManager.Filter = capture;
					Render(root, header);
				});
			}
			Transform transform = val.transform;
			Color color = Brown();
			object obj = <>c.<>9__31_1;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					ExportFile(HistoryManager.Path, "History");
					Render(root, header);
				};
				<>c.<>9__31_1 = val2;
				obj = (object)val2;
			}
			MakeButton(transform, "Export", color, (UnityAction)obj);
			TextList(parent, HistoryManager.Describe(), 12);
		}

		private static void RenderSettings(Transform parent)
		{
			//IL_0153: 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)
			//IL_0169: Expected O, but got Unknown
			//IL_0175: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			SettingsManager.Load();
			AdminSettings data = SettingsManager.Data;
			GameObject val = Form(parent, 0f, 0f, 1f, 1f);
			InputField tokens = MakeInput(val.transform, data.TokensPerHour.ToString(), "Tokens Per Hour");
			Toggle popup = MakeToggle(val.transform, "Reward Popup", data.RewardPopup);
			InputField duration = MakeInput(val.transform, data.PopupDuration.ToString(), "Popup Duration");
			Toggle animations = MakeToggle(val.transform, "Animations", data.Animations);
			Toggle redeem = MakeToggle(val.transform, "Redeem Enabled", data.RedeemEnabled);
			Toggle webhook = MakeToggle(val.transform, "Webhook Enabled", data.WebhookEnabled);
			Toggle autoReload = MakeToggle(val.transform, "Auto Reload", data.AutoReload);
			Toggle debug = MakeToggle(val.transform, "Debug Logging", data.DebugLogging);
			Toggle backups = MakeToggle(val.transform, "Config Auto Backup", data.ConfigAutoBackup);
			GameObject obj = Row(val.transform, "SettingsActions", 34f, topAnchored: false);
			MakeButton(obj.transform, "Save", Green(), (UnityAction)delegate
			{
				SettingsManager.Update(tokens.text, popup.isOn, duration.text, animations.isOn, redeem.isOn, webhook.isOn, autoReload.isOn, debug.isOn, backups.isOn);
				Render(root, header);
			});
			Transform transform = obj.transform;
			Color color = Brown();
			object obj2 = <>c.<>9__32_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					Forteca_ServerRewards.ReloadExternalAssetsFromAdmin();
					SetStatus("Custom Themes & Assets reloaded from " + ExternalAssetSystem.RootPath);
					Render(root, header);
				};
				<>c.<>9__32_1 = val2;
				obj2 = (object)val2;
			}
			MakeButton(transform, "Reload Themes", color, (UnityAction)obj2);
			Transform transform2 = obj.transform;
			Color color2 = Brown();
			object obj3 = <>c.<>9__32_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					ExportAll();
					Render(root, header);
				};
				<>c.<>9__32_2 = val3;
				obj3 = (object)val3;
			}
			MakeButton(transform2, "Export All", color2, (UnityAction)obj3);
			Transform transform3 = obj.transform;
			Color color3 = Brown();
			object obj4 = <>c.<>9__32_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					SetStatus("Import prepared: place reviewed JSON/CFG files in " + exportPath + " and reload the relevant page.");
					Render(root, header);
				};
				<>c.<>9__32_3 = val4;
				obj4 = (object)val4;
			}
			MakeButton(transform3, "Import", color3, (UnityAction)obj4);
			MakeLabel(val.transform, "Settings UI writes Internal/Settings.json. Editable files are under Editable/; old flat Daily/Redeem/User paths are not supported by Hotfix 2.", 12, (TextAnchor)3, Color.yellow);
		}

		private static GameObject AnchoredPanel(Transform parent, string name, Color color, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel(parent, name, color);
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
			return obj;
		}

		private static string CompactRewardLabel(int index, RewardLine reward)
		{
			if (reward == null)
			{
				return index + ". Empty";
			}
			string text = ((reward.Amount > 0) ? (" x" + reward.Amount) : " empty");
			return index + ". " + Short(reward.Prefab, 13) + text;
		}

		private static InputField MakeLabeledInput(Transform parent, string label, string value)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Row(parent, "Field_" + label, 32f, topAnchored: false);
			LayoutElement component = ((Component)MakeLabel(obj.transform, label, 13, (TextAnchor)3, new Color(0.9f, 0.82f, 0.62f, 1f))).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.minWidth = 110f;
			}
			InputField obj2 = MakeInput(obj.transform, value, label);
			LayoutElement component2 = ((Component)obj2).GetComponent<LayoutElement>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.minWidth = 220f;
				component2.flexibleWidth = 1f;
			}
			return obj2;
		}

		private static void MakeReadOnlyField(Transform parent, string label, string value)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Row(parent, "Readonly_" + label, 28f, topAnchored: false);
			LayoutElement component = ((Component)MakeLabel(obj.transform, label, 13, (TextAnchor)3, new Color(0.9f, 0.82f, 0.62f, 1f))).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.minWidth = 110f;
			}
			MakeLabel(obj.transform, value ?? "", 13, (TextAnchor)3, Color.white);
		}

		private static void MakeIconPreview(Transform parent, RewardLine reward)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = Panel(parent, "IconPreview", new Color(0.02f, 0.015f, 0.01f, 0.8f));
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.minWidth = 52f;
				obj.minHeight = 52f;
				obj.preferredWidth = 52f;
				obj.preferredHeight = 52f;
				Image component = val.GetComponent<Image>();
				Sprite val2 = (component.sprite = RewardIcon(reward));
				component.preserveAspect = true;
				((Graphic)component).color = (Color)(((Object)(object)val2 != (Object)null) ? Color.white : new Color(0.12f, 0.08f, 0.045f, 0.95f));
				if ((Object)(object)val2 == (Object)null)
				{
					Stretch(((Component)MakeLabel(val.transform, "no icon", 10, (TextAnchor)4, new Color(0.9f, 0.82f, 0.62f, 1f))).GetComponent<RectTransform>());
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("Admin Daily icon preview failed: " + ex.Message);
				try
				{
					LayoutElement component2 = ((Component)MakeLabel(parent, "Icon Preview: unavailable", 12, (TextAnchor)3, Color.yellow)).GetComponent<LayoutElement>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.minHeight = 28f;
					}
				}
				catch
				{
				}
			}
		}

		private static string RewardDisplayName(RewardLine reward)
		{
			if (reward == null || string.IsNullOrWhiteSpace(reward.Prefab))
			{
				return "No reward selected";
			}
			try
			{
				GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(reward.Prefab) : null);
				val = val ?? (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(reward.Prefab) : null);
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 != (Object)null && val2.m_itemData != null && val2.m_itemData.m_shared != null && !string.IsNullOrWhiteSpace(val2.m_itemData.m_shared.m_name))
				{
					return (Localization.instance != null) ? Localization.instance.Localize(val2.m_itemData.m_shared.m_name) : val2.m_itemData.m_shared.m_name;
				}
			}
			catch
			{
			}
			return reward.Prefab;
		}

		private static Sprite RewardIcon(RewardLine reward)
		{
			try
			{
				GameObject val = ((reward != null && (Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(reward.Prefab) : null);
				val = val ?? ((reward != null && (Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(reward.Prefab) : null);
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 != (Object)null && val2.m_itemData != null && val2.m_itemData.m_shared != null && val2.m_itemData.m_shared.m_icons != null && val2.m_itemData.m_shared.m_icons.Length != 0)
				{
					return val2.m_itemData.m_shared.m_icons[0];
				}
			}
			catch
			{
			}
			return null;
		}

		private static string RewardPreviewReadable(RewardLine reward)
		{
			if (reward == null)
			{
				return "No reward selected";
			}
			return "Prefab " + reward.Prefab + ", Amount " + reward.Amount + ", Quality " + reward.Quality + ", Variant " + reward.Variant;
		}

		private static GameObject Form(Transform parent, float x0, float y0, float x1, float y1)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			GameObject obj = Panel(parent, "Form", new Color(0.04f, 0.025f, 0.015f, 0.65f));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(x0, y0);
			component.anchorMax = new Vector2(x1, y1);
			component.offsetMin = new Vector2(0f, 0f);
			component.offsetMax = new Vector2(0f, -40f);
			VerticalLayoutGroup obj2 = obj.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 6f;
			((LayoutGroup)obj2).padding = new RectOffset(10, 10, 10, 10);
			return obj;
		}

		private static void TextList(Transform parent, IEnumerable<string> rows, int size)
		{
			ScrollAreaInto(Form(parent, 0f, 0f, 1f, 0.88f).transform, "TextList", rows, size);
		}

		private static void ScrollAreaInto(Transform parent, string name, IEnumerable<string> rows, int size)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ScrollArea(parent, name);
			foreach (string item in (rows ?? Enumerable.Empty<string>()).Take(200))
			{
				MakeLabel(val.transform, item, size, (TextAnchor)3, Color.white);
			}
		}

		private static GameObject ScrollArea(Transform parent, string name)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel(parent, name + "Viewport", new Color(0f, 0f, 0f, 0.12f));
			RectTransform component = obj.GetComponent<RectTransform>();
			LayoutElement obj2 = obj.AddComponent<LayoutElement>();
			obj2.minHeight = 120f;
			obj2.preferredHeight = 260f;
			obj2.flexibleHeight = 1f;
			obj.AddComponent<Mask>().showMaskGraphic = false;
			ScrollRect val = obj.AddComponent<ScrollRect>();
			val.horizontal = false;
			val.vertical = true;
			val.movementType = (MovementType)2;
			GameObject obj3 = Panel(obj.transform, name + "Content", new Color(0f, 0f, 0f, 0f));
			RectTransform component2 = obj3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.offsetMin = new Vector2(0f, 0f);
			component2.offsetMax = new Vector2(0f, 0f);
			VerticalLayoutGroup obj4 = obj3.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj4).spacing = 3f;
			obj3.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			val.viewport = component;
			val.content = component2;
			return obj3;
		}

		private static GameObject Panel(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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)
			//IL_0040: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = color;
			return val;
		}

		private static GameObject NavGrid(Transform parent, string name, float height)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			GameObject obj = Panel(parent, name, new Color(0f, 0f, 0f, 0f));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, height);
			GridLayoutGroup obj2 = obj.AddComponent<GridLayoutGroup>();
			obj2.cellSize = new Vector2(128f, 32f);
			obj2.spacing = new Vector2(6f, 6f);
			obj2.constraint = (Constraint)1;
			obj2.constraintCount = 4;
			((LayoutGroup)obj2).childAlignment = (TextAnchor)0;
			((LayoutGroup)obj2).padding = new RectOffset(8, 8, 4, 4);
			return obj;
		}

		private static GameObject Row(Transform parent, string name, float height, bool topAnchored)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel(parent, name, new Color(0f, 0f, 0f, 0f));
			RectTransform component = obj.GetComponent<RectTransform>();
			if (topAnchored)
			{
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
			}
			component.sizeDelta = new Vector2(0f, height);
			HorizontalLayoutGroup obj2 = obj.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 5f;
			return obj;
		}

		private static Text MakeLabel(Transform parent, string text, int size, TextAnchor anchor, Color color)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = size;
			component.alignment = anchor;
			((Graphic)component).color = color;
			component.text = text;
			val.AddComponent<LayoutElement>().minHeight = Mathf.Max(22f, (float)size + 8f);
			return component;
		}

		private static Button MakeButton(Transform parent, string text, Color color, UnityAction action)
		{
			//IL_001b: 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)
			GameObject obj = Panel(parent, "Button_" + text.Replace(" ", "_"), color);
			Button val = obj.AddComponent<Button>();
			((UnityEvent)val.onClick).AddListener(action);
			Stretch(((Component)MakeLabel(obj.transform, text, 12, (TextAnchor)4, Color.white)).GetComponent<RectTransform>());
			LayoutElement obj2 = obj.AddComponent<LayoutElement>();
			obj2.minHeight = 30f;
			obj2.minWidth = 80f;
			return val;
		}

		private static InputField MakeInput(Transform parent, string value, string placeholder)
		{
			//IL_002f: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel(parent, "Input_" + placeholder.Replace(" ", "_"), new Color(0.08f, 0.055f, 0.035f, 0.95f));
			InputField val = obj.AddComponent<InputField>();
			Text val2 = MakeLabel(obj.transform, value ?? "", 13, (TextAnchor)3, Color.white);
			Text val3 = MakeLabel(obj.transform, placeholder, 13, (TextAnchor)3, new Color(0.75f, 0.65f, 0.55f, 0.6f));
			val.textComponent = val2;
			val.placeholder = (Graphic)(object)val3;
			val.text = value ?? "";
			Stretch(((Component)val2).GetComponent<RectTransform>(), 8f, 0f, -8f);
			Stretch(((Component)val3).GetComponent<RectTransform>(), 8f, 0f, -8f);
			LayoutElement obj2 = obj.AddComponent<LayoutElement>();
			obj2.minHeight = 30f;
			obj2.minWidth = 110f;
			return val;
		}

		private static Toggle MakeToggle(Transform parent, string label, bool value)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(parent, "Toggle_" + label.Replace(" ", "_"), new Color(0.08f, 0.055f, 0.035f, 0.45f));
			Toggle obj = val.AddComponent<Toggle>();
			GameObject box = Panel(val.transform, "Checkmark", value ? Green() : Brown());
			RectTransform component = box.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0f, 0.5f);
			component.sizeDelta = new Vector2(22f, 22f);
			component.anchoredPosition = new Vector2(14f, 0f);
			obj.graphic = (Graphic)(object)box.GetComponent<Image>();
			obj.isOn = value;
			Stretch(((Component)MakeLabel(val.transform, label, 13, (TextAnchor)3, Color.white)).GetComponent<RectTransform>(), 36f, 0f, -4f);
			val.AddComponent<LayoutElement>().minHeight = 28f;
			((UnityEvent<bool>)(object)obj.onValueChanged).AddListener((UnityAction<bool>)delegate(bool on)
			{
				//IL_0015: 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)
				((Graphic)box.GetComponent<Image>()).color = (on ? Green() : Brown());
			});
			return obj;
		}

		private static void Stretch(RectTransform rect, float left = 0f, float bottom = 0f, float right = 0f, float top = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(right, top);
		}

		private static void Clear(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
			}
		}

		private static IEnumerable<string> BuildGlobalSearchResults(string term)
		{
			string needle = term ?? "";
			string[] categories = Categories;
			foreach (string cat in categories)
			{
				DailyData data = DailyManager.Get(cat);
				for (int j = 1; j <= 28; j++)
				{
					string text = data.Get(j).ToLine();
					if (text.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						yield return cat + " day " + j + " -> " + text;
					}
				}
			}
			foreach (string item in RewardPackManager.Describe())
			{
				if (item.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					yield return "Reward Pack -> " + item;
				}
			}
			foreach (string item2 in RedeemAdminManager.Describe())
			{
				if (item2.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					yield return "Redeem Code -> " + item2;
				}
			}
			foreach (string item3 in GetPrefabNames(needle).Take(25))
			{
				yield return "Prefab -> " + item3;
			}
		}

		private static IEnumerable<string> GetPrefabNames(string filter)
		{
			List<string> list = new List<string>();
			if ((Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items != null)
			{
				foreach (GameObject item2 in ObjectDB.instance.m_items)
				{
					if ((Object)(object)item2 != (Object)null && ((Object)item2).name != null)
					{
						list.Add(((Object)item2).name);
					}
				}
			}
			string[] array = new string[8] { "Wood", "Stone", "FineWood", "CoreWood", "Iron", "Silver", "Coins", "Tokens" };
			foreach (string item in array)
			{
				list.Add(item);
			}
			string needle = filter ?? "";
			return from n in list.Distinct<string>(StringComparer.OrdinalIgnoreCase)
				where string.IsNullOrWhiteSpace(needle) || n.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0
				orderby n
				select n;
		}

		private static string RewardPreview(RewardLine reward)
		{
			if (reward == null)
			{
				return "Preview: no reward selected";
			}
			string text = reward.Prefab;
			string value = "";
			bool flag = false;
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(reward.Prefab) : null);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				text = ((Localization.instance != null) ? Localization.instance.Localize(val2.m_itemData.m_shared.m_name) : val2.m_itemData.m_shared.m_name);
				value = ((Localization.instance != null) ? Localization.instance.Localize(val2.m_itemData.m_shared.m_description) : val2.m_itemData.m_shared.m_description);
				flag = val2.m_itemData.m_shared.m_icons != null && val2.m_itemData.m_shared.m_icons.Length != 0 && (Object)(object)val2.m_itemData.m_shared.m_icons[0] != (Object)null;
			}
			return "Preview: " + text + " | Prefab=" + reward.Prefab + " | Amount=" + reward.Amount + " | Quality=" + reward.Quality + " | Variant=" + reward.Variant + " | Icon=" + (flag ? "found" : "placeholder") + (string.IsNullOrEmpty(value) ? "" : (" | " + Short(value, 80)));
		}

		private static Color Brown()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.17f, 0.11f, 0.06f, 0.95f);
		}

		private static Color Green()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.17f, 0.42f, 0.14f, 0.95f);
		}

		private static Color Danger()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.44f, 0.08f, 0.06f, 0.95f);
		}

		private static string Short(string value, int len)
		{
			if (!string.IsNullOrEmpty(value))
			{
				if (value.Length > len)
				{
					return value.Substring(0, len - 1) + "...";
				}
				return value;
			}
			return "Empty";
		}

		private static void SetStatus(string message)
		{
			status = DateTime.Now.ToString("HH:mm:ss") + " - " + message;
		}

		private static void BackupFile(string path)
		{
			if (File.Exists(path))
			{
				Directory.CreateDirectory(backupPath);
				File.Copy(path, Path.Combine(backupPath, Path.GetFileName(path) + "." + DateTime.Now.ToString("yyyyMMdd-HHmmss") + ".bak"), overwrite: true);
			}
		}

		private static void ExportFile(string path, string name)
		{
			if (!File.Exists(path))
			{
				SetStatus("Export skipped, missing " + name);
				return;
			}
			Directory.CreateDirectory(exportPath);
			File.Copy(path, Path.Combine(exportPath, name + "." + DateTime.Now.ToString("yyyyMMdd-HHmmss") + Path.GetExtension(path)), overwrite: true);
			SetStatus("Exported " + name);
		}

		private static void ExportAll()
		{
			string[] categories = Categories;
			foreach (string text in categories)
			{
				ExportFile(DailyManager.PathFor(text), text + "Rewards");
			}
			ExportFile(RewardPackManager.Path, "RewardPacks");
			ExportFile(RedeemAdminManager.Path, "RedeemCodes");
			ExportFile(WebhookManager.Path, "Webhook");
			ExportFile(SettingsManager.Path, "Settings");
			SetStatus("Exported all config groups");
		}

		internal static void NotifyWebhook(string eventName, string message)
		{
			try
			{
				WebhookManager.SendEvent(eventName, message);
			}
			catch (Exception ex)
			{
				LogsModule.Log("Webhook notify skipped: " + ex.Message);
			}
		}

		private static int ParseInt(string[] p, int i, int fallback)
		{
			if (p.Length <= i || !int.TryParse(p[i], out var result))
			{
				return fallback;
			}
			return result;
		}
	}
	public static class EXTENTIONS
	{
		public static void Compress(this ZPackage pkg, CompressionLevel mode = CompressionLevel.Optimal)
		{
			byte[] array = pkg.GetArray();
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, mode))
			{
				gZipStream.Write(array, 0, array.Length);
			}
			byte[] array2 = memoryStream.ToArray();
			pkg.Clear();
			pkg.Write(array2);
		}

		public static void Decompress(this ZPackage pkg)
		{
			byte[] array = Utils.Decompress(pkg.GetArray());
			pkg.Clear();
			pkg.Write(array);
		}

		public static string ToTime(this int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			string text = "";
			if (timeSpan.Days > 0)
			{
				text += $"{timeSpan.Days:D2}d ";
			}
			if (timeSpan.Hours > 0)
			{
				text += $"{timeSpan.Hours:D2}h ";
			}
			if (timeSpan.Minutes > 0)
			{
				text += $"{timeSpan.Minutes:D2}m ";
			}
			return text + $"{timeSpan.Seconds:D2}s";
		}

		public static string ToTimeNoS(this int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			string text = "";
			if (timeSpan.Days > 0)
			{
				text += $"{timeSpan.Days:D2}d ";
			}
			if (timeSpan.Hours > 0)
			{
				text += $"{timeSpan.Hours:D2}h ";
			}
			if (timeSpan.Minutes > 0)
			{
				text += $"{timeSpan.Minutes:D2}m ";
			}
			return text;
		}
	}
	internal static class ExternalAssetSystem
	{
		private static readonly Dictionary<string, Sprite> SpriteCache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Texture2D> TextureCache = new Dictionary<string, Texture2D>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> LoggedStatus = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> LoggedInvalid = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool initialized;

		private static readonly string[] Directories = new string[7] { "", "Icons", "Backgrounds", "Frames", "Buttons", "Logos", "Decorations" };

		private static readonly string[] NavigationIcons = new string[8] { "daily", "premium", "epic", "legendary", "kit_packs", "redeem", "admin", "webhook" };

		private static readonly string[] Backgrounds = new string[9] { "store", "daily", "premium", "epic", "legendary", "kit_packs", "redeem", "admin", "webhook" };

		private static readonly string[] Frames = new string[5] { "default", "window", "panel", "slot", "tooltip" };

		private static readonly string[] Buttons = new string[4] { "button", "button_hover", "button_pressed", "button_disabled" };

		private static readonly string[] Logos = new string[1] { "logo" };

		private static readonly string[] Decorations = new string[1] { "raven" };

		public static string RootPath => FortecaPaths.AssetsRoot;

		public static void Init()
		{
			if (!initialized)
			{
				initialized = true;
				EnsureFolders();
				EnsureReadme();
				LoadAllKnown();
				Log("Custom Themes & Assets initialized: " + RootPath);
			}
		}

		public static void Reload()
		{
			ClearCaches();
			EnsureFolders();
			EnsureReadme();
			LoadAllKnown();
			Log("Custom Themes & Assets reloaded.");
		}

		public static Sprite GetIcon(string key, Sprite internalFallback)
		{
			Init();
			string text = NavigationIconFileName(key);
			if (!string.IsNullOrEmpty(text))
			{
				Sprite spriteFromFolder = GetSpriteFromFolder("Icons", text, "custom icon", internalFallback, logFallback: true);
				if ((Object)(object)spriteFromFolder != (Object)null)
				{
					return spriteFromFolder;
				}
			}
			return internalFallback ?? GetPlaceholder(internalFallback);
		}

		public static Sprite GetBackground(string pageKey, Sprite embeddedFallback)
		{
			Init();
			string text = PageFileName(pageKey);
			if (string.IsNullOrEmpty(text))
			{
				return embeddedFallback;
			}
			return GetSpriteFromFolder("Backgrounds", text, "custom background", embeddedFallback, logFallback: true) ?? embeddedFallback;
		}

		public static Sprite GetFrame(string key, Sprite embeddedFallback)
		{
			Init();
			string fileName = FileNameOrDefault(key, "default.png");
			return GetSpriteFromFolder("Frames", fileName, "custom frame", embeddedFallback, logFallback: true) ?? embeddedFallback;
		}

		public static Sprite GetButton(string key, Sprite embeddedFallback)
		{
			Init();
			string fileName = FileNameOrDefault(key, "button.png");
			return GetSpriteFromFolder("Buttons", fileName, "custom button", embeddedFallback, logFallback: true) ?? embeddedFallback;
		}

		public static Sprite GetLogo(string key, Sprite embeddedFallback)
		{
			Init();
			string fileName = FileNameOrDefault(key, "logo.png");
			return GetSpriteFromFolder("Logos", fileName, "custom logo", embeddedFallback, logFallback: true) ?? embeddedFallback;
		}

		public static Sprite GetDecoration(string key, Sprite embeddedFallback)
		{
			Init();
			string fileName = FileNameOrDefault(key, "raven.png");
			return GetSpriteFromFolder("Decorations", fileName, "custom decoration", embeddedFallback, logFallback: true) ?? embeddedFallback;
		}

		public static Sprite GetSprite(string key)
		{
			Init();
			string text = NormalizeKey(key);
			if (SpriteCache.TryGetValue(text, out var value))
			{
				return value;
			}
			string text2 = ResolveLegacyPath(text);
			if (string.IsNullOrEmpty(text2))
			{
				LogStatus("Using embedded fallback:", text + ".png");
				return null;
			}
			Sprite val = LoadSprite(text2, text);
			if ((Object)(object)val != (Object)null)
			{
				SpriteCache[text] = val;
			}
			return val;
		}

		private static Sprite GetSpriteFromFolder(string folder, string fileName, string label, Sprite embeddedFallback, bool logFallback)
		{
			string text = NormalizeFileName(fileName);
			string key = folder.ToLowerInvariant() + "/" + Path.GetFileNameWithoutExtension(text).ToLowerInvariant();
			if (SpriteCache.TryGetValue(key, out var value))
			{
				return value;
			}
			string path = Path.Combine(RootPath, folder, text);
			if (!File.Exists(path))
			{
				if (logFallback)
				{
					LogStatus("Using embedded fallback:", text);
				}
				return embeddedFallback;
			}
			Sprite val = LoadSprite(path, key);
			if ((Object)(object)val == (Object)null)
			{
				if (logFallback)
				{
					LogStatus("Using embedded fallback:", text);
				}
				return embeddedFallback;
			}
			SpriteCache[key] = val;
			LogStatus("Loaded " + label + ":", text);
			return val;
		}

		private static Sprite GetPlaceholder(Sprite fallback)
		{
			return GetSpriteFromFolder("Icons", "placeholder.png", "custom icon", null, logFallback: false) ?? fallback;
		}

		private static void LoadAllKnown()
		{
			string[] navigationIcons = NavigationIcons;
			foreach (string text in navigationIcons)
			{
				GetSpriteFromFolder("Icons", text + ".png", "custom icon", null, logFallback: true);
			}
			navigationIcons = Backgrounds;
			foreach (string text2 in navigationIcons)
			{
				GetSpriteFromFolder("Backgrounds", text2 + ".png", "custom background", null, logFallback: true);
			}
			navigationIcons = Frames;
			foreach (string text3 in navigationIcons)
			{
				GetSpriteFromFolder("Frames", text3 + ".png", "custom frame", null, logFallback: true);
			}
			navigationIcons = Buttons;
			foreach (string text4 in navigationIcons)
			{
				GetSpriteFromFolder("Buttons", text4 + ".png", "custom button", null, logFallback: true);
			}
			navigationIcons = Logos;
			foreach (string text5 in navigationIcons)
			{
				GetSpriteFromFolder("Logos", text5 + ".png", "custom logo", null, logFallback: true);
			}
			navigationIcons = Decorations;
			foreach (string text6 in navigationIcons)
			{
				GetSpriteFromFolder("Decorations", text6 + ".png", "custom decoration", null, logFallback: true);
			}
		}

		private static void EnsureFolders()
		{
			string[] directories = Directories;
			foreach (string text in directories)
			{
				Directory.CreateDirectory(Path.Combine(RootPath, text.Replace('/', Path.DirectorySeparatorChar)));
			}
		}

		private static void EnsureReadme()
		{
			string path = Path.Combine(RootPath, "README.txt");
			if (!File.Exists(path))
			{
				File.WriteAllText(path, BuildReadme());
			}
		}

		private static string BuildReadme()
		{
			return string.Join(Environment.NewLine, "Forteca Server Rewards", "", "Custom Themes & Assets", "", "This folder allows you to customize the appearance of the mod without rebuilding the DLL.", "", "Supported folders:", "", "Icons", "Backgrounds", "Frames", "Buttons", "Logos", "Decorations", "", "Replace PNG files with your own artwork.", "", "If an external asset is missing, the mod automatically falls back to the built-in version.", "", "Recommended format:", "", "PNG", "Transparent background", "Power-of-two resolutions when possible.", "", "Restart the game after replacing assets.", "");
		}

		private static Sprite LoadSprite(string path, string key)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					LogInvalid(path);
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Object)val).name = "FortecaTheme_" + key.Replace('/', '_');
				TextureCache[key] = val;
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}
			catch (Exception ex)
			{
				LogInvalid(path + " (" + ex.GetType().Name + ")");
				return null;
			}
		}

		private static string NavigationIconFileName(string key)
		{
			switch (NormalizeKey(key))
			{
			case "daily":
				return "daily.png";
			case "premium":
				return "premium.png";
			case "epic":
				return "epic.png";
			case "legendary":
				return "legendary.png";
			case "store":
			case "kit packs":
			case "kit_packs":
				return "kit_packs.png";
			case "redeem":
				return "redeem.png";
			case "admin":
				return "admin.png";
			case "webhook":
				return "webhook.png";
			default:
				return null;
			}
		}

		private static string PageFileName(string key)
		{
			string text = NormalizeKey(key);
			switch (text)
			{
			case "store":
				return "store.png";
			case "daily":
				return "daily.png";
			case "premium":
				return "premium.png";
			case "epic":
				return "epic.png";
			case "legendary":
				return "legendary.png";
			case "kit packs":
			case "kit_packs":
				return "kit_packs.png";
			case "redeem":
				return "redeem.png";
			case "admin":
				return "admin.png";
			case "webhook":
				return "webhook.png";
			default:
				return text + ".png";
			}
		}

		private static string FileNameOrDefault(string key, string fallback)
		{
			string text = NormalizeKey(key);
			if (string.IsNullOrWhiteSpace(text))
			{
				return fallback;
			}
			return NormalizeFileName(text);
		}

		private static string NormalizeFileName(string fileName)
		{
			string text = Path.GetFileName((fileName ?? "").Trim().Replace('\\', '/'));
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "placeholder.png";
			}
			if (!text.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
			{
				text += ".png";
			}
			return text.ToLowerInvariant();
		}

		private static string ResolveLegacyPath(string normalized)
		{
			string[] array = new string[11]
			{
				"Icons",
				"Backgrounds",
				"Frames",
				"Buttons",
				"Decorations",
				"Logos",
				Path.Combine("Icons", "Player"),
				Path.Combine("Icons", "Admin"),
				Path.Combine("Icons", "Utility"),
				Path.Combine("Icons", "Rewards"),
				Path.Combine("Icons", "Placeholder")
			};
			foreach (string path in array)
			{
				string text = Path.Combine(RootPath, path, normalized + ".png");
				if (File.Exists(text))
				{
					return text;
				}
			}
			string text2 = Path.Combine(RootPath, normalized.Replace('/', Path.DirectorySeparatorChar) + ".png");
			if (!File.Exists(text2))
			{
				return null;
			}
			return text2;
		}

		private static string NormalizeKey(string key)
		{
			string text = (key ?? "").Trim().Replace("\\", "/").Replace(" ", "_")
				.ToLowerInvariant();
			return text switch
			{
				"forteca_store" => "store", 
				"reward_packs" => "kit_packs", 
				"player/store" => "store", 
				"player/daily" => "daily", 
				"player/premium" => "premium", 
				"player/epic" => "epic", 
				"player/legendary" => "legendary", 
				"player/redeem" => "redeem", 
				"admin/admin" => "admin", 
				"admin/webhook" => "webhook", 
				"placeholder/placeholder" => "placeholder", 
				_ => text, 
			};
		}

		private static void ClearCaches()
		{
			foreach (Texture2D value in TextureCache.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			TextureCache.Clear();
			SpriteCache.Clear();
			LoggedStatus.Clear();
			LoggedInvalid.Clear();
		}

		private static void LogStatus(string prefix, string value)
		{
			string item = prefix + value;
			if (LoggedStatus.Add(item))
			{
				Log(prefix + Environment.NewLine + value);
			}
		}

		private static void LogInvalid(string path)
		{
			if (LoggedInvalid.Add(path))
			{
				Log("Custom Themes & Assets PNG could not be loaded: " + path + ". Using embedded fallback.");
			}
		}

		private static void Log(string message)
		{
			MonoBehaviour.print((object)("[Forteca ServerRewards] " + message));
		}
	}
	internal static class FortecaPaths
	{
		private sealed class WebhookTemplate
		{
			public string WebhookUrl = "";

			public bool EnableWebhook;

			public bool StorePurchases = true;

			public bool DailyClaims = true;

			public bool PremiumClaims = true;

			public bool EpicClaims = true;

			public bool LegendaryClaims = true;

			public bool RedeemSuccess = true;

			public bool RedeemFailed = true;

			public bool RewardGrants = true;

			public bool AdminActions = true;

			public bool Errors = true;

			public bool ServerStarted = true;

			public bool ServerStopped = true;

			public bool FutureEventRewards;
		}

		private sealed class SettingsTemplate
		{
			public int TokensPerHour = 10;

			public int RewardCooldownHours = 24;

			public bool RewardPopup = true;

			public float PopupDuration = 4f;

			public bool Animations = true;

			public bool RedeemEnabled = true;

			public bool WebhookEnabled;

			public bool AutoReload = true;

			public bool DebugLogging;

			public bool ConfigAutoBackup = true;
		}

		private static bool logged;

		private static readonly HashSet<string> loggedConfigStatus = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static string Root => Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards");

		public static string Editable => Path.Combine(Root, "Editable");

		public static string DailyRewardsDirectory => Path.Combine(Editable, "DailyRewards");

		public static string EditableDailyRewards => DailyRewardsDirectory;

		public static string RedeemDirectory => Path.Combine(Editable, "Redeem");

		public static string EditableRedeem => RedeemDirectory;

		public static string RewardPacksDirectory => Path.Combine(Editable, "RewardPacks");

		public static string EditableRewardPacks => RewardPacksDirectory;

		public static string UsersDirectory => Path.Combine(Editable, "Users");

		public static string EditableUsers => UsersDirectory;

		public static string EditableWebhook => Path.Combine(Editable, "Webhook");

		public static string Internal => Path.Combine(Root, "Internal");

		public static string Generated => Path.Combine(Internal, "Generated");

		public static string Assets => Path.Combine(Root, "Assets");

		public static string AssetsRoot => Assets;

		public static string AssetsReadmePath => Path.Combine(Assets, "README.txt");

		public static string DailyConfigPath => Path.Combine(DailyRewardsDirectory, "DailyRewardsData.cfg");

		public static string PremiumConfigPath => Path.Combine(DailyRewardsDirectory, "DailyRewardsData_PREMIUM.cfg");

		public static string EpicConfigPath => Path.Combine(DailyRewardsDirectory, "DailyRewardsData_EPIC.cfg");

		public static string LegendaryConfigPath => Path.Combine(DailyRewardsDirectory, "DailyRewardsData_LEGENDARY.cfg");

		public static string DailyRewardsPath => DailyConfigPath;

		public static string PremiumRewardsPath => PremiumConfigPath;

		public static string EpicRewardsPath => EpicConfigPath;

		public static string LegendaryRewardsPath => LegendaryConfigPath;

		public static string RedeemCodesPath => Path.Combine(RedeemDirectory, "RedeemCodes.json");

		public static string RedeemReadmePath => Path.Combine(EditableRedeem, "README_REDEEM_CODES.txt");

		public static string RewardPacksPath => Path.Combine(RewardPacksDirectory, "RewardPacks.json");

		public static string RewardPacksReadmePath => Path.Combine(EditableRewardPacks, "README_REWARD_PACKS.txt");

		public static string AdminUsersPath => Path.Combine(UsersDirectory, "AdminUsers.cfg");

		public static string PremiumUsersPath => Path.Combine(UsersDirectory, "PremiumUsers.cfg");

		public static string EpicUsersPath => Path.Combine(UsersDirectory, "EpicUsers.cfg");

		public static string LegendaryUsersPath => Path.Combine(UsersDirectory, "LegendaryUsers.cfg");

		public static string WebhookPath => Path.Combine(EditableWebhook, "Webhook.json");

		public static string WebhookSettingsPath => Path.Combine(EditableWebhook, "WebhookSettings.cfg");

		public static string SettingsPath => Path.Combine(Internal, "Settings.json");

		public static string RuntimeCachePath => Path.Combine(Internal, "RuntimeCache.json");

		public static string ClaimHistoryPath => Path.Combine(Internal, "ClaimHistory.json");

		public static string RedeemClaimsPath => Path.Combine(Generated, "RedeemClaims.json");

		public static string LogPath => Path.Combine(Generated, "Forteca_ServerRewards.log");

		public static string BackupsPath => Path.Combine(Generated, "Backups");

		public static string ExportsPath => Path.Combine(Generated, "Exports");

		public static string EditableReadmePath => Path.Combine(Root, "README_EDITABLE_FILES.txt");

		public static string DailyPathFor(string category)
		{
			if (string.Equals(category, "Premium", StringComparison.OrdinalIgnoreCase))
			{
				return PremiumRewardsPath;
			}
			if (string.Equals(category, "Epic", StringComparison.OrdinalIgnoreCase))
			{
				return EpicRewardsPath;
			}
			if (string.Equals(category, "Legendary", StringComparison.OrdinalIgnoreCase))
			{
				return LegendaryRewardsPath;
			}
			return DailyRewardsPath;
		}

		public static void EnsureFreshStructure()
		{
			Directory.CreateDirectory(Root);
			Directory.CreateDirectory(Editable);
			Directory.CreateDirectory(EditableDailyRewards);
			Directory.CreateDirectory(EditableRedeem);
			Directory.CreateDirectory(EditableRewardPacks);
			Directory.CreateDirectory(EditableUsers);
			Directory.CreateDirectory(EditableWebhook);
			Directory.CreateDirectory(Internal);
			Directory.CreateDirectory(Generated);
			Directory.CreateDirectory(BackupsPath);
			Directory.CreateDirectory(ExportsPath);
			EnsureAssetDirectories();
			CopyLegacyConfigOnce("Daily", Path.Combine(Root, "DailyRewardsData.cfg"), DailyConfigPath);
			CopyLegacyConfigOnce("Premium", Path.Combine(Root, "DailyRewardsData_PREMIUM.cfg"), PremiumConfigPath);
			CopyLegacyConfigOnce("Epic", Path.Combine(Root, "DailyRewardsData_EPIC.cfg"), EpicConfigPath);
			CopyLegacyConfigOnce("Legendary", Path.Combine(Root, "DailyRewardsData_LEGENDARY.cfg"), LegendaryConfigPath);
			CopyLegacyConfigOnce("RewardPacks", Path.Combine(Root, "RewardPacks.json"), RewardPacksPath);
			CopyLegacyConfigOnce("RedeemCodes", Path.Combine(Root, "Redeem", "RedeemCodes.json"), RedeemCodesPath);
			CopyLegacyConfigOnce("AdminUsers", Path.Combine(Root, "AdminUsers.cfg"), AdminUsersPath);
			CopyLegacyConfigOnce("PremiumUsers", Path.Combine(Root, "PremiumUsers.cfg"), PremiumUsersPath);
			CopyLegacyConfigOnce("EpicUsers", Path.Combine(Root, "EpicUsers.cfg"), EpicUsersPath);
			CopyLegacyConfigOnce("LegendaryUsers", Path.Combine(Root, "LegendaryUsers.cfg"), LegendaryUsersPath);
			EnsureTextFile(EditableReadmePath, BuildEditableReadme());
			EnsureTextFile(AssetsReadmePath, BuildAssetsReadme());
			EnsureTextFile(DailyRewardsPath, BuildDailyCalendar("Daily"));
			EnsureTextFile(PremiumRewardsPath, BuildDailyCalendar("Premium"));
			EnsureTextFile(EpicRewardsPath, BuildDailyCalendar("Epic"));
			EnsureTextFile(LegendaryRewardsPath, BuildDailyCalendar("Legendary"));
			EnsureTextFile(AdminUsersPath, BuildUsersFile("Admin"));
			EnsureTextFile(PremiumUsersPath, BuildUsersFile("Premium"));
			EnsureTextFile(EpicUsersPath, BuildUsersFile("Epic"));
			EnsureTextFile(LegendaryUsersPath, BuildUsersFile("Legendary"));
			EnsureTextFile(RedeemReadmePath, BuildRedeemReadme());
			EnsureTextFile(RewardPacksReadmePath, BuildRewardPacksReadme());
			EnsureTextFile(RedeemCodesPath, BuildRedeemTemplateJson());
			EnsureTextFile(RewardPacksPath, BuildRewardPackTemplateJson());
			EnsureTextFile(WebhookPath, JSON.ToNiceJSON(new WebhookTemplate()));
			EnsureTextFile(WebhookSettingsPath, BuildWebhookSettingsCfg());
			EnsureTextFile(SettingsPath, JSON.ToNiceJSON(new SettingsTemplate()));
			EnsureRewardCooldownSetting(SettingsPath);
			EnsureRewardCooldownSetting(Path.Combine(Root, "Settings.json"));
			EnsureTextFile(RuntimeCachePath, "{}" + Environment.NewLine);
			EnsureTextFile(ClaimHistoryPath, "{\"Entries\":[]}" + Environment.NewLine);
			EnsureTextFile(RedeemClaimsPath, "{\"Claims\":[]}" + Environment.NewLine);
			LogResolvedPathsOnce();
		}

		private static void EnsureRewardCooldownSetting(string path)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
				{
					return;
				}
				string text = File.ReadAllText(path);
				if (Regex.IsMatch(text, "\"RewardCooldownHours\"\\s*:\\s*24\\b"))
				{
					return;
				}
				if (Regex.IsMatch(text, "\"RewardCooldownHours\"\\s*:"))
				{
					text = Regex.Replace(text, "(\"RewardCooldownHours\"\\s*:\\s*)[-0-9.]+", "$1 24");
				}
				else
				{
					int num = text.LastIndexOf('}');
					if (num < 0)
					{
						return;
					}
					string text2 = text.Substring(0, num).TrimEnd(Array.Empty<char>());
					string text3 = text.Substring(num);
					if (!text2.EndsWith("{"))
					{
						text2 += ",";
					}
					text = text2 + Environment.NewLine + "   \"RewardCooldownHours\" : 24" + Environment.NewLine + text3;
				}
				File.WriteAllText(path, text, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				LogsModule.Log("[RewardsTimer] Migrated RewardCooldownHours to 24 in " + path);
			}
			catch (Exception ex)
			{
				LogsModule.Log("[RewardsTimer] Settings migration skipped for " + path + ": " + ex.Message);
			}
		}

		public static void EnsureTextFile(string path, string content)
		{
			try
			{
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				if (!File.Exists(path))
				{
					File.WriteAllText(path, content ?? string.Empty, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("Failed to ensure file " + path + ": " + ex.Message);
			}
		}

		private static void CopyLegacyConfigOnce(string label, string legacyPath, string targetPath)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(legacyPath) || string.IsNullOrWhiteSpace(targetPath) || !File.Exists(legacyPath))
				{
					return;
				}
				long length = new FileInfo(legacyPath).Length;
				LogsModule.Log("[ServerRewards Config] Legacy " + label + " found: " + legacyPath + " (" + length + " bytes)");
				if (File.Exists(targetPath) && new FileInfo(targetPath).Length > 0)
				{
					LogsModule.Log("[ServerRewards Config] Fresh " + label + " already exists, legacy not copied: " + targetPath);
					return;
				}
				string directoryName = Path.GetDirectoryName(targetPath);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.Copy(legacyPath, targetPath, overwrite: false);
				LogsModule.Log("[ServerRewards Config] Copied legacy " + label + " to fresh path: " + targetPath);
			}
			catch (Exception ex)
			{
				LogsModule.Log("[ServerRewards Config] Legacy copy failed for " + label + ": " + ex.Message);
			}
		}

		public static void LogConfigStatus(string label, string path, int entriesLoaded)
		{
			try
			{
				LogsModule.Log("[ServerRewards Config] " + label + " path: " + path);
				LogsModule.Log("[ServerRewards Config] " + label + " exists: " + File.Exists(path).ToString().ToLowerInvariant());
				LogsModule.Log("[ServerRewards Config] " + label + " entries loaded: " + entriesLoaded);
			}
			catch
			{
			}
		}

		public static int CountDailyEntries(string path)
		{
			try
			{
				if (!File.Exists(path))
				{
					return 0;
				}
				return Math.Max(0, (from x in File.ReadAllLines(path)
					select (x ?? "").Trim()).Count((string x) => x.Length > 0 && !x.StartsWith("#")) - 1);
			}
			catch
			{
				return 0;
			}
		}

		public static int CountJsonArrayEntries(string path, string arrayName)
		{
			try
			{
				if (!File.Exists(path))
				{
					return 0;
				}
				Match match = Regex.Match(File.ReadAllText(path), "[\\\"']" + Regex.Escape(arrayName) + "[\\\"']\\s*:\\s*\\[([\\s\\S]*?)\\]");
				if (!match.Success || string.IsNullOrWhiteSpace(match.Groups[1].Value))
				{
					return 0;
				}
				return Regex.Matches(match.Groups[1].Value, "\\{").Count;
			}
			catch
			{
				return 0;
			}
		}

		private static void EnsureAssetDirectories()
		{
			string[] array = new string[11]
			{
				Assets,
				Path.Combine(Assets, "Backgrounds"),
				Path.Combine(Assets, "Icons", "Player"),
				Path.Combine(Assets, "Icons", "Admin"),
				Path.Combine(Assets, "Icons", "Utility"),
				Path.Combine(Assets, "Icons", "Rewards"),
				Path.Combine(Assets, "Icons", "Placeholder"),
				Path.Combine(Assets, "Buttons"),
				Path.Combine(Assets, "Frames"),
				Path.Combine(Assets, "Decorations"),
				Path.Combine(Assets, "Logos")
			};
			for (int i = 0; i < array.Length; i++)
			{
				Directory.CreateDirectory(array[i]);
			}
		}

		private static string BuildAssetsReadme()
		{
			return string.Join(Environment.NewLine, "Forteca Server Rewards", "", "Custom Themes & Assets", "", "This folder allows you to customize the appearance of the mod without rebuilding the DLL.", "", "Supported folders:", "", "Icons", "Backgrounds", "Frames", "Buttons", "Logos", "Decorations", "", "Replace PNG files with your own artwork.", "", "If an external asset is missing, the mod automatically falls back to the built-in version.", "", "Recommended format:", "", "PNG", "Transparent background", "Power-of-two resolutions when possible.", "", "Restart the game after replacing assets.", "");
		}

		private static string BuildDailyCalendar(string category)
		{
			List<string> list = new List<string> { category + ",86400" };
			for (int i = 0; i < 28; i++)
			{
				list.Add("Wood,1");
			}
			return string.Join(Environment.NewLine, list) + Environment.NewLine;
		}

		private static string BuildUsersFile(string name)
		{
			return string.Join(Environment.NewLine, "# " + name + " access list. One SteamID64 per line.", "# Only 17 digit SteamID64 values are accepted.", "# Built-in permanent authorized users are always active even if removed here:", "76561198007625196", "76561199693548808", "");
		}

		private static string BuildEditableReadme()
		{
			return string.Join(Environment.NewLine, "FORTeca_ServerRewards v2.0 Hotfix 2 fresh config structure", "", "Edit files only inside Editable unless you know the mod internals.", "Daily reward calendars: Editable/DailyRewards/*.cfg", "Redeem codes: Editable/Redeem/RedeemCodes.json", "Reward packs: Editable/RewardPacks/RewardPacks.json", "User access lists: Editable/Users/*.cfg", "Webhook settings: Editable/Webhook/WebhookSettings.cfg", "", "Internal contains runtime data and generated files. Do not normally edit Internal.", "Assets contains Custom Themes & Assets PNG replacements for backgrounds, icons, buttons, frames, decorations and logos.", "", "Old flat config paths directly under BepInEx/config/Forteca_ServerRewards are no longer supported for Daily, Premium, Epic, Legendary, Redeem, RewardPacks or user access lists.", "");
		}

		private static string BuildRedeemReadme()
		{
			return string.Join(Environment.NewLine, "RedeemCodes.json schema used by this build:", "{ Codes: [ { Code, Disabled, MaxUses, ExpirationUtc, OneTimePerSteamID, AllowedSteamIDs, Used, ClaimedSteamIDs, Rewards } ] }", "Rewards entries use: Prefab, Amount, Quality, Variant.", "MaxUses 0 means unlimited global uses.", "ExpirationUtc may be empty or an UTC date string such as 2026-12-31T23:59:59Z.", "AllowedSteamIDs may be empty, or contain SteamID64 values allowed to use the code.", "Default public codes are FORTECA-FEHU, FORTECA-WELCOME and FORTECA-VIKING.", "");
		}

		private static string BuildRewardPacksReadme()
		{
			return string.Join(Environment.NewLine, "RewardPacks.json schema used by the Admin Suite:", "{ Packs: [ { Name, Description, Icon, Rewards } ] }", "Rewards entries use: Prefab, Amount, Quality, Variant.", "Current player redeem codes grant their own Rewards list directly; reward packs are managed separately by the Admin Suite.", "");
		}

		private static string BuildRedeemTemplateJson()
		{
			return string.Join(Environment.NewLine, "{", "  \"Codes\": [", "    {", "      \"Code\": \"FORTECA-FEHU\",", "      \"Disabled\": false,", "      \"MaxUses\": 0,", "      \"ExpirationUtc\": \"\",", "      \"OneTimePerSteamID\": true,", "      \"AllowedSteamIDs\": [],", "      \"Used\": 0,", "      \"ClaimedSteamIDs\": [],", "      \"Rewards\": [ { \"Prefab\": \"Coins\", \"Amount\": 100, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"Wood\", \"Amount\": 25, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"Stone\", \"Amount\": 25, \"Quality\": 1, \"Variant\": 0 } ]", "    },", "    {", "      \"Code\": \"FORTECA-WELCOME\",", "      \"Disabled\": false,", "      \"MaxUses\": 0,", "      \"ExpirationUtc\": \"\",", "      \"OneTimePerSteamID\": true,", "      \"AllowedSteamIDs\": [],", "      \"Used\": 0,", "      \"ClaimedSteamIDs\": [],", "      \"Rewards\": [ { \"Prefab\": \"Wood\", \"Amount\": 100, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"Stone\", \"Amount\": 100, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"Resin\", \"Amount\": 50, \"Quality\": 1, \"Variant\": 0 } ]", "    },", "    {", "      \"Code\": \"FORTECA-VIKING\",", "      \"Disabled\": false,", "      \"MaxUses\": 0,", "      \"ExpirationUtc\": \"\",", "      \"OneTimePerSteamID\": true,", "      \"AllowedSteamIDs\": [],", "      \"Used\": 0,", "      \"ClaimedSteamIDs\": [],", "      \"Rewards\": [ { \"Prefab\": \"Coins\", \"Amount\": 250, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"CookedMeat\", \"Amount\": 20, \"Quality\": 1, \"Variant\": 0 }, { \"Prefab\": \"Honey\", \"Amount\": 20, \"Quality\": 1, \"Variant\": 0 } ]", "    }", "  ]", "}", "");
		}

		private static string BuildRewardPackTemplateJson()
		{
			return string.Join(Environment.NewLine, "{", "  \"Packs\": [", "    {", "      \"PackId\": \"StarterWood\",", "      \"Name\": \"StarterWood\",", "      \"Description\": \"Example pack managed by Admin Suite.\",", "      \"Icon\": \"\",", "      \"TokenCost\": 0,", "      \"Enabled\": true,", "      \"Rewards\": [ { \"Prefab\": \"Wood\", \"Amount\": 1, \"Quality\": 1, \"Variant\": 0 } ]", "    }", "  ]", "}", "");
		}

		private static void LogResolvedPathsOnce()
		{
			if (!logged)
			{
				logged = true;
				LogsModule.Log("Fresh config root: " + Root);
				LogsModule.Log("Daily config path: " + DailyRewardsDirectory);
				LogsModule.Log("Redeem codes path: " + RedeemCodesPath);
				LogsModule.Log("Reward packs path: " + RewardPacksPath);
				LogsModule.Log("Users path: " + UsersDirectory);
				LogsModule.Log("Webhook path: " + WebhookSettingsPath);
				LogsModule.Log("Internal path: " + Internal);
				LogsModule.Log("Custom Themes & Assets path: " + Assets);
				LogConfigStatus("RewardPacks", RewardPacksPath, CountJsonArrayEntries(RewardPacksPath, "Packs"));
				LogConfigStatus("RedeemCodes", RedeemCodesPath, CountJsonArrayEntries(RedeemCodesPath, "Codes"));
			}
		}

		private static string BuildWebhookSettingsCfg()
		{
			return string.Join(Environment.NewLine, "# Forteca_ServerRewards Discord webhook settings", "# URL is stored here for server-side delivery. The Admin UI masks the saved URL.", "EnableWebhook=false", "WebhookUrl=", "StorePurchases=true", "DailyClaims=true", "PremiumClaims=true", "EpicClaims=true", "LegendaryClaims=true", "RedeemSuccess=true", "RedeemFailed=true", "RewardGrants=true", "AdminActions=true", "Errors=true", "ServerStarted=true", "ServerStopped=true", "FutureEventRewards=false", "LastSendStatus=Never sent", "LastHttpError=", "LastSendUtc=", "");
		}
	}
	internal enum FortecaUiPageId
	{
		Daily,
		Premium,
		Epic,
		Legendary,
		KitPacks,
		Redeem,
		Admin,
		Webhook
	}
	internal enum FortecaUiRewardTier
	{
		Daily,
		Premium,
		Epic,
		Legendary
	}
	internal enum FortecaUiStatusType
	{
		Info,
		Success,
		Warning,
		Error
	}
	internal sealed class FortecaRewardTierView
	{
		public FortecaUiRewardTier Tier;

		public string Title = "";

		public string Description = "";

		public bool HasAccess = true;

		public string LockedMessage = "";

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

		public int CurrentTaken;

		public bool Available;

		public int RemainingSeconds;
	}
	internal static class FortecaRewardPackService
	{
		internal sealed class FileModel
		{
			public List<Pack> Packs = new List<Pack>();
		}

		internal sealed class Pack
		{
			public string PackId = "";

			public string Id = "";

			public string Name = "";

			public string Description = "";

			public string Icon = "";

			public string RuneIcon = "";

			public string PurchaseType = "";

			public string Type = "";

			public bool OneTimeOnly;

			public int TokenCost;

			public int Cost;

			public int Price;

			public bool Enabled = true;

			public bool Disabled;

			public bool OneTime;

			public int Limit;

			public List<Item> Rewards = new List<Item>();

			public List<Item> Items = new List<Item>();
		}

		internal sealed class Item
		{
			public string Prefab = "Wood";

			public int Amount = 1;

			public int Quality = 1;

			public int Variant;
		}

		private static FileModel data = new FileModel();

		public static string LastError { get; private set; } = "";

		public static int RewardCount { get; private set; }

		public static string SourcePath { get; private set; } = "";

		public static IReadOnlyList<Pack> Packs => data.Packs;

		public static void Load()
		{
			LastError = "";
			RewardCount = 0;
			SourcePath = FortecaPaths.RewardPacksPath;
			try
			{
				FortecaPaths.EnsureFreshStructure();
				data = LoadFromPath(FortecaPaths.RewardPacksPath, optional: false);
				if ((data == null || data.Packs == null || data.Packs.Count == 0) && LooksLikeAnonymousFastJson(FortecaPaths.RewardPacksPath))
				{
					string text = Path.Combine(FortecaPaths.Root, "RewardPacks.json");
					if (File.Exists(text))
					{
						LogsModule.Log("[Rewards] Reward Packs fresh file contains no Packs data, trying legacy readable file: " + text);
						FileModel fileModel = LoadFromPath(text, optional: true);
						if (fileModel != null && fileModel.Packs != null && fileModel.Packs.Count > 0)
						{
							data = fileModel;
							Normalize();
							SaveCanonical(FortecaPaths.RewardPacksPath, data);
							SourcePath = FortecaPaths.RewardPacksPath;
							LastError = "";
							LogsModule.Log("[Rewards Data] RewardPacks repaired from legacy: true");
						}
					}
				}
				if (data == null)
				{
					data = new FileModel();
				}
			}
			catch (Exception ex)
			{
				data = new FileModel();
				LastError = "Reward Packs configuration error.";
				LogsModule.Log("[Rewards UI ERROR] Page=KitPacks Section=Load Reason=" + ex);
			}
			Normalize();
			if (data.Packs.Count > 0)
			{
				LastError = "";
			}
			LogsModule.Log("[Rewards] Reward Packs Loaded: " + data.Packs.Count);
			LogsModule.Log("[Rewards] Reward Packs Rewards: " + RewardCount);
			LogsModule.Log("[Rewards] Reward Packs Path: " + SourcePath);
			if (data.Packs.Count == 0 && string.IsNullOrWhiteSpace(LastError))
			{
				LastError = "No valid Reward Packs found.";
			}
		}

		private static FileModel LoadFromPath(string path, bool optional)
		{
			if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
			{
				if (!optional)
				{
					LastError = "Reward Packs configuration is missing.";
				}
				if (!optional)
				{
					LogsModule.Log("[Rewards] Reward Packs missing: " + path);
				}
				return new FileModel();
			}
			string text = File.ReadAllText(path);
			if (string.IsNullOrWhiteSpace(text))
			{
				return new FileModel();
			}
			string text2 = text.TrimStart(Array.Empty<char>());
			try
			{
				if (text2.StartsWith("["))
				{
					return new FileModel
					{
						Packs = (JSON.ToObject<List<Pack>>(text) ?? new List<Pack>())
					};
				}
				FileModel fileModel = JSON.ToObject<FileModel>(text) ?? new FileModel();
				if (fileModel.Packs == null)
				{
					fileModel.Packs = new List<Pack>();
				}
				return fileModel;
			}
			catch (Exception ex)
			{
				LastError = "Reward Packs configuration error.";
				LogsModule.Log("[Rewards UI ERROR] Page=KitPacks Section=Load Path=" + path + " Reason=" + ex.Message);
				return new FileModel();
			}
		}

		private static bool LooksLikeAnonymousFastJson(string path)
		{
			try
			{
				if (!File.Exists(path))
				{
					return false;
				}
				string text = File.ReadAllText(path);
				return text.Contains("$types") && text.Contains("<>f__AnonymousType") && !text.Contains("\"Packs\"");
			}
			catch
			{
				return false;
			}
		}

		private static void Normalize()
		{
			if (data.Packs == null)
			{
				data.Packs = new List<Pack>();
			}
			foreach (Pack pack in data.Packs)
			{
				if (pack.Rewards == null)
				{
					pack.Rewards = new List<Item>();
				}
				if (pack.Rewards.Count == 0 && pack.Items != null && pack.Items.Count > 0)
				{
					pack.Rewards = pack.Items;
				}
				if (pack.Rewards == null)
				{
					pack.Rewards = new List<Item>();
				}
				if (string.IsNullOrWhiteSpace(pack.PackId))
				{
					pack.PackId = ((!string.IsNullOrWhiteSpace(pack.Id)) ? pack.Id : ((!string.IsNullOrWhiteSpace(pack.Name)) ? pack.Name : Guid.NewGuid().ToString("N")));
				}
				if (string.IsNullOrWhiteSpace(pack.Name))
				{
					pack.Name = pack.PackId;
				}
				if (string.IsNullOrWhiteSpace(pack.RuneIcon))
				{
					pack.RuneIcon = pack.Icon;
				}
				if (string.IsNullOrWhiteSpace(pack.Icon))
				{
					pack.Icon = pack.RuneIcon;
				}
				if (string.IsNullOrWhiteSpace(pack.PurchaseType))
				{
					pack.PurchaseType = ((pack.OneTime || pack.OneTimeOnly || pack.Limit == 1) ? "OneTime" : "Repeatable");
				}
				pack.OneTime = IsOneTime(pack);
				pack.OneTimeOnly = pack.OneTime;
				pack.PurchaseType = (pack.OneTime ? "OneTime" : "Repeatable");
				pack.Limit = (pack.OneTime ? 1 : Math.Max(0, pack.Limit));
				foreach (Item reward in pack.Rewards)
				{
					if (reward != null)
					{
						reward.Prefab = (reward.Prefab ?? "").Trim();
						if (reward.Amount < 0)
						{
							reward.Amount = 0;
						}
						if (reward.Quality <= 0)
						{
							reward.Quality = 1;
						}
						if (reward.Variant < 0)
						{
							reward.Variant = 0;
						}
					}
				}
			}
			RewardCount = data.Packs.Sum((Pack p) => (p.Rewards != null) ? p.Rewards.Count((Item r) => r != null && !string.IsNullOrWhiteSpace(r.Prefab) && r.Amount > 0) : 0);
		}

		private static void SaveCanonical(string path, FileModel model)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(path) || model == null)
				{
					return;
				}
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("{");
				stringBuilder.AppendLine("  \"Packs\": [");
				for (int i = 0; i < model.Packs.Count; i++)
				{
					Pack pack = model.Packs[i];
					stringBuilder.AppendLine("    {");
					stringBuilder.AppendLine("      \"PackId\": \"" + JsonEscape(pack.PackId) + "\",");
					stringBuilder.AppendLine("      \"Name\": \"" + JsonEscape(pack.Name) + "\",");
					stringBuilder.AppendLine("      \"Description\": \"" + JsonEscape(pack.Description) + "\",");
					stringBuilder.AppendLine("      \"Icon\": \"" + JsonEscape(string.IsNullOrWhiteSpace(pack.RuneIcon) ? pack.Icon : pack.RuneIcon) + "\",");
					stringBuilder.AppendLine("      \"RuneIcon\": \"" + JsonEscape(string.IsNullOrWhiteSpace(pack.RuneIcon) ? pack.Icon : pack.RuneIcon) + "\",");
					stringBuilder.AppendLine("      \"PurchaseType\": \"" + (IsOneTime(pack) ? "OneTime" : "Repeatable") + "\",");
					if (!string.IsNullOrWhiteSpace(pack.Type))
					{
						stringBuilder.AppendLine("      \"Type\": \"" + JsonEscape(pack.Type) + "\",");
					}
					stringBuilder.AppendLine("      \"TokenCost\": " + CostOf(pack) + ",");
					stringBuilder.AppendLine("      \"Enabled\": " + (IsEnabled(pack) ? "true" : "false") + ",");
					stringBuilder.AppendLine("      \"OneTime\": " + (IsOneTime(pack) ? "true" : "false") + ",");
					stringBuilder.AppendLine("      \"OneTimeOnly\": " + (IsOneTime(pack) ? "true" : "false") + ",");
					stringBuilder.AppendLine("      \"Limit\": " + (IsOneTime(pack) ? 1 : Math.Max(0, pack.Limit)) + ",");
					stringBuilder.AppendLine("      \"Rewards\": [");
					List<Item> list = pack.Rewards ?? new List<Item>();
					for (int j = 0; j < list.Count; j++)
					{
						Item item = list[j];
						stringBuilder.Append("        { \"Prefab\": \"").Append(JsonEscape((item == null) ? "" : item.Prefab)).Append("\", \"Amount\": ")
							.Append(item?.Amount ?? 0)
							.Append(", \"Quality\": ")
							.Append(item?.Quality ?? 1)
							.Append(", \"Variant\": ")
							.Append(item?.Variant ?? 0)
							.Append(" }");
						if (j < list.Count - 1)
						{
							stringBuilder.Append(',');
						}
						stringBuilder.AppendLine();
					}
					stringBuilder.AppendLine("      ]");
					stringBuilder.Append("    }");
					if (i < model.Packs.Count - 1)
					{
						stringBuilder.Append(',');
					}
					stringBuilder.AppendLine();
				}
				stringBuilder.AppendLine("  ]");
				stringBuilder.AppendLine("}");
				File.WriteAllText(path, stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards Data] RewardPacks canonical save failed: " + ex.Message);
			}
		}

		private static string JsonEscape(string value)
		{
			return (value ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "")
				.Replace("\n", " ");
		}

		public static bool IsOneTime(Pack p)
		{
			if (p != null)
			{
				if (!p.OneTime && !p.OneTimeOnly && p.Limit != 1 && !string.Equals(p.PurchaseType, "OneTime", StringComparison.OrdinalIgnoreCase))
				{
					return string.Equals(p.PurchaseType, "One-Time", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}
			return false;
		}

		public static bool IsSpecial(Pack p)
		{
			if (p != null)
			{
				if (!string.Equals(p.Type, "SPECIAL", StringComparison.OrdinalIgnoreCase))
				{
					return string.Equals(p.PurchaseType, "SPECIAL", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}
			return false;
		}

		public static string PurchaseLabel(Pack p)
		{
			if (!IsSpecial(p))
			{
				if (!IsOneTime(p))
				{
					return "REPEATABLE";
				}
				return "ONE-TIME";
			}
			return "SPECIAL";
		}

		public static string RuneKey(Pack p)
		{
			if (p != null)
			{
				if (string.IsNullOrWhiteSpace(p.RuneIcon))
				{
					return (p.Icon ?? "").Trim();
				}
				return p.RuneIcon.Trim();
			}
			return "";
		}

		public static int CostOf(Pack p)
		{
			if (p != null)
			{
				if (p.TokenCost <= 0)
				{
					if (p.Cost <= 0)
					{
						return Math.Max(0, p.Price);
					}
					return p.Cost;
				}
				return p.TokenCost;
			}
			return 0;
		}

		public static bool IsEnabled(Pack p)
		{
			if (p != null && p.Enabled)
			{
				return !p.Disabled;
			}
			return false;
		}

		public static Pack Find(string id)
		{
			if (data == null || data.Packs == null)
			{
				Load();
			}
			return data.Packs.FirstOrDefault((Pack p) => string.Equals(p.PackId, id, StringComparison.OrdinalIgnoreCase) || string.Equals(p.Id, id, StringComparison.OrdinalIgnoreCase) || string.Equals(p.Name, id, StringComparison.OrdinalIgnoreCase));
		}

		public static Forteca_ServerRewards.ShopData.ShopSlot ToShopSlot(string id)
		{
			Pack pack = Find(id);
			if (!IsEnabled(pack))
			{
				return null;
			}
			Forteca_ServerRewards.ShopData.ShopSlot shopSlot = new Forteca_ServerRewards.ShopData.ShopSlot
			{
				Name = pack.PackId,
				Cost = CostOf(pack),
				OneTime = IsOneTime(pack),
				Color = (IsOneTime(pack) ? "#3a2608" : "#082b32")
			};
			shopSlot.Items = new List<Forteca_ServerRewards.ShopData.ShopSlot.ShopItem>();
			foreach (Item item in pack.Rewards ?? new List<Item>())
			{
				if (item != null && !string.IsNullOrWhiteSpace(item.Prefab) && item.Amount > 0)
				{
					shopSlot.Items.Add(new Forteca_ServerRewards.ShopData.ShopSlot.ShopItem
					{
						Prefab = item.Prefab.Trim(),
						Amount = item.Amount
					});
				}
			}
			if (shopSlot.Items.Count != 0)
			{
				return shopSlot;
			}
			return null;
		}
	}
	internal sealed class FortecaRewardsUIRoot
	{
		internal sealed class Context
		{
			public Func<int> GetTokens;

			public Func<bool> IsAdmin;

			public Func<FortecaUiRewardTier, FortecaRewardTierView> GetRewardTier;

			public Action<FortecaUiRewardTier, int, string> ClaimReward;

			public Action<string> PurchasePack;

			public Action<GameObject, Text> RenderRedeem;
		}

		private sealed class AdminColumns
		{
			public RectTransform Left;

			public RectTransform Center;

			public RectTransform Right;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Close;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<FortecaRewardPackService.Pack, bool> <>9__45_0;

			public static Func<FortecaRewardPackService.Pack, bool> <>9__45_1;

			public static Func<FortecaRewardPackService.Pack, bool> <>9__45_2;

			public static Func<FortecaRewardPackService.Item, string> <>9__48_0;

			public static UnityAction <>9__57_0;

			public static UnityAction <>9__57_1;

			public static Func<FortecaRewardPackService.Pack, bool> <>9__61_0;

			public static UnityAction <>9__61_9;

			public static UnityAction <>9__61_1;

			public static UnityAction <>9__61_2;

			public static UnityAction <>9__61_3;

			public static UnityAction <>9__61_10;

			public static UnityAction <>9__61_5;

			public static UnityAction <>9__61_6;

			public static UnityAction <>9__61_7;

			public static Func<RedeemSystem.RedeemCode, string> <>9__62_0;

			public static UnityAction <>9__62_9;

			public static UnityAction <>9__62_1;

			public static UnityAction <>9__62_2;

			public static UnityAction <>9__62_3;

			public static UnityAction <>9__62_10;

			public static UnityAction <>9__62_5;

			public static UnityAction <>9__62_6;

			public static UnityAction <>9__62_7;

			public static UnityAction <>9__63_0;

			public static UnityAction <>9__63_1;

			public static UnityAction <>9__63_2;

			public static UnityAction <>9__63_3;

			public static UnityAction <>9__63_6;

			public static UnityAction <>9__64_1;

			public static UnityAction <>9__64_2;

			public static UnityAction <>9__65_1;

			public static UnityAction <>9__65_2;

			public static UnityAction <>9__66_0;

			public static UnityAction <>9__66_1;

			public static UnityAction <>9__66_2;

			public static UnityAction <>9__67_0;

			public static UnityAction <>9__67_1;

			public static Func<string, string> <>9__69_0;

			public static Func<string, bool> <>9__69_1;

			public static Func<KeyValuePair<string, string>, string> <>9__78_0;

			public static UnityAction <>9__101_0;

			internal bool <RenderKitPacks>b__45_0(FortecaRewardPackService.Pack x)
			{
				return !FortecaRewardPackService.IsSpecial(x);
			}

			internal bool <RenderKitPacks>b__45_1(FortecaRewardPackService.Pack x)
			{
				return FortecaRewardPackService.IsSpecial(x);
			}

			internal bool <RenderKitPacks>b__45_2(FortecaRewardPackService.Pack x)
			{
				return x.PackId == selectedPackId;
			}

			internal string <PackCard>b__48_0(FortecaRewardPackService.Item r)
			{
				return "- " + r.Prefab + " x" + r.Amount;
			}

			internal void <AdminDaily>b__57_0()
			{
				FortecaDailyDataService.Load(adminTier);
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminDaily>b__57_1()
			{
				FortecaDailyDataService.Save(adminTier);
				SetStatus("Saved " + adminTier, FortecaUiStatusType.Success);
			}

			internal bool <AdminPacks>b__61_0(FortecaRewardPackService.Pack x)
			{
				return x.PackId == selectedPackId;
			}

			internal void <AdminPacks>b__61_9()
			{
				SetStatus("Select a reward before removing.", FortecaUiStatusType.Warning);
			}

			internal void <AdminPacks>b__61_1()
			{
				SetStatus("Add Reward prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminPacks>b__61_2()
			{
				SetStatus("Add Pack prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminPacks>b__61_3()
			{
				SetStatus("Duplicate prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminPacks>b__61_10()
			{
				SetStatus("Delete Pack confirmed. Save is required to persist admin data changes.", FortecaUiStatusType.Warning);
			}

			internal void <AdminPacks>b__61_5()
			{
				FortecaRewardPackService.Load();
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminPacks>b__61_6()
			{
				SetStatus("Pack saved.", FortecaUiStatusType.Success);
			}

			internal void <AdminPacks>b__61_7()
			{
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal string <AdminRedeem>b__62_0(RedeemSystem.RedeemCode c)
			{
				return c.Code;
			}

			internal void <AdminRedeem>b__62_9()
			{
				SetStatus("Select a reward before removing.", FortecaUiStatusType.Warning);
			}

			internal void <AdminRedeem>b__62_1()
			{
				SetStatus("Add Reward prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminRedeem>b__62_2()
			{
				SetStatus("New Code prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminRedeem>b__62_3()
			{
				SetStatus("Duplicate Code prepared.", FortecaUiStatusType.Info);
			}

			internal void <AdminRedeem>b__62_10()
			{
				SetStatus("Delete Code confirmed. Save is required to persist admin data changes.", FortecaUiStatusType.Warning);
			}

			internal void <AdminRedeem>b__62_5()
			{
				FortecaRedeemDataService.Load();
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminRedeem>b__62_6()
			{
				SetStatus("Code saved.", FortecaUiStatusType.Success);
			}

			internal void <AdminRedeem>b__62_7()
			{
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminGrant>b__63_0()
			{
				SetStatus("Online player list refreshed when peers are available.", FortecaUiStatusType.Info);
			}

			internal void <AdminGrant>b__63_1()
			{
				SetStatus("Item added to queue preview.", FortecaUiStatusType.Info);
			}

			internal void <AdminGrant>b__63_2()
			{
				SetStatus("Selected queue item removed.", FortecaUiStatusType.Warning);
			}

			internal void <AdminGrant>b__63_3()
			{
				SetStatus("Reward queue cleared.", FortecaUiStatusType.Warning);
			}

			internal void <AdminGrant>b__63_6()
			{
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminAccess>b__64_1()
			{
				SetStatus(adminAccessRole + " list saved.", FortecaUiStatusType.Success);
			}

			internal void <AdminAccess>b__64_2()
			{
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminWebhook>b__65_1()
			{
				SetStatus("Test webhook requires a saved URL.", FortecaUiStatusType.Info);
			}

			internal void <AdminWebhook>b__65_2()
			{
				WriteWebhookCfg("", enabled: false);
				SetStatus("Webhook URL cleared.", FortecaUiStatusType.Warning);
				NavigateTo(FortecaUiPageId.Admin);
			}

			internal void <AdminHistory>b__66_0()
			{
				SetStatus("History refreshed.", FortecaUiStatusType.Info);
			}

			internal void <AdminHistory>b__66_1()
			{
				SetStatus("Clear History requires confirmation.", FortecaUiStatusType.Warning);
			}

			internal void <AdminHistory>b__66_2()
			{
			}

			internal void <AdminSettings>b__67_0()
			{
				SetStatus("Settings saved.", FortecaUiStatusType.Success);
			}

			internal void <AdminSettings>b__67_1()
			{
				ExternalAssetSystem.Reload();
				RefreshCurrentPage();
				LogsModule.Log("[Rewards UI] Theme reloaded");
			}

			internal string <SafeLines>b__69_0(string x)
			{
				return x.Trim();
			}

			internal bool <SafeLines>b__69_1(string x)
			{
				if (x.Length > 0)
				{
					return !x.StartsWith("#");
				}
				return false;
			}

			internal string <WriteWebhookCfg>b__78_0(KeyValuePair<string, string> kv)
			{
				return kv.Key + "=" + kv.Value;
			}

			internal void <ShowConfirmModal>b__101_0()
			{
				HideConfirmModal();
			}
		}

		private static Context ctx;

		private static GameObject root;

		private static GameObject mainWindow;

		private static RectTransform content;

		private static RectTransform viewport;

		private static RectTransform headerRoot;

		private static RectTransform leftNavigationRoot;

		private static Button globalCloseButton;

		private static GameObject confirmModal;

		private static RectTransform adminNavigationRoot;

		private static RectTransform adminContentRoot;

		private static RectTransform adminActionsRoot;

		private static Text titleText;

		private static Text tokenText;

		private static Text tokenHelpText;

		private static Text statusText;

		private static Font font;

		private static Sprite fallbackIcon;

		private static FortecaUiPageId current = FortecaUiPageId.Daily;

		private static readonly Dictionary<FortecaUiPageId, Image> nav = new Dictionary<FortecaUiPageId, Image>();

		private static readonly Dictionary<string, Sprite> runeIconCache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Sprite> itemIconCache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static bool runeIconLoadLogged;

		private static string adminPage = "Daily Rewards";

		private static FortecaUiRewardTier adminTier = FortecaUiRewardTier.Daily;

		private static int adminDay = 1;

		private static string selectedPackId = "";

		private static string adminAccessRole = "Admin";

		public static Text HeaderText => titleText;

		public static bool IsVisible
		{
			get
			{
				if ((Object)(object)root != (Object)null)
				{
					return root.activeSelf;
				}
				return false;
			}
		}

		public static void Init(Context context)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			ctx = context;
			font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			fallbackIcon = FallbackSprite(new Color(0.55f, 0.42f, 0.2f, 1f));
			BuildRoot();
			root.SetActive(false);
			LogsModule.Log("[Rewards UI] Root created");
		}

		public static void Open()
		{
			if ((Object)(object)root == (Object)null)
			{
				Init(ctx);
			}
			root.SetActive(true);
			NavigateTo(current);
		}

		public static void Close()
		{
			if ((Object)(object)root != (Object)null)
			{
				root.SetActive(false);
			}
		}

		public static void Toggle()
		{
			if (IsVisible)
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		public static void UpdateTokens()
		{
			if ((Object)(object)tokenText != (Object)null)
			{
				tokenText.text = "Server Tokens: " + (ctx?.GetTokens?.Invoke()).GetValueOrDefault();
			}
			if ((Object)(object)tokenHelpText != (Object)null)
			{
				tokenHelpText.text = "Server Tokens are earned through gameplay.\n1 hour on the server = 10 Tokens.\nNot tradable.\nCan only be spent on Kit Packs.";
			}
		}

		public static void RefreshCurrentPage()
		{
			NavigateTo(current);
		}

		public static void NavigateTo(FortecaUiPageId page)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			current = page;
			try
			{
				LogsModule.Log("[Rewards UI] Navigate: " + page);
				ClearContent();
				SetTitle(Title(page));
				SetStatus("", FortecaUiStatusType.Info);
				UpdateTokens();
				ApplyBackground(page);
				foreach (KeyValuePair<FortecaUiPageId, Image> item in nav)
				{
					((Graphic)item.Value).color = ((item.Key == page) ? new Color(0.18f, 0.15f, 0.1f, 1f) : new Color(0.075f, 0.05f, 0.034f, 0.98f));
				}
				switch (page)
				{
				case FortecaUiPageId.Daily:
					RenderRewards(FortecaUiRewardTier.Daily);
					break;
				case FortecaUiPageId.Premium:
					RenderRewards(FortecaUiRewardTier.Premium);
					break;
				case FortecaUiPageId.Epic:
					RenderRewards(FortecaUiRewardTier.Epic);
					break;
				case FortecaUiPageId.Legendary:
					RenderRewards(FortecaUiRewardTier.Legendary);
					break;
				case FortecaUiPageId.KitPacks:
					RenderKitPacks();
					break;
				case FortecaUiPageId.Redeem:
					RenderRedeem();
					break;
				case FortecaUiPageId.Admin:
					RenderAdmin();
					break;
				default:
					RenderWebhookInfo();
					break;
				}
				RestoreGlobalNavigationLayers();
				ScrollRect val = (((Object)(object)viewport != (Object)null) ? ((Component)viewport).GetComponent<ScrollRect>() : null);
				if ((Object)(object)val != (Object)null)
				{
					val.verticalNormalizedPosition = 1f;
				}
				LayoutRebuilder.ForceRebuildLayoutImmediate(content);
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI ERROR] Page=" + page.ToString() + " Section=Navigate Reason=" + ex);
				ClearContent();
				Empty(content, "This page could not be rendered.");
			}
		}

		private static void BuildRoot()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Expected O, but got Unknown
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_071d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_0772: Unknown result type (might be due to invalid IL or missing references)
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_0790: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			root = new GameObject("RewardsRoot", new Type[4]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			Object.DontDestroyOnLoad((Object)(object)root);
			Canvas component = root.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.sortingOrder = 1000;
			CanvasScaler component2 = root.GetComponent<CanvasScaler>();
			component2.uiScaleMode = (ScaleMode)1;
			component2.referenceResolution = new Vector2(1920f, 1080f);
			component2.matchWidthOrHeight = 0.5f;
			Stretch(root.GetComponent<RectTransform>());
			Stretch(Panel(root.transform, "RewardsOverlayBlocker", new Color(0f, 0f, 0f, 0.32f)).GetComponent<RectTransform>());
			mainWindow = Panel(root.transform, "RewardsMainWindow", new Color(0.035f, 0.025f, 0.018f, 0.96f));
			Anchor(mainWindow.GetComponent<RectTransform>(), 0.08f, 0.08f, 0.92f, 0.92f, 0f, 0f, 0f, 0f);
			Stretch(Panel(mainWindow.transform, "RewardsBackground", new Color(0.07f, 0.05f, 0.035f, 0.86f)).GetComponent<RectTransform>());
			RectTransform obj = (headerRoot = Panel(mainWindow.transform, "RewardsHeader", new Color(0.08f, 0.055f, 0.04f, 0.98f)).GetComponent<RectTransform>());
			Anchor(obj, 0f, 0.9f, 1f, 1f, 0f, 0f, 0f, 0f);
			Text obj2 = Label((Transform)(object)obj, "Forteca - Fehu", 18, (TextAnchor)3, new Color(1f, 0.78f, 0.32f, 1f));
			obj2.fontStyle = (FontStyle)1;
			Anchor(((Component)obj2).GetComponent<RectTransform>(), 0.015f, 0.43f, 0.18f, 0.95f, 0f, 0f, 0f, 0f);
			Anchor(((Component)Label((Transform)(object)obj, "Forteca.net", 11, (TextAnchor)0, new Color(0.82f, 0.74f, 0.58f, 1f))).GetComponent<RectTransform>(), 0.015f, 0.1f, 0.18f, 0.48f, 0f, 0f, 0f, 0f);
			titleText = Label((Transform)(object)obj, "Forteca Rewards", 30, (TextAnchor)4, Color.white);
			titleText.fontStyle = (FontStyle)1;
			Anchor(((Component)titleText).GetComponent<RectTransform>(), 0.2f, 0f, 0.72f, 1f, 0f, 0f, 0f, 0f);
			tokenText = Label((Transform)(object)obj, "Server Tokens: 0", 17, (TextAnchor)5, new Color(1f, 0.85f, 0.35f, 1f));
			Anchor(((Component)tokenText).GetComponent<RectTransform>(), 0.64f, 0.5f, 0.925f, 0.98f, 0f, 0f, -22f, 0f);
			tokenHelpText = Label((Transform)(object)obj, "Server Tokens are earned through gameplay.\n1 hour on the server = 10 Tokens.\nNot tradable.\nCan only be spent on Kit Packs.", 10, (TextAnchor)2, new Color(0.86f, 0.78f, 0.62f, 1f));
			Anchor(((Component)tokenHelpText).GetComponent<RectTransform>(), 0.5f, 0.02f, 0.925f, 0.62f, 0f, 0f, -22f, 0f);
			Color color = new Color(0.28f, 0.085f, 0.045f, 1f);
			object obj3 = <>O.<0>__Close;
			if (obj3 == null)
			{
				UnityAction val = Close;
				<>O.<0>__Close = val;
				obj3 = (object)val;
			}
			Button obj4 = (globalCloseButton = Button((Transform)(object)obj, "X", 18, color, (UnityAction)obj3));
			((Object)((Component)obj4).gameObject).name = "RewardsGlobalCloseButton";
			Anchor(((Component)obj4).GetComponent<RectTransform>(), 0.94f, 0.16f, 0.985f, 0.84f, 0f, 0f, 0f, 0f);
			RectTransform val2 = (leftNavigationRoot = Panel(mainWindow.transform, "RewardsLeftNavigation", new Color(0.025f, 0.018f, 0.014f, 0.86f)).GetComponent<RectTransform>());
			Anchor(val2, 0f, 0f, 0.14f, 0.9f, 8f, 8f, -4f, -8f);
			VerticalLayoutGroup obj5 = ((Component)val2).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj5).padding = new RectOffset(8, 8, 4, 4);
			((HorizontalOrVerticalLayoutGroup)obj5).spacing = 3f;
			((HorizontalOrVerticalLayoutGroup)obj5).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childControlHeight = false;
			FortecaUiPageId[] array = new FortecaUiPageId[8]
			{
				FortecaUiPageId.Daily,
				FortecaUiPageId.Premium,
				FortecaUiPageId.Epic,
				FortecaUiPageId.Legendary,
				FortecaUiPageId.KitPacks,
				FortecaUiPageId.Redeem,
				FortecaUiPageId.Admin,
				FortecaUiPageId.Webhook
			};
			foreach (FortecaUiPageId page in array)
			{
				NavButton(val2, page);
			}
			RectTransform component3 = Panel(mainWindow.transform, "RewardsContentRoot", new Color(0.015f, 0.011f, 0.009f, 0.52f)).GetComponent<RectTransform>();
			Anchor(component3, 0.14f, 0f, 1f, 0.9f, 4f, 8f, -8f, -8f);
			RectTransform component4 = Panel((Transform)(object)component3, "PageStatus", new Color(0.035f, 0.025f, 0.018f, 0.65f)).GetComponent<RectTransform>();
			Anchor(component4, 0f, 0.92f, 1f, 1f, 0f, 0f, 0f, 0f);
			statusText = Label((Transform)(object)component4, "", 15, (TextAnchor)3, new Color(0.9f, 0.82f, 0.65f, 1f));
			Anchor(((Component)statusText).GetComponent<RectTransform>(), 0.02f, 0f, 0.98f, 1f, 0f, 0f, 0f, 0f);
			viewport = Panel((Transform)(object)component3, "PageViewport", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			Anchor(viewport, 0f, 0f, 1f, 0.92f, 0f, 0f, 0f, 0f);
			((Component)viewport).gameObject.AddComponent<RectMask2D>();
			ScrollRect obj6 = ((Component)viewport).gameObject.AddComponent<ScrollRect>();
			obj6.horizontal = false;
			obj6.vertical = true;
			obj6.movementType = (MovementType)2;
			content = Panel((Transform)(object)viewport, "PageContent", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(1f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.offsetMin = Vector2.zero;
			content.offsetMax = Vector2.zero;
			obj6.viewport = viewport;
			obj6.content = content;
			RectTransform component5 = Panel((Transform)(object)component3, "Footer", new Color(0.035f, 0.025f, 0.018f, 0.18f)).GetComponent<RectTransform>();
			Anchor(component5, 0f, 0f, 1f, 0.006f, 0f, 0f, 0f, 0f);
			((Graphic)((Component)component5).GetComponent<Image>()).raycastTarget = false;
		}

		private static void NavButton(RectTransform parent, FortecaUiPageId page)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			Button val = Button((Transform)(object)parent, Title(page), 12, new Color(0.075f, 0.05f, 0.034f, 0.98f), (UnityAction)delegate
			{
				NavigateTo(page);
			});
			((Component)val).gameObject.AddComponent<LayoutElement>().preferredHeight = 86f;
			nav[page] = ((Component)val).GetComponent<Image>();
			Sprite icon = ExternalAssetSystem.GetIcon(IconKey(page), (page == FortecaUiPageId.Webhook) ? WebhookFallbackSprite() : fallbackIcon);
			Anchor(((Component)Image(((Component)val).transform, icon)).GetComponent<RectTransform>(), 0.12f, 0.04f, 0.88f, 0.68f, 0f, 0f, 0f, 0f);
			Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
			Anchor(((Component)componentInChildren).GetComponent<RectTransform>(), 0.03f, 0.7f, 0.97f, 0.98f, 0f, 0f, 0f, 0f);
			componentInChildren.alignment = (TextAnchor)4;
			componentInChildren.fontSize = 12;
			componentInChildren.fontStyle = (FontStyle)1;
			componentInChildren.horizontalOverflow = (HorizontalWrapMode)1;
			LogsModule.Log("[Rewards UI] Navigation icon prepared: " + IconKey(page));
		}

		private static void RenderRewards(FortecaUiRewardTier tier)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			FortecaRewardTierView fortecaRewardTierView = ctx.GetRewardTier(tier);
			SetTitle(fortecaRewardTierView.Title);
			if (!fortecaRewardTierView.HasAccess)
			{
				Empty(content, fortecaRewardTierView.LockedMessage);
				return;
			}
			Section(content, "", fortecaRewardTierView.Description);
			RectTransform component = Panel((Transform)(object)content, "RewardGrid", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -70f);
			GridLayoutGroup val = ((Component)component).gameObject.AddComponent<GridLayoutGroup>();
			val.cellSize = new Vector2(144f, 154f);
			val.spacing = new Vector2(14f, 14f);
			val.constraint = (Constraint)1;
			val.constraintCount = 7;
			((LayoutGroup)val).padding = new RectOffset(22, 22, 12, 12);
			int num = 0;
			int num2 = ((fortecaRewardTierView.RawEntries != null) ? Math.Min(28, fortecaRewardTierView.RawEntries.Count) : 0);
			for (int i = 0; i < 28; i++)
			{
				if (!RewardCard(component, tier, i + 1, (i < num2) ? fortecaRewardTierView.RawEntries[i] : "", fortecaRewardTierView))
				{
					num++;
				}
			}
			int num3 = Mathf.CeilToInt(28f / (float)val.constraintCount);
			float num4 = (float)(((LayoutGroup)val).padding.top + ((LayoutGroup)val).padding.bottom) + (float)num3 * val.cellSize.y + (float)Math.Max(0, num3 - 1) * val.spacing.y;
			component.sizeDelta = new Vector2(0f, num4);
			content.sizeDelta = new Vector2(0f, 96f + num4);
			LogsModule.Log("[Rewards UI] Resolution: " + Screen.width + "x" + Screen.height);
			LogsModule.Log("[Rewards UI] Reward grid: columns=" + val.constraintCount + " rows=" + num3 + " cell=" + val.cellSize.x + "x" + val.cellSize.y);
			LogsModule.Log("[Rewards UI] " + tier.ToString() + " entries: " + num2);
			LogsModule.Log("[Rewards UI] " + tier.ToString() + " cards created: 28");
			LogsModule.Log("[Rewards UI] " + tier.ToString() + " invalid cards: " + num);
		}

		private static bool RewardCard(RectTransform parent, FortecaUiRewardTier tier, int day, string raw, FortecaRewardTierView view)
		{
			//IL_013b: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Expected O, but got Unknown
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			string[] array = (raw ?? "").Split(new char[1] { ',' });
			string prefab = ((array.Length != 0) ? array[0].Trim() : "");
			int result;
			int amount = ((array.Length > 1 && int.TryParse(array[1], out result)) ? result : 0);
			int result2;
			int num = ((array.Length <= 2 || !int.TryParse(array[2], out result2)) ? 1 : Math.Max(1, result2));
			string text = State(day, view);
			bool flag = !string.IsNullOrWhiteSpace(prefab) && amount > 0;
			bool flag2 = string.Equals(text, "Claimed", StringComparison.OrdinalIgnoreCase);
			bool flag3 = string.Equals(text, "Available", StringComparison.OrdinalIgnoreCase);
			Color color = ((!flag) ? new Color(0.28f, 0.04f, 0.03f, 0.96f) : (flag2 ? new Color(0.18f, 0.045f, 0.055f, 0.97f) : (flag3 ? new Color(0.045f, 0.085f, 0.045f, 0.96f) : new Color(0.052f, 0.046f, 0.018f, 0.94f))));
			GameObject val = Panel((Transform)(object)parent, "RewardCard_" + day, color);
			GameObject obj = Panel(val.transform, "RewardCardBorder", flag2 ? new Color(0.4f, 0.1f, 0.1f, 0.85f) : (flag3 ? new Color(0.18f, 0.3f, 0.14f, 0.78f) : new Color(0.18f, 0.13f, 0.07f, 0.55f)));
			Anchor(obj.GetComponent<RectTransform>(), 0f, 0f, 1f, 1f, 0f, 0f, 0f, 0f);
			obj.transform.SetAsFirstSibling();
			((Graphic)obj.GetComponent<Image>()).raycastTarget = false;
			AbsLabel(val.transform, "Day " + day, 12, (TextAnchor)4, Color.white, 0f, -10f, 144f, 20f);
			GameObject val2 = ResolvePrefab(prefab);
			Image val3 = Image(val.transform, SafeIcon(val2));
			Anchor(((Component)val3).GetComponent<RectTransform>(), 0.4f, 0.52f, 0.6f, 0.7f, 0f, 0f, 0f, 0f);
			if (flag2)
			{
				((Graphic)val3).color = new Color(0.75f, 0.62f, 0.62f, 0.85f);
			}
			AbsLabel(val.transform, flag ? Display(prefab, val2) : (string.IsNullOrWhiteSpace(prefab) ? "Invalid reward" : prefab), 11, (TextAnchor)4, Color.white, 8f, -82f, 134f, 22f);
			AbsLabel(val.transform, flag ? ("x" + amount + ((num > 1) ? (" Q" + num) : "")) : "Invalid config", 11, (TextAnchor)4, (Color)(flag ? new Color(1f, 0.85f, 0.34f, 1f) : Color.yellow), 8f, -104f, 134f, 18f);
			if (flag && flag3)
			{
				Anchor(((Component)Button(val.transform, "Claim", 12, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
				{
					ctx.ClaimReward(tier, day, prefab + "," + amount);
				})).GetComponent<RectTransform>(), 0.18f, 0.045f, 0.82f, 0.22f, 0f, 0f, 0f, 0f);
			}
			else if (flag && flag2)
			{
				Button obj2 = Button(val.transform, "CLAIMED", 10, new Color(0.19f, 0.065f, 0.06f, 1f), null);
				((Selectable)obj2).interactable = false;
				Anchor(((Component)obj2).GetComponent<RectTransform>(), 0.16f, 0.045f, 0.84f, 0.22f, 0f, 0f, 0f, 0f);
			}
			else
			{
				AbsLabel(val.transform, flag ? text.ToUpperInvariant() : "Invalid Config", 10, (TextAnchor)4, (Color)(flag ? new Color(0.86f, 0.78f, 0.62f, 1f) : Color.yellow), 8f, -126f, 134f, 18f);
			}
			return flag;
		}

		private static string State(int day, FortecaRewardTierView v)
		{
			if (v.CurrentTaken >= day)
			{
				return "Claimed";
			}
			if (v.CurrentTaken + 1 < day)
			{
				return "Future";
			}
			if (!v.Available)
			{
				if (v.RemainingSeconds <= 0)
				{
					return "Locked";
				}
				return v.RemainingSeconds.ToTime();
			}
			return "Available";
		}

		private static void RenderKitPacks()
		{
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Expected O, but got Unknown
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			FortecaRewardPackService.Load();
			Section(content, "", "Spend Server Tokens on themed Futhark reward packs.\nGold packs are One-Time purchases.\nBlue packs are Repeatable.\nClick a pack to preview its contents.");
			if (!string.IsNullOrWhiteSpace(FortecaRewardPackService.LastError))
			{
				LogsModule.Log("[Rewards UI] Kit Packs warning: " + FortecaRewardPackService.LastError);
				Empty(content, "No Kit Packs configured.");
				return;
			}
			if (FortecaRewardPackService.Packs.Count == 0)
			{
				Empty(content, "No Kit Packs configured.");
				return;
			}
			List<FortecaRewardPackService.Pack> source = FortecaRewardPackService.Packs.Take(28).ToList();
			List<FortecaRewardPackService.Pack> list = source.Where((FortecaRewardPackService.Pack x) => !FortecaRewardPackService.IsSpecial(x)).Take(24).ToList();
			List<FortecaRewardPackService.Pack> list2 = source.Where((FortecaRewardPackService.Pack x) => FortecaRewardPackService.IsSpecial(x)).Take(4).ToList();
			List<FortecaRewardPackService.Pack> packs = new List<FortecaRewardPackService.Pack>();
			for (int num = 0; num < 4; num++)
			{
				for (int num2 = 0; num2 < 6; num2++)
				{
					int num3 = num * 6 + num2;
					if (num3 < list.Count)
					{
						packs.Add(list[num3]);
					}
				}
				if (num < list2.Count)
				{
					packs.Add(list2[num]);
				}
			}
			foreach (FortecaRewardPackService.Pack item in source.Where((FortecaRewardPackService.Pack x) => !packs.Contains(x)).Take(28 - packs.Count))
			{
				packs.Add(item);
			}
			if (string.IsNullOrWhiteSpace(selectedPackId) && packs.Count > 0)
			{
				selectedPackId = packs[0].PackId;
			}
			RectTransform component = Panel((Transform)(object)content, "KitPackTileGrid_7x4", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -112f);
			component.sizeDelta = new Vector2(0f, 472f);
			GridLayoutGroup obj = ((Component)component).gameObject.AddComponent<GridLayoutGroup>();
			obj.cellSize = new Vector2(166f, 104f);
			obj.spacing = new Vector2(10f, 9f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 7;
			((LayoutGroup)obj).padding = new RectOffset(24, 24, 12, 12);
			int num4 = 0;
			foreach (FortecaRewardPackService.Pack item2 in packs)
			{
				PackTile(component, item2, num4 + 1);
				num4++;
			}
			RectTransform component2 = Panel((Transform)(object)content, "KitPackDetailsPanel", new Color(0.028f, 0.02f, 0.014f, 0.88f)).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.05f, 1f);
			component2.anchorMax = new Vector2(0.95f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = new Vector2(0f, -596f);
			component2.sizeDelta = new Vector2(0f, 132f);
			FortecaRewardPackService.Pack pack = packs.FirstOrDefault((FortecaRewardPackService.Pack x) => x.PackId == selectedPackId) ?? packs.FirstOrDefault();
			if (pack != null)
			{
				PackDetails(component2, pack);
			}
			else
			{
				Label((Transform)(object)component2, "Select a pack to edit.", 15, (TextAnchor)4, new Color(0.86f, 0.78f, 0.62f, 1f));
			}
			LogRuneIconSummaryOnce();
			content.sizeDelta = new Vector2(0f, 754f);
		}

		private static void PackTile(RectTransform parent, FortecaRewardPackService.Pack p, int index)
		{
			//IL_0075: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_014f: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			bool flag = FortecaRewardPackService.IsOneTime(p);
			bool flag2 = FortecaRewardPackService.IsSpecial(p);
			Color color = (flag2 ? new Color(0.05f, 0.035f, 0.095f, 0.97f) : (flag ? new Color(0.13f, 0.085f, 0.035f, 0.97f) : new Color(0.035f, 0.055f, 0.085f, 0.97f)));
			Color color2 = (flag2 ? new Color(0.3f, 0.18f, 0.48f, 0.86f) : (flag ? new Color(0.36f, 0.27f, 0.13f, 0.82f) : new Color(0.13f, 0.2f, 0.3f, 0.82f)));
			GameObject val = Panel((Transform)(object)parent, "PackTile_" + p.PackId, color);
			Button obj = val.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			((Graphic)val.GetComponent<Image>()).raycastTarget = true;
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				selectedPackId = p.PackId;
				RefreshCurrentPage();
			});
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.preferredWidth = 166f;
			obj2.preferredHeight = 104f;
			GameObject obj3 = Panel(val.transform, "PackTypeBorder", color2);
			Anchor(obj3.GetComponent<RectTransform>(), 0f, 0f, 1f, 1f, 0f, 0f, 0f, 0f);
			obj3.transform.SetAsFirstSibling();
			((Graphic)obj3.GetComponent<Image>()).raycastTarget = false;
			Anchor(((Component)Image(val.transform, LoadRuneIcon(FortecaRewardPackService.RuneKey(p), index))).GetComponent<RectTransform>(), 0.07f, 0.38f, 0.31f, 0.86f, 0f, 0f, 0f, 0f);
			AbsLabel(val.transform, p.Name.Replace(" PACK", ""), 12, (TextAnchor)3, (Color)(flag2 ? new Color(0.96f, 0.78f, 0.36f, 1f) : Color.white), 56f, -8f, 96f, 22f);
			AbsLabel(val.transform, FortecaRewardPackService.PurchaseLabel(p), 9, (TextAnchor)3, (Color)(flag2 ? Color.white : (flag ? new Color(0.86f, 0.68f, 0.38f, 1f) : new Color(0.58f, 0.72f, 0.92f, 1f))), 56f, -32f, 96f, 16f);
			AbsLabel(val.transform, FortecaRewardPackService.CostOf(p) + " Tokens", 9, (TextAnchor)3, new Color(0.92f, 0.82f, 0.52f, 1f), 56f, -50f, 96f, 18f);
			bool ok = FortecaRewardPackService.IsEnabled(p) && (ctx.GetTokens?.Invoke() ?? 0) >= FortecaRewardPackService.CostOf(p);
			Button obj4 = Button(val.transform, ok ? "Buy" : "Locked", 9, ok ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.13f, 0.08f, 0.06f, 0.85f), (UnityAction)delegate
			{
				if (ok)
				{
					ctx.PurchasePack(p.PackId);
					SetStatus("Purchase requested: " + p.Name, FortecaUiStatusType.Info);
				}
			});
			((Selectable)obj4).interactable = ok;
			Anchor(((Component)obj4).GetComponent<RectTransform>(), 0.58f, 0.05f, 0.95f, 0.27f, 0f, 0f, 0f, 0f);
		}

		private static void PackDetails(RectTransform panel, FortecaRewardPackService.Pack p)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			Anchor(((Component)Image((Transform)(object)panel, LoadRuneIcon(FortecaRewardPackService.RuneKey(p), 1))).GetComponent<RectTransform>(), 0.025f, 0.22f, 0.105f, 0.86f, 0f, 0f, 0f, 0f);
			AbsLabel(((Component)panel).transform, p.Name, 17, (TextAnchor)3, Color.white, 116f, -8f, 320f, 24f);
			AbsLabel(((Component)panel).transform, p.Description ?? "No description.", 11, (TextAnchor)0, new Color(0.86f, 0.78f, 0.62f, 1f), 116f, -34f, 430f, 36f);
			int num = -10;
			foreach (FortecaRewardPackService.Item item in (p.Rewards ?? new List<FortecaRewardPackService.Item>()).Take(4))
			{
				RewardIconLine(((Component)panel).transform, item.Prefab, item.Amount, item.Quality, 560f, num, 300f, showPrefab: false);
				num -= 28;
			}
			AbsLabel(((Component)panel).transform, FortecaRewardPackService.PurchaseLabel(p) + "  |  " + FortecaRewardPackService.CostOf(p) + " Tokens", 12, (TextAnchor)4, new Color(0.92f, 0.78f, 0.36f, 1f), 942f, -14f, 240f, 24f);
			Button obj = Button(((Component)panel).transform, "Purchase Pack", 11, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				ctx.PurchasePack(p.PackId);
			});
			((Selectable)obj).interactable = FortecaRewardPackService.IsEnabled(p);
			Anchor(((Component)obj).GetComponent<RectTransform>(), 0.8f, 0.16f, 0.97f, 0.43f, 0f, 0f, 0f, 0f);
		}

		private static void PackCard(RectTransform parent, FortecaRewardPackService.Pack p)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel((Transform)(object)parent, "Pack_" + p.PackId, new Color(0.055f, 0.033f, 0.022f, 0.96f));
			obj.AddComponent<LayoutElement>().preferredHeight = 212f;
			Anchor(((Component)Image(obj.transform, ExternalAssetSystem.GetIcon("kit_packs", fallbackIcon))).GetComponent<RectTransform>(), 0.03f, 0.52f, 0.115f, 0.86f, 0f, 0f, 0f, 0f);
			AbsLabel(obj.transform, p.Name, 21, (TextAnchor)3, Color.white, 124f, -18f, 440f, 32f);
			AbsLabel(obj.transform, p.Description ?? "", 13, (TextAnchor)0, new Color(0.86f, 0.78f, 0.62f, 1f), 124f, -56f, 620f, 42f);
			string text = string.Join("\n", from r in (p.Rewards ?? new List<FortecaRewardPackService.Item>()).Take(6)
				select "- " + r.Prefab + " x" + r.Amount);
			GameObject obj2 = Panel(obj.transform, "PackRewardsPreview", new Color(0.025f, 0.017f, 0.012f, 0.76f));
			Anchor(obj2.GetComponent<RectTransform>(), 0.08f, 0.08f, 0.73f, 0.46f, 0f, 0f, 0f, 0f);
			Label(obj2.transform, string.IsNullOrWhiteSpace(text) ? "No rewards listed." : text, 13, (TextAnchor)3, new Color(0.92f, 0.88f, 0.78f, 1f));
			AbsLabel(obj.transform, "Token Price", 12, (TextAnchor)4, new Color(0.86f, 0.78f, 0.62f, 1f), 760f, -30f, 170f, 20f);
			AbsLabel(obj.transform, FortecaRewardPackService.CostOf(p) + " Tokens", 19, (TextAnchor)4, new Color(1f, 0.85f, 0.34f, 1f), 760f, -58f, 170f, 30f);
			bool flag = FortecaRewardPackService.IsEnabled(p) && (ctx.GetTokens?.Invoke() ?? 0) >= FortecaRewardPackService.CostOf(p);
			Button obj3 = Button(obj.transform, flag ? "Purchase" : "Unavailable", 14, flag ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.2f, 0.12f, 0.08f, 0.85f), (UnityAction)delegate
			{
				ctx.PurchasePack(p.PackId);
			});
			((Selectable)obj3).interactable = flag;
			Anchor(((Component)obj3).GetComponent<RectTransform>(), 0.78f, 0.14f, 0.965f, 0.34f, 0f, 0f, 0f, 0f);
			Anchor(Panel(obj.transform, "PackSeparator", new Color(0.32f, 0.2f, 0.11f, 0.62f)).GetComponent<RectTransform>(), 0.02f, 0f, 0.98f, 0.01f, 0f, 0f, 0f, 0f);
		}

		private static void RenderRedeem()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (ctx.RenderRedeem != null)
			{
				ctx.RenderRedeem(((Component)content).gameObject, titleText);
				content.sizeDelta = new Vector2(0f, 560f);
			}
		}

		private static void RenderWebhookInfo()
		{
			//IL_005f: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = ReadWebhookCfg();
			bool flag = dictionary.ContainsKey("EnableWebhook") && dictionary["EnableWebhook"].Equals("true", StringComparison.OrdinalIgnoreCase);
			Section(content, "", "Reward notifications may be sent to the community Discord by the server administrator.");
			GameObject obj = Panel((Transform)(object)content, "WebhookInfoCard", new Color(0.035f, 0.024f, 0.017f, 0.88f));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.22f, 1f);
			component.anchorMax = new Vector2(0.78f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 260f);
			component.anchoredPosition = new Vector2(0f, -112f);
			Anchor(((Component)Image(obj.transform, ExternalAssetSystem.GetIcon("webhook", WebhookFallbackSprite()))).GetComponent<RectTransform>(), 0.08f, 0.52f, 0.22f, 0.86f, 0f, 0f, 0f, 0f);
			AbsLabel(obj.transform, "Discord Notifications", 23, (TextAnchor)3, Color.white, 210f, -36f, 500f, 32f);
			AbsLabel(obj.transform, "Status: " + (flag ? "Enabled" : "Disabled"), 16, (TextAnchor)3, flag ? new Color(0.66f, 0.78f, 0.52f, 1f) : new Color(0.78f, 0.68f, 0.55f, 1f), 210f, -78f, 320f, 28f);
			AbsLabel(obj.transform, "Possible notifications:\n- Reward claims\n- Kit Pack purchases\n- Redeem codes\n- Admin grants", 14, (TextAnchor)0, new Color(0.9f, 0.82f, 0.65f, 1f), 210f, -116f, 460f, 100f);
			content.sizeDelta = new Vector2(0f, 420f);
		}

		private static void RenderAdmin()
		{
			//IL_005f: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			if (ctx.IsAdmin != null && !ctx.IsAdmin())
			{
				Empty(content, "Admin rewards tools are not available for this account.");
				return;
			}
			SetTitle("Admin - " + adminPage);
			RectTransform component = Panel((Transform)(object)content, "AdminRoot", new Color(0.025f, 0.018f, 0.014f, 0.88f)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 735f);
			((Graphic)((Component)component).GetComponent<Image>()).raycastTarget = false;
			RectTransform val = (adminNavigationRoot = Panel((Transform)(object)component, "AdminNavigationRoot", new Color(0f, 0f, 0f, 0.1f)).GetComponent<RectTransform>());
			Anchor(val, 0f, 0.875f, 1f, 1f, 8f, 0f, -8f, -6f);
			GridLayoutGroup obj = ((Component)val).gameObject.AddComponent<GridLayoutGroup>();
			obj.cellSize = new Vector2(188f, 31f);
			obj.spacing = new Vector2(8f, 6f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 4;
			((LayoutGroup)obj).padding = new RectOffset(0, 0, 4, 4);
			string[] array = new string[8] { "Daily Rewards", "Reward Packs", "Redeem Codes", "Grant Rewards", "Access Management", "Webhook", "History", "Settings" };
			foreach (string text in array)
			{
				string cap = text;
				Button((Transform)(object)val, text, 11, (cap == adminPage) ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.12f, 0.07f, 0.035f, 1f), (UnityAction)delegate
				{
					ShowAdminPage(cap);
				});
			}
			RectTransform val2 = (adminContentRoot = Panel((Transform)(object)component, "AdminPageBody", new Color(0.006f, 0.004f, 0.003f, 0.5f)).GetComponent<RectTransform>());
			Anchor(val2, 0f, 0.105f, 1f, 0.865f, 8f, 8f, -8f, -8f);
			((Component)val2).gameObject.AddComponent<RectMask2D>();
			RectTransform obj2 = (adminActionsRoot = Panel((Transform)(object)component, "AdminPageActions", new Color(0.035f, 0.025f, 0.018f, 0.86f)).GetComponent<RectTransform>());
			Anchor(obj2, 0f, 0f, 1f, 0.085f, 8f, 8f, -8f, -4f);
			HorizontalLayoutGroup obj3 = ((Component)obj2).gameObject.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 10f;
			((LayoutGroup)obj3).padding = new RectOffset(12, 12, 8, 8);
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			try
			{
				ShowAdminPage(adminPage, val2);
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI ERROR] Page=Admin Section=" + adminPage + " Reason=" + ex);
				ClearChildren(val2);
				Empty(val2, "Admin page could not be rendered.");
			}
			RestoreAdminNavigationLayers();
			content.sizeDelta = new Vector2(0f, 735f);
			LogsModule.Log("[Rewards UI] Admin page opened");
		}

		private static void ShowAdminPage(string pageName)
		{
			adminPage = pageName;
			LogsModule.Log("[RewardsUI] Opening Admin page: " + adminPage);
			NavigateTo(FortecaUiPageId.Admin);
		}

		private static void ShowAdminPage(string pageName, RectTransform body)
		{
			adminPage = pageName;
			LogsModule.Log("[RewardsUI] Opening Admin page: " + adminPage);
			ClearChildren(body);
			if ((Object)(object)adminActionsRoot != (Object)null)
			{
				ClearChildren(adminActionsRoot);
			}
			if (adminPage == "Daily Rewards")
			{
				AdminDaily(body);
			}
			else if (adminPage == "Reward Packs")
			{
				AdminPacks(body);
			}
			else if (adminPage == "Redeem Codes")
			{
				AdminRedeem(body);
			}
			else if (adminPage == "Grant Rewards")
			{
				AdminGrant(body);
			}
			else if (adminPage == "Access Management")
			{
				AdminAccess(body);
			}
			else if (adminPage == "Webhook")
			{
				AdminWebhook(body);
			}
			else if (adminPage == "History")
			{
				AdminHistory(body);
			}
			else if (adminPage == "Settings")
			{
				AdminSettings(body);
			}
			else
			{
				AdminSimple(body, adminPage);
			}
			RestoreAdminNavigationLayers();
			LogsModule.Log("[RewardsUI] Active Admin page count: 1");
		}

		private static void RestoreAdminNavigationLayers()
		{
			if ((Object)(object)adminContentRoot != (Object)null)
			{
				((Transform)adminContentRoot).SetAsFirstSibling();
			}
			if ((Object)(object)adminActionsRoot != (Object)null)
			{
				((Transform)adminActionsRoot).SetAsLastSibling();
			}
			if ((Object)(object)adminNavigationRoot != (Object)null)
			{
				((Transform)adminNavigationRoot).SetAsLastSibling();
				LogsModule.Log("[RewardsUI] Admin navigation restored.");
			}
			RestoreGlobalNavigationLayers();
		}

		private static void RestoreGlobalNavigationLayers()
		{
			if ((Object)(object)leftNavigationRoot != (Object)null)
			{
				((Transform)leftNavigationRoot).SetAsLastSibling();
			}
			if ((Object)(object)headerRoot != (Object)null)
			{
				((Transform)headerRoot).SetAsLastSibling();
			}
			if ((Object)(object)globalCloseButton != (Object)null)
			{
				((Component)globalCloseButton).transform.SetAsLastSibling();
				LogsModule.Log("[RewardsUI] Global close button restored.");
			}
		}

		private static void ClearChildren(RectTransform r)
		{
			if (!((Object)(object)r == (Object)null))
			{
				for (int num = ((Transform)r).childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)((Transform)r).GetChild(num)).gameObject);
				}
			}
		}

		private static void AdminDaily(RectTransform parent)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Expected O, but got Unknown
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: 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_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: 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_0662: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Expected O, but got Unknown
			//IL_06f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Expected O, but got Unknown
			//IL_072d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0739: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Expected O, but got Unknown
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Expected O, but got Unknown
			FortecaDailyDataService.DailyData data = FortecaDailyDataService.Get(adminTier);
			RectTransform parent2 = HBar(parent, "DailyTierTabs", 0.88f, 1f);
			foreach (FortecaUiRewardTier value in Enum.GetValues(typeof(FortecaUiRewardTier)))
			{
				FortecaUiRewardTier cap = value;
				Button((Transform)(object)parent2, value.ToString(), 12, (cap == adminTier) ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.12f, 0.07f, 0.035f, 1f), (UnityAction)delegate
				{
					adminTier = cap;
					adminDay = 1;
					NavigateTo(FortecaUiPageId.Admin);
				});
			}
			RectTransform component = Panel((Transform)(object)parent, "DaySelector", new Color(0.018f, 0.012f, 0.009f, 0.72f)).GetComponent<RectTransform>();
			Anchor(component, 0.04f, 0.47f, 0.96f, 0.86f, 0f, 0f, 0f, 0f);
			GridLayoutGroup obj = ((Component)component).gameObject.AddComponent<GridLayoutGroup>();
			obj.cellSize = new Vector2(132f, 46f);
			obj.spacing = new Vector2(9f, 8f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 7;
			((LayoutGroup)obj).padding = new RectOffset(12, 12, 12, 12);
			Vector2 val2 = default(Vector2);
			for (int num = 1; num <= 28; num++)
			{
				int cap2 = num;
				FortecaDailyDataService.RewardLine rewardLine = data.Rewards[num - 1];
				bool flag = num == adminDay;
				GameObject val = Panel((Transform)(object)component, "DayTile_" + num, flag ? new Color(0.32f, 0.16f, 0.06f, 1f) : new Color(0.1f, 0.06f, 0.035f, 1f));
				Button obj2 = val.AddComponent<Button>();
				((Selectable)obj2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
				((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
				{
					adminDay = cap2;
					NavigateTo(FortecaUiPageId.Admin);
				});
				AbsLabel(val.transform, "Day " + num, 9, (TextAnchor)4, Color.white, 0f, -2f, 132f, 14f);
				Image obj3 = Image(val.transform, ResolveItemIcon(rewardLine.Prefab));
				((Graphic)obj3).raycastTarget = false;
				RectTransform component2 = ((Component)obj3).GetComponent<RectTransform>();
				((Vector2)(ref val2))..ctor(0.5f, 0.5f);
				component2.anchorMax = val2;
				component2.anchorMin = val2;
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.sizeDelta = new Vector2(24f, 24f);
				component2.anchoredPosition = new Vector2(0f, -1f);
				AbsLabel(val.transform, "x" + Mathf.Max(0, rewardLine.Amount), 9, (TextAnchor)4, new Color(0.92f, 0.78f, 0.36f, 1f), 0f, -32f, 132f, 14f);
			}
			GameObject obj4 = Panel((Transform)(object)parent, "DailyEditorRoot", new Color(0.02f, 0.014f, 0.01f, 0.76f));
			Anchor(obj4.GetComponent<RectTransform>(), 0.04f, 0.05f, 0.96f, 0.44f, 0f, 0f, 0f, 0f);
			FortecaDailyDataService.RewardLine reward = data.Rewards[Mathf.Clamp(adminDay - 1, 0, 27)];
			GameObject val3 = ResolvePrefab(reward.Prefab);
			RectTransform component3 = Panel(obj4.transform, "DailyEditorLeft", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			Anchor(component3, 0.03f, 0.08f, 0.56f, 0.92f, 0f, 0f, 0f, 0f);
			VerticalLayoutGroup obj5 = ((Component)component3).gameObject.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj5).spacing = 7f;
			((LayoutGroup)obj5).padding = new RectOffset(8, 12, 8, 8);
			((HorizontalOrVerticalLayoutGroup)obj5).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childControlHeight = false;
			RectTransform component4 = Panel(obj4.transform, "DailyEditorRight", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			Anchor(component4, 0.6f, 0.08f, 0.97f, 0.92f, 0f, 0f, 0f, 0f);
			InputField prefab = LabeledInput(component3, "Prefab", reward.Prefab);
			LabelRow(component3, "Display Name", Display(reward.Prefab, val3));
			InputField amount = LabeledInput(component3, "Amount", reward.Amount.ToString());
			InputField quality = LabeledInput(component3, "Quality", reward.Quality.ToString());
			InputField variant = LabeledInput(component3, "Variant", reward.Variant.ToString());
			AbsLabel((Transform)(object)component4, "Item Preview", 16, (TextAnchor)4, Color.white, 0f, -2f, 360f, 26f);
			Anchor(((Component)Image((Transform)(object)component4, SafeIcon(val3))).GetComponent<RectTransform>(), 0.36f, 0.46f, 0.64f, 0.8f, 0f, 0f, 0f, 0f);
			AdminMiniRow((Transform)(object)component4, "Validation", (string.IsNullOrWhiteSpace(reward.Prefab) || reward.Amount <= 0) ? "Invalid config" : "Ready", 18f, -184f, 340f);
			RectTransform parent3 = adminActionsRoot;
			Color color = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj6 = <>c.<>9__57_0;
			if (obj6 == null)
			{
				UnityAction val4 = delegate
				{
					FortecaDailyDataService.Load(adminTier);
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__57_0 = val4;
				obj6 = (object)val4;
			}
			Button((Transform)(object)parent3, "Reload", 12, color, (UnityAction)obj6);
			RectTransform parent4 = adminActionsRoot;
			Color color2 = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj7 = <>c.<>9__57_1;
			if (obj7 == null)
			{
				UnityAction val5 = delegate
				{
					FortecaDailyDataService.Save(adminTier);
					SetStatus("Saved " + adminTier, FortecaUiStatusType.Success);
				};
				<>c.<>9__57_1 = val5;
				obj7 = (object)val5;
			}
			Button((Transform)(object)parent4, "Save", 12, color2, (UnityAction)obj7);
			Button((Transform)(object)adminActionsRoot, "Apply", 12, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				reward.Prefab = prefab.text;
				int.TryParse(amount.text, out reward.Amount);
				int.TryParse(quality.text, out reward.Quality);
				int.TryParse(variant.text, out reward.Variant);
				NavigateTo(FortecaUiPageId.Admin);
			});
			Button((Transform)(object)adminActionsRoot, "Reset Day", 12, new Color(0.2f, 0.07f, 0.06f, 1f), (UnityAction)delegate
			{
				data.Rewards[adminDay - 1] = new FortecaDailyDataService.RewardLine();
				NavigateTo(FortecaUiPageId.Admin);
			});
		}

		private static Color AdminPackRowColor(FortecaRewardPackService.Pack pack)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			string text = FortecaRewardPackService.PurchaseLabel(pack) ?? "";
			if (text.IndexOf("SPECIAL", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return new Color(0.27f, 0.15f, 0.45f, 0.92f);
			}
			if (text.IndexOf("REPEAT", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return new Color(0.1f, 0.18f, 0.28f, 0.92f);
			}
			return new Color(0.34f, 0.24f, 0.09f, 0.92f);
		}

		private static Color SelectedPackRowColor(FortecaRewardPackService.Pack pack)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Color val = AdminPackRowColor(pack);
			return new Color(Mathf.Min(val.r + 0.08f, 1f), Mathf.Min(val.g + 0.07f, 1f), Mathf.Min(val.b + 0.04f, 1f), val.a);
		}

		private static void AdminAddRewardCard(RectTransform parent, string name, UnityAction action)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = AdminCard(parent, name, 0f, 0.02f, 1f, 0.55f, "Add Reward", "").GetComponent<RectTransform>();
			AdminField((Transform)(object)component, "Prefab", "Item prefab to add.", "Wood", 18f, -76f, 138f);
			AdminField((Transform)(object)component, "Amount", "Stack amount.", "1", 176f, -76f, 76f);
			AdminField((Transform)(object)component, "Quality", "Item quality.", "1", 282f, -76f, 76f);
			AdminButton((Transform)(object)component, "Add Reward", 18f, -154f, 170f, new Color(0.16f, 0.23f, 0.12f, 1f), action);
		}

		private static void AdminPacks(RectTransform parent)
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Expected O, but got Unknown
			//IL_0734: Unknown result type (might be due to invalid IL or missing references)
			//IL_0704: Unknown result type (might be due to invalid IL or missing references)
			//IL_0709: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Expected O, but got Unknown
			//IL_077e: Unknown result type (might be due to invalid IL or missing references)
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Expected O, but got Unknown
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07de: Expected O, but got Unknown
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a2: Expected O, but got Unknown
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0818: Unknown result type (might be due to invalid IL or missing references)
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0823: Expected O, but got Unknown
			//IL_0893: Unknown result type (might be due to invalid IL or missing references)
			//IL_0862: Unknown result type (might be due to invalid IL or missing references)
			//IL_0867: Unknown result type (might be due to invalid IL or missing references)
			//IL_086d: Expected O, but got Unknown
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Expected O, but got Unknown
			FortecaRewardPackService.Load();
			AdminColumns adminColumns = AdminTemplate(parent, "RewardPacksTemplate");
			AdminColumnHeader(adminColumns.Left, "Pack List", "Search, select, add or duplicate packs.");
			AdminColumnHeader(adminColumns.Center, "Pack Settings", "Readable pack settings for administrators.");
			AdminColumnHeader(adminColumns.Right, "Rewards", "Items granted by this pack.");
			AdminField((Transform)(object)adminColumns.Left, "Search", "Filter pack names.", "", 16f, -76f, 280f);
			if (string.IsNullOrWhiteSpace(selectedPackId) && FortecaRewardPackService.Packs.Count > 0)
			{
				selectedPackId = FortecaRewardPackService.Packs[0].PackId;
			}
			RectTransform parent2 = AdminScrollList(adminColumns.Left, "PackList", 0.02f, 0.66f, 12, 8, -12, -8);
			foreach (FortecaRewardPackService.Pack pack in FortecaRewardPackService.Packs)
			{
				FortecaRewardPackService.Pack cap = pack;
				bool flag = pack.PackId == selectedPackId;
				GameObject val = Panel((Transform)(object)parent2, "PackRow", flag ? SelectedPackRowColor(pack) : AdminPackRowColor(pack));
				if (flag)
				{
					Outline obj = val.AddComponent<Outline>();
					((Shadow)obj).effectColor = new Color(0.92f, 0.78f, 0.36f, 0.8f);
					((Shadow)obj).effectDistance = new Vector2(1f, -1f);
				}
				val.AddComponent<LayoutElement>().preferredHeight = 58f;
				Anchor(((Component)Image(val.transform, LoadRuneIcon(FortecaRewardPackService.RuneKey(pack), 1))).GetComponent<RectTransform>(), 0.04f, 0.18f, 0.18f, 0.82f, 0f, 0f, 0f, 0f);
				Button obj2 = val.AddComponent<Button>();
				((Selectable)obj2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
				((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
				{
					selectedPackId = cap.PackId;
					NavigateTo(FortecaUiPageId.Admin);
				});
				AbsLabel(val.transform, pack.Name.Replace(" PACK", ""), 12, (TextAnchor)3, Color.white, 76f, -8f, 170f, 18f);
				AbsLabel(val.transform, FortecaRewardPackService.PurchaseLabel(pack) + " | " + FortecaRewardPackService.CostOf(pack) + " Tokens", 10, (TextAnchor)3, new Color(0.86f, 0.78f, 0.62f, 1f), 76f, -32f, 190f, 16f);
			}
			FortecaRewardPackService.Pack p = FortecaRewardPackService.Packs.FirstOrDefault((FortecaRewardPackService.Pack x) => x.PackId == selectedPackId) ?? FortecaRewardPackService.Packs.FirstOrDefault();
			if (p == null)
			{
				Label((Transform)(object)adminColumns.Center, "No reward packs found.", 18, (TextAnchor)4, Color.yellow);
				return;
			}
			RectTransform component = AdminCard(adminColumns.Center, "PackIdentity", 0f, 0.64f, 1f, 1f, "Pack Identity", "Internal ID and player-facing text.").GetComponent<RectTransform>();
			AdminField((Transform)(object)component, "Pack ID", "Internal unique identifier.", p.PackId, 18f, -70f, 210f);
			AdminField((Transform)(object)component, "Display Name", "Name shown to players.", p.Name, 252f, -70f, 310f);
			AdminField((Transform)(object)component, "Description", "Short player-facing description.", p.Description ?? "", 18f, -166f, 544f);
			RectTransform component2 = AdminCard(adminColumns.Center, "PackRules", 0f, 0.34f, 1f, 0.64f, "Pack Rules", "Cost and availability.").GetComponent<RectTransform>();
			AdminField((Transform)(object)component2, "Rune", "Futhark icon key or number.", FortecaRewardPackService.RuneKey(p), 18f, -72f, 118f);
			AdminField((Transform)(object)component2, "Token Price", "Server Token cost.", FortecaRewardPackService.CostOf(p).ToString(), 152f, -72f, 118f);
			AdminField((Transform)(object)component2, "Purchase Type", "One-Time or Repeatable.", FortecaRewardPackService.PurchaseLabel(p), 286f, -72f, 150f);
			AdminToggle((Transform)(object)component2, "Enabled", "", FortecaRewardPackService.IsEnabled(p), 456f, -120f, 110f);
			RectTransform component3 = AdminCard(adminColumns.Center, "PackPreview", 0f, 0.04f, 1f, 0.33f, "Pack Preview", "How the selected pack appears to players.").GetComponent<RectTransform>();
			Anchor(((Component)Image((Transform)(object)component3, LoadRuneIcon(FortecaRewardPackService.RuneKey(p), 1))).GetComponent<RectTransform>(), 0.06f, 0.2f, 0.18f, 0.6f, 0f, 0f, 0f, 0f);
			AbsLabel((Transform)(object)component3, p.Name, 14, (TextAnchor)3, Color.white, 108f, -64f, 300f, 20f);
			AbsLabel((Transform)(object)component3, p.Description + "\n" + FortecaRewardPackService.PurchaseLabel(p) + " | " + FortecaRewardPackService.CostOf(p) + " Tokens", 10, (TextAnchor)0, new Color(0.86f, 0.78f, 0.62f, 1f), 108f, -92f, 330f, 42f);
			RectTransform component4 = AdminCard(adminColumns.Right, "PackRewardsList", 0f, 0.57f, 1f, 1f, "Rewards", "Items granted by this pack.").GetComponent<RectTransform>();
			int num = -72;
			foreach (FortecaRewardPackService.Item item in (p.Rewards ?? new List<FortecaRewardPackService.Item>()).Take(6))
			{
				RewardIconLine((Transform)(object)component4, item.Prefab, item.Amount, item.Quality, 18f, num, 220f, showPrefab: true);
				float y = num;
				Color color = new Color(0.2f, 0.07f, 0.06f, 1f);
				object obj3 = <>c.<>9__61_9;
				if (obj3 == null)
				{
					UnityAction val2 = delegate
					{
						SetStatus("Select a reward before removing.", FortecaUiStatusType.Warning);
					};
					<>c.<>9__61_9 = val2;
					obj3 = (object)val2;
				}
				AdminButton((Transform)(object)component4, "Remove", 250f, y, 72f, color, (UnityAction)obj3);
				num -= 46;
			}
			RectTransform right = adminColumns.Right;
			object obj4 = <>c.<>9__61_1;
			if (obj4 == null)
			{
				UnityAction val3 = delegate
				{
					SetStatus("Add Reward prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__61_1 = val3;
				obj4 = (object)val3;
			}
			AdminAddRewardCard(right, "AddRewardPackReward", (UnityAction)obj4);
			RectTransform parent3 = adminActionsRoot;
			Color color2 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj5 = <>c.<>9__61_2;
			if (obj5 == null)
			{
				UnityAction val4 = delegate
				{
					SetStatus("Add Pack prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__61_2 = val4;
				obj5 = (object)val4;
			}
			Button((Transform)(object)parent3, "Add", 12, color2, (UnityAction)obj5);
			RectTransform parent4 = adminActionsRoot;
			Color color3 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj6 = <>c.<>9__61_3;
			if (obj6 == null)
			{
				UnityAction val5 = delegate
				{
					SetStatus("Duplicate prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__61_3 = val5;
				obj6 = (object)val5;
			}
			Button((Transform)(object)parent4, "Duplicate", 12, color3, (UnityAction)obj6);
			Button((Transform)(object)adminActionsRoot, "Delete", 12, new Color(0.2f, 0.07f, 0.06f, 1f), (UnityAction)delegate
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				string message = "You are about to delete:\n" + p.Name + "\n\nThis action cannot be undone.";
				object obj10 = <>c.<>9__61_10;
				if (obj10 == null)
				{
					UnityAction val9 = delegate
					{
						SetStatus("Delete Pack confirmed. Save is required to persist admin data changes.", FortecaUiStatusType.Warning);
					};
					<>c.<>9__61_10 = val9;
					obj10 = (object)val9;
				}
				ShowConfirmModal("Delete Reward Pack?", message, "Delete Pack", (UnityAction)obj10);
			});
			RectTransform parent5 = adminActionsRoot;
			Color color4 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj7 = <>c.<>9__61_5;
			if (obj7 == null)
			{
				UnityAction val6 = delegate
				{
					FortecaRewardPackService.Load();
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__61_5 = val6;
				obj7 = (object)val6;
			}
			Button((Transform)(object)parent5, "Reload", 12, color4, (UnityAction)obj7);
			RectTransform parent6 = adminActionsRoot;
			Color color5 = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj8 = <>c.<>9__61_6;
			if (obj8 == null)
			{
				UnityAction val7 = delegate
				{
					SetStatus("Pack saved.", FortecaUiStatusType.Success);
				};
				<>c.<>9__61_6 = val7;
				obj8 = (object)val7;
			}
			Button((Transform)(object)parent6, "Save", 12, color5, (UnityAction)obj8);
			RectTransform parent7 = adminActionsRoot;
			Color color6 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj9 = <>c.<>9__61_7;
			if (obj9 == null)
			{
				UnityAction val8 = delegate
				{
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__61_7 = val8;
				obj9 = (object)val8;
			}
			Button((Transform)(object)parent7, "Cancel", 12, color6, (UnityAction)obj9);
		}

		private static void AdminRedeem(RectTransform parent)
		{
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Expected O, but got Unknown
			//IL_060a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Expected O, but got Unknown
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Expected O, but got Unknown
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Expected O, but got Unknown
			//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Expected O, but got Unknown
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Expected O, but got Unknown
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Expected O, but got Unknown
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Expected O, but got Unknown
			FortecaRedeemDataService.Load();
			List<RedeemSystem.RedeemCode> list = FortecaRedeemDataService.CurrentData.Codes.OrderBy((RedeemSystem.RedeemCode redeemCode) => redeemCode.Code).ToList();
			AdminColumns adminColumns = AdminTemplate(parent, "RedeemCodesTemplate");
			AdminColumnHeader(adminColumns.Left, "Code List", "Search, select or duplicate redeem codes.");
			AdminColumnHeader(adminColumns.Center, "Code Settings", "Public/private code rules.");
			AdminColumnHeader(adminColumns.Right, "Rewards", "Rewards granted by this code.");
			AdminField((Transform)(object)adminColumns.Left, "Search", "Filter code names.", "", 16f, -76f, 280f);
			RectTransform parent2 = AdminScrollList(adminColumns.Left, "CodeList", 0.02f, 0.66f, 12, 8, -12, -8);
			foreach (RedeemSystem.RedeemCode code in list)
			{
				GameObject val = Panel((Transform)(object)parent2, "CodeRow", (!code.Disabled) ? new Color(0.04f, 0.07f, 0.052f, 0.92f) : new Color(0.08f, 0.045f, 0.045f, 0.92f));
				val.AddComponent<LayoutElement>().preferredHeight = 58f;
				Button obj = val.AddComponent<Button>();
				((Selectable)obj).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
				((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
				{
					SetStatus("Selected code: " + code.Code, FortecaUiStatusType.Info);
				});
				AbsLabel(val.transform, code.Code, 12, (TextAnchor)3, Color.white, 14f, -8f, 220f, 18f);
				string text = ((code.MaxUses <= 0) ? "unlimited" : code.MaxUses.ToString());
				AbsLabel(val.transform, ((!code.Disabled) ? "Enabled" : "Disabled") + " | limit " + text, 10, (TextAnchor)3, new Color(0.86f, 0.78f, 0.62f, 1f), 14f, -32f, 220f, 16f);
			}
			RedeemSystem.RedeemCode c = list.FirstOrDefault();
			if (c == null)
			{
				Label((Transform)(object)adminColumns.Center, "No redeem codes found.", 18, (TextAnchor)4, Color.yellow);
				return;
			}
			RectTransform component = AdminCard(adminColumns.Center, "CodeIdentity", 0f, 0.67f, 1f, 1f, "Code Identity", "Code value and admin label.").GetComponent<RectTransform>();
			AdminField((Transform)(object)component, "Code", "Players type this value in the Redeem tab.", c.Code, 18f, -70f, 300f);
			AdminField((Transform)(object)component, "Description", "Admin-facing note or display label.", c.Code, 18f, -164f, 430f);
			RectTransform component2 = AdminCard(adminColumns.Center, "CodeRules", 0f, 0.36f, 1f, 0.65f, "Rules", "Limits and expiration.").GetComponent<RectTransform>();
			AdminToggle((Transform)(object)component2, "Enabled", "Disabled codes are rejected.", !c.Disabled, 18f, -76f, 220f);
			AdminToggle((Transform)(object)component2, "One Use Per SteamID", "Each SteamID64 may claim once.", c.OneTimePerSteamID, 270f, -76f, 260f);
			AdminField((Transform)(object)component2, "Maximum Uses", "Global claim limit.", (c.MaxUses <= 0) ? "Unlimited" : c.MaxUses.ToString(), 18f, -148f, 160f);
			AdminField((Transform)(object)component2, "Expiration UTC", "Optional UTC expiration date.", string.IsNullOrWhiteSpace(c.ExpirationUtc) ? "" : c.ExpirationUtc, 210f, -148f, 230f);
			AdminField((Transform)(object)AdminCard(adminColumns.Center, "CodeAccess", 0f, 0.04f, 1f, 0.36f, "Access Restrictions", "Optional private SteamID64 allow-list.").GetComponent<RectTransform>(), "Allowed SteamIDs", "Comma-separated private claim list.", (c.AllowedSteamIDs != null && c.AllowedSteamIDs.Count > 0) ? string.Join(",", c.AllowedSteamIDs) : "", 18f, -72f, 430f);
			RectTransform component3 = AdminCard(adminColumns.Right, "RedeemRewardsList", 0f, 0.57f, 1f, 1f, "Rewards", "Rewards granted by this code.").GetComponent<RectTransform>();
			int num = -72;
			foreach (RedeemSystem.RedeemReward item in (c.Rewards ?? new List<RedeemSystem.RedeemReward>()).Take(6))
			{
				RewardIconLine((Transform)(object)component3, item.Prefab, item.Amount, item.Quality, 18f, num, 220f, showPrefab: true);
				float y = num;
				Color color = new Color(0.2f, 0.07f, 0.06f, 1f);
				object obj2 = <>c.<>9__62_9;
				if (obj2 == null)
				{
					UnityAction val2 = delegate
					{
						SetStatus("Select a reward before removing.", FortecaUiStatusType.Warning);
					};
					<>c.<>9__62_9 = val2;
					obj2 = (object)val2;
				}
				AdminButton((Transform)(object)component3, "Remove", 250f, y, 72f, color, (UnityAction)obj2);
				num -= 46;
			}
			RectTransform right = adminColumns.Right;
			object obj3 = <>c.<>9__62_1;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					SetStatus("Add Reward prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__62_1 = val3;
				obj3 = (object)val3;
			}
			AdminAddRewardCard(right, "AddRedeemReward", (UnityAction)obj3);
			RectTransform parent3 = adminActionsRoot;
			Color color2 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj4 = <>c.<>9__62_2;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					SetStatus("New Code prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__62_2 = val4;
				obj4 = (object)val4;
			}
			Button((Transform)(object)parent3, "New", 12, color2, (UnityAction)obj4);
			RectTransform parent4 = adminActionsRoot;
			Color color3 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj5 = <>c.<>9__62_3;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					SetStatus("Duplicate Code prepared.", FortecaUiStatusType.Info);
				};
				<>c.<>9__62_3 = val5;
				obj5 = (object)val5;
			}
			Button((Transform)(object)parent4, "Duplicate", 12, color3, (UnityAction)obj5);
			Button((Transform)(object)adminActionsRoot, "Delete", 12, new Color(0.2f, 0.07f, 0.06f, 1f), (UnityAction)delegate
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				string message = "You are about to delete:\n" + c.Code + "\n\nThis action cannot be undone.";
				object obj9 = <>c.<>9__62_10;
				if (obj9 == null)
				{
					UnityAction val9 = delegate
					{
						SetStatus("Delete Code confirmed. Save is required to persist admin data changes.", FortecaUiStatusType.Warning);
					};
					<>c.<>9__62_10 = val9;
					obj9 = (object)val9;
				}
				ShowConfirmModal("Delete Redeem Code?", message, "Delete Code", (UnityAction)obj9);
			});
			RectTransform parent5 = adminActionsRoot;
			Color color4 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj6 = <>c.<>9__62_5;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					FortecaRedeemDataService.Load();
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__62_5 = val6;
				obj6 = (object)val6;
			}
			Button((Transform)(object)parent5, "Reload", 12, color4, (UnityAction)obj6);
			RectTransform parent6 = adminActionsRoot;
			Color color5 = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj7 = <>c.<>9__62_6;
			if (obj7 == null)
			{
				UnityAction val7 = delegate
				{
					SetStatus("Code saved.", FortecaUiStatusType.Success);
				};
				<>c.<>9__62_6 = val7;
				obj7 = (object)val7;
			}
			Button((Transform)(object)parent6, "Save", 12, color5, (UnityAction)obj7);
			RectTransform parent7 = adminActionsRoot;
			Color color6 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj8 = <>c.<>9__62_7;
			if (obj8 == null)
			{
				UnityAction val8 = delegate
				{
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__62_7 = val8;
				obj8 = (object)val8;
			}
			Button((Transform)(object)parent7, "Cancel", 12, color6, (UnityAction)obj8);
		}

		private static void AdminGrant(RectTransform parent)
		{
			//IL_00a9: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_02b2: 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_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Expected O, but got Unknown
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Expected O, but got Unknown
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Expected O, but got Unknown
			AdminColumns adminColumns = AdminTemplate(parent, "GrantRewardsTemplate");
			AdminColumnHeader(adminColumns.Left, "Players", "Select a target or enter SteamID64 manually.");
			AdminColumnHeader(adminColumns.Center, "Reward Builder", "Build a readable reward queue.");
			AdminColumnHeader(adminColumns.Right, "Summary", "Review before sending.");
			AdminField((Transform)(object)adminColumns.Left, "Search online players", "Filter connected players.", "", 16f, -76f, 300f);
			RectTransform left = adminColumns.Left;
			Color color = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj = <>c.<>9__63_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					SetStatus("Online player list refreshed when peers are available.", FortecaUiStatusType.Info);
				};
				<>c.<>9__63_0 = val;
				obj = (object)val;
			}
			AdminButton((Transform)(object)left, "Refresh", 16f, -154f, 150f, color, (UnityAction)obj);
			InputField steam = AdminField((Transform)(object)adminColumns.Left, "SteamID64", "17 digit account ID.", "", 16f, -238f, 260f);
			InputField val2 = AdminField((Transform)(object)adminColumns.Left, "Player Name", "Optional display helper.", "", 16f, -326f, 260f);
			InputField val3 = AdminField((Transform)(object)adminColumns.Center, "Prefab", "Internal item prefab, e.g. Wood.", "Wood", 18f, -76f, 240f);
			AdminField((Transform)(object)adminColumns.Center, "Amount", "Stack amount.", "1", 290f, -76f, 110f);
			AdminField((Transform)(object)adminColumns.Center, "Quality", "Item quality.", "1", 18f, -166f, 120f);
			AdminField((Transform)(object)adminColumns.Center, "Variant", "Variant index if supported.", "0", 170f, -166f, 120f);
			RectTransform center = adminColumns.Center;
			Color color2 = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj2 = <>c.<>9__63_1;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					SetStatus("Item added to queue preview.", FortecaUiStatusType.Info);
				};
				<>c.<>9__63_1 = val4;
				obj2 = (object)val4;
			}
			AdminButton((Transform)(object)center, "Add Item", 18f, -254f, 130f, color2, (UnityAction)obj2);
			RectTransform center2 = adminColumns.Center;
			Color color3 = new Color(0.2f, 0.07f, 0.06f, 1f);
			object obj3 = <>c.<>9__63_2;
			if (obj3 == null)
			{
				UnityAction val5 = delegate
				{
					SetStatus("Selected queue item removed.", FortecaUiStatusType.Warning);
				};
				<>c.<>9__63_2 = val5;
				obj3 = (object)val5;
			}
			AdminButton((Transform)(object)center2, "Remove Selected", 164f, -254f, 150f, color3, (UnityAction)obj3);
			RectTransform center3 = adminColumns.Center;
			Color color4 = new Color(0.2f, 0.07f, 0.06f, 1f);
			object obj4 = <>c.<>9__63_3;
			if (obj4 == null)
			{
				UnityAction val6 = delegate
				{
					SetStatus("Reward queue cleared.", FortecaUiStatusType.Warning);
				};
				<>c.<>9__63_3 = val6;
				obj4 = (object)val6;
			}
			AdminButton((Transform)(object)center3, "Clear Queue", 330f, -254f, 120f, color4, (UnityAction)obj4);
			AbsLabel((Transform)(object)adminColumns.Center, "Reward queue", 14, (TextAnchor)3, new Color(0.92f, 0.78f, 0.36f, 1f), 18f, -328f, 250f, 20f);
			RewardIconLine((Transform)(object)adminColumns.Center, val3.text, 1, 1, 18f, -366f, 330f, showPrefab: true);
			InputField tokens = AdminField((Transform)(object)adminColumns.Right, "Token Amount", "Server Tokens to grant.", "10", 18f, -76f, 170f);
			AdminMiniRow((Transform)(object)adminColumns.Right, "Selected player", string.IsNullOrWhiteSpace(val2.text) ? "No player selected" : val2.text, 18f, -170f, 330f);
			AdminMiniRow((Transform)(object)adminColumns.Right, "SteamID64", steam.text, 18f, -212f, 330f);
			AbsLabel((Transform)(object)adminColumns.Right, "Queued rewards", 14, (TextAnchor)3, new Color(0.92f, 0.78f, 0.36f, 1f), 18f, -268f, 250f, 20f);
			RewardIconLine((Transform)(object)adminColumns.Right, val3.text, 1, 1, 18f, -306f, 300f, showPrefab: true);
			AdminMiniRow((Transform)(object)adminColumns.Right, "Token total", tokens.text, 18f, -400f, 330f);
			AbsLabel((Transform)(object)adminColumns.Right, "Status: ready. No reward is sent until a grant button is clicked.", 11, (TextAnchor)0, new Color(0.82f, 0.74f, 0.58f, 1f), 18f, -438f, 330f, 44f);
			Button((Transform)(object)adminActionsRoot, "Grant Tokens", 12, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				SetStatus("Token grant prepared for " + steam.text + " amount " + tokens.text, FortecaUiStatusType.Info);
			});
			Button((Transform)(object)adminActionsRoot, "Grant Rewards", 12, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				SetStatus("Reward grant prepared for " + steam.text + ".", FortecaUiStatusType.Info);
			});
			RectTransform parent2 = adminActionsRoot;
			Color color5 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj5 = <>c.<>9__63_6;
			if (obj5 == null)
			{
				UnityAction val7 = delegate
				{
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__63_6 = val7;
				obj5 = (object)val7;
			}
			Button((Transform)(object)parent2, "Cancel", 12, color5, (UnityAction)obj5);
		}

		private static void AdminAccess(RectTransform parent)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Expected O, but got Unknown
			RectTransform component = Panel((Transform)(object)parent, "AdminAccessManagementPage", new Color(0.01f, 0.014f, 0.015f, 0.62f)).GetComponent<RectTransform>();
			Stretch(component, 8f, 8f, -8f, -8f);
			RectTransform parent2 = HBar(component, "AccessRoleTabs", 0.84f, 1f);
			string[] array = new string[4] { "Admin", "Premium", "Epic", "Legendary" };
			foreach (string text in array)
			{
				string cap = text;
				Button((Transform)(object)parent2, text, 12, (text == adminAccessRole) ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.12f, 0.07f, 0.035f, 1f), (UnityAction)delegate
				{
					adminAccessRole = cap;
					NavigateTo(FortecaUiPageId.Admin);
				});
			}
			string path = ((adminAccessRole == "Admin") ? FortecaPaths.AdminUsersPath : ((adminAccessRole == "Premium") ? FortecaPaths.PremiumUsersPath : ((adminAccessRole == "Epic") ? FortecaPaths.EpicUsersPath : FortecaPaths.LegendaryUsersPath)));
			List<string> list = SafeLines(path).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
			RectTransform component2 = AdminCard(component, "AccessControls", 0f, 0.1f, 0.31f, 0.78f, "Access Controls", "SteamID64 only. Character names are ignored.").GetComponent<RectTransform>();
			AbsLabel((Transform)(object)component2, "Permission", 11, (TextAnchor)3, new Color(0.82f, 0.74f, 0.58f, 1f), 18f, -66f, 140f, 18f);
			AbsLabel((Transform)(object)component2, adminAccessRole, 14, (TextAnchor)3, Color.white, 18f, -88f, 220f, 22f);
			InputField addInput = AdminField((Transform)(object)component2, "SteamID64", "Enter a 17 digit account ID.", "", 18f, -112f, 250f);
			AdminField((Transform)(object)component2, "Description", "Optional admin note.", "", 18f, -204f, 250f);
			AdminButton((Transform)(object)component2, "Add User", 18f, -294f, 112f, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				AddSteamId(path, addInput.text);
				NavigateTo(FortecaUiPageId.Admin);
			});
			Color color = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj = <>c.<>9__64_1;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					SetStatus(adminAccessRole + " list saved.", FortecaUiStatusType.Success);
				};
				<>c.<>9__64_1 = val;
				obj = (object)val;
			}
			AdminButton((Transform)(object)component2, "Save", 146f, -294f, 112f, color, (UnityAction)obj);
			Color color2 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj2 = <>c.<>9__64_2;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__64_2 = val2;
				obj2 = (object)val2;
			}
			AdminButton((Transform)(object)component2, "Reload", 82f, -336f, 112f, color2, (UnityAction)obj2);
			RectTransform parent3 = AdminScrollList(AdminCard(component, "AccessMembers", 0.32f, 0.36f, 1f, 0.78f, "Members", "Configured Members: " + list.Count).GetComponent<RectTransform>(), "AccessRows", 0f, 0.68f, 18, 14, -18, -8);
			AccessMemberRow(parent3, "SteamID64", "Permission", "Description", "Status", "Action", header: true, locked: false, path);
			if (list.Count == 0)
			{
				EmptyRow(parent3, "No configured users.");
			}
			foreach (string item in list)
			{
				bool flag = SteamIdAccess.IsBuiltIn(item);
				AccessMemberRow(parent3, item, adminAccessRole, flag ? "Permanent owner" : "Configured user", flag ? "Permanent Owner" : "Configured", flag ? "Locked" : "Remove", header: false, flag, path);
			}
		}

		private static void AdminWebhook(RectTransform parent)
		{
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: 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_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Expected O, but got Unknown
			Dictionary<string, string> dictionary = ReadWebhookCfg();
			bool value = dictionary.ContainsKey("EnableWebhook") && dictionary["EnableWebhook"].Equals("true", StringComparison.OrdinalIgnoreCase);
			string text = (dictionary.ContainsKey("WebhookUrl") ? dictionary["WebhookUrl"] : "");
			RectTransform component = AdminCard(parent, "WebhookGeneral", 0f, 0.52f, 1f, 1f, "General", "Webhook failures are logged but never block rewards.").GetComponent<RectTransform>();
			Toggle toggle = AdminToggle((Transform)(object)component, "Enable Discord Webhook", "Turns Discord delivery on or off.", value, 18f, -76f, 320f);
			InputField url = AdminField((Transform)(object)component, "Webhook URL", "Paste the Discord webhook URL. Saved URL is masked in UI.", "", 18f, -150f, 620f);
			AdminMiniRow((Transform)(object)component, "Status", string.IsNullOrWhiteSpace(text) ? "Not configured" : "Configured", 18f, -242f, 360f);
			AdminMiniRow((Transform)(object)component, "Saved URL", MaskUrl(text), 18f, -282f, 520f);
			RectTransform component2 = AdminCard(parent, "WebhookEvents", 0f, 0f, 1f, 0.5f, "Events", "Choose which server actions should be reported.").GetComponent<RectTransform>();
			string[] array = new string[8] { "Daily", "Premium", "Epic", "Legendary", "Kit Packs", "Redeem", "Admin Grants", "Errors" };
			for (int i = 0; i < array.Length; i++)
			{
				float x = 18 + i % 4 * 260;
				float y = -80 - i / 4 * 82;
				AdminToggle((Transform)(object)component2, array[i], DescriptionForWebhookEvent(array[i]), value: true, x, y, 220f);
			}
			Button((Transform)(object)adminActionsRoot, "Save", 12, new Color(0.16f, 0.23f, 0.12f, 1f), (UnityAction)delegate
			{
				WriteWebhookCfg(url.text, toggle.isOn);
				SetStatus("Webhook settings saved.", FortecaUiStatusType.Success);
				NavigateTo(FortecaUiPageId.Admin);
			});
			RectTransform parent2 = adminActionsRoot;
			Color color = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj = <>c.<>9__65_1;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					SetStatus("Test webhook requires a saved URL.", FortecaUiStatusType.Info);
				};
				<>c.<>9__65_1 = val;
				obj = (object)val;
			}
			Button((Transform)(object)parent2, "Test", 12, color, (UnityAction)obj);
			RectTransform parent3 = adminActionsRoot;
			Color color2 = new Color(0.2f, 0.07f, 0.06f, 1f);
			object obj2 = <>c.<>9__65_2;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					WriteWebhookCfg("", enabled: false);
					SetStatus("Webhook URL cleared.", FortecaUiStatusType.Warning);
					NavigateTo(FortecaUiPageId.Admin);
				};
				<>c.<>9__65_2 = val2;
				obj2 = (object)val2;
			}
			Button((Transform)(object)parent3, "Clear", 12, color2, (UnityAction)obj2);
		}

		private static void AdminHistory(RectTransform parent)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			RectTransform component = AdminCard(parent, "HistoryFilterBar", 0f, 0.82f, 1f, 1f, "Filters", "Search and narrow the reward history.").GetComponent<RectTransform>();
			HorizontalLayoutGroup obj = ((Component)component).gameObject.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(18, 18, 66, 14);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			Input((Transform)(object)component, "", "Search");
			Input((Transform)(object)component, "All types", "Type");
			Input((Transform)(object)component, "", "From date");
			Input((Transform)(object)component, "", "To date");
			Color color = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj2 = <>c.<>9__66_0;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					SetStatus("History refreshed.", FortecaUiStatusType.Info);
				};
				<>c.<>9__66_0 = val;
				obj2 = (object)val;
			}
			Button((Transform)(object)component, "Refresh", 11, color, (UnityAction)obj2);
			RectTransform component2 = Panel((Transform)(object)AdminCard(parent, "HistoryTable", 0f, 0f, 1f, 0.8f, "History Viewer", "Stored in Internal/ClaimHistory.json.").GetComponent<RectTransform>(), "HistoryRows", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			Anchor(component2, 0f, 0f, 1f, 0.76f, 18f, 18f, -18f, -8f);
			((Component)component2).gameObject.AddComponent<RectMask2D>();
			VerticalLayoutGroup obj3 = ((Component)component2).gameObject.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			TableRow(component2, new string[5] { "UTC Time", "Type", "Player", "SteamID64", "Result" }, new float[5] { 190f, 150f, 230f, 230f, 170f }, header: true, 0, null);
			EmptyRow(component2, "No history entries.");
			RectTransform parent2 = adminActionsRoot;
			Color color2 = new Color(0.2f, 0.07f, 0.06f, 1f);
			object obj4 = <>c.<>9__66_1;
			if (obj4 == null)
			{
				UnityAction val2 = delegate
				{
					SetStatus("Clear History requires confirmation.", FortecaUiStatusType.Warning);
				};
				<>c.<>9__66_1 = val2;
				obj4 = (object)val2;
			}
			Button((Transform)(object)parent2, "Clear History", 12, color2, (UnityAction)obj4);
			RectTransform parent3 = adminActionsRoot;
			Color color3 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj5 = <>c.<>9__66_2;
			if (obj5 == null)
			{
				UnityAction val3 = delegate
				{
				};
				<>c.<>9__66_2 = val3;
				obj5 = (object)val3;
			}
			Button((Transform)(object)parent3, "Total entries: 0", 12, color3, (UnityAction)obj5);
		}

		private static void AdminSettings(RectTransform parent)
		{
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			RectTransform component = AdminCard(parent, "SettingsGeneral", 0f, 0.53f, 0.49f, 1f, "General", "Server identity and core reward timing.").GetComponent<RectTransform>();
			AdminField((Transform)(object)component, "Server Name", "Display name used in notifications.", "Forteca", 18f, -76f, 220f);
			AdminField((Transform)(object)component, "Reward Cooldown Hours", "Number of hours before the next reward becomes available.", "24", 270f, -76f, 170f);
			RectTransform component2 = AdminCard(parent, "SettingsEconomy", 0.51f, 0.53f, 1f, 1f, "Economy", "Server Token earning rules.").GetComponent<RectTransform>();
			AdminField((Transform)(object)component2, "Tokens Per Hour", "Server Tokens earned per hour of gameplay.", "10", 18f, -76f, 170f);
			AdminField((Transform)(object)component2, "Maximum Tokens", "Optional cap. 0 means unlimited.", "0", 230f, -76f, 170f);
			RectTransform component3 = AdminCard(parent, "SettingsNotifications", 0f, 0f, 0.49f, 0.5f, "Notifications", "Client-side reminder and feedback options.").GetComponent<RectTransform>();
			AdminToggle((Transform)(object)component3, "Claim Reminder", "Shows a message when a reward is ready to claim.", value: true, 18f, -74f, 240f);
			AdminField((Transform)(object)component3, "Reminder Hours", "How often the reminder may repeat.", "24", 300f, -74f, 170f);
			AdminToggle((Transform)(object)component3, "Enable Sounds", "Plays small UI feedback sounds.", value: true, 18f, -166f, 240f);
			RectTransform component4 = AdminCard(parent, "SettingsUiHelp", 0.51f, 0f, 1f, 0.5f, "User Interface / Help", "Visible UI hints and administrator help.").GetComponent<RectTransform>();
			AdminToggle((Transform)(object)component4, "Show Tooltips", "Shows additional item information inside reward pages.", value: true, 18f, -74f, 260f);
			RectTransform component5 = Panel((Transform)(object)component4, "SettingsHelpViewport", new Color(0.01f, 0.008f, 0.006f, 0.35f)).GetComponent<RectTransform>();
			Anchor(component5, 0f, 0f, 1f, 0.48f, 18f, 18f, -18f, -8f);
			((Component)component5).gameObject.AddComponent<RectMask2D>();
			Stretch(((Component)Label((Transform)(object)component5, "Reward Cooldown Hours\nNumber of hours before the next reward becomes available.\n\nTokens Per Hour\nNumber of Server Tokens earned per hour of gameplay.\n\nClaim Reminder\nShows a message when a reward is ready to claim.", 11, (TextAnchor)0, new Color(0.86f, 0.78f, 0.62f, 1f))).GetComponent<RectTransform>(), 10f, 8f, -10f, -8f);
			RectTransform parent2 = adminActionsRoot;
			Color color = new Color(0.16f, 0.23f, 0.12f, 1f);
			object obj = <>c.<>9__67_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					SetStatus("Settings saved.", FortecaUiStatusType.Success);
				};
				<>c.<>9__67_0 = val;
				obj = (object)val;
			}
			Button((Transform)(object)parent2, "Save", 12, color, (UnityAction)obj);
			RectTransform parent3 = adminActionsRoot;
			Color color2 = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj2 = <>c.<>9__67_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					ExternalAssetSystem.Reload();
					RefreshCurrentPage();
					LogsModule.Log("[Rewards UI] Theme reloaded");
				};
				<>c.<>9__67_1 = val2;
				obj2 = (object)val2;
			}
			Button((Transform)(object)parent3, "Reload", 12, color2, (UnityAction)obj2);
		}

		private static void AdminSimple(RectTransform parent, string page)
		{
			Section(VList(parent, "Admin" + page.Replace(" ", "")), page, "Contained admin workspace. Backend and config paths retained through FortecaPaths.");
		}

		private static IEnumerable<string> SafeLines(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					return (from x in File.ReadAllLines(path)
						select x.Trim() into x
						where x.Length > 0 && !x.StartsWith("#")
						select x).ToList();
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI ERROR] Page=Admin Section=Access Reason=" + ex.Message);
			}
			return Enumerable.Empty<string>();
		}

		private static void EmptyRow(RectTransform parent, string message)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = Panel((Transform)(object)parent, "EmptyTableRow", new Color(0.018f, 0.012f, 0.009f, 0.78f)).GetComponent<RectTransform>();
			((Component)component).gameObject.AddComponent<LayoutElement>().preferredHeight = 96f;
			Label((Transform)(object)component, message, 14, (TextAnchor)4, new Color(0.86f, 0.78f, 0.62f, 1f));
		}

		private static void TableRow(RectTransform parent, string[] values, float[] widths, bool header, int index, UnityAction action)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			Color color = (header ? new Color(0.07f, 0.045f, 0.03f, 0.96f) : ((index % 2 == 0) ? new Color(0.026f, 0.018f, 0.014f, 0.88f) : new Color(0.036f, 0.024f, 0.018f, 0.88f)));
			RectTransform component = Panel((Transform)(object)parent, header ? "TableHeaderRow" : "TableDataRow", color).GetComponent<RectTransform>();
			((Component)component).gameObject.AddComponent<LayoutElement>().preferredHeight = (header ? 36 : 46);
			HorizontalLayoutGroup obj = ((Component)component).gameObject.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(12, 12, 5, 5);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			if (action != null)
			{
				Button obj2 = ((Component)component).gameObject.AddComponent<Button>();
				((Selectable)obj2).targetGraphic = (Graphic)(object)((Component)component).GetComponent<Image>();
				((UnityEvent)obj2.onClick).AddListener(action);
			}
			for (int i = 0; i < values.Length; i++)
			{
				Text obj3 = Label((Transform)(object)component, values[i], header ? 12 : 13, (TextAnchor)3, (Color)(header ? new Color(0.9f, 0.78f, 0.55f, 1f) : Color.white));
				obj3.horizontalOverflow = (HorizontalWrapMode)0;
				((Component)obj3).gameObject.GetComponent<LayoutElement>().preferredWidth = ((i < widths.Length) ? widths[i] : 120f);
			}
		}

		private static void AccessMemberRow(RectTransform parent, string steamId, string permission, string description, string status, string actionText, bool header, bool locked, string path)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			RectTransform component = Panel((Transform)(object)parent, header ? "AccessHeaderRow" : "AccessUserRow", header ? new Color(0.07f, 0.045f, 0.03f, 0.96f) : new Color(0.026f, 0.018f, 0.014f, 0.88f)).GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(0f, (float)(header ? 28 : 32));
			((Component)component).gameObject.AddComponent<LayoutElement>().preferredHeight = (header ? 28 : 32);
			HorizontalLayoutGroup obj = ((Component)component).gameObject.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(10, 10, 1, 1);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((Component)Label((Transform)(object)component, steamId, header ? 12 : 13, (TextAnchor)3, (Color)(header ? new Color(0.9f, 0.78f, 0.55f, 1f) : Color.white))).gameObject.GetComponent<LayoutElement>().preferredWidth = 240f;
			((Component)Label((Transform)(object)component, permission, 12, (TextAnchor)3, (Color)(header ? new Color(0.9f, 0.78f, 0.55f, 1f) : Color.white))).gameObject.GetComponent<LayoutElement>().preferredWidth = 120f;
			((Component)Label((Transform)(object)component, description, 12, (TextAnchor)3, header ? new Color(0.9f, 0.78f, 0.55f, 1f) : new Color(0.86f, 0.78f, 0.62f, 1f))).gameObject.GetComponent<LayoutElement>().preferredWidth = 230f;
			((Component)Label((Transform)(object)component, status, 12, (TextAnchor)3, header ? new Color(0.9f, 0.78f, 0.55f, 1f) : (locked ? new Color(0.95f, 0.78f, 0.38f, 1f) : new Color(0.75f, 0.95f, 0.65f, 1f)))).gameObject.GetComponent<LayoutElement>().preferredWidth = 145f;
			if (header)
			{
				((Component)Label((Transform)(object)component, actionText, 12, (TextAnchor)4, new Color(0.9f, 0.78f, 0.55f, 1f))).gameObject.GetComponent<LayoutElement>().preferredWidth = 98f;
				return;
			}
			LayoutElement component2 = ((Component)Button((Transform)(object)component, actionText, 11, locked ? new Color(0.1f, 0.08f, 0.05f, 1f) : new Color(0.2f, 0.07f, 0.06f, 1f), (UnityAction)delegate
			{
				SetStatus(locked ? "Permanent owners cannot be removed here." : "Remove requires confirmation.", locked ? FortecaUiStatusType.Warning : FortecaUiStatusType.Info);
			})).gameObject.GetComponent<LayoutElement>();
			component2.preferredWidth = 84f;
			component2.preferredHeight = 22f;
		}

		private static void AccessListRow(RectTransform parent, string steamId, string permission, string description, string actionText, bool header, bool locked, string path)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0099: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			RectTransform component = Panel((Transform)(object)parent, header ? "AccessHeaderRow" : "AccessUserRow", header ? new Color(0.035f, 0.025f, 0.018f, 0.92f) : new Color(0.025f, 0.018f, 0.014f, 0.78f)).GetComponent<RectTransform>();
			((Component)component).gameObject.AddComponent<LayoutElement>().preferredHeight = (header ? 34 : 42);
			HorizontalLayoutGroup obj = ((Component)component).gameObject.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(10, 10, 4, 4);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((Component)Label((Transform)(object)component, steamId, header ? 12 : 13, (TextAnchor)3, (Color)(header ? new Color(0.86f, 0.78f, 0.62f, 1f) : Color.white))).gameObject.GetComponent<LayoutElement>().preferredWidth = 240f;
			((Component)Label((Transform)(object)component, permission, 12, (TextAnchor)3, (Color)(header ? new Color(0.86f, 0.78f, 0.62f, 1f) : Color.white))).gameObject.GetComponent<LayoutElement>().preferredWidth = 150f;
			((Component)Label((Transform)(object)component, description, 12, (TextAnchor)3, new Color(0.86f, 0.78f, 0.62f, 1f))).gameObject.GetComponent<LayoutElement>().preferredWidth = 340f;
			if (header)
			{
				((Component)Label((Transform)(object)component, actionText, 12, (TextAnchor)4, new Color(0.86f, 0.78f, 0.62f, 1f))).gameObject.GetComponent<LayoutElement>().preferredWidth = 98f;
				return;
			}
			LayoutElement component2 = ((Component)Button((Transform)(object)component, actionText, 11, locked ? new Color(0.1f, 0.08f, 0.05f, 1f) : new Color(0.2f, 0.07f, 0.06f, 1f), (UnityAction)delegate
			{
				SetStatus(locked ? "Permanent owners cannot be removed here." : "Remove requires confirmation.", locked ? FortecaUiStatusType.Warning : FortecaUiStatusType.Info);
			})).gameObject.GetComponent<LayoutElement>();
			component2.preferredWidth = 84f;
			component2.preferredHeight = 22f;
		}

		private static string DescriptionForWebhookEvent(string name)
		{
			return name switch
			{
				"Daily" => "Standard daily claims.", 
				"Premium" => "Premium tier claims.", 
				"Epic" => "Epic tier claims.", 
				"Legendary" => "Legendary tier claims.", 
				"Kit Packs" => "Token pack purchases.", 
				"Redeem" => "Successful code claims.", 
				"Admin Grants" => "Manual admin rewards.", 
				_ => "Webhook or reward errors.", 
			};
		}

		private static Toggle ToggleRow(RectTransform parent, string label, bool value)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel((Transform)(object)parent, "Toggle_" + label.Replace(" ", "_"), new Color(0.08f, 0.055f, 0.035f, 0.7f));
			((Graphic)val.GetComponent<Image>()).raycastTarget = true;
			Toggle obj = val.AddComponent<Toggle>();
			((Selectable)obj).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			val.AddComponent<LayoutElement>().preferredHeight = 34f;
			Stretch(((Component)Label(val.transform, label, 13, (TextAnchor)3, Color.white)).GetComponent<RectTransform>(), 42f, 0f, -4f);
			GameObject val2 = Panel(val.transform, "Checkmark", value ? new Color(0.16f, 0.23f, 0.12f, 1f) : new Color(0.12f, 0.07f, 0.035f, 1f));
			RectTransform component = val2.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0f, 0.5f);
			component.anchorMax = val3;
			component.anchorMin = val3;
			component.sizeDelta = new Vector2(24f, 24f);
			component.anchoredPosition = new Vector2(18f, 0f);
			obj.graphic = (Graphic)(object)val2.GetComponent<Image>();
			obj.isOn = value;
			return obj;
		}

		private static void AddSteamId(string path, string steam)
		{
			steam = (steam ?? "").Trim();
			if (!Regex.IsMatch(steam, "^[0-9]{17}$"))
			{
				SetStatus("Invalid SteamID64.", FortecaUiStatusType.Error);
				return;
			}
			List<string> list = (File.Exists(path) ? File.ReadAllLines(path).ToList() : new List<string>());
			if (list.Any((string x) => x.Trim() == steam))
			{
				SetStatus("SteamID already exists.", FortecaUiStatusType.Warning);
				return;
			}
			list.Add(steam);
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			File.WriteAllLines(path, list);
			SetStatus("Added SteamID64.", FortecaUiStatusType.Success);
		}

		private static Dictionary<string, string> ReadWebhookCfg()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				if (File.Exists(FortecaPaths.WebhookSettingsPath))
				{
					string[] array = File.ReadAllLines(FortecaPaths.WebhookSettingsPath);
					for (int i = 0; i < array.Length; i++)
					{
						string text = (array[i] ?? "").Trim();
						if (text.Length != 0 && !text.StartsWith("#") && text.Contains("="))
						{
							int num = text.IndexOf('=');
							dictionary[text.Substring(0, num).Trim()] = text.Substring(num + 1).Trim();
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI ERROR] Webhook cfg read: " + ex.Message);
			}
			return dictionary;
		}

		private static void WriteWebhookCfg(string url, bool enabled)
		{
			Dictionary<string, string> dictionary = ReadWebhookCfg();
			if (!string.IsNullOrWhiteSpace(url))
			{
				dictionary["WebhookUrl"] = url.Trim();
			}
			else
			{
				dictionary["WebhookUrl"] = "";
			}
			dictionary["EnableWebhook"] = (enabled ? "true" : "false");
			string[] array = new string[7] { "NotifyDailyClaim", "NotifyPremiumClaim", "NotifyEpicClaim", "NotifyLegendaryClaim", "NotifyKitPurchase", "NotifyRedeem", "NotifyAdminGrant" };
			foreach (string key in array)
			{
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = "true";
				}
			}
			if (!dictionary.ContainsKey("NotifyRedeemFailure"))
			{
				dictionary["NotifyRedeemFailure"] = "false";
			}
			if (!dictionary.ContainsKey("ServerName"))
			{
				dictionary["ServerName"] = "Forteca";
			}
			Directory.CreateDirectory(FortecaPaths.EditableWebhook);
			File.WriteAllLines(FortecaPaths.WebhookSettingsPath, dictionary.Select((KeyValuePair<string, string> kv) => kv.Key + "=" + kv.Value));
		}

		private static string MaskUrl(string url)
		{
			if (string.IsNullOrWhiteSpace(url))
			{
				return "Not configured";
			}
			if (url.Length >= 36)
			{
				return url.Substring(0, Math.Min(url.Length, 36)) + "/...***";
			}
			return "***";
		}

		private static Sprite LoadRuneIcon(string key, int index)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			string text = NormalizeRuneKey(key, index);
			if (runeIconCache.TryGetValue(text, out var value))
			{
				return value;
			}
			try
			{
				string path = Path.Combine(FortecaPaths.AssetsRoot, "Icons", "Rewards");
				string[] array = new string[3] { ".png", ".jpg", ".jpeg" };
				foreach (string text2 in array)
				{
					string path2 = Path.Combine(path, text + text2);
					if (File.Exists(path2))
					{
						byte[] array2 = File.ReadAllBytes(path2);
						Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
						if (ImageConversion.LoadImage(val, array2))
						{
							Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
							runeIconCache[text] = val2;
							return val2;
						}
					}
				}
				LogsModule.Log("[RewardPacks] Missing rune icon: " + text);
			}
			catch (Exception ex)
			{
				LogsModule.Log("[RewardPacks] Rune icon load failed: " + text + " Reason=" + ex.Message);
			}
			runeIconCache[text] = fallbackIcon;
			return fallbackIcon;
		}

		private static string NormalizeRuneKey(string key, int index)
		{
			string text = (key ?? "").Trim().Replace("\\", "/");
			if (text.Contains("/"))
			{
				text = text.Substring(text.LastIndexOf('/') + 1);
			}
			text = Path.GetFileNameWithoutExtension(text);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = index.ToString();
			}
			return text;
		}

		private static void LogRuneIconSummaryOnce()
		{
			if (runeIconLoadLogged)
			{
				return;
			}
			runeIconLoadLogged = true;
			int num = 0;
			string path = Path.Combine(FortecaPaths.AssetsRoot, "Icons", "Rewards");
			for (int i = 1; i <= 24; i++)
			{
				if (File.Exists(Path.Combine(path, i + ".png")) || File.Exists(Path.Combine(path, i + ".jpg")) || File.Exists(Path.Combine(path, i + ".jpeg")))
				{
					num++;
				}
			}
			LogsModule.Log("[RewardPacks] Rune icons loaded: " + num + "/24");
		}

		private static void ClearContent()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)content == (Object)null))
			{
				for (int num = ((Transform)content).childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)((Transform)content).GetChild(num)).gameObject);
				}
				content.sizeDelta = Vector2.zero;
			}
		}

		private static void SetTitle(string s)
		{
			if ((Object)(object)titleText != (Object)null)
			{
				titleText.text = s;
			}
		}

		private static void SetStatus(string s, FortecaUiStatusType type)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)statusText == (Object)null))
			{
				statusText.text = s ?? "";
				((Graphic)statusText).color = (Color)(type switch
				{
					FortecaUiStatusType.Success => Color.green, 
					FortecaUiStatusType.Warning => Color.yellow, 
					FortecaUiStatusType.Error => Color.red, 
					_ => new Color(0.9f, 0.82f, 0.65f, 1f), 
				});
			}
		}

		private static string Title(FortecaUiPageId p)
		{
			return p switch
			{
				FortecaUiPageId.KitPacks => "Kit Packs", 
				FortecaUiPageId.Legendary => "Legendary Rewards", 
				FortecaUiPageId.Epic => "Epic Rewards", 
				FortecaUiPageId.Premium => "Premium Rewards", 
				FortecaUiPageId.Daily => "Daily Rewards", 
				_ => p.ToString(), 
			};
		}

		private static string IconKey(FortecaUiPageId p)
		{
			if (p != FortecaUiPageId.KitPacks)
			{
				return p.ToString().ToLowerInvariant();
			}
			return "kit_packs";
		}

		private static void Section(RectTransform parent, string title, string desc)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Panel((Transform)(object)parent, "SectionIntro", new Color(0.035f, 0.024f, 0.017f, 0.72f));
			obj.AddComponent<LayoutElement>().preferredHeight = 64f;
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 64f);
			AbsLabel(obj.transform, desc, 13, (TextAnchor)3, new Color(0.86f, 0.78f, 0.62f, 1f), 22f, -8f, 1100f, 52f);
		}

		private static void Empty(RectTransform parent, string text)
		{
			Empty(parent, text, -120f);
		}

		private static void Empty(RectTransform parent, string text, float y)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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)
			GameObject obj = Panel((Transform)(object)parent, "EmptyState", new Color(0.035f, 0.024f, 0.017f, 0.82f));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.15f, 1f);
			component.anchorMax = new Vector2(0.85f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 180f);
			component.anchoredPosition = new Vector2(0f, y);
			Label(obj.transform, text, 18, (TextAnchor)4, new Color(0.9f, 0.82f, 0.65f, 1f));
			parent.sizeDelta = new Vector2(0f, Mathf.Max(360f, Mathf.Abs(y) + 220f));
		}

		private static RectTransform AdminScrollList(RectTransform parent, string name, float minY, float maxY, int left, int bottom, int right, int top)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			RectTransform component = Panel((Transform)(object)parent, name + "Viewport", new Color(0.004f, 0.006f, 0.006f, 0.78f)).GetComponent<RectTransform>();
			Anchor(component, 0f, minY, 1f, maxY, left, bottom, right, top);
			((Component)component).gameObject.AddComponent<RectMask2D>();
			ScrollRect obj = ((Component)component).gameObject.AddComponent<ScrollRect>();
			obj.horizontal = false;
			obj.vertical = true;
			obj.movementType = (MovementType)2;
			obj.viewport = component;
			RectTransform component2 = Panel((Transform)(object)component, name + "Content", new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(0f, 0f);
			VerticalLayoutGroup obj2 = ((Component)component2).gameObject.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 5f;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 4, 4);
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((Component)component2).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			obj.content = component2;
			return component2;
		}

		private static RectTransform VList(RectTransform parent, string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = Panel((Transform)(object)parent, name, new Color(0f, 0f, 0f, 0f)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 700f);
			VerticalLayoutGroup obj = ((Component)component).gameObject.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 14f;
			((LayoutGroup)obj).padding = new RectOffset(18, 18, 18, 18);
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((Component)component).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			parent.sizeDelta = new Vector2(0f, 760f);
			return component;
		}

		private static RectTransform HBar(RectTransform parent, string name, float y0, float y1)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			RectTransform component = Panel((Transform)(object)parent, name, new Color(0f, 0f, 0f, 0.12f)).GetComponent<RectTransform>();
			if (y1 > y0)
			{
				Anchor(component, 0f, y0, 1f, y1, 0f, 0f, 0f, 0f);
			}
			HorizontalLayoutGroup obj = ((Component)component).gameObject.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((LayoutGroup)obj).padding = new RectOffset(8, 8, 5, 5);
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			return component;
		}

		private static InputField LabeledInput(RectTransform parent, string label, string val)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = HBar(parent, "Row_" + label, 0f, 0f);
			obj.sizeDelta = new Vector2(0f, 36f);
			((Component)obj).gameObject.AddComponent<LayoutElement>().preferredHeight = 40f;
			((Component)Label((Transform)(object)obj, label, 13, (TextAnchor)3, Color.white)).GetComponent<LayoutElement>().preferredWidth = 170f;
			return Input((Transform)(object)obj, val, label);
		}

		private static void LabelRow(RectTransform parent, string label, string val)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = HBar(parent, "Row_" + label, 0f, 0f);
			obj.sizeDelta = new Vector2(0f, 32f);
			((Component)obj).gameObject.AddComponent<LayoutElement>().preferredHeight = 36f;
			((Component)Label((Transform)(object)obj, label, 12, (TextAnchor)3, new Color(0.86f, 0.78f, 0.62f, 1f))).GetComponent<LayoutElement>().preferredWidth = 180f;
			Label((Transform)(object)obj, val, 12, (TextAnchor)3, Color.white);
		}

		private static GameObject AdminCard(RectTransform parent, string name, float minX, float minY, float maxX, float maxY, string title, string desc)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel((Transform)(object)parent, name, new Color(0.032f, 0.02f, 0.017f, 0.92f));
			Anchor(val.GetComponent<RectTransform>(), minX, minY, maxX, maxY, 8f, 8f, -8f, -8f);
			Outline obj = val.AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(0.2f, 0.13f, 0.08f, 0.72f);
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
			Anchor(Panel(val.transform, name + "HeaderShade", new Color(0.07f, 0.032f, 0.024f, 0.38f)).GetComponent<RectTransform>(), 0f, 0.86f, 1f, 1f, 0f, 0f, 0f, 0f);
			if (!string.IsNullOrWhiteSpace(title))
			{
				AbsLabel(val.transform, title, 16, (TextAnchor)3, Color.white, 18f, -12f, 420f, 24f);
			}
			if (!string.IsNullOrWhiteSpace(desc))
			{
				AbsLabel(val.transform, desc, 11, (TextAnchor)0, new Color(0.82f, 0.74f, 0.58f, 1f), 18f, -40f, 560f, 42f);
			}
			return val;
		}

		private static InputField AdminField(Transform parent, string label, string description, string value, float x, float y, float w)
		{
			//IL_0005: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			AbsLabel(parent, label, 12, (TextAnchor)3, Color.white, x, y, w, 18f);
			if (!string.IsNullOrWhiteSpace(description))
			{
				AbsLabel(parent, description, 10, (TextAnchor)0, new Color(0.72f, 0.65f, 0.5f, 1f), x, y - 18f, w, 26f);
			}
			InputField obj = Input(parent, value, label);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(x, y - 48f);
			component.sizeDelta = new Vector2(w, 34f);
			return obj;
		}

		private static Toggle AdminToggle(Transform parent, string label, string description, bool value, float x, float y, float w)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Toggle obj = ToggleRow((RectTransform)parent, label, value);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(x, y);
			component.sizeDelta = new Vector2(w, 34f);
			if (!string.IsNullOrWhiteSpace(description))
			{
				AbsLabel(parent, description, 10, (TextAnchor)0, new Color(0.72f, 0.65f, 0.5f, 1f), x, y - 38f, w, 28f);
			}
			return obj;
		}

		private static Button AdminButton(Transform parent, string text, float x, float y, float w, Color color, UnityAction action)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Button obj = Button(parent, text, 11, color, action);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(x, y);
			component.sizeDelta = new Vector2(w, 34f);
			return obj;
		}

		private static void AdminMiniRow(Transform parent, string label, string value, float x, float y, float w)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			AbsLabel(parent, label, 11, (TextAnchor)3, new Color(0.82f, 0.74f, 0.58f, 1f), x, y, w * 0.42f, 22f);
			AbsLabel(parent, value, 11, (TextAnchor)3, Color.white, x + w * 0.44f, y, w * 0.54f, 22f);
		}

		private static void ShowConfirmModal(string title, string message, string dangerLabel, UnityAction confirm)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			HideConfirmModal();
			if ((Object)(object)mainWindow == (Object)null)
			{
				return;
			}
			confirmModal = Panel(mainWindow.transform, "ConfirmModalBackdrop", new Color(0f, 0f, 0f, 0.58f));
			Stretch(confirmModal.GetComponent<RectTransform>());
			confirmModal.transform.SetAsLastSibling();
			RectTransform component = Panel(confirmModal.transform, "ConfirmModal", new Color(0.045f, 0.02f, 0.016f, 0.98f)).GetComponent<RectTransform>();
			Anchor(component, 0.32f, 0.35f, 0.68f, 0.66f, 0f, 0f, 0f, 0f);
			AbsLabel((Transform)(object)component, title, 22, (TextAnchor)4, Color.white, 18f, -18f, 620f, 34f);
			AbsLabel((Transform)(object)component, message, 14, (TextAnchor)4, new Color(0.9f, 0.82f, 0.65f, 1f), 34f, -70f, 580f, 110f);
			Color color = new Color(0.12f, 0.07f, 0.035f, 1f);
			object obj = <>c.<>9__101_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					HideConfirmModal();
				};
				<>c.<>9__101_0 = val;
				obj = (object)val;
			}
			AdminButton((Transform)(object)component, "Cancel", 112f, -204f, 170f, color, (UnityAction)obj);
			AdminButton((Transform)(object)component, dangerLabel, 356f, -204f, 190f, new Color(0.32f, 0.08f, 0.055f, 1f), (UnityAction)delegate
			{
				HideConfirmModal();
				if (confirm != null)
				{
					confirm.Invoke();
				}
			});
			RestoreGlobalNavigationLayers();
		}

		private static void HideConfirmModal()
		{
			if ((Object)(object)confirmModal != (Object)null)
			{
				Object.Destroy((Object)(object)confirmModal);
				confirmModal = null;
			}
		}

		private static AdminColumns AdminTemplate(RectTransform parent, string name)
		{
			RectTransform component = AdminCard(parent, name + "_Left", 0f, 0f, 0.27f, 1f, "", "").GetComponent<RectTransform>();
			RectTransform component2 = AdminCard(parent, name + "_Center", 0.27f, 0f, 0.72f, 1f, "", "").GetComponent<RectTransform>();
			RectTransform component3 = AdminCard(parent, name + "_Right", 0.72f, 0f, 1f, 1f, "", "").GetComponent<RectTransform>();
			return new AdminColumns
			{
				Left = component,
				Center = component2,
				Right = component3
			};
		}

		private static void AdminColumnHeader(RectTransform parent, string title, string help)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			AbsLabel((Transform)(object)parent, title, 16, (TextAnchor)3, Color.white, 16f, -12f, 360f, 24f);
			AbsLabel((Transform)(object)parent, help, 10, (TextAnchor)0, new Color(0.82f, 0.74f, 0.58f, 1f), 16f, -40f, 360f, 34f);
		}

		private static Sprite ResolveItemIcon(string prefabName)
		{
			string text = (string.IsNullOrWhiteSpace(prefabName) ? "__fallback" : prefabName.Trim());
			if (itemIconCache.TryGetValue(text, out var value))
			{
				return value;
			}
			try
			{
				GameObject obj = ResolvePrefab(text);
				Sprite val = SafeIcon(obj);
				itemIconCache[text] = (((Object)(object)val != (Object)null) ? val : fallbackIcon);
				if ((Object)(object)obj == (Object)null)
				{
					LogsModule.Log("[Rewards UI] Missing item icon prefab: " + text);
				}
				return itemIconCache[text];
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI] Item icon resolve failed: " + text + " reason=" + ex.Message);
				itemIconCache[text] = fallbackIcon;
				return fallbackIcon;
			}
		}

		private static void RewardIconLine(Transform parent, string prefab, int amount, int quality, float x, float y, float w, bool showPrefab)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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)
			RectTransform component = ((Component)Image(parent, ResolveItemIcon(prefab))).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(x, y);
			component.sizeDelta = new Vector2(28f, 28f);
			GameObject go = ResolvePrefab(prefab);
			string text = Display(prefab, go);
			string text2 = "x" + amount + ((quality > 1) ? (" Q" + quality) : "");
			AbsLabel(parent, text + "  " + text2, 11, (TextAnchor)3, Color.white, x + 36f, y - 2f, w - 36f, 16f);
			if (showPrefab)
			{
				AbsLabel(parent, prefab, 9, (TextAnchor)3, new Color(0.7f, 0.63f, 0.48f, 1f), x + 36f, y - 18f, w - 36f, 14f);
			}
		}

		private static GameObject Panel(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			if (color.a <= 0.02f)
			{
				((Graphic)component).raycastTarget = false;
			}
			return val;
		}

		private static Text Label(Transform parent, string text, int size, TextAnchor anchor, Color color)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = size;
			component.alignment = anchor;
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = false;
			component.supportRichText = true;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			component.text = text ?? "";
			Stretch(val.GetComponent<RectTransform>(), 8f, 4f, -8f, -4f);
			val.AddComponent<LayoutElement>().preferredHeight = Mathf.Max(26, size + 10);
			return component;
		}

		private static void AbsLabel(Transform parent, string text, int size, TextAnchor anchor, Color color, float left, float top, float width, float height)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)Label(parent, text, size, anchor, color)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(left, top);
			component.sizeDelta = new Vector2(width, height);
		}

		private static Button Button(Transform parent, string text, int size, Color color, UnityAction action)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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)
			GameObject obj = Panel(parent, "Button_" + text.Replace(" ", "_"), color);
			Button val = obj.AddComponent<Button>();
			Image component = obj.GetComponent<Image>();
			((Graphic)component).raycastTarget = true;
			((Selectable)val).targetGraphic = (Graphic)(object)component;
			if (action != null)
			{
				((UnityEvent)val.onClick).AddListener(action);
			}
			ColorBlock colors = ((Selectable)val).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.18f, 1.1f, 1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.82f, 0.76f, 0.68f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(1.08f, 1.02f, 0.94f, 1f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)val).colors = colors;
			Stretch(((Component)Label(obj.transform, text, size, (TextAnchor)4, Color.white)).GetComponent<RectTransform>(), 4f, 2f, -4f, -2f);
			obj.AddComponent<LayoutElement>().minHeight = 32f;
			return val;
		}

		private static InputField Input(Transform parent, string value, string placeholder)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(parent, "Input_" + placeholder.Replace(" ", "_"), new Color(0.08f, 0.055f, 0.035f, 0.95f));
			((Graphic)val.GetComponent<Image>()).raycastTarget = true;
			InputField obj = val.AddComponent<InputField>();
			((Selectable)obj).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			Text val2 = Label(val.transform, value ?? "", 13, (TextAnchor)3, Color.white);
			Text val3 = Label(val.transform, placeholder, 13, (TextAnchor)3, new Color(0.8f, 0.7f, 0.55f, 0.55f));
			obj.textComponent = val2;
			obj.placeholder = (Graphic)(object)val3;
			obj.text = value ?? "";
			Stretch(((Component)val2).GetComponent<RectTransform>(), 8f, 0f, -8f);
			Stretch(((Component)val3).GetComponent<RectTransform>(), 8f, 0f, -8f);
			val.AddComponent<LayoutElement>().minHeight = 32f;
			return obj;
		}

		private static Image Image(Transform parent, Sprite sprite)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Image", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			((Graphic)component).color = Color.white;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static void Anchor(RectTransform r, float x0, float y0, float x1, float y1, float l, float b, float rr, float t)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			r.anchorMin = new Vector2(x0, y0);
			r.anchorMax = new Vector2(x1, y1);
			r.pivot = new Vector2(0.5f, 0.5f);
			r.offsetMin = new Vector2(l, b);
			r.offsetMax = new Vector2(rr, t);
		}

		private static void Stretch(RectTransform r, float l = 0f, float b = 0f, float rr = 0f, float t = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			r.anchorMin = Vector2.zero;
			r.anchorMax = Vector2.one;
			r.pivot = new Vector2(0.5f, 0.5f);
			r.offsetMin = new Vector2(l, b);
			r.offsetMax = new Vector2(rr, t);
		}

		private static GameObject ResolvePrefab(string prefab)
		{
			try
			{
				return (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(prefab) : null) ?? (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefab) : null);
			}
			catch
			{
				return null;
			}
		}

		private static Sprite SafeIcon(GameObject prefab)
		{
			try
			{
				ItemDrop val = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val != (Object)null && val.m_itemData != null && val.m_itemData.m_shared != null && val.m_itemData.m_shared.m_icons != null && val.m_itemData.m_shared.m_icons.Count() > 0)
				{
					return val.m_itemData.m_shared.m_icons[0];
				}
			}
			catch
			{
			}
			return fallbackIcon;
		}

		private static string Display(string prefab, GameObject go)
		{
			try
			{
				ItemDrop val = (((Object)(object)go != (Object)null) ? go.GetComponent<ItemDrop>() : null);
				string text = (((Object)(object)val != (Object)null && val.m_itemData != null && val.m_itemData.m_shared != null) ? val.m_itemData.m_shared.m_name : prefab);
				return (Localization.instance != null) ? Localization.instance.Localize(text) : text;
			}
			catch
			{
				return prefab;
			}
		}

		private static void ApplyBackground(FortecaUiPageId p)
		{
			try
			{
				object obj;
				if (!((Object)(object)mainWindow != (Object)null))
				{
					obj = null;
				}
				else
				{
					Transform obj2 = mainWindow.transform.Find("Background");
					obj = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null);
				}
				Image val = (Image)obj;
				if ((Object)(object)val != (Object)null)
				{
					Sprite background = ExternalAssetSystem.GetBackground(IconKey(p), null);
					if ((Object)(object)background != (Object)null)
					{
						val.sprite = background;
					}
					val.preserveAspect = false;
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("[Rewards UI ERROR] Page=" + p.ToString() + " Section=Background Reason=" + ex.Message);
			}
		}

		private static Sprite FallbackSprite(Color c)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			val.SetPixels((Color[])(object)new Color[4] { c, c, c, c });
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 2f, 2f), new Vector2(0.5f, 0.5f));
		}

		private static Sprite WebhookFallbackSprite()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			Color gold = new Color(0.9f, 0.65f, 0.25f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.08f, 0.05f, 0.035f, 1f);
			Color[] pix = (Color[])(object)new Color[4096];
			for (int i = 0; i < pix.Length; i++)
			{
				pix[i] = val2;
			}
			Action<int, int, int> obj = delegate(int cx, int cy, int rad)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				for (int j = 0; j < 64; j++)
				{
					for (int k = 0; k < 64; k++)
					{
						int num = k - cx;
						int num2 = j - cy;
						if (num * num + num2 * num2 <= rad * rad)
						{
							pix[j * 64 + k] = gold;
						}
					}
				}
			};
			Action<int, int, int, int> obj2 = delegate(int x0, int y0, int x1, int y1)
			{
				//IL_0054: 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)
				for (int j = 0; j <= 100; j++)
				{
					int num = x0 + (x1 - x0) * j / 100;
					int num2 = y0 + (y1 - y0) * j / 100;
					for (int k = -1; k <= 1; k++)
					{
						for (int l = -1; l <= 1; l++)
						{
							int num3 = num + l;
							int num4 = num2 + k;
							if (num3 >= 0 && num3 < 64 && num4 >= 0 && num4 < 64)
							{
								pix[num4 * 64 + num3] = gold;
							}
						}
					}
				}
			};
			obj2(20, 22, 44, 22);
			obj2(20, 22, 32, 44);
			obj2(44, 22, 32, 44);
			obj(20, 22, 7);
			obj(44, 22, 7);
			obj(32, 44, 7);
			val.SetPixels(pix);
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
		}
	}
	internal static class FortecaRedeemDataService
	{
		public static RedeemSystem.RedeemCodesData CurrentData { get; private set; } = new RedeemSystem.RedeemCodesData();

		public static string LastError { get; private set; } = "";

		public static string SourcePath { get; private set; } = "";

		public static void Load()
		{
			LastError = "";
			SourcePath = FortecaPaths.RedeemCodesPath;
			try
			{
				FortecaPaths.EnsureFreshStructure();
				CurrentData = ReadCodes(FortecaPaths.RedeemCodesPath);
				if ((CurrentData.Codes == null || CurrentData.Codes.Count == 0) && LooksLikeAnonymousFastJson(FortecaPaths.RedeemCodesPath))
				{
					string text = Path.Combine(FortecaPaths.Root, "Redeem", "RedeemCodes.json");
					if (File.Exists(text))
					{
						RedeemSystem.RedeemCodesData redeemCodesData = ReadCodes(text);
						if (redeemCodesData.Codes != null && redeemCodesData.Codes.Count > 0)
						{
							CurrentData = redeemCodesData;
							SourcePath = text;
							LogsModule.Log("[Rewards] Redeem fresh file contains no Codes data, using legacy readable file: " + text);
						}
					}
				}
			}
			catch (Exception ex)
			{
				CurrentData = new RedeemSystem.RedeemCodesData();
				LastError = "Redeem Codes configuration error.";
				LogsModule.Log("[Rewards UI ERROR] Page=Redeem Section=Load Reason=" + ex);
			}
			if (CurrentData.Codes == null)
			{
				CurrentData.Codes = new List<RedeemSystem.RedeemCode>();
			}
			LogsModule.Log("[Rewards] Redeem Loaded: " + CurrentData.Codes.Count);
			LogsModule.Log("[Rewards] Redeem Path: " + SourcePath);
		}

		private static RedeemSystem.RedeemCodesData ReadCodes(string path)
		{
			if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
			{
				return new RedeemSystem.RedeemCodesData();
			}
			string text = File.ReadAllText(path);
			RedeemSystem.RedeemCodesData redeemCodesData = (string.IsNullOrWhiteSpace(text) ? new RedeemSystem.RedeemCodesData() : (JSON.ToObject<RedeemSystem.RedeemCodesData>(text) ?? new RedeemSystem.RedeemCodesData()));
			if (redeemCodesData.Codes == null)
			{
				redeemCodesData.Codes = new List<RedeemSystem.RedeemCode>();
			}
			return redeemCodesData;
		}

		private static bool LooksLikeAnonymousFastJson(string path)
		{
			try
			{
				if (!File.Exists(path))
				{
					return false;
				}
				string text = File.ReadAllText(path);
				return text.Contains("$types") && text.Contains("<>f__AnonymousType") && !text.Contains("\"Codes\"");
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class FortecaDailyDataService
	{
		internal sealed class DailyData
		{
			public string Name = "Daily";

			public int Cooldown = 86400;

			public List<RewardLine> Rewards = new List<RewardLine>();

			public string LastError = "";

			public int ValidCount;

			public int InvalidCount;

			public string SourcePath = "";
		}

		internal sealed class RewardLine
		{
			public int Day;

			public string Prefab = "";

			public string DisplayName = "";

			public int Amount;

			public int Quality = 1;

			public int Variant;

			public bool IsValid;

			public string Error = "";

			public string Raw = "";

			public string ToCsv()
			{
				return Prefab + "," + Amount + "," + Math.Max(1, Quality) + "," + Math.Max(0, Variant) + (string.IsNullOrWhiteSpace(DisplayName) ? "" : ("," + DisplayName));
			}
		}

		private static readonly Dictionary<FortecaUiRewardTier, DailyData> cache = new Dictionary<FortecaUiRewardTier, DailyData>();

		public static DailyData Get(FortecaUiRewardTier tier)
		{
			if (!cache.ContainsKey(tier))
			{
				Load(tier);
			}
			return cache[tier];
		}

		public static void Load(FortecaUiRewardTier tier)
		{
			DailyData dailyData = new DailyData
			{
				Name = tier.ToString(),
				SourcePath = PathFor(tier)
			};
			try
			{
				string text = PathFor(tier);
				LogsModule.Log("[Rewards] Loaded config: " + text);
				if (!File.Exists(text))
				{
					dailyData.LastError = "Missing config file.";
					LogsModule.Log("[Rewards] Parse error path=" + text + " reason=missing file expected format: Category,86400 then 28 lines Prefab,Amount[,Quality][,Variant][,DisplayName]");
				}
				else
				{
					string[] array = File.ReadAllLines(text);
					List<Tuple<int, string>> list = new List<Tuple<int, string>>();
					for (int i = 0; i < array.Length; i++)
					{
						string text2 = StripComment(array[i]).Trim();
						if (text2.Length != 0)
						{
							list.Add(Tuple.Create(i + 1, text2));
						}
					}
					if (list.Count > 0)
					{
						string[] array2 = Tokenize(list[0].Item2);
						if (array2.Length != 0 && !string.IsNullOrWhiteSpace(array2[0]))
						{
							dailyData.Name = array2[0].Trim();
						}
						if (array2.Length > 1 && int.TryParse(array2[1].Trim(), out var result) && result >= 0)
						{
							dailyData.Cooldown = result;
						}
					}
					int num = 1;
					foreach (Tuple<int, string> item in list.Skip(1).Take(28))
					{
						RewardLine rewardLine = Parse(item.Item2, num, item.Item1, text);
						dailyData.Rewards.Add(rewardLine);
						if (rewardLine.IsValid)
						{
							dailyData.ValidCount++;
						}
						else
						{
							dailyData.InvalidCount++;
						}
						num++;
					}
				}
			}
			catch (Exception ex)
			{
				dailyData.LastError = ex.Message;
				LogsModule.Log("[Rewards UI ERROR] Page=AdminDaily Section=Load Reason=" + ex);
			}
			while (dailyData.Rewards.Count < 28)
			{
				int day = dailyData.Rewards.Count + 1;
				dailyData.Rewards.Add(new RewardLine
				{
					Day = day,
					Prefab = "",
					Amount = 0,
					Quality = 1,
					Variant = 0,
					IsValid = false,
					Error = "Missing reward line",
					Raw = ""
				});
				dailyData.InvalidCount++;
			}
			cache[tier] = dailyData;
			LogsModule.Log("[Rewards] " + tier.ToString() + " Entries: " + dailyData.Rewards.Count);
			LogsModule.Log("[Rewards] " + tier.ToString() + " Valid: " + dailyData.ValidCount);
			LogsModule.Log("[Rewards] " + tier.ToString() + " Invalid: " + dailyData.InvalidCount);
		}

		public static void Save(FortecaUiRewardTier tier)
		{
			DailyData dailyData = Get(tier);
			List<string> list = new List<string> { dailyData.Name + "," + dailyData.Cooldown };
			list.AddRange(from r in dailyData.Rewards.Take(28)
				select r.ToCsv());
			File.WriteAllLines(PathFor(tier), list);
			cache.Remove(tier);
			Load(tier);
		}

		public static string PathFor(FortecaUiRewardTier tier)
		{
			return tier switch
			{
				FortecaUiRewardTier.Premium => FortecaPaths.PremiumConfigPath, 
				FortecaUiRewardTier.Epic => FortecaPaths.EpicConfigPath, 
				FortecaUiRewardTier.Legendary => FortecaPaths.LegendaryConfigPath, 
				_ => FortecaPaths.DailyConfigPath, 
			};
		}

		public static RewardLine Parse(string raw)
		{
			return Parse(raw, 0, 0, "");
		}

		public static RewardLine Parse(string raw, int day, int lineNumber, string path)
		{
			RewardLine rewardLine = new RewardLine
			{
				Day = day,
				Raw = (raw ?? ""),
				Quality = 1,
				Variant = 0
			};
			string[] array = Tokenize(raw);
			if (array.Length < 2)
			{
				rewardLine.Error = "expected at least Prefab,Amount";
				LogParseError(path, lineNumber, raw, rewardLine.Error, array.Length);
				return rewardLine;
			}
			rewardLine.Prefab = (array[0] ?? "").Trim();
			if (string.IsNullOrWhiteSpace(rewardLine.Prefab))
			{
				rewardLine.Error = "empty prefab";
				LogParseError(path, lineNumber, raw, rewardLine.Error, array.Length);
				return rewardLine;
			}
			if (!int.TryParse((array[1] ?? "").Trim(), out rewardLine.Amount) || rewardLine.Amount <= 0)
			{
				rewardLine.Error = "invalid amount";
				LogParseError(path, lineNumber, raw, rewardLine.Error, array.Length);
				return rewardLine;
			}
			if (array.Length > 2 && !string.IsNullOrWhiteSpace(array[2]) && (!int.TryParse(array[2].Trim(), out rewardLine.Quality) || rewardLine.Quality <= 0))
			{
				rewardLine.Error = "invalid quality";
				LogParseError(path, lineNumber, raw, rewardLine.Error, array.Length);
				rewardLine.Quality = 1;
				return rewardLine;
			}
			if (array.Length > 3 && !string.IsNullOrWhiteSpace(array[3]) && (!int.TryParse(array[3].Trim(), out rewardLine.Variant) || rewardLine.Variant < 0))
			{
				rewardLine.Error = "invalid variant";
				LogParseError(path, lineNumber, raw, rewardLine.Error, array.Length);
				rewardLine.Variant = 0;
				return rewardLine;
			}
			if (array.Length > 4)
			{
				rewardLine.DisplayName = string.Join(",", array.Skip(4)).Trim();
			}
			rewardLine.Quality = Math.Max(1, rewardLine.Quality);
			rewardLine.Variant = Math.Max(0, rewardLine.Variant);
			rewardLine.IsValid = true;
			return rewardLine;
		}

		private static string StripComment(string raw)
		{
			if (raw == null)
			{
				return "";
			}
			int num = raw.IndexOf('#');
			if (num < 0)
			{
				return raw;
			}
			return raw.Substring(0, num);
		}

		private static string[] Tokenize(string raw)
		{
			return (from x in StripComment(raw).Split(new char[1] { ',' })
				select (x ?? "").Trim()).ToArray();
		}

		private static void LogParseError(string path, int lineNumber, string raw, string reason, int receivedFields)
		{
			LogsModule.Log("[Rewards] Parse error path=" + path + " line=" + lineNumber + " raw='" + raw + "' reason=" + reason + " expected=Prefab,Amount[,Quality][,Variant][,DisplayName] receivedFields=" + receivedFields);
		}
	}
	[BepInPlugin("Forteca_ServerRewards", "Forteca_ServerRewards", "1.2.0")]
	public class Forteca_ServerRewards : BaseUnityPlugin
	{
		public class KitData
		{
			public string Name = "Default";

			public int Cooldown;

			public string Group;

			public List<string> Items = new List<string>();
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch_Kits
		{
			private static void Postfix(ZNetScene __instance)
			{
				ZRoutedRpc.instance.Register<ZPackage>("Forteca_ServerRewards Kits", (Action<long, ZPackage>)AcceptKits);
				RedeemSystem.RegisterRpcHandlers();
			}

			private static void AcceptKits(long sender, ZPackage pkg)
			{
				pkg.Decompress();
				_kits = JSON.ToObject<List<KitData>>(pkg.ReadString());
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class ZnetSync_Kits
		{
			private static void Postfix(ZRpc rpc)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				if (IsServer)
				{
					ZNetPeer peer = ValheimCompat.GetPeer(rpc);
					if (peer != null)
					{
						ZPackage val = new ZPackage();
						val.Write(KitsJSON);
						val.Compress();
						ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_ServerRewards Kits", new object[1] { val });
					}
				}
			}
		}

		[HarmonyPatch(typeof(Chat), "InputText")]
		private static class Chat_InputText_Patch
		{
			private const string command = "/kits";

			private const string takeKit = "/kit ";

			private static bool CanTake(KitData kit, out int timeLeft)
			{
				timeLeft = 0;
				if (!IsInGroup(kit))
				{
					return false;
				}
				if (Player.m_localPlayer.m_customData.ContainsKey("UL_Kits_" + kit.Name))
				{
					double num = ValheimCompat.TotalSeconds();
					int num2 = int.Parse(Player.m_localPlayer.m_customData["UL_Kits_" + kit.Name]);
					timeLeft = kit.Cooldown - (int)(num - (double)num2);
					if (timeLeft > 0)
					{
						return false;
					}
					return true;
				}
				return true;
			}

			public static bool IsInGroup(KitData kit)
			{
				return kit.Group == "ALL";
			}

			private static void DecodeKit(KitData kit)
			{
				foreach (string item in kit.Items)
				{
					string[] array = item.Split(new char[1] { ',' });
					GameObject prefab = ZNetScene.instance.GetPrefab(array[0]);
					if (ValheimCompat.Exists((Object)(object)prefab))
					{
						ItemDrop component = prefab.GetComponent<ItemDrop>();
						string text = Localization.instance.Localize(component.m_itemData.m_shared.m_name);
						string text2 = ((array.Length > 1) ? array[1] : "1");
						((Terminal)Chat.instance).AddString(text + " <color=yellow>x" + text2 + "</color>");
					}
				}
			}

			private static bool Prefix(Chat __instance)
			{
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				string text = ((TMP_InputField)((Terminal)__instance).m_input).text;
				if (text == "/kits")
				{
					((Terminal)__instance).AddString("Avaliable Kits:");
					foreach (KitData kit in _kits)
					{
						if (IsInGroup(kit))
						{
							((Terminal)__instance).AddString("<color=#00FFFF>" + kit.Name + "</color> (" + (CanTake(kit, out var timeLeft) ? "<color=green>+</color>" : ("<color=red>- " + timeLeft.ToTime() + " left</color>")) + ")");
							DecodeKit(kit);
						}
					}
					return false;
				}
				if (text.StartsWith("/kit "))
				{
					string kitName = text.Replace("/kit ", "");
					KitData kitData = _kits.Find((KitData x) => x.Name == kitName);
					if (kitData == null)
					{
						((Terminal)__instance).AddString("<color=red>Kit " + kitName + " not found.</color>");
						return false;
					}
					if (!CanTake(kitData, out var _))
					{
						((Terminal)__instance).AddString("<color=red>You already have this kit.</color>");
						return false;
					}
					foreach (string item in kitData.Items)
					{
						string[] array = item.Split(new char[1] { ',' });
						GameObject prefab = ZNetScene.instance.GetPrefab(array[0]);
						if (ValheimCompat.Exists((Object)(object)prefab))
						{
							Player localPlayer = Player.m_localPlayer;
							GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
							ItemDrop component = val.GetComponent<ItemDrop>();
							component.m_itemData.m_stack = ((array.Length <= 1) ? 1 : int.Parse(array[1]));
							ValheimCompat.SaveItemDrop(component);
							if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val, -1))
							{
								ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
								ZNetScene.instance.Destroy(val);
							}
						}
					}
					Player.m_localPlayer.m_customData["UL_Kits_" + kitData.Name] = ((int)ValheimCompat.TotalSeconds()).ToString();
					((Terminal)__instance).AddString("<color=green>Added kit " + kitData.Name + ".</color>");
					LogsModule.SendLogsToSS(Player.m_localPlayer.GetPlayerName() + " just took kit " + kitData.Name + ".");
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class Player_OnSpawned_Patch
		{
			private static void Postfix(Player __instance)
			{
				if (ValheimCompat.Exists((Object)(object)Player.m_localPlayer))
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsID", out var value))
					{
						_currentRewardID = value;
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTime", out var value2))
					{
						_currentRewardTime = int.Parse(value2);
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTaken", out var value3))
					{
						_currentTakenReward = int.Parse(value3);
					}
					if (_dailyRewardData.Name != _currentRewardID)
					{
						_currentRewardID = _dailyRewardData.Name;
						_currentTakenReward = 0;
						_currentRewardTime = -99999999;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsID"] = _currentRewardID;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken"] = "0";
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime"] = "-99999999";
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsID_PREMIUM", out var value4))
					{
						_currentRewardID_PREMIUM = value4;
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTime_PREMIUM", out var value5))
					{
						_currentRewardTime_PREMIUM = int.Parse(value5);
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTaken_PREMIUM", out var value6))
					{
						_currentTakenReward_PREMIUM = int.Parse(value6);
					}
					if (_dailyRewardData_PREMIUM.Name != _currentRewardID_PREMIUM)
					{
						_currentRewardID_PREMIUM = _dailyRewardData_PREMIUM.Name;
						_currentTakenReward_PREMIUM = 0;
						_currentRewardTime_PREMIUM = -99999999;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsID_PREMIUM"] = _currentRewardID_PREMIUM;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_PREMIUM"] = "0";
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_PREMIUM"] = "-99999999";
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsID_EPIC", out var value7))
					{
						_currentRewardID_EPIC = value7;
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTime_EPIC", out var value8))
					{
						_currentRewardTime_EPIC = int.Parse(value8);
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTaken_EPIC", out var value9))
					{
						_currentTakenReward_EPIC = int.Parse(value9);
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsID_LEGENDARY", out var value10))
					{
						_currentRewardID_LEGENDARY = value10;
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTime_LEGENDARY", out var value11))
					{
						_currentRewardTime_LEGENDARY = int.Parse(value11);
					}
					if (localPlayer.m_customData.TryGetValue("Forteca_SR_LastRewardsTaken_LEGENDARY", out var value12))
					{
						_currentTakenReward_LEGENDARY = int.Parse(value12);
					}
					if (_dailyRewardData_EPIC.Name != _currentRewardID_EPIC)
					{
						_currentRewardID_EPIC = _dailyRewardData_EPIC.Name;
						_currentTakenReward_EPIC = 0;
						_currentRewardTime_EPIC = -99999999;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsID_EPIC"] = _currentRewardID_EPIC;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_EPIC"] = "0";
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_EPIC"] = "-99999999";
					}
					if (_dailyRewardData_LEGENDARY.Name != _currentRewardID_LEGENDARY)
					{
						_currentRewardID_LEGENDARY = _dailyRewardData_LEGENDARY.Name;
						_currentTakenReward_LEGENDARY = 0;
						_currentRewardTime_LEGENDARY = -99999999;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsID_LEGENDARY"] = _currentRewardID_LEGENDARY;
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_LEGENDARY"] = "0";
						Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_LEGENDARY"] = "-99999999";
					}
				}
			}
		}

		public class ShopData
		{
			public class ShopSlot
			{
				public class ShopItem
				{
					public string Prefab;

					public int Amount;
				}

				public string Name;

				public int Cost;

				public string Color;

				public bool OneTime;

				public string icon;

				public List<ShopItem> Items = new List<ShopItem>();
			}

			public List<ShopSlot> ShopSlots = new List<ShopSlot>();
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch_Shop
		{
			private static void Postfix(ZNetScene __instance)
			{
				if (IsServer)
				{
					ZRoutedRpc.instance.Register<string>("Forteca_Shop RequestBuy", (Action<long, string>)RPC_Buy);
					ZRoutedRpc.instance.Register("Forteca_Shop RequestTokens", (Action<long>)RPC_RequestTokens);
					ZRoutedRpc.instance.Register<int, string>("Forteca_Shop RequestTokens_Int", (Action<long, int, string>)RPC_RequestTokens_Valued);
				}
				else
				{
					ZRoutedRpc.instance.Register<ZPackage>("Forteca_Shop Accept", (Action<long, ZPackage>)AcceptShop);
					ZRoutedRpc.instance.Register<int>("Forteca_Shop Tokens", (Action<long, int>)AcceptTokens);
					ZRoutedRpc.instance.Register<ZPackage>("Forteca_Shop ResponceBuy", (Action<long, ZPackage>)RPC_BuyResponce);
				}
			}

			private static void RPC_RequestTokens(long sender)
			{
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer == null)
				{
					return;
				}
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (!(hostName == "0"))
				{
					if (!_playerTokens.ContainsKey(hostName))
					{
						_playerTokens.Add(hostName, 0);
					}
					_playerTokens[hostName] += HourTokensAmount.Value;
					LogsModule.Log($"{hostName} got {HourTokensAmount.Value} tokens. Current balance: {_playerTokens[hostName]} (Hour Cycle)");
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Tokens", new object[1] { _playerTokens[hostName] });
					SaveTokens();
				}
			}

			private static void RPC_RequestTokens_Valued(long sender, int val, string msg)
			{
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer == null)
				{
					return;
				}
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (!(hostName == "0"))
				{
					if (!_playerTokens.ContainsKey(hostName))
					{
						_playerTokens.Add(hostName, 0);
					}
					_playerTokens[hostName] += val;
					LogsModule.Log($"{hostName} got {val} tokens. Current balance: {_playerTokens[hostName]} ({msg})");
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Tokens", new object[1] { _playerTokens[hostName] });
					SaveTokens();
				}
			}

			private static void RPC_BuyResponce(long sender, ZPackage pkg)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				pkg.Decompress();
				if (!pkg.ReadBool())
				{
					string text = pkg.ReadString();
					MessageHud.instance.ShowMessage((MessageType)2, "Failed to buy item: " + text, 0, (Sprite)null, false);
					RewardsUI.Hide();
					return;
				}
				List<ShopData.ShopSlot.ShopItem> list = JSON.ToObject<List<ShopData.ShopSlot.ShopItem>>(pkg.ReadString());
				Player localPlayer = Player.m_localPlayer;
				foreach (ShopData.ShopSlot.ShopItem item in list)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.Prefab);
					if (ValheimCompat.Exists((Object)(object)itemPrefab))
					{
						GameObject val = Object.Instantiate<GameObject>(itemPrefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
						ItemDrop component = val.GetComponent<ItemDrop>();
						component.m_itemData.m_stack = item.Amount;
						ValheimCompat.SaveItemDrop(component);
						if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val, -1))
						{
							ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
							ZNetScene.instance.Destroy(val);
						}
					}
				}
			}

			private static void RPC_Buy(long sender, string name)
			{
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Expected O, but got Unknown
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Expected O, but got Unknown
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer == null)
				{
					return;
				}
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (hostName == "0" || !_playerTokens.ContainsKey(hostName))
				{
					return;
				}
				ShopData.ShopSlot shopSlot = ((_shopData != null && _shopData.ShopSlots != null) ? _shopData.ShopSlots.Find((ShopData.ShopSlot x) => x.Name == name) : null);
				if (shopSlot == null)
				{
					FortecaRewardPackService.Load();
					shopSlot = FortecaRewardPackService.ToShopSlot(name);
				}
				if (shopSlot == null)
				{
					ZPackage val = new ZPackage();
					val.Write(false);
					val.Write("Reward Pack is not configured");
					val.Compress();
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_Shop ResponceBuy", new object[1] { val });
					return;
				}
				if (shopSlot.OneTime && _oneTimePurchases.ContainsKey(hostName) && _oneTimePurchases[hostName].Contains(name))
				{
					ZPackage val2 = new ZPackage();
					val2.Write(false);
					val2.Write("You already bought this item");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_Shop ResponceBuy", new object[1] { val2 });
					return;
				}
				if (shopSlot.Cost > _playerTokens[hostName])
				{
					ZPackage val3 = new ZPackage();
					val3.Write(false);
					val3.Write("Not enough tokens");
					val3.Compress();
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_Shop ResponceBuy", new object[1] { val3 });
					return;
				}
				_playerTokens[hostName] -= shopSlot.Cost;
				ZPackage val4 = new ZPackage();
				val4.Write(true);
				val4.Write(JSON.ToJSON(shopSlot.Items));
				val4.Compress();
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_Shop ResponceBuy", new object[1] { val4 });
				if (shopSlot.OneTime)
				{
					if (!_oneTimePurchases.ContainsKey(hostName))
					{
						_oneTimePurchases.Add(hostName, new List<string>());
					}
					_oneTimePurchases[hostName].Add(name);
					SaveOneTimePurchases();
				}
				LogsModule.Log($"{hostName} bought {name} for {shopSlot.Cost} tokens. Their balance is {_playerTokens[hostName]}");
				AdminSuite.NotifyWebhook("Kit Pack Purchase", hostName + " purchased " + name + " for " + shopSlot.Cost + " Server Tokens. Balance: " + _playerTokens[hostName]);
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Tokens", new object[1] { _playerTokens[hostName] });
				SaveTokens();
			}

			private static void AcceptShop(long sender, ZPackage pkg)
			{
				pkg.Decompress();
				_shopData = JSON.ToObject<ShopData>(pkg.ReadString());
			}

			private static void AcceptTokens(long sender, int tokens)
			{
				int myTokens = MyTokens;
				MyTokens = tokens;
				FortecaRewardsUIRoot.UpdateTokens();
				if (_tokenSyncReceived && tokens > myTokens && (Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)1, "You earned " + (tokens - myTokens) + " Server Tokens.", 0, (Sprite)null, false);
				}
				_tokenSyncReceived = true;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class ZnetSync_Shop
		{
			private static void Postfix(ZRpc rpc)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				if (!IsServer)
				{
					return;
				}
				ZNetPeer peer = ValheimCompat.GetPeer(rpc);
				if (peer != null)
				{
					ZPackage val = new ZPackage();
					val.Write(ShopJSON);
					val.Compress();
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Accept", new object[1] { val });
					string hostName = peer.m_socket.GetHostName();
					if (!_playerTokens.ContainsKey(hostName) && hostName != "0")
					{
						_playerTokens.Add(hostName, 0);
						SaveTokens();
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Tokens", new object[1] { _playerTokens[hostName] });
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class Player_SetLocalPlayer_Patch
		{
			[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
			private static class Player_ConsumeItem_PatchDItem
			{
				private static DateTime LastActivation;

				private static bool Prefix(InventoryGrid grid, ItemData item)
				{
					if (ValheimCompat.GetInventory(grid) != ValheimCompat.GetInventory((Humanoid)(object)Player.m_localPlayer))
					{
						return true;
					}
					if (item != null && ValheimCompat.Exists((Object)(object)Player.m_localPlayer) && item.m_shared.m_name == "Forteca Tokens")
					{
						if ((DateTime.Now - LastActivation).TotalSeconds >= 8.0)
						{
							int stack = item.m_stack;
							Inventory inventory = ValheimCompat.GetInventory(grid);
							if (inventory != null)
							{
								inventory.RemoveItem(item, stack);
							}
							LastActivation = DateTime.Now;
							ZRoutedRpc.instance.InvokeRoutedRPC(ValheimCompat.GetServerPeerID(), "Forteca_Shop RequestTokens_Int", new object[2] { stack, "Used Forteca Tokens Item" });
							MessageHud.instance.ShowMessage((MessageType)2, $"Added {stack} tokens to your account", 0, (Sprite)null, false);
						}
						return false;
					}
					return true;
				}
			}

			private const string key = "UL_SR_Time";

			private static Player routinePlayer;

			private static IEnumerator EachMinuteRoutine(Player player)
			{
				while (ValheimCompat.Exists((Object)(object)player) && (Object)(object)player == (Object)(object)Player.m_localPlayer)
				{
					yield return (object)new WaitForSeconds(60f);
					if (ValheimCompat.Exists((Object)(object)player))
					{
						if (!player.m_customData.ContainsKey("UL_SR_Time"))
						{
							player.m_customData.Add("UL_SR_Time", "0");
						}
						if (!int.TryParse(player.m_customData["UL_SR_Time"], out var result) || result < 0)
						{
							result = 0;
						}
						result += 60;
						player.m_customData["UL_SR_Time"] = result.ToString();
						if (result >= 3600)
						{
							player.m_customData["UL_SR_Time"] = "0";
							ZRoutedRpc.instance.InvokeRoutedRPC(ValheimCompat.GetServerPeerID(), "Forteca_Shop RequestTokens", new object[1]);
						}
					}
				}
			}

			private static void Postfix()
			{
				if (ValheimCompat.Exists((Object)(object)Player.m_localPlayer) && !((Object)(object)routinePlayer == (Object)(object)Player.m_localPlayer))
				{
					routinePlayer = Player.m_localPlayer;
					((MonoBehaviour)Player.m_localPlayer).StartCoroutine(EachMinuteRoutine(Player.m_localPlayer));
				}
			}
		}

		private static class RewardsUI
		{
			[HarmonyPatch(typeof(UITooltip), "OnHoverStart")]
			private static class UITooltip_OnHoverStart_Patch
			{
				private static void Postfix(UITooltip __instance)
				{
					if (((Object)((Component)__instance).gameObject).name == "ServerShop_Element(Clone)")
					{
						ValheimCompat.SetTooltipShowTimer(__instance, 1f);
					}
				}
			}

			[HarmonyPatch(typeof(TextInput), "IsVisible")]
			private static class TextInput_IsVisible_Patch
			{
				private static void Postfix(ref bool __result)
				{
					__result |= IsVisible();
				}
			}

			[HarmonyPatch(typeof(StoreGui), "IsVisible")]
			private static class StoreGui_IsVisible_Patch
			{
				private static void Postfix(ref bool __result)
				{
					__result |= IsVisible();
				}
			}

			[HarmonyPatch(typeof(InventoryGui), "Awake")]
			private static class InventoryGui_Awake_Patch
			{
				private static InventoryGui initializedInstance;

				private static InventoryGui scheduledInstance;

				private static void Postfix(InventoryGui __instance)
				{
					try
					{
						if (!IsServer)
						{
							if ((Object)(object)__instance == (Object)null)
							{
								SafeInventoryGuiLog("[RewardsUI] InventoryGui integration skipped: InventoryGui instance is null.");
							}
							else if ((Object)(object)initializedInstance == (Object)(object)__instance)
							{
								SafeInventoryGuiLog("[RewardsUI] InventoryGui integration already initialized; skipping.");
							}
							else if (!((Object)(object)scheduledInstance == (Object)(object)__instance))
							{
								scheduledInstance = __instance;
								SafeInventoryGuiLog("[RewardsUI] InventoryGui not ready; deferring initialization.");
								((MonoBehaviour)__instance).StartCoroutine(DeferredInventoryGuiIntegration(__instance));
							}
						}
					}
					catch (Exception ex)
					{
						SafeInventoryGuiLog("[RewardsUI] InventoryGui integration failed safely: " + ex.GetType().Name + "/" + ex.Message);
					}
				}

				private static IEnumerator DeferredInventoryGuiIntegration(InventoryGui instance)
				{
					for (int i = 0; i < 10; i++)
					{
						yield return null;
						try
						{
							if ((Object)(object)instance == (Object)null)
							{
								SafeInventoryGuiLog("[RewardsUI] InventoryGui integration skipped: InventoryGui instance disappeared.");
								scheduledInstance = null;
								yield break;
							}
							if (TryInitializeInventoryGuiIntegration(instance, out var reason))
							{
								initializedInstance = instance;
								scheduledInstance = null;
								SafeInventoryGuiLog("[RewardsUI] InventoryGui integration initialized successfully.");
								yield break;
							}
							if (i == 9)
							{
								SafeInventoryGuiLog("[RewardsUI] InventoryGui integration skipped: " + reason);
							}
						}
						catch (Exception ex)
						{
							SafeInventoryGuiLog("[RewardsUI] InventoryGui integration failed safely: " + ex.GetType().Name + "/" + ex.Message);
							scheduledInstance = null;
							yield break;
						}
					}
					scheduledInstance = null;
				}

				private static bool TryInitializeInventoryGuiIntegration(InventoryGui instance, out string reason)
				{
					reason = "unknown missing reference";
					if ((Object)(object)instance == (Object)null)
					{
						reason = "InventoryGui instance is null";
						return false;
					}
					if ((Object)(object)ServerShop_Element == (Object)null)
					{
						reason = "ServerShop_Element is not available";
						return false;
					}
					UITooltip component = ServerShop_Element.GetComponent<UITooltip>();
					if ((Object)(object)component == (Object)null)
					{
						reason = "ServerShop_Element UITooltip component is missing";
						return false;
					}
					if ((Object)(object)instance.m_playerGrid == (Object)null)
					{
						reason = "InventoryGui player grid is not available";
						return false;
					}
					GameObject elementPrefab = instance.m_playerGrid.m_elementPrefab;
					if ((Object)(object)elementPrefab == (Object)null)
					{
						reason = "InventoryGui player grid element prefab is not available";
						return false;
					}
					UITooltip component2 = elementPrefab.GetComponent<UITooltip>();
					if ((Object)(object)component2 == (Object)null)
					{
						reason = "InventoryGui player grid element UITooltip component is missing";
						return false;
					}
					if ((Object)(object)component2.m_tooltipPrefab == (Object)null)
					{
						reason = "InventoryGui tooltip prefab is not available";
						return false;
					}
					component.m_tooltipPrefab = component2.m_tooltipPrefab;
					return true;
				}

				private static void SafeInventoryGuiLog(string message)
				{
					try
					{
						LogsModule.Log(message);
					}
					catch
					{
						Debug.Log((object)("[Forteca_ServerRewards] " + message));
					}
				}
			}

			[CompilerGenerated]
			private static class _003C_003EO
			{
				public static UnityAction _003C0_003E__OpenShop;

				public static UnityAction _003C1_003E__OpenRewards;

				public static UnityAction _003C2_003E__OpenRewards_PREMIUM;
			}

			private sealed class RewardCardState
			{
				public string Label;

				public Color BorderColor;

				public bool CanClick;
			}

			private static GameObject UI;

			private static GameObject ServerRewards_DailyElement;

			private static GameObject ServerRewards_WeeklyElement;

			private static GameObject ServerShop_Element;

			private static Transform DailyRewards_Content;

			private static Transform Shop_Content;

			public static Text Header;

			private static List<Image> ToDropColor = new List<Image>(8);

			private static readonly Dictionary<string, RewardsPageBase> Pages = new Dictionary<string, RewardsPageBase>(StringComparer.OrdinalIgnoreCase);

			private static readonly List<TabButton> PlayerTabs = new List<TabButton>();

			private static readonly List<TabButton> AdminTabs = new List<TabButton>();

			private static PageContainer PlaceholderPageContainer;

			private static IconRegistry Icons;

			private static Sprite DefaultTabIcon;

			private static Image ThemeBackgroundImage;

			private static Sprite DefaultThemeBackgroundSprite;

			private static readonly HashSet<string> LoggedRenderErrors = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			private static readonly HashSet<string> LoggedAccessRoles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public static void Init()
			{
				FortecaPaths.EnsureFreshStructure();
				ExternalAssetSystem.Init();
				FortecaRewardPackService.Load();
				FortecaRedeemDataService.Load();
				FortecaRewardsUIRoot.Init(BuildNewUiContext());
				Header = FortecaRewardsUIRoot.HeaderText;
				LogsModule.Log("[Rewards UI] Legacy ServerRewardsUI prefab disconnected from active runtime path");
			}

			private static FortecaRewardsUIRoot.Context BuildNewUiContext()
			{
				return new FortecaRewardsUIRoot.Context
				{
					GetTokens = () => MyTokens,
					IsAdmin = IsAdminUiVisible,
					GetRewardTier = BuildTierView,
					ClaimReward = ClaimTierFromNewUi,
					PurchasePack = PurchaseRewardPackFromNewUi,
					RenderRedeem = delegate(GameObject root, Text header)
					{
						RedeemSystem.RenderPlayerPage(root, header);
					}
				};
			}

			private static FortecaRewardTierView BuildTierView(FortecaUiRewardTier tier)
			{
				FortecaDailyDataService.DailyData dailyData = FortecaDailyDataService.Get(tier);
				int currentTaken = _currentTakenReward;
				bool available = false;
				int remainingTime = 0;
				bool hasAccess = true;
				string lockedMessage = "";
				string title = "Daily Rewards";
				string description = "Claim one reward every 24 hours. Your progress is saved automatically.";
				switch (tier)
				{
				case FortecaUiRewardTier.Daily:
					available = CanTakeReward(out remainingTime);
					break;
				case FortecaUiRewardTier.Premium:
					currentTaken = _currentTakenReward_PREMIUM;
					available = CanTakeReward_PREMIUM(out remainingTime);
					title = "Premium Rewards";
					description = "Premium account rewards. Claim one reward every 24 hours.";
					hasAccess = HasPremiumAccess(_localUserID);
					lockedMessage = "Premium rewards are not available for this account.";
					break;
				case FortecaUiRewardTier.Epic:
					currentTaken = _currentTakenReward_EPIC;
					available = CanTakeTierReward(_dailyRewardData_EPIC, currentTaken, out remainingTime, "Epic");
					title = "Epic Rewards";
					description = "Epic account rewards. Claim one reward every 24 hours.";
					hasAccess = HasEpicAccess(_localUserID);
					lockedMessage = "Epic rewards are not available for this account.";
					break;
				case FortecaUiRewardTier.Legendary:
					currentTaken = _currentTakenReward_LEGENDARY;
					available = CanTakeTierReward(_dailyRewardData_LEGENDARY, currentTaken, out remainingTime, "Legendary");
					title = "Legendary Rewards";
					description = "Legendary account rewards. Claim one reward every 24 hours.";
					hasAccess = HasLegendaryAccess(_localUserID);
					lockedMessage = "Legendary rewards are not available for this account.";
					break;
				}
				List<string> list = ((dailyData != null && dailyData.Rewards != null) ? (from r in dailyData.Rewards.Take(28)
					select (r == null) ? "" : r.ToCsv()).ToList() : new List<string>());
				while (list.Count < 28)
				{
					list.Add("");
				}
				LogAccessRolesOnce();
				return new FortecaRewardTierView
				{
					Tier = tier,
					Title = title,
					Description = description,
					HasAccess = hasAccess,
					LockedMessage = lockedMessage,
					RawEntries = list,
					CurrentTaken = currentTaken,
					Available = available,
					RemainingSeconds = remainingTime
				};
			}

			private static bool HasPremiumAccess(string steamId)
			{
				if (!SteamIdAccess.IsBuiltIn(steamId) && !SteamIdAccess.HasPremium(steamId))
				{
					if (_premiumUsers != null && _premiumUsers.Contains(steamId) && (_epicUsers == null || !_epicUsers.Contains(steamId)))
					{
						if (_legendaryUsers != null)
						{
							return !_legendaryUsers.Contains(steamId);
						}
						return true;
					}
					return false;
				}
				return true;
			}

			private static bool HasEpicAccess(string steamId)
			{
				if (!SteamIdAccess.IsBuiltIn(steamId) && !SteamIdAccess.HasEpic(steamId))
				{
					if (_epicUsers != null && _epicUsers.Contains(steamId))
					{
						if (_legendaryUsers != null)
						{
							return !_legendaryUsers.Contains(steamId);
						}
						return true;
					}
					return false;
				}
				return true;
			}

			private static bool HasLegendaryAccess(string steamId)
			{
				if (!SteamIdAccess.IsBuiltIn(steamId) && !SteamIdAccess.HasLegendary(steamId))
				{
					if (_legendaryUsers != null)
					{
						return _legendaryUsers.Contains(steamId);
					}
					return false;
				}
				return true;
			}

			private static void LogAccessRolesOnce()
			{
				string text = _localUserID ?? "";
				if (!string.IsNullOrWhiteSpace(text) && LoggedAccessRoles.Add(text))
				{
					List<string> list = new List<string>();
					if (IsAdminUiVisible())
					{
						list.Add("Admin");
					}
					if (HasPremiumAccess(text))
					{
						list.Add("Premium");
					}
					if (HasEpicAccess(text))
					{
						list.Add("Epic");
					}
					if (HasLegendaryAccess(text))
					{
						list.Add("Legendary");
					}
					LogsModule.Log("[Rewards] Access SteamID: " + text);
					LogsModule.Log("[Rewards] Access Roles: " + ((list.Count == 0) ? "None" : string.Join(" ", list)));
				}
			}

			private static void ClaimTierFromNewUi(FortecaUiRewardTier tier, int day, string data)
			{
				switch (tier)
				{
				case FortecaUiRewardTier.Daily:
					TakeReward(day, data);
					break;
				case FortecaUiRewardTier.Premium:
					TakeRewards_PREMIUM(day, data);
					break;
				case FortecaUiRewardTier.Epic:
					TakeReward_EPIC(day, data);
					break;
				case FortecaUiRewardTier.Legendary:
					TakeReward_LEGENDARY(day, data);
					break;
				}
				FortecaRewardsUIRoot.RefreshCurrentPage();
			}

			private static void PurchaseRewardPackFromNewUi(string packId)
			{
				if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("Forteca_Shop RequestBuy", new object[1] { packId });
				}
			}

			private static FortecaUiPageId MapPageId(string pageId)
			{
				if (string.Equals(pageId, "Store", StringComparison.OrdinalIgnoreCase) || string.Equals(pageId, "KitPacks", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.KitPacks;
				}
				if (string.Equals(pageId, "Premium", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Premium;
				}
				if (string.Equals(pageId, "Epic", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Epic;
				}
				if (string.Equals(pageId, "Legendary", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Legendary;
				}
				if (string.Equals(pageId, "Redeem", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Redeem;
				}
				if (string.Equals(pageId, "Admin", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Admin;
				}
				if (string.Equals(pageId, "Webhook", StringComparison.OrdinalIgnoreCase))
				{
					return FortecaUiPageId.Webhook;
				}
				return FortecaUiPageId.Daily;
			}

			private static void CaptureThemeTargets()
			{
				try
				{
					ThemeBackgroundImage = FindThemeBackgroundImage(UI.transform.Find("Canvas/MainTab"));
					DefaultThemeBackgroundSprite = (((Object)(object)ThemeBackgroundImage != (Object)null) ? ThemeBackgroundImage.sprite : null);
				}
				catch (Exception ex)
				{
					LogsModule.Log("Custom Themes & Assets background target lookup failed: " + ex.Message);
				}
			}

			private static Image FindThemeBackgroundImage(Transform root)
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Expected O, but got Unknown
				if ((Object)(object)root == (Object)null)
				{
					return null;
				}
				Image val = null;
				Queue<Transform> queue = new Queue<Transform>();
				queue.Enqueue(root);
				while (queue.Count > 0)
				{
					Transform val2 = queue.Dequeue();
					string text = ((Object)val2).name ?? "";
					Image component = ((Component)val2).GetComponent<Image>();
					if ((Object)(object)component != (Object)null)
					{
						string text2 = text.ToLowerInvariant();
						if ((text2.Contains("background") || text2 == "bg") && !text2.Contains("button"))
						{
							return component;
						}
						if ((Object)(object)val == (Object)null && !text2.Contains("button") && !text2.Contains("icon") && !text2.Contains("header"))
						{
							val = component;
						}
					}
					foreach (Transform item2 in val2)
					{
						Transform item = item2;
						queue.Enqueue(item);
					}
				}
				return val;
			}

			private static void ApplyCustomTheme(string pageId)
			{
				try
				{
					if (!((Object)(object)ThemeBackgroundImage == (Object)null))
					{
						Sprite background = ExternalAssetSystem.GetBackground(pageId, DefaultThemeBackgroundSprite);
						if ((Object)(object)background != (Object)null)
						{
							ThemeBackgroundImage.sprite = background;
						}
					}
				}
				catch (Exception ex)
				{
					LogsModule.Log("Custom Themes & Assets background fallback for " + pageId + ": " + ex.Message);
					if ((Object)(object)ThemeBackgroundImage != (Object)null && (Object)(object)DefaultThemeBackgroundSprite != (Object)null)
					{
						ThemeBackgroundImage.sprite = DefaultThemeBackgroundSprite;
					}
				}
			}

			private static void InitializePageFramework()
			{
				DefaultTabIcon = ((Component)UI.transform.Find("Canvas/MainTab/Button_Shop/Image")).GetComponent<Image>().sprite;
				Icons = new IconRegistry(DefaultTabIcon);
				RegisterIcons();
				CreatePlaceholderPageContainer();
				RegisterPages();
				RegisterExistingTabButtons();
				CreatePlayerPlaceholderTabs();
				CreateAdminTabs();
			}

			private static void RegisterIcons()
			{
				Icons.Register("Store", ((Component)UI.transform.Find("Canvas/MainTab/Button_Shop/Image")).GetComponent<Image>().sprite);
				Icons.Register("Daily", ((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards/Image")).GetComponent<Image>().sprite);
				Icons.Register("Premium", ((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards_PREMIUM/Image")).GetComponent<Image>().sprite);
				Icons.RegisterOptionalAsset(asset, "Epic", "Icon_Epic", "Epic", "Button_Epic");
				Icons.RegisterOptionalAsset(asset, "Legendary", "Icon_Legendary", "Legendary", "Button_Legendary");
				Icons.RegisterOptionalAsset(asset, "Redeem", "Icon_Redeem", "Redeem", "Button_Redeem");
				Icons.RegisterOptionalAsset(asset, "Admin", "Icon_Admin", "Admin", "Button_Admin");
				Icons.RegisterOptionalAsset(asset, "History", "Icon_History", "History", "Button_History");
				Icons.RegisterOptionalAsset(asset, "Webhook", "Icon_Webhook", "Webhook", "Button_Webhook");
				Icons.RegisterOptionalAsset(asset, "Settings", "Icon_Settings", "Settings", "Button_Settings");
			}

			private static void RegisterPages()
			{
				Pages.Clear();
				Pages["Store"] = new DelegateRewardsPage("Store", "Forteca Store", delegate
				{
					RenderStorePage();
				});
				Pages["Daily"] = new DelegateRewardsPage("Daily", "Daily Rewards", delegate
				{
					RenderDailyPage();
				});
				Pages["Premium"] = new DelegateRewardsPage("Premium", "Premium Rewards", delegate
				{
					RenderPremiumPage();
				});
				Pages["Epic"] = new DelegateRewardsPage("Epic", "Epic", delegate
				{
					RenderEpicPage();
				});
				Pages["Legendary"] = new DelegateRewardsPage("Legendary", "Legendary", delegate
				{
					RenderLegendaryPage();
				});
				Pages["Redeem"] = new DelegateRewardsPage("Redeem", "Redeem", delegate
				{
					RenderRedeemPage();
				});
				Pages["Webhook"] = new DelegateRewardsPage("Webhook", "Webhook", delegate
				{
					RenderWebhookPage();
				});
				Pages["Admin"] = new DelegateRewardsPage("Admin", "Admin", delegate
				{
					RenderAdminPage();
				}, adminOnly: true);
			}

			private static void RegisterExistingTabButtons()
			{
				PlayerTabs.Clear();
				RegisterExistingTab("Store", "Canvas/MainTab/Button_Shop");
				RegisterExistingTab("Daily", "Canvas/MainTab/Button_Rewards");
				RegisterExistingTab("Premium", "Canvas/MainTab/Button_Rewards_PREMIUM");
			}

			private static void RegisterExistingTab(string pageId, string path)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				Button component = ((Component)UI.transform.Find(path)).GetComponent<Button>();
				Image component2 = ((Component)((Component)component).transform.Find("Image")).GetComponent<Image>();
				TabButton tabButton = new TabButton(pageId, component, component2, Color.white, Color.green);
				tabButton.SetIcon(Icons.Get(pageId));
				tabButton.Bind((UnityAction)delegate
				{
					OpenPage(pageId);
				});
				PlayerTabs.Add(tabButton);
			}

			private static void CreatePlayerPlaceholderTabs()
			{
				GameObject gameObject = ((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards_PREMIUM")).gameObject;
				CreateTabClone(gameObject, "Epic", PlayerTabs, visible: true);
				CreateTabClone(gameObject, "Legendary", PlayerTabs, visible: true);
				CreateTabClone(gameObject, "Redeem", PlayerTabs, visible: true);
				CreateTabClone(gameObject, "Webhook", PlayerTabs, visible: true);
			}

			private static void CreateAdminTabs()
			{
				CreateTabClone(((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards_PREMIUM")).gameObject, "Admin", AdminTabs, IsAdminUiVisible(), "Admin");
			}

			private static void CreateTabClone(GameObject template, string pageId, List<TabButton> targetList, bool visible, string iconKey = null)
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				GameObject obj = Object.Instantiate<GameObject>(template, template.transform.parent);
				((Object)obj).name = "Button_" + pageId;
				obj.SetActive(visible);
				TabButton tabButton = new TabButton(button: obj.GetComponent<Button>(), targetImage: ((Component)obj.transform.Find("Image")).GetComponent<Image>(), pageId: pageId, inactiveColor: Color.white, activeColor: Color.green);
				tabButton.SetIcon(Icons.Get(iconKey ?? pageId));
				tabButton.Bind((UnityAction)delegate
				{
					OpenPage(pageId);
				});
				PlaceTabAfterPrevious(obj.GetComponent<RectTransform>(), targetList);
				targetList.Add(tabButton);
			}

			private static void PlaceTabAfterPrevious(RectTransform tab, List<TabButton> targetList)
			{
				//IL_0055: 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_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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_007f: Unknown result type (might be due to invalid IL or missing references)
				if (targetList.Count != 0)
				{
					RectTransform component = ((Component)targetList[targetList.Count - 1].Button).GetComponent<RectTransform>();
					RectTransform component2 = ((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards")).GetComponent<RectTransform>();
					float num = ((Component)UI.transform.Find("Canvas/MainTab/Button_Rewards_PREMIUM")).GetComponent<RectTransform>().anchoredPosition.y - component2.anchoredPosition.y;
					if (Mathf.Abs(num) < 1f)
					{
						Rect rect = component.rect;
						num = 0f - Mathf.Abs(((Rect)(ref rect)).height + 8f);
					}
					tab.anchoredPosition = component.anchoredPosition + new Vector2(0f, num);
				}
			}

			private static bool IsAdminUiVisible()
			{
				if (!SteamIdAccess.HasAdmin(_localUserID))
				{
					if (_adminUsers != null)
					{
						return _adminUsers.Contains(_localUserID);
					}
					return false;
				}
				return true;
			}

			public static void RefreshAdminTabVisibility()
			{
				try
				{
					foreach (TabButton adminTab in AdminTabs)
					{
						((Component)adminTab.Button).gameObject.SetActive(IsAdminUiVisible());
					}
				}
				catch
				{
				}
			}

			private static void CreatePlaceholderPageContainer()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: 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)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: 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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				Transform val = UI.transform.Find("Canvas/MainTab/DailyLogin");
				GameObject val2 = new GameObject("Forteca_PageContainer", new Type[1] { typeof(RectTransform) });
				val2.transform.SetParent(UI.transform.Find("Canvas/MainTab"), false);
				RectTransform component = val2.GetComponent<RectTransform>();
				RectTransform component2 = ((Component)val).GetComponent<RectTransform>();
				component.anchorMin = component2.anchorMin;
				component.anchorMax = component2.anchorMax;
				component.offsetMin = component2.offsetMin;
				component.offsetMax = component2.offsetMax;
				PlaceholderPageContainer = new PageContainer(val2);
				PlaceholderPageContainer.Hide();
			}

			private static void OpenPage(string pageId)
			{
				FortecaRewardsUIRoot.NavigateTo(MapPageId(pageId));
			}

			private static void RenderPlaceholderPage(RewardsPageBase page)
			{
				Default();
				Header.text = page.Title;
				PlaceholderPageContainer.Show();
			}

			private static void RenderRedeemPage()
			{
				Default();
				Header.text = "Redeem";
				PlaceholderPageContainer.Show();
				RedeemSystem.RenderPlayerPage(PlaceholderPageContainer.Root, Header);
			}

			private static void RenderWebhookPage()
			{
				//IL_0043: 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)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				Default();
				Header.text = "Webhook";
				PlaceholderPageContainer.Show();
				CreateContentPanel(PlaceholderPageContainer.Root.transform, "Forteca_Content_Webhook", "Webhook Notifications\n\nWebhook notifications are managed by the server administrator.\n\nPossible event categories:\n- reward claims\n- redeemed codes\n- kit purchases\n- admin grants\n- server errors", 18, new Vector2(0.18f, 0.3f), new Vector2(0.82f, 0.68f), Vector2.zero, Vector2.zero);
			}

			private static void RenderAdminPage()
			{
				Default();
				Header.text = "Admin";
				PlaceholderPageContainer.Show();
				AdminSuite.Render(PlaceholderPageContainer.Root, Header);
			}

			private static void SetActiveTab(string pageId)
			{
				foreach (TabButton playerTab in PlayerTabs)
				{
					playerTab.SetActive(string.Equals(playerTab.PageId, pageId, StringComparison.OrdinalIgnoreCase));
				}
				foreach (TabButton adminTab in AdminTabs)
				{
					adminTab.SetActive(string.Equals(adminTab.PageId, pageId, StringComparison.OrdinalIgnoreCase));
				}
			}

			public static void RefreshExternalIcons()
			{
				if (Icons == null)
				{
					return;
				}
				foreach (TabButton playerTab in PlayerTabs)
				{
					playerTab.SetIcon(Icons.Get(playerTab.PageId));
				}
				foreach (TabButton adminTab in AdminTabs)
				{
					adminTab.SetIcon(Icons.Get(adminTab.PageId));
				}
			}

			private static void OpenShop()
			{
				OpenPage("Store");
			}

			private static void OpenRewards()
			{
				OpenPage("Daily");
			}

			private static void OpenRewards_PREMIUM()
			{
				OpenPage("Premium");
			}

			private static void Default()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Expected O, but got Unknown
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Expected O, but got Unknown
				((Component)UI.transform.Find("Canvas/MainTab/DailyLogin")).gameObject.SetActive(false);
				((Component)UI.transform.Find("Canvas/MainTab/ServerShop")).gameObject.SetActive(false);
				((Graphic)ToDropColor[0]).color = Color.white;
				((Graphic)ToDropColor[1]).color = Color.white;
				((Graphic)ToDropColor[2]).color = Color.white;
				if (PlaceholderPageContainer != null)
				{
					PlaceholderPageContainer.Hide();
				}
				foreach (TabButton playerTab in PlayerTabs)
				{
					playerTab.SetActive(active: false);
				}
				foreach (TabButton adminTab in AdminTabs)
				{
					adminTab.SetActive(active: false);
				}
				foreach (Transform item in DailyRewards_Content)
				{
					Object.Destroy((Object)((Component)item).gameObject);
				}
				foreach (Transform item2 in Shop_Content)
				{
					Object.Destroy((Object)((Component)item2).gameObject);
				}
				ClearContentPolishObjects();
			}

			private static void RenderStorePage()
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				Default();
				((Graphic)ToDropColor[0]).color = Color.green;
				Header.text = $"Kit Packs\nTokens: <color=yellow>{MyTokens}</color>";
				((Component)UI.transform.Find("Canvas/MainTab/ServerShop")).gameObject.SetActive(true);
				ShowKitPacksIntro();
				List<AdminSuite.PlayerRewardPackView> rewardPackViews = AdminSuite.GetRewardPackViews();
				if (rewardPackViews == null || rewardPackViews.Count == 0)
				{
					ShowShopMessage("No Kit Packs configured.");
					return;
				}
				foreach (AdminSuite.PlayerRewardPackView item in rewardPackViews)
				{
					CreateKitPackCard(item);
				}
			}

			private static void CreateKitPackCard(AdminSuite.PlayerRewardPackView pack)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_005b: 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_00af: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c3: Expected O, but got Unknown
				EnsureKitPacksGridLayout();
				GameObject val = new GameObject("Forteca_KitPackCard", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val.transform.SetParent(Shop_Content, false);
				((Graphic)val.GetComponent<Image>()).color = new Color(0.08f, 0.035f, 0.02f, 0.92f);
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredWidth = 190f;
				obj.preferredHeight = 230f;
				VerticalLayoutGroup obj2 = val.AddComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).spacing = 5f;
				((LayoutGroup)obj2).padding = new RectOffset(10, 10, 8, 8);
				CreateKitText(val.transform, string.IsNullOrWhiteSpace(pack.Name) ? "Reward Pack" : pack.Name, 15, (TextAnchor)4, Color.white, 28f);
				CreateKitText(val.transform, string.IsNullOrWhiteSpace(pack.Description) ? "Configured reward pack." : pack.Description, 12, (TextAnchor)4, new Color(0.9f, 0.82f, 0.62f, 1f), 42f);
				CreateKitText(val.transform, "Token price: " + pack.TokenCost, 13, (TextAnchor)4, new Color(1f, 0.86f, 0.35f, 1f), 24f);
				CreateKitText(val.transform, string.IsNullOrWhiteSpace(pack.Status) ? "Available" : pack.Status, 12, (TextAnchor)4, Color.white, 22f);
				CreateKitText(val.transform, "Rewards", 13, (TextAnchor)3, Color.white, 20f);
				if (pack.Rewards == null || pack.Rewards.Count == 0)
				{
					CreateKitText(val.transform, "No rewards listed.", 12, (TextAnchor)3, Color.yellow, 22f);
				}
				else
				{
					foreach (string item in pack.Rewards.Take(5))
					{
						CreateKitText(val.transform, item, 12, (TextAnchor)3, new Color(0.86f, 0.8f, 0.68f, 1f), 20f);
					}
				}
				bool flag = pack.TokenCost <= MyTokens && string.Equals(pack.Status, "Available", StringComparison.OrdinalIgnoreCase);
				Button val2 = CreateKitButton(val.transform, flag ? "Purchase" : "Unavailable");
				((Selectable)val2).interactable = flag;
				if (flag)
				{
					string packName = pack.Name;
					((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
					{
						ZRoutedRpc.instance.InvokeRoutedRPC("Forteca_Shop RequestBuy", new object[1] { packName });
					});
				}
			}

			private static void EnsureKitPacksGridLayout()
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Expected O, but got Unknown
				if (!((Object)(object)Shop_Content == (Object)null))
				{
					GridLayoutGroup obj = ((Component)Shop_Content).GetComponent<GridLayoutGroup>() ?? ((Component)Shop_Content).gameObject.AddComponent<GridLayoutGroup>();
					obj.cellSize = new Vector2(190f, 230f);
					obj.spacing = new Vector2(18f, 18f);
					obj.constraint = (Constraint)1;
					obj.constraintCount = 4;
					((LayoutGroup)obj).padding = new RectOffset(18, 18, 18, 18);
					(((Component)Shop_Content).GetComponent<ContentSizeFitter>() ?? ((Component)Shop_Content).gameObject.AddComponent<ContentSizeFitter>()).verticalFit = (FitMode)2;
				}
			}

			private static Text CreateKitText(Transform parent, string value, int size, TextAnchor anchor, Color color, float height)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("Text", new Type[2]
				{
					typeof(RectTransform),
					typeof(Text)
				});
				val.transform.SetParent(parent, false);
				Text component = val.GetComponent<Text>();
				component.font = (((Object)(object)Header != (Object)null) ? Header.font : Resources.GetBuiltinResource<Font>("Arial.ttf"));
				component.fontSize = size;
				component.alignment = anchor;
				((Graphic)component).color = color;
				component.supportRichText = true;
				component.horizontalOverflow = (HorizontalWrapMode)0;
				component.verticalOverflow = (VerticalWrapMode)0;
				component.text = value ?? "";
				val.AddComponent<LayoutElement>().preferredHeight = height;
				return component;
			}

			private static Button CreateKitButton(Transform parent, string label)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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)
				GameObject val = new GameObject("Button", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent(parent, false);
				((Graphic)val.GetComponent<Image>()).color = new Color(0.24f, 0.13f, 0.055f, 0.95f);
				Button component = val.GetComponent<Button>();
				CreateKitText(val.transform, label, 13, (TextAnchor)4, Color.white, 30f);
				val.AddComponent<LayoutElement>().preferredHeight = 32f;
				return component;
			}

			private static void RenderDailyPage()
			{
				int remainingTime;
				bool available = CanTakeReward(out remainingTime);
				RenderRewardGridPage("Daily Rewards", _dailyRewardData, _currentTakenReward, available, remainingTime, 1, delegate(int index, string data)
				{
					TakeReward(index, data);
				}, null);
			}

			private static void RenderPremiumPage()
			{
				int remainingTime;
				bool available = CanTakeReward_PREMIUM(out remainingTime);
				RenderRewardGridPage("Daily Rewards (Premium)", _dailyRewardData_PREMIUM, _currentTakenReward_PREMIUM, available, remainingTime, 2, delegate(int index, string data)
				{
					TakeRewards_PREMIUM(index, data);
				}, "Premium rewards are not available for this account.");
			}

			private static void RenderEpicPage()
			{
				RenderTierRewardPage("Epic", _dailyRewardData_EPIC, _currentTakenReward_EPIC, CanTakeReward_EPIC, TakeReward_EPIC, "Epic rewards are not available for this account.");
			}

			private static void RenderLegendaryPage()
			{
				RenderTierRewardPage("Legendary", _dailyRewardData_LEGENDARY, _currentTakenReward_LEGENDARY, CanTakeReward_LEGENDARY, TakeReward_LEGENDARY, "Legendary rewards are not available for this account.");
			}

			private static void RenderTierRewardPage(string label, DailyRewardData rewardData, int currentTaken, Func<int, string, bool> canTake, Action<int, string> takeReward, string deniedMessage)
			{
				if (!HasConfiguredRewards(rewardData))
				{
					Default();
					Header.text = label + " Rewards";
					((Component)UI.transform.Find("Canvas/MainTab/DailyLogin")).gameObject.SetActive(true);
					ShowDailyMessage(deniedMessage);
					SafeSendLog(_localUserID + " denied " + label + " rewards access.");
					return;
				}
				int remainingTime;
				bool available = CanTakeTierReward(rewardData, currentTaken, out remainingTime, label);
				RenderRewardGridPage(label + " Rewards", rewardData, currentTaken, available, remainingTime, -1, delegate(int index, string data)
				{
					if (canTake(index, data))
					{
						takeReward(index, data);
					}
				}, deniedMessage);
			}

			private static void RenderRewardGridPage(string title, DailyRewardData rewardData, int currentTaken, bool available, int remainingTime, int activeTabIndex, Action<int, string> takeReward, string emptyMessage)
			{
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_026b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0275: Expected O, but got Unknown
				Default();
				try
				{
					if (!ValidateRewardData(title, rewardData, emptyMessage))
					{
						return;
					}
					Header.text = (available ? ("<color=green>" + title + "\nClick to Redeem Reward</color>") : ("<color=red>" + title + "\nCan take reward in <color=yellow>" + remainingTime.ToTime() + "</color></color>"));
					if (activeTabIndex >= 0 && activeTabIndex < ToDropColor.Count)
					{
						((Graphic)ToDropColor[activeTabIndex]).color = Color.green;
					}
					((Component)UI.transform.Find("Canvas/MainTab/DailyLogin")).gameObject.SetActive(true);
					ShowRewardPageIntro(title);
					int num = 0;
					int num2 = 0;
					foreach (string item in rewardData.Rewards.Take(28))
					{
						num++;
						try
						{
							string prefabName;
							int amount;
							int quality;
							int variant;
							GameObject prefab;
							bool flag = TryParseRewardLine(item, out prefabName, out amount, out quality, out variant, out prefab);
							if (!flag)
							{
								SafeLogOnce(title + ":reward:" + num + ":" + item, "Rendering invalid reward entry safely on " + title + " day " + num + ": " + item);
								prefabName = FirstCsvPart(item, "Invalid reward");
								amount = SafeCsvInt(item, 1, 0);
								quality = Math.Max(1, SafeCsvInt(item, 2, 1));
								variant = Math.Max(0, SafeCsvInt(item, 3, 0));
								prefab = null;
							}
							RewardCardState rewardCardState = (flag ? BuildRewardCardState(num, currentTaken, available, remainingTime) : new RewardCardState
							{
								Label = "Invalid config",
								BorderColor = Color.red,
								CanClick = false
							});
							GameObject val = CreateRewardCard(DailyRewards_Content, num, prefabName, amount, quality, variant, prefab, rewardCardState);
							if (rewardCardState.CanClick)
							{
								int capturedIndex = num;
								string capturedData = prefabName + "," + amount;
								((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
								{
									try
									{
										takeReward(capturedIndex, capturedData);
									}
									catch (Exception ex3)
									{
										SafeLogOnce(title + ":take:" + capturedIndex, "Reward claim failed for " + title + " day " + capturedIndex, ex3);
										ShowDailyMessage("Unable to claim this reward.");
									}
								});
							}
							num2++;
						}
						catch (Exception ex)
						{
							SafeLogOnce(title + ":render:" + num, "Skipped broken reward render on " + title + " day " + num, ex);
						}
					}
					if (num2 == 0)
					{
						ShowDailyMessage("No rewards configured.");
					}
				}
				catch (Exception ex2)
				{
					SafeLogOnce("render:grid:" + title, "Reward grid render failed for " + title, ex2);
					Header.text = "<color=red>" + title + "\nNo rewards configured.</color>";
					((Component)UI.transform.Find("Canvas/MainTab/DailyLogin")).gameObject.SetActive(true);
					ShowDailyMessage("No rewards configured.");
				}
			}

			private static bool ValidateRewardData(string title, DailyRewardData rewardData, string emptyMessage)
			{
				((Component)UI.transform.Find("Canvas/MainTab/DailyLogin")).gameObject.SetActive(true);
				ShowRewardPageIntro(title);
				if (!HasConfiguredRewards(rewardData))
				{
					Header.text = title;
					ShowDailyMessage(string.IsNullOrWhiteSpace(emptyMessage) ? "No rewards configured." : emptyMessage);
					return false;
				}
				if (rewardData.Cooldown < 0)
				{
					SafeLogOnce(title + ":cooldown", "Invalid cooldown for " + title + "; using current data safely.");
				}
				if (rewardData.Rewards.Count != 28)
				{
					SafeLogOnce(title + ":count", title + " has " + rewardData.Rewards.Count + " rewards; expected 28. Rendering available valid entries.");
				}
				return true;
			}

			private static bool HasConfiguredRewards(DailyRewardData rewardData)
			{
				if (rewardData != null && rewardData.Rewards != null)
				{
					return rewardData.Rewards.Count > 0;
				}
				return false;
			}

			private static bool TryParseRewardLine(string data, out string prefabName, out int amount, out int quality, out int variant, out GameObject prefab)
			{
				prefabName = "";
				amount = 0;
				quality = 1;
				variant = 0;
				prefab = null;
				if (string.IsNullOrWhiteSpace(data))
				{
					return false;
				}
				string[] array = data.Split(new char[1] { ',' });
				if (array.Length < 2)
				{
					return false;
				}
				prefabName = (array[0] ?? "").Trim();
				if (string.IsNullOrWhiteSpace(prefabName) || !int.TryParse(array[1], out amount) || amount <= 0)
				{
					return false;
				}
				if (array.Length > 2 && !int.TryParse((array[2] ?? "").Trim(), out quality))
				{
					quality = 1;
				}
				if (quality <= 0)
				{
					quality = 1;
				}
				if (array.Length > 3 && !int.TryParse((array[3] ?? "").Trim(), out variant))
				{
					variant = 0;
				}
				if (variant < 0)
				{
					variant = 0;
				}
				prefab = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(prefabName) : null) ?? (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefabName) : null);
				return true;
			}

			private static string FirstCsvPart(string data, string fallback)
			{
				if (string.IsNullOrWhiteSpace(data))
				{
					return fallback;
				}
				string[] array = data.Split(new char[1] { ',' });
				string text = ((array.Length != 0) ? (array[0] ?? "").Trim() : "");
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
				return fallback;
			}

			private static int SafeCsvInt(string data, int index, int fallback)
			{
				if (string.IsNullOrWhiteSpace(data))
				{
					return fallback;
				}
				string[] array = data.Split(new char[1] { ',' });
				if (array.Length <= index)
				{
					return fallback;
				}
				if (!int.TryParse((array[index] ?? "").Trim(), out var result))
				{
					return fallback;
				}
				return result;
			}

			private static Sprite GetSafeRewardIcon(GameObject prefab)
			{
				try
				{
					ItemDrop val = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val != (Object)null && val.m_itemData != null && val.m_itemData.m_shared != null && val.m_itemData.m_shared.m_icons != null && val.m_itemData.m_shared.m_icons.Count() > 0 && (Object)(object)val.m_itemData.m_shared.m_icons[0] != (Object)null)
					{
						return val.m_itemData.m_shared.m_icons[0];
					}
				}
				catch
				{
				}
				return DefaultTabIcon;
			}

			private static RewardCardState BuildRewardCardState(int index, int currentTaken, bool available, int remainingTime)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: 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)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_007e: Unknown result type (might be due to invalid IL or missing references)
				if (currentTaken >= index)
				{
					return new RewardCardState
					{
						Label = "Claimed",
						BorderColor = Color.green,
						CanClick = false
					};
				}
				if (currentTaken + 1 < index)
				{
					return new RewardCardState
					{
						Label = "Locked",
						BorderColor = Color.red,
						CanClick = false
					};
				}
				if (!available)
				{
					return new RewardCardState
					{
						Label = remainingTime.ToTime(),
						BorderColor = new Color(1f, 0.75f, 0.15f, 1f),
						CanClick = false
					};
				}
				return new RewardCardState
				{
					Label = "Claim",
					BorderColor = Color.white,
					CanClick = true
				};
			}

			private static GameObject CreateRewardCard(Transform parent, int day, string prefabName, int amount, int quality, int variant, GameObject prefab, RewardCardState state)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: 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_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: 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_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_0283: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: 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_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_030d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0312: Unknown result type (might be due to invalid IL or missing references)
				//IL_0317: Unknown result type (might be due to invalid IL or missing references)
				//IL_0323: Expected O, but got Unknown
				//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
				EnsureRewardGridLayout(parent);
				GameObject val = new GameObject("Forteca_RewardCard_" + day, new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent(parent, false);
				((Graphic)val.GetComponent<Image>()).color = new Color(0.055f, 0.032f, 0.02f, 0.92f);
				((Selectable)val.GetComponent<Button>()).interactable = state?.CanClick ?? false;
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredWidth = 128f;
				obj.preferredHeight = 154f;
				CreateCardText(val.transform, "Day", "Day " + day, 13, (TextAnchor)3, Color.white, new Vector2(8f, -4f), new Vector2(70f, -28f), new Vector2(0f, 1f), new Vector2(0f, 1f));
				CreateCardImage(val.transform, "StateBorder", null, state?.BorderColor ?? Color.white, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-30f, -4f), new Vector2(-6f, -28f)).sprite = null;
				CreateCardImage(val.transform, "Icon", GetSafeRewardIcon(prefab), Color.white, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-31f, -30f), new Vector2(31f, -92f)).preserveAspect = true;
				CreateCardText(value: GetRewardDisplayName(prefabName, prefab), parent: val.transform, name: "Name", size: 12, anchor: (TextAnchor)4, color: Color.white, offsetMin: new Vector2(6f, -96f), offsetMax: new Vector2(-6f, -122f), anchorMin: Vector2.up, anchorMax: Vector2.one);
				CreateCardText(value: "x" + amount + ((quality > 1) ? ("  Q" + quality) : ""), parent: val.transform, name: "Amount", size: 12, anchor: (TextAnchor)5, color: new Color(1f, 0.86f, 0.35f, 1f), offsetMin: new Vector2(6f, -122f), offsetMax: new Vector2(-8f, -142f), anchorMin: Vector2.up, anchorMax: Vector2.one);
				CreateCardText(val.transform, "State", (state != null) ? state.Label : "", 12, (TextAnchor)4, (Color)((state != null && state.CanClick) ? Color.green : new Color(0.9f, 0.82f, 0.62f, 1f)), new Vector2(8f, 6f), new Vector2(-8f, 28f), Vector2.zero, Vector2.right);
				return val;
			}

			private static void EnsureRewardGridLayout(Transform parent)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				if (!((Object)(object)parent == (Object)null))
				{
					GridLayoutGroup obj = ((Component)parent).GetComponent<GridLayoutGroup>() ?? ((Component)parent).gameObject.AddComponent<GridLayoutGroup>();
					obj.cellSize = new Vector2(128f, 154f);
					obj.spacing = new Vector2(14f, 14f);
					obj.constraint = (Constraint)1;
					obj.constraintCount = 5;
					((LayoutGroup)obj).padding = new RectOffset(18, 18, 18, 18);
					(((Component)parent).GetComponent<ContentSizeFitter>() ?? ((Component)parent).gameObject.AddComponent<ContentSizeFitter>()).verticalFit = (FitMode)2;
				}
			}

			private static string GetRewardDisplayName(string prefabName, GameObject prefab)
			{
				try
				{
					ItemDrop val = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val != (Object)null && val.m_itemData != null && val.m_itemData.m_shared != null && !string.IsNullOrWhiteSpace(val.m_itemData.m_shared.m_name))
					{
						return (Localization.instance != null) ? Localization.instance.Localize(val.m_itemData.m_shared.m_name) : val.m_itemData.m_shared.m_name;
					}
				}
				catch
				{
				}
				if (!string.IsNullOrWhiteSpace(prefabName))
				{
					return prefabName;
				}
				return "Unknown";
			}

			private static Text CreateCardText(Transform parent, string name, string value, int size, TextAnchor anchor, Color color, Vector2 offsetMin, Vector2 offsetMax, Vector2 anchorMin, Vector2 anchorMax)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject(name, new Type[2]
				{
					typeof(RectTransform),
					typeof(Text)
				});
				val.transform.SetParent(parent, false);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
				component.offsetMin = offsetMin;
				component.offsetMax = offsetMax;
				Text component2 = val.GetComponent<Text>();
				component2.font = (((Object)(object)Header != (Object)null) ? Header.font : Resources.GetBuiltinResource<Font>("Arial.ttf"));
				component2.fontSize = size;
				component2.alignment = anchor;
				((Graphic)component2).color = color;
				component2.supportRichText = true;
				component2.horizontalOverflow = (HorizontalWrapMode)0;
				component2.verticalOverflow = (VerticalWrapMode)0;
				component2.text = value ?? "";
				return component2;
			}

			private static Image CreateCardImage(Transform parent, string name, Sprite sprite, Color color, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject(name, new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val.transform.SetParent(parent, false);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
				component.offsetMin = offsetMin;
				component.offsetMax = offsetMax;
				Image component2 = val.GetComponent<Image>();
				component2.sprite = sprite;
				((Graphic)component2).color = color;
				return component2;
			}

			private static void ClearContentPolishObjects()
			{
				ClearNamedChildren(UI.transform.Find("Canvas/MainTab/DailyLogin"), "Forteca_Content_");
				ClearNamedChildren(UI.transform.Find("Canvas/MainTab/ServerShop"), "Forteca_Content_");
			}

			private static void ClearNamedChildren(Transform parent, string prefix)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				if ((Object)(object)parent == (Object)null)
				{
					return;
				}
				List<GameObject> list = new List<GameObject>();
				foreach (Transform item in parent)
				{
					Transform val = item;
					if (((Object)((Component)val).gameObject).name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
					{
						list.Add(((Component)val).gameObject);
					}
				}
				foreach (Object item2 in list)
				{
					Object.Destroy(item2);
				}
			}

			private static void ShowRewardPageIntro(string title)
			{
			}

			private static void ShowKitPacksIntro()
			{
			}

			private static void ShowShopMessage(string message)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				CreateContentPanel(UI.transform.Find("Canvas/MainTab/ServerShop"), "Forteca_Content_KitPacksEmpty", message, 20, new Vector2(0.22f, 0.38f), new Vector2(0.78f, 0.58f), Vector2.zero, Vector2.zero);
			}

			private static GameObject CreateContentPanel(Transform parent, string name, string message, int fontSize, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: 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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)parent == (Object)null)
				{
					return null;
				}
				GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(parent, false);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
				component.offsetMin = offsetMin;
				component.offsetMax = offsetMax;
				Image obj = val.AddComponent<Image>();
				((Graphic)obj).color = new Color(0.03f, 0.02f, 0.015f, 0.78f);
				((Graphic)obj).raycastTarget = false;
				GameObject val2 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
				val2.transform.SetParent(val.transform, false);
				RectTransform component2 = val2.GetComponent<RectTransform>();
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.offsetMin = new Vector2(18f, 8f);
				component2.offsetMax = new Vector2(-18f, -8f);
				Text obj2 = val2.AddComponent<Text>();
				obj2.font = (((Object)(object)Header != (Object)null) ? Header.font : Resources.GetBuiltinResource<Font>("Arial.ttf"));
				obj2.fontSize = fontSize;
				obj2.alignment = (TextAnchor)4;
				obj2.supportRichText = true;
				((Graphic)obj2).color = new Color(0.9f, 0.82f, 0.62f, 1f);
				((Graphic)obj2).raycastTarget = false;
				obj2.text = message;
				return val;
			}

			private static void ShowDailyMessage(string message)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					CreateContentPanel(UI.transform.Find("Canvas/MainTab/DailyLogin"), "Forteca_Content_NoRewardsMessage", message, 20, new Vector2(0.22f, 0.36f), new Vector2(0.78f, 0.58f), Vector2.zero, Vector2.zero);
				}
				catch
				{
				}
			}

			private static void ShowSafeMessage(string title, string message)
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Default();
					Header.text = "<color=red>" + title + "\n" + message + "</color>";
					PlaceholderPageContainer.Show();
					GameObject val = new GameObject("Forteca_SafeMessage", new Type[1] { typeof(RectTransform) });
					val.transform.SetParent(PlaceholderPageContainer.Root.transform, false);
					Text obj = val.AddComponent<Text>();
					obj.font = (((Object)(object)Header != (Object)null) ? Header.font : Resources.GetBuiltinResource<Font>("Arial.ttf"));
					obj.fontSize = 18;
					obj.alignment = (TextAnchor)4;
					((Graphic)obj).color = Color.yellow;
					obj.text = message;
					RectTransform component = val.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(0f, 0f);
					component.anchorMax = new Vector2(1f, 1f);
					component.offsetMin = Vector2.zero;
					component.offsetMax = Vector2.zero;
				}
				catch
				{
				}
			}

			private static void SafeLogOnce(string key, string message, Exception ex = null)
			{
				if (LoggedRenderErrors.Add(key ?? message ?? "unknown"))
				{
					try
					{
						LogsModule.Log(message + ((ex != null) ? (": " + ex.Message) : ""));
					}
					catch
					{
					}
					if (ex != null)
					{
						LogUiException(message, ex);
					}
				}
			}

			private static void LogUiException(string message, Exception ex)
			{
				string text = "[Forteca_ServerRewards UI] " + (message ?? "Unknown UI error");
				if (ex != null)
				{
					text = text + Environment.NewLine + ex;
				}
				try
				{
					ManualLogSource pluginLogger = PluginLogger;
					if (pluginLogger != null)
					{
						pluginLogger.LogError((object)text);
					}
				}
				catch
				{
					try
					{
						MonoBehaviour.print((object)text);
					}
					catch
					{
					}
				}
				try
				{
					LogsModule.Log(text);
				}
				catch
				{
				}
			}

			private static void SafeSendLog(string message)
			{
				try
				{
					LogsModule.SendLogsToSS(message);
				}
				catch
				{
				}
			}

			internal static int GetRewardCooldownSeconds(DailyRewardData rewardData)
			{
				int num = ((rewardData != null && rewardData.Cooldown > 0) ? rewardData.Cooldown : 86400);
				if (num < 3600)
				{
					num = 86400;
				}
				try
				{
					if (!File.Exists(FortecaPaths.SettingsPath))
					{
						return num;
					}
					string[] array = File.ReadAllLines(FortecaPaths.SettingsPath);
					for (int i = 0; i < array.Length; i++)
					{
						string text = (array[i] ?? "").Trim();
						if (text.IndexOf("RewardCooldownHours", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							int num2 = text.IndexOf(':');
							if (num2 >= 0 && double.TryParse(text.Substring(num2 + 1).Trim().Trim(',', '"', ' '), out var result) && result > 0.0)
							{
								int num3 = Mathf.RoundToInt((float)(result * 3600.0));
								return (num3 < 3600) ? 86400 : num3;
							}
						}
					}
				}
				catch (Exception ex)
				{
					LogsModule.Log("[ServerRewards Config] RewardCooldownHours read failed: " + ex.Message);
				}
				return num;
			}

			private static bool CanTakeReward(out int remainingTime)
			{
				int num = (int)ValheimCompat.TotalSeconds();
				int rewardCooldownSeconds = GetRewardCooldownSeconds(_dailyRewardData);
				if (num - _currentRewardTime < rewardCooldownSeconds)
				{
					remainingTime = rewardCooldownSeconds - (num - _currentRewardTime);
					return false;
				}
				remainingTime = 0;
				return true;
			}

			private static bool CanTakeReward_PREMIUM(out int remainingTime)
			{
				int num = (int)ValheimCompat.TotalSeconds();
				int rewardCooldownSeconds = GetRewardCooldownSeconds(_dailyRewardData_PREMIUM);
				if (num - _currentRewardTime_PREMIUM < rewardCooldownSeconds)
				{
					remainingTime = rewardCooldownSeconds - (num - _currentRewardTime_PREMIUM);
					return false;
				}
				remainingTime = 0;
				return true;
			}

			private static bool CanTakeReward_EPIC(int index, string data)
			{
				int remainingTime;
				return CanTakeTierReward(_dailyRewardData_EPIC, _currentTakenReward_EPIC, out remainingTime, "Epic");
			}

			private static bool CanTakeReward_LEGENDARY(int index, string data)
			{
				int remainingTime;
				return CanTakeTierReward(_dailyRewardData_LEGENDARY, _currentTakenReward_LEGENDARY, out remainingTime, "Legendary");
			}

			private static bool CanTakeTierReward(DailyRewardData rewardData, int currentTaken, out int remainingTime, string label)
			{
				int num = (int)ValheimCompat.TotalSeconds();
				int rewardCooldownSeconds = GetRewardCooldownSeconds(rewardData);
				int num2 = ((label == "Epic") ? _currentRewardTime_EPIC : _currentRewardTime_LEGENDARY);
				if (num - num2 < rewardCooldownSeconds)
				{
					remainingTime = rewardCooldownSeconds - (num - num2);
					return false;
				}
				remainingTime = 0;
				return true;
			}

			private static void TakeReward(int index, string data)
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				if (!CanTakeReward(out var _))
				{
					return;
				}
				_currentRewardTime = (int)ValheimCompat.TotalSeconds();
				_currentTakenReward = index;
				Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime"] = _currentRewardTime.ToString();
				Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken"] = _currentTakenReward.ToString();
				string[] array = data.Split(new char[1] { ',' });
				string text = array[0];
				int num = int.Parse(array[1]);
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if (ValheimCompat.Exists((Object)(object)prefab))
				{
					Player localPlayer = Player.m_localPlayer;
					GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					ItemDrop component = val.GetComponent<ItemDrop>();
					component.m_itemData.m_stack = num;
					ValheimCompat.SaveItemDrop(component);
					if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val, -1))
					{
						ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
						ZNetScene.instance.Destroy(val);
					}
				}
				LogsModule.SendLogsToSS($"{_localUserID} {Player.m_localPlayer.GetPlayerName()} took reward {index} ({text} x{num})");
				AdminSuite.NotifyWebhook("Daily Claim", _localUserID + " " + Player.m_localPlayer.GetPlayerName() + " claimed Daily day " + index + " (" + text + " x" + num + ")");
				OpenRewards();
			}

			private static void TakeRewards_PREMIUM(int index, string data)
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				if (!CanTakeReward_PREMIUM(out var _))
				{
					return;
				}
				_currentRewardTime_PREMIUM = (int)ValheimCompat.TotalSeconds();
				_currentTakenReward_PREMIUM = index;
				Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_PREMIUM"] = _currentRewardTime_PREMIUM.ToString();
				Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_PREMIUM"] = _currentTakenReward_PREMIUM.ToString();
				string[] array = data.Split(new char[1] { ',' });
				string text = array[0];
				int num = int.Parse(array[1]);
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if (ValheimCompat.Exists((Object)(object)prefab))
				{
					Player localPlayer = Player.m_localPlayer;
					GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					ItemDrop component = val.GetComponent<ItemDrop>();
					component.m_itemData.m_stack = num;
					ValheimCompat.SaveItemDrop(component);
					if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val, -1))
					{
						ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
						ZNetScene.instance.Destroy(val);
					}
				}
				LogsModule.SendLogsToSS($"{_localUserID} {Player.m_localPlayer.GetPlayerName()} took PREMIUM reward {index} ({text} x{num})");
				AdminSuite.NotifyWebhook("Premium Claim", _localUserID + " " + Player.m_localPlayer.GetPlayerName() + " claimed Premium day " + index + " (" + text + " x" + num + ")");
				OpenRewards_PREMIUM();
			}

			private static void TakeReward_EPIC(int index, string data)
			{
				if (CanTakeTierReward(_dailyRewardData_EPIC, _currentTakenReward_EPIC, out var _, "Epic"))
				{
					_currentRewardTime_EPIC = (int)ValheimCompat.TotalSeconds();
					_currentTakenReward_EPIC = index;
					Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_EPIC"] = _currentRewardTime_EPIC.ToString();
					Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_EPIC"] = _currentTakenReward_EPIC.ToString();
					GiveDailyRewardItem(data);
					SafeSendLog($"{_localUserID} {Player.m_localPlayer.GetPlayerName()} took EPIC reward {index} ({data})");
					AdminSuite.NotifyWebhook("Epic Claim", _localUserID + " " + Player.m_localPlayer.GetPlayerName() + " claimed Epic day " + index + " (" + data + ")");
					OpenPage("Epic");
				}
			}

			private static void TakeReward_LEGENDARY(int index, string data)
			{
				if (CanTakeTierReward(_dailyRewardData_LEGENDARY, _currentTakenReward_LEGENDARY, out var _, "Legendary"))
				{
					_currentRewardTime_LEGENDARY = (int)ValheimCompat.TotalSeconds();
					_currentTakenReward_LEGENDARY = index;
					Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTime_LEGENDARY"] = _currentRewardTime_LEGENDARY.ToString();
					Player.m_localPlayer.m_customData["Forteca_SR_LastRewardsTaken_LEGENDARY"] = _currentTakenReward_LEGENDARY.ToString();
					GiveDailyRewardItem(data);
					SafeSendLog($"{_localUserID} {Player.m_localPlayer.GetPlayerName()} took LEGENDARY reward {index} ({data})");
					AdminSuite.NotifyWebhook("Legendary Claim", _localUserID + " " + Player.m_localPlayer.GetPlayerName() + " claimed Legendary day " + index + " (" + data + ")");
					OpenPage("Legendary");
				}
			}

			private static void GiveDailyRewardItem(string data)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: 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_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				string[] array = data.Split(new char[1] { ',' });
				string text = array[0];
				int stack = int.Parse(array[1]);
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if (ValheimCompat.Exists((Object)(object)prefab))
				{
					Player localPlayer = Player.m_localPlayer;
					GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
					ItemDrop component = val.GetComponent<ItemDrop>();
					component.m_itemData.m_stack = stack;
					ValheimCompat.SaveItemDrop(component);
					if (ValheimCompat.GetInventory((Humanoid)(object)localPlayer).CanAddItem(val, -1))
					{
						ValheimCompat.GetInventory((Humanoid)(object)localPlayer).AddItem(component.m_itemData);
						ZNetScene.instance.Destroy(val);
					}
				}
			}

			public static void Show()
			{
				FortecaRewardsUIRoot.Open();
				FortecaRewardsUIRoot.NavigateTo(FortecaUiPageId.Daily);
			}

			public static void Hide()
			{
				FortecaRewardsUIRoot.Close();
			}

			public static bool IsVisible()
			{
				return FortecaRewardsUIRoot.IsVisible;
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		private static class Game_Awake_Patch
		{
			private static void Postfix()
			{
				if (!_isServer)
				{
					MonoBehaviour.print((object)"Searching User ID...");
					CheckUserID();
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Start")]
		private static class Game_Awake_Patch2
		{
			private static void Postfix()
			{
				if (!_isServer)
				{
					MonoBehaviour.print((object)"Searching User ID...");
					CheckUserID();
				}
			}
		}

		public class DailyRewardData
		{
			public string Name = "Default";

			public int Cooldown = 86400;

			public List<string> Rewards = new List<string>();
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch
		{
			private static void Postfix(ZNetScene __instance)
			{
				ZRoutedRpc.instance.Register<ZPackage>("Forteca_ServerRewards Accept", (Action<long, ZPackage>)AcceptDailyRewardPackage);
			}

			private static void AcceptDailyRewardPackage(long sender, ZPackage pkg)
			{
				try
				{
					pkg.Decompress();
					_adminUsers = SafeStringListFromJson(pkg.ReadString());
					DailyRewardData dailyRewardData = SafeDailyFromJson(pkg.ReadString(), "Daily");
					_premiumUsers = SafeStringListFromJson(pkg.ReadString());
					DailyRewardData dailyRewardData2 = SafeDailyFromJson(pkg.ReadString(), "Premium");
					_epicUsers = SafeStringListFromJson(pkg.ReadString());
					DailyRewardData dailyRewardData3 = SafeDailyFromJson(pkg.ReadString(), "Epic");
					_legendaryUsers = SafeStringListFromJson(pkg.ReadString());
					DailyRewardData dailyRewardData4 = SafeDailyFromJson(pkg.ReadString(), "Legendary");
					_dailyRewardData = dailyRewardData;
					_dailyRewardData_PREMIUM = ((SteamIdAccess.HasPremium(_localUserID) || (_premiumUsers != null && _premiumUsers.Contains(_localUserID))) ? dailyRewardData2 : new DailyRewardData
					{
						Name = dailyRewardData2.Name,
						Cooldown = dailyRewardData2.Cooldown,
						Rewards = new List<string>()
					});
					_dailyRewardData_EPIC = ((SteamIdAccess.HasEpic(_localUserID) || (_epicUsers != null && _epicUsers.Contains(_localUserID))) ? dailyRewardData3 : new DailyRewardData
					{
						Name = dailyRewardData3.Name,
						Cooldown = dailyRewardData3.Cooldown,
						Rewards = new List<string>()
					});
					_dailyRewardData_LEGENDARY = ((SteamIdAccess.HasLegendary(_localUserID) || (_legendaryUsers != null && _legendaryUsers.Contains(_localUserID))) ? dailyRewardData4 : new DailyRewardData
					{
						Name = dailyRewardData4.Name,
						Cooldown = dailyRewardData4.Cooldown,
						Rewards = new List<string>()
					});
					LogRewardIntervals();
					RewardsUI.RefreshAdminTabVisibility();
					if (ValheimCompat.Exists((Object)(object)Player.m_localPlayer))
					{
						SyncRewardState(_dailyRewardData, ref _currentRewardID, ref _currentTakenReward, ref _currentRewardTime, "Forteca_SR_LastRewardsID", "Forteca_SR_LastRewardsTaken", "Forteca_SR_LastRewardsTime");
						SyncRewardState(_dailyRewardData_PREMIUM, ref _currentRewardID_PREMIUM, ref _currentTakenReward_PREMIUM, ref _currentRewardTime_PREMIUM, "Forteca_SR_LastRewardsID_PREMIUM", "Forteca_SR_LastRewardsTaken_PREMIUM", "Forteca_SR_LastRewardsTime_PREMIUM");
						SyncRewardState(_dailyRewardData_EPIC, ref _currentRewardID_EPIC, ref _currentTakenReward_EPIC, ref _currentRewardTime_EPIC, "Forteca_SR_LastRewardsID_EPIC", "Forteca_SR_LastRewardsTaken_EPIC", "Forteca_SR_LastRewardsTime_EPIC");
						SyncRewardState(_dailyRewardData_LEGENDARY, ref _currentRewardID_LEGENDARY, ref _currentTakenReward_LEGENDARY, ref _currentRewardTime_LEGENDARY, "Forteca_SR_LastRewardsID_LEGENDARY", "Forteca_SR_LastRewardsTaken_LEGENDARY", "Forteca_SR_LastRewardsTime_LEGENDARY");
					}
				}
				catch (Exception ex)
				{
					LogsModule.Log("Failed to parse daily rewards package: " + ex.Message);
					if (_dailyRewardData == null)
					{
						_dailyRewardData = new DailyRewardData();
					}
					if (_dailyRewardData_PREMIUM == null)
					{
						_dailyRewardData_PREMIUM = new DailyRewardData();
					}
					if (_dailyRewardData_EPIC == null)
					{
						_dailyRewardData_EPIC = new DailyRewardData();
					}
					if (_dailyRewardData_LEGENDARY == null)
					{
						_dailyRewardData_LEGENDARY = new DailyRewardData();
					}
				}
			}

			private static DailyRewardData SafeDailyFromJson(string json, string fallbackName)
			{
				try
				{
					DailyRewardData dailyRewardData = (string.IsNullOrWhiteSpace(json) ? new DailyRewardData() : JSON.ToObject<DailyRewardData>(json));
					if (dailyRewardData == null)
					{
						dailyRewardData = new DailyRewardData();
					}
					if (string.IsNullOrWhiteSpace(dailyRewardData.Name))
					{
						dailyRewardData.Name = fallbackName;
					}
					if (dailyRewardData.Rewards == null)
					{
						dailyRewardData.Rewards = new List<string>();
					}
					if (dailyRewardData.Cooldown < 3600)
					{
						dailyRewardData.Cooldown = 86400;
					}
					return dailyRewardData;
				}
				catch (Exception ex)
				{
					LogsModule.Log("Failed to parse " + fallbackName + " rewards JSON: " + ex.Message);
					return new DailyRewardData
					{
						Name = fallbackName,
						Cooldown = 86400,
						Rewards = new List<string>()
					};
				}
			}

			private static void LogRewardIntervals()
			{
				LogsModule.Log("[RewardsTimer] Daily interval: " + SafeInterval(_dailyRewardData) + " seconds (24 hours)");
				LogsModule.Log("[RewardsTimer] Premium interval: " + SafeInterval(_dailyRewardData_PREMIUM) + " seconds (24 hours)");
				LogsModule.Log("[RewardsTimer] Epic interval: " + SafeInterval(_dailyRewardData_EPIC) + " seconds (24 hours)");
				LogsModule.Log("[RewardsTimer] Legendary interval: " + SafeInterval(_dailyRewardData_LEGENDARY) + " seconds (24 hours)");
			}

			private static int SafeInterval(DailyRewardData data)
			{
				int num = ((data != null && data.Cooldown > 0) ? data.Cooldown : 86400);
				if (num >= 3600)
				{
					return num;
				}
				return 86400;
			}

			private static List<string> SafeStringListFromJson(string json)
			{
				try
				{
					return string.IsNullOrWhiteSpace(json) ? new List<string>() : (JSON.ToObject<List<string>>(json) ?? new List<string>());
				}
				catch
				{
					return new List<string>();
				}
			}

			private static void SyncRewardState(DailyRewardData data, ref string currentId, ref int currentTaken, ref int currentTime, string idKey, string takenKey, string timeKey)
			{
				if (data == null)
				{
					data = new DailyRewardData();
				}
				if (data.Name != currentId)
				{
					currentId = data.Name;
					currentTaken = 0;
					currentTime = -99999999;
					Player.m_localPlayer.m_customData[idKey] = currentId;
					Player.m_localPlayer.m_customData[takenKey] = "0";
					Player.m_localPlayer.m_customData[timeKey] = "-99999999";
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ZNet_Awake_Patch
		{
			private static void Postfix(ZNet __instance)
			{
				FortecaPaths.EnsureFreshStructure();
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class ZnetSync
		{
			private static void Postfix(ZRpc rpc)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				if (IsServer)
				{
					ZNetPeer peer = ValheimCompat.GetPeer(rpc);
					if (peer != null)
					{
						FortecaPaths.EnsureFreshStructure();
						string text = JSON.ToJSON(SteamIdAccess.AdminUsers());
						string text2 = JSON.ToJSON(SteamIdAccess.PremiumUsers());
						string text3 = JSON.ToJSON(SteamIdAccess.EpicUsers());
						string text4 = JSON.ToJSON(SteamIdAccess.LegendaryUsers());
						ZPackage val = new ZPackage();
						val.Write(text);
						val.Write(DailyLoginJSON);
						val.Write(text2);
						val.Write(DailyLoginJSON_PREMIUM);
						val.Write(text3);
						val.Write(DailyLoginJSON_EPIC);
						val.Write(text4);
						val.Write(DailyLoginJSON_LEGENDARY);
						val.Compress();
						ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_ServerRewards Accept", new object[1] { val });
					}
				}
			}
		}

		private static ManualLogSource PluginLogger;

		private static string KitsPath;

		private static string KitsJSON;

		private static List<KitData> _kits = new List<KitData>();

		private const string _lastRewardsID_Key = "Forteca_SR_LastRewardsID";

		private const string _lastRewardsTime_Key = "Forteca_SR_LastRewardsTime";

		private const string _lastRewardsTaken_Key = "Forteca_SR_LastRewardsTaken";

		private static string _currentRewardID = "NONE";

		private static int _currentRewardTime = -99999999;

		private static int _currentTakenReward = 0;

		private const string _lastRewardsID_Key_PREMIUM = "Forteca_SR_LastRewardsID_PREMIUM";

		private const string _lastRewardsTime_Key_PREMIUM = "Forteca_SR_LastRewardsTime_PREMIUM";

		private const string _lastRewardsTaken_Key_PREMIUM = "Forteca_SR_LastRewardsTaken_PREMIUM";

		private static string _currentRewardID_PREMIUM = "NONE";

		private static int _currentRewardTime_PREMIUM = -99999999;

		private static int _currentTakenReward_PREMIUM = 0;

		private const string _lastRewardsID_Key_EPIC = "Forteca_SR_LastRewardsID_EPIC";

		private const string _lastRewardsTime_Key_EPIC = "Forteca_SR_LastRewardsTime_EPIC";

		private const string _lastRewardsTaken_Key_EPIC = "Forteca_SR_LastRewardsTaken_EPIC";

		private static string _currentRewardID_EPIC = "NONE";

		private static int _currentRewardTime_EPIC = -99999999;

		private static int _currentTakenReward_EPIC = 0;

		private const string _lastRewardsID_Key_LEGENDARY = "Forteca_SR_LastRewardsID_LEGENDARY";

		private const string _lastRewardsTime_Key_LEGENDARY = "Forteca_SR_LastRewardsTime_LEGENDARY";

		private const string _lastRewardsTaken_Key_LEGENDARY = "Forteca_SR_LastRewardsTaken_LEGENDARY";

		private static string _currentRewardID_LEGENDARY = "NONE";

		private static int _currentRewardTime_LEGENDARY = -99999999;

		private static int _currentTakenReward_LEGENDARY = 0;

		private static int MyTokens = 0;

		private static bool _tokenSyncReceived;

		private static Dictionary<string, int> _playerTokens = new Dictionary<string, int>();

		private static ShopData _shopData = new ShopData();

		private static string ShopPath;

		private static string TokensPath;

		private static string TokensControlPath;

		private static string ShopJSON;

		private static string OneTimePurchasesPath;

		private static Dictionary<string, List<string>> _oneTimePurchases = new Dictionary<string, List<string>>();

		private static ConfigEntry<int> HourTokensAmount;

		private const string GUID = "Forteca_ServerRewards";

		private const string VERSION = "1.2.0";

		private static Forteca_ServerRewards _thistype;

		private static AssetBundle asset;

		private static FileSystemWatcher fsw;

		private static Dictionary<string, Sprite> ShopIcons = new Dictionary<string, Sprite>();

		private static ConfigEntry<KeyCode> Hotkey;

		private static string _localUserID;

		private static DailyRewardData _dailyRewardData = new DailyRewardData();

		private static string DailyLoginPath;

		private static string DailyLoginJSON;

		private static DailyRewardData _dailyRewardData_PREMIUM = new DailyRewardData();

		private static string DailyLoginPath_PREMIUM;

		private static string DailyLoginJSON_PREMIUM;

		private static DailyRewardData _dailyRewardData_EPIC = new DailyRewardData();

		private static string DailyLoginPath_EPIC;

		private static string DailyLoginJSON_EPIC;

		private static DailyRewardData _dailyRewardData_LEGENDARY = new DailyRewardData();

		private static string DailyLoginPath_LEGENDARY;

		private static string DailyLoginJSON_LEGENDARY;

		private static List<string> _adminUsers = new List<string>();

		private static List<string> _premiumUsers = new List<string>();

		private static List<string> _epicUsers = new List<string>();

		private static List<string> _legendaryUsers = new List<string>();

		private static bool IsServer => (int)SystemInfo.graphicsDeviceType == 4;

		private static bool _isServer => (int)SystemInfo.graphicsDeviceType == 4;

		internal static string CurrentUserID => _localUserID;

		private static void InitKitsServer()
		{
			KitsPath = Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards", "KitsData.cfg");
			if (!Directory.Exists(Path.GetDirectoryName(KitsPath)))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(KitsPath));
			}
			if (!File.Exists(KitsPath))
			{
				File.Create(KitsPath).Dispose();
			}
			ReadKitsData();
		}

		private static void ReadKitsData()
		{
			_kits = new List<KitData>();
			string[] array = File.ReadAllLines(KitsPath);
			KitData kitData = new KitData();
			for (int i = 0; i < array.Length; i++)
			{
				if (!string.IsNullOrWhiteSpace(array[i]) && !array[i].StartsWith("#"))
				{
					if (array[i].StartsWith("["))
					{
						string[] array2 = array[i].Trim(new char[1] { '[' }).Trim(new char[1] { ']' }).Split(new char[1] { ':' });
						kitData = new KitData
						{
							Name = array2[0],
							Group = array2[1],
							Cooldown = int.Parse(array2[2])
						};
						_kits.Add(kitData);
					}
					else
					{
						kitData.Items.Add(array[i].Replace(" ", ""));
					}
				}
			}
			KitsJSON = JSON.ToJSON(_kits);
			MonoBehaviour.print((object)KitsJSON);
		}

		private static void OnKitsChange()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			MonoBehaviour.print((object)"[Forteca ServerRewards] Kits Changed. Sending to all players.");
			ReadKitsData();
			foreach (ZNetPeer peer in ValheimCompat.GetPeers())
			{
				ZPackage val = new ZPackage();
				val.Write(KitsJSON);
				val.Compress();
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_ServerRewards Kits", new object[1] { val });
			}
		}

		private static void InitShopServerSide()
		{
			HourTokensAmount = ((BaseUnityPlugin)_thistype).Config.Bind<int>("Shop", "HourTokensAmount", 10, "How many tokens you get per hour");
			ShopPath = Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards", "ShopData.cfg");
			TokensPath = Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards", "PlayerTokens.json");
			TokensControlPath = Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards", "AddTokensToPlayer.txt");
			OneTimePurchasesPath = Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards", "OneTimePurchases.data");
			if (!Directory.Exists(Path.GetDirectoryName(ShopPath)))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(ShopPath));
			}
			if (!File.Exists(ShopPath))
			{
				File.Create(ShopPath).Dispose();
			}
			if (!File.Exists(TokensPath))
			{
				File.Create(TokensPath).Dispose();
			}
			if (!File.Exists(TokensControlPath))
			{
				File.Create(TokensControlPath).Dispose();
			}
			if (!File.Exists(OneTimePurchasesPath))
			{
				File.Create(OneTimePurchasesPath).Dispose();
			}
			if (!string.IsNullOrEmpty(File.ReadAllText(TokensPath)))
			{
				_playerTokens = JSON.ToObject<Dictionary<string, int>>(File.ReadAllText(TokensPath));
			}
			else
			{
				SaveTokens();
			}
			if (!string.IsNullOrEmpty(File.ReadAllText(OneTimePurchasesPath)))
			{
				_oneTimePurchases = JSON.ToObject<Dictionary<string, List<string>>>(File.ReadAllText(OneTimePurchasesPath));
			}
			else
			{
				SaveOneTimePurchases();
			}
			ReadShopData();
		}

		private static void SaveOneTimePurchases()
		{
			File.WriteAllText(OneTimePurchasesPath, JSON.ToJSON(_oneTimePurchases));
		}

		private static void SaveTokens()
		{
			File.WriteAllText(TokensPath, JSON.ToNiceJSON(_playerTokens));
		}

		private static void ReadShopData()
		{
			_shopData = new ShopData();
			string[] array = File.ReadAllLines(ShopPath);
			ShopData.ShopSlot shopSlot = null;
			for (int i = 0; i < array.Length; i++)
			{
				if (string.IsNullOrWhiteSpace(array[i]) || array[i].StartsWith("#"))
				{
					continue;
				}
				if (array[i].StartsWith("["))
				{
					string[] array2 = array[i].Replace("[", "").Replace("]", "").Split(new char[1] { '=' });
					if (array2.Length >= 4)
					{
						shopSlot = new ShopData.ShopSlot();
						shopSlot.Name = array2[0];
						shopSlot.Cost = int.Parse(array2[1]);
						shopSlot.Color = array2[2];
						shopSlot.OneTime = bool.Parse(array2[3]);
						if (array2.Length > 4)
						{
							shopSlot.icon = array2[4];
						}
						_shopData.ShopSlots.Add(shopSlot);
					}
				}
				else
				{
					string[] array3 = array[i].Replace(" ", "").Split(new char[1] { ',' });
					if (array3.Length == 2)
					{
						ShopData.ShopSlot.ShopItem shopItem = new ShopData.ShopSlot.ShopItem();
						shopItem.Prefab = array3[0];
						shopItem.Amount = int.Parse(array3[1]);
						shopSlot.Items.Add(shopItem);
					}
				}
			}
			ShopJSON = JSON.ToNiceJSON(_shopData);
		}

		private static void OnShopChange()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			MonoBehaviour.print((object)"[Forteca ServerRewards] Shop Changed. Sending to all players.");
			ReadShopData();
			ZPackage val = new ZPackage();
			val.Write(ShopJSON);
			val.Compress();
			foreach (ZNetPeer peer in ValheimCompat.GetPeers())
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_Shop Accept", new object[1] { val });
			}
		}

		private static void OnTokensChange()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			string text = File.ReadAllText(TokensControlPath);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split(new char[1] { ' ' });
			File.WriteAllText(TokensControlPath, string.Empty);
			if (array.Length == 2)
			{
				string text2 = array[0];
				int num = int.Parse(array[1]);
				if (_playerTokens.ContainsKey(text2))
				{
					_playerTokens[text2] += num;
					_playerTokens[text2] = Mathf.Clamp(_playerTokens[text2], 0, int.MaxValue);
				}
				else
				{
					_playerTokens.Add(text2, num);
				}
				LogsModule.Log($"Added {num} tokens to {text2}. Current balance: {_playerTokens[text2]} (Admin File)");
				SaveTokens();
				ZNetPeer peerByHostName = ZNet.instance.GetPeerByHostName(text2);
				if (peerByHostName != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(peerByHostName.m_uid, "Forteca_Shop Tokens", new object[1] { _playerTokens[text2] });
				}
			}
		}

		private void Awake()
		{
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			_thistype = this;
			PluginLogger = ((BaseUnityPlugin)this).Logger;
			ExternalAssetSystem.Init();
			RedeemSystem.Init((BaseUnityPlugin)(object)this);
			AdminSuite.Init();
			asset = GetAssetBundle("forteca_serverrewards");
			Hotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Hotkeys", "Open Shop", (KeyCode)290, "Open the shop menu");
			new Item(asset.LoadAsset<GameObject>("ServerTokens")).Configurable = Configurability.Disabled;
			FortecaPaths.EnsureFreshStructure();
			if (IsServer)
			{
				InitServerSide();
				InitShopServerSide();
				InitKitsServer();
				LogsModule.Init();
				fsw = new FileSystemWatcher(Path.Combine(Paths.ConfigPath, "Forteca_ServerRewards"))
				{
					Filter = "*.*",
					EnableRaisingEvents = true,
					IncludeSubdirectories = true,
					SynchronizingObject = ThreadingHelper.SynchronizingObject
				};
				fsw.Changed += DataChanged;
				MonoBehaviour.print((object)"[Leaderboard] FSW started");
			}
			else
			{
				RewardsUI.Init();
				string path = Path.Combine(FortecaPaths.Assets, "Icons", "Rewards");
				if (!Directory.Exists(path))
				{
					Directory.CreateDirectory(path);
				}
				string[] files = Directory.GetFiles(path);
				foreach (string path2 in files)
				{
					try
					{
						byte[] array = File.ReadAllBytes(path2);
						Texture2D val = new Texture2D(2, 2);
						ImageConversion.LoadImage(val, array);
						Sprite value = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.zero);
						ShopIcons.Add(Path.GetFileNameWithoutExtension(path2), value);
					}
					catch (Exception ex)
					{
						MonoBehaviour.print((object)ex);
					}
				}
			}
			new Harmony("Forteca_ServerRewards").PatchAll();
		}

		internal static void ReloadExternalAssetsFromAdmin()
		{
			ExternalAssetSystem.Reload();
			RewardsUI.RefreshExternalIcons();
		}

		internal static void RefreshAccessAfterAdminEdit()
		{
			try
			{
				_adminUsers = SteamIdAccess.AdminUsers();
				_premiumUsers = SteamIdAccess.PremiumUsers();
				_epicUsers = SteamIdAccess.EpicUsers();
				_legendaryUsers = SteamIdAccess.LegendaryUsers();
				RewardsUI.RefreshAdminTabVisibility();
			}
			catch (Exception ex)
			{
				LogsModule.Log("Failed to refresh access lists after admin edit: " + ex.Message);
			}
		}

		private static void CheckUserID()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			_localUserID = ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID.m_userID;
			if (string.IsNullOrWhiteSpace(_localUserID))
			{
				_localUserID = "ERROR";
			}
			MonoBehaviour.print((object)("User ID found: " + _localUserID));
			RewardsUI.RefreshAdminTabVisibility();
		}

		private void DataChanged(object sender, FileSystemEventArgs e)
		{
			if (e.ChangeType != WatcherChangeTypes.Changed || !ValheimCompat.Exists((Object)(object)ZNetScene.instance))
			{
				return;
			}
			string fileName = Path.GetFileName(e.Name);
			if (fileName == null)
			{
				return;
			}
			switch (fileName.Length)
			{
			case 12:
				switch (fileName[0])
				{
				case 'S':
					if (fileName == "ShopData.cfg")
					{
						DelayedAction(OnShopChange);
					}
					break;
				case 'K':
					if (fileName == "KitsData.cfg")
					{
						DelayedAction(OnKitsChange);
					}
					break;
				}
				break;
			case 20:
				if (!(fileName == "DailyRewardsData.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 28:
				if (!(fileName == "DailyRewardsData_PREMIUM.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 25:
				if (!(fileName == "DailyRewardsData_EPIC.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 30:
				if (!(fileName == "DailyRewardsData_LEGENDARY.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 14:
				if (!(fileName == "AdminUsers.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 16:
				if (!(fileName == "PremiumUsers.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 13:
				if (!(fileName == "EpicUsers.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 18:
				if (!(fileName == "LegendaryUsers.cfg"))
				{
					break;
				}
				goto IL_016b;
			case 21:
				if (fileName == "AddTokensToPlayer.txt")
				{
					DelayedAction(OnTokensChange, 1f);
				}
				break;
			case 15:
			case 17:
			case 19:
			case 22:
			case 23:
			case 24:
			case 26:
			case 27:
			case 29:
				break;
				IL_016b:
				DelayedAction(OnRewardsChange);
				break;
			}
		}

		private static IEnumerator DelayedActionRoutine(Action action, float time)
		{
			yield return (object)new WaitForSecondsRealtime(time);
			action?.Invoke();
		}

		private static void DelayedAction(Action action, float time = 3f)
		{
			if (action != null)
			{
				((MonoBehaviour)_thistype).StartCoroutine(DelayedActionRoutine(action, time));
			}
		}

		private void Update()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)27) && RewardsUI.IsVisible())
			{
				RewardsUI.Hide();
				Menu instance = Menu.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.OnClose();
				}
			}
			if (Input.GetKeyDown(Hotkey.Value))
			{
				RewardsUI.Show();
			}
		}

		private static AssetBundle GetAssetBundle(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}

		private static void InitServerSide()
		{
			DailyLoginPath = FortecaPaths.DailyConfigPath;
			EnsureDailyRewardFile(DailyLoginPath, "Daily");
			ReadDailyLogin();
			DailyLoginPath_PREMIUM = FortecaPaths.PremiumConfigPath;
			EnsureDailyRewardFile(DailyLoginPath_PREMIUM, "Premium");
			ReadDailyLogin_PREMIUM();
			DailyLoginPath_EPIC = FortecaPaths.EpicConfigPath;
			EnsureDailyRewardFile(DailyLoginPath_EPIC, "Epic");
			ReadDailyLogin_EPIC();
			DailyLoginPath_LEGENDARY = FortecaPaths.LegendaryConfigPath;
			EnsureDailyRewardFile(DailyLoginPath_LEGENDARY, "Legendary");
			ReadDailyLogin_LEGENDARY();
		}

		private static void ReadDailyLogin()
		{
			_dailyRewardData = ReadDailyRewardFile(DailyLoginPath, "Daily");
			FortecaPaths.LogConfigStatus("Daily", DailyLoginPath, (_dailyRewardData != null && _dailyRewardData.Rewards != null) ? _dailyRewardData.Rewards.Count : 0);
			DailyLoginJSON = JSON.ToJSON(_dailyRewardData);
		}

		private static void ReadDailyLogin_PREMIUM()
		{
			_dailyRewardData_PREMIUM = ReadDailyRewardFile(DailyLoginPath_PREMIUM, "Premium");
			FortecaPaths.LogConfigStatus("Premium", DailyLoginPath_PREMIUM, (_dailyRewardData_PREMIUM != null && _dailyRewardData_PREMIUM.Rewards != null) ? _dailyRewardData_PREMIUM.Rewards.Count : 0);
			DailyLoginJSON_PREMIUM = JSON.ToJSON(_dailyRewardData_PREMIUM);
		}

		private static void ReadDailyLogin_EPIC()
		{
			_dailyRewardData_EPIC = ReadDailyRewardFile(DailyLoginPath_EPIC, "Epic");
			FortecaPaths.LogConfigStatus("Epic", DailyLoginPath_EPIC, (_dailyRewardData_EPIC != null && _dailyRewardData_EPIC.Rewards != null) ? _dailyRewardData_EPIC.Rewards.Count : 0);
			DailyLoginJSON_EPIC = JSON.ToJSON(_dailyRewardData_EPIC);
		}

		private static void ReadDailyLogin_LEGENDARY()
		{
			_dailyRewardData_LEGENDARY = ReadDailyRewardFile(DailyLoginPath_LEGENDARY, "Legendary");
			FortecaPaths.LogConfigStatus("Legendary", DailyLoginPath_LEGENDARY, (_dailyRewardData_LEGENDARY != null && _dailyRewardData_LEGENDARY.Rewards != null) ? _dailyRewardData_LEGENDARY.Rewards.Count : 0);
			DailyLoginJSON_LEGENDARY = JSON.ToJSON(_dailyRewardData_LEGENDARY);
		}

		private static DailyRewardData ReadDailyRewardFile(string path, string fallbackName)
		{
			int tier = (string.Equals(fallbackName, "Premium", StringComparison.OrdinalIgnoreCase) ? 1 : (string.Equals(fallbackName, "Epic", StringComparison.OrdinalIgnoreCase) ? 2 : (string.Equals(fallbackName, "Legendary", StringComparison.OrdinalIgnoreCase) ? 3 : 0)));
			FortecaDailyDataService.Load((FortecaUiRewardTier)tier);
			FortecaDailyDataService.DailyData dailyData = FortecaDailyDataService.Get((FortecaUiRewardTier)tier);
			DailyRewardData dailyRewardData = new DailyRewardData
			{
				Name = dailyData.Name,
				Cooldown = dailyData.Cooldown,
				Rewards = new List<string>()
			};
			if (dailyData.Rewards != null)
			{
				dailyRewardData.Rewards.AddRange(from r in dailyData.Rewards.Take(28)
					select (r == null) ? "" : r.ToCsv());
			}
			return dailyRewardData;
		}

		private static void EnsureDailyRewardFile(string path, string category)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrWhiteSpace(directoryName) && !Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			if (!File.Exists(path) || File.ReadAllLines(path).Length == 0)
			{
				LogsModule.Log("[ServerRewards Config] Missing " + category + " path: " + path);
				FortecaPaths.EnsureTextFile(path, category + ",86400" + Environment.NewLine + string.Join(Environment.NewLine, Enumerable.Repeat("Wood,1", 28)) + Environment.NewLine);
			}
		}

		private static void OnRewardsChange()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			MonoBehaviour.print((object)"[Forteca ServerRewards] Rewards Changed. Sending to all players.");
			FortecaPaths.EnsureFreshStructure();
			ReadDailyLogin();
			ReadDailyLogin_PREMIUM();
			ReadDailyLogin_EPIC();
			ReadDailyLogin_LEGENDARY();
			string text = JSON.ToJSON(SteamIdAccess.AdminUsers());
			string text2 = JSON.ToJSON(SteamIdAccess.PremiumUsers());
			string text3 = JSON.ToJSON(SteamIdAccess.EpicUsers());
			string text4 = JSON.ToJSON(SteamIdAccess.LegendaryUsers());
			foreach (ZNetPeer peer in ValheimCompat.GetPeers())
			{
				ZPackage val = new ZPackage();
				val.Write(text);
				val.Write(DailyLoginJSON);
				val.Write(text2);
				val.Write(DailyLoginJSON_PREMIUM);
				val.Write(text3);
				val.Write(DailyLoginJSON_EPIC);
				val.Write(text4);
				val.Write(DailyLoginJSON_LEGENDARY);
				val.Compress();
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "Forteca_ServerRewards Accept", new object[1] { val });
			}
		}
	}
	public static class LogsModule
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch
		{
			private static void Postfix(ZNetScene __instance)
			{
				ZRoutedRpc.instance.Register<string>("UL ServerRewards Log", (Action<long, string>)delegate(long _, string msg)
				{
					Log(msg);
				});
			}
		}

		private static string logFile;

		public static void Init()
		{
			EnsureLogPath();
		}

		public static void SendLogsToSS(string message)
		{
			try
			{
				if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ValheimCompat.GetServerPeerID(), "UL ServerRewards Log", new object[1] { message ?? "" });
					return;
				}
			}
			catch
			{
			}
			Log(message);
		}

		public static void Log(string message)
		{
			try
			{
				if (EnsureLogPath())
				{
					message = $"[{DateTime.Now}] {message}";
					File.AppendAllText(logFile, message + Environment.NewLine);
				}
			}
			catch
			{
			}
		}

		private static bool EnsureLogPath()
		{
			try
			{
				if (string.IsNullOrWhiteSpace(logFile))
				{
					logFile = FortecaPaths.LogPath;
				}
				string directoryName = Path.GetDirectoryName(logFile);
				if (string.IsNullOrWhiteSpace(directoryName))
				{
					return false;
				}
				Directory.CreateDirectory(directoryName);
				if (!File.Exists(logFile))
				{
					File.Create(logFile).Dispose();
				}
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class RedeemSystem
	{
		private sealed class InFlightRedeem
		{
			public string Code = "";

			public string SteamID = "";

			public string PlayerName = "";

			public long Sender;

			public DateTime ExpiresUtc;
		}

		public sealed class RedeemCodesData
		{
			public List<RedeemCode> Codes = new List<RedeemCode>();
		}

		public sealed class RedeemCode
		{
			public string Code = "";

			public bool Disabled;

			public int MaxUses = 1;

			public string ExpirationUtc = "";

			public bool OneTimePerSteamID = true;

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

			public int Used;

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

			public List<RedeemReward> Rewards = new List<RedeemReward>();
		}

		public sealed class RedeemReward
		{
			public string Prefab = "";

			public int Amount = 1;

			public int Quality = 1;

			public int Variant;
		}

		public sealed class RedeemClaimsData
		{
			public List<RedeemClaim> Claims = new List<RedeemClaim>();
		}

		public sealed class RedeemClaim
		{
			public string Code = "";

			public string SteamID = "";

			public string PlayerName = "";

			public string DateUtc = "";

			public string Result = "";
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__24_0;

			public static Func<RedeemCode, bool> <>9__25_0;

			public static Func<KeyValuePair<string, InFlightRedeem>, string> <>9__45_1;

			internal void <RenderPlayerPage>b__24_0()
			{
				ClientRequestRedeem(((Object)(object)codeInput != (Object)null) ? codeInput.text : "");
			}

			internal bool <HasRedeemCodesForDisplay>b__25_0(RedeemCode code)
			{
				if (code != null)
				{
					return !code.Disabled;
				}
				return false;
			}

			internal string <CleanupInFlight>b__45_1(KeyValuePair<string, InFlightRedeem> kv)
			{
				return kv.Key;
			}
		}

		private const string RpcRequest = "Forteca_SR Redeem Request";

		private const string RpcGrant = "Forteca_SR Redeem Grant";

		private const string RpcAck = "Forteca_SR Redeem Ack";

		private const string RpcResult = "Forteca_SR Redeem Result";

		private static readonly object fileLock = new object();

		private static readonly Dictionary<string, InFlightRedeem> inFlight = new Dictionary<string, InFlightRedeem>(StringComparer.OrdinalIgnoreCase);

		private static string dataFolder;

		private static string codesPath;

		private static string claimsPath;

		private static bool requestRegistered;

		private static bool grantRegistered;

		private static bool ackRegistered;

		private static bool resultRegistered;

		private static RedeemCodesData codesData = new RedeemCodesData();

		private static RedeemClaimsData claimsData = new RedeemClaimsData();

		private static InputField codeInput;

		private static Text statusText;

		private static Button redeemButton;

		internal static string CodesPath => codesPath;

		internal static string ClaimsPath => claimsPath;

		internal static void Init(BaseUnityPlugin plugin)
		{
			FortecaPaths.EnsureFreshStructure();
			dataFolder = FortecaPaths.EditableRedeem;
			codesPath = FortecaPaths.RedeemCodesPath;
			claimsPath = FortecaPaths.RedeemClaimsPath;
		}

		internal static void RegisterRpcHandlers()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null)
			{
				return;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				EnsureServerFilesLoaded();
				if (!requestRegistered)
				{
					instance.Register<string>("Forteca_SR Redeem Request", (Action<long, string>)OnRedeemRequestServer);
					requestRegistered = true;
				}
				if (!ackRegistered)
				{
					instance.Register<string, bool>("Forteca_SR Redeem Ack", (Action<long, string, bool>)OnRedeemAckServer);
					ackRegistered = true;
				}
			}
			if (!grantRegistered)
			{
				instance.Register<ZPackage>("Forteca_SR Redeem Grant", (Action<long, ZPackage>)OnGrantClient);
				grantRegistered = true;
			}
			if (!resultRegistered)
			{
				instance.Register<bool, string>("Forteca_SR Redeem Result", (Action<long, bool, string>)OnRedeemResultClient);
				resultRegistered = true;
			}
		}

		internal static void RenderPlayerPage(GameObject root, Text header)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Clear(root.transform);
			RectTransform component = root.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
			}
			VerticalLayoutGroup component2 = root.GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			ContentSizeFitter component3 = root.GetComponent<ContentSizeFitter>();
			if ((Object)(object)component3 != (Object)null)
			{
				((Behaviour)component3).enabled = false;
			}
			Font font = (((Object)(object)header != (Object)null) ? header.font : Resources.GetBuiltinResource<Font>("Arial.ttf"));
			GameObject obj = CreateAnchoredPanel(root.transform, "Redeem_ContentPanel", new Color(0.02f, 0.015f, 0.01f, 0.1f), new Vector2(1320f, 360f), new Vector2(0f, 126f));
			GameObject obj2 = CreateAnchoredPanel(obj.transform, "Redeem_InputCard", new Color(0.025f, 0.018f, 0.012f, 0.82f), new Vector2(710f, 340f), new Vector2(-310f, 0f));
			CreateAnchoredText(obj2.transform, font, "Redeem Codes", 28, (TextAnchor)4, Color.white, new Vector2(640f, 40f), new Vector2(0f, 134f));
			CreateOverlayText(CreateAnchoredPanel(obj2.transform, "Redeem_DescriptionPanel", new Color(0.02f, 0.015f, 0.01f, 0.74f), new Vector2(620f, 54f), new Vector2(0f, 78f)).transform, font, "Redeem special rewards using codes distributed through Discord, community events, giveaways and administrators.", 15, (TextAnchor)4, new Color(0.86f, 0.8f, 0.68f, 1f));
			CreateAnchoredText(obj2.transform, font, "Reward Code", 17, (TextAnchor)4, Color.white, new Vector2(620f, 24f), new Vector2(0f, 18f));
			codeInput = CreateInput(obj2.transform, font, 600f, 52f, "ENTER-CODE-HERE");
			SetAnchoredRect(((Component)codeInput).GetComponent<RectTransform>(), new Vector2(600f, 50f), new Vector2(0f, -26f));
			redeemButton = CreateButton(obj2.transform, font, "Redeem Reward", 320f, 54f);
			SetAnchoredRect(((Component)redeemButton).GetComponent<RectTransform>(), new Vector2(320f, 50f), new Vector2(0f, -84f));
			((UnityEventBase)redeemButton.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = redeemButton.onClick;
			object obj3 = <>c.<>9__24_0;
			if (obj3 == null)
			{
				UnityAction val = delegate
				{
					ClientRequestRedeem(((Object)(object)codeInput != (Object)null) ? codeInput.text : "");
				};
				<>c.<>9__24_0 = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			CreateAnchoredText(obj2.transform, font, "Status", 16, (TextAnchor)4, Color.white, new Vector2(620f, 22f), new Vector2(0f, -126f));
			GameObject obj4 = CreateAnchoredPanel(obj2.transform, "Redeem_StatusPanel", new Color(0.04f, 0.03f, 0.02f, 0.84f), new Vector2(620f, 44f), new Vector2(0f, -154f));
			string text = (HasRedeemCodesForDisplay() ? "Enter a reward code." : "No redeem codes available.");
			statusText = CreateOverlayText(obj4.transform, font, text, 15, (TextAnchor)4, Color.yellow);
			CreateAnchoredText(obj2.transform, font, "Need help? Verify the code and contact a server administrator if the problem continues.", 13, (TextAnchor)4, new Color(0.78f, 0.72f, 0.62f, 1f), new Vector2(620f, 24f), new Vector2(0f, -180f));
			GameObject obj5 = CreateAnchoredPanel(obj.transform, "Redeem_InfoCard", new Color(0.025f, 0.018f, 0.012f, 0.82f), new Vector2(540f, 340f), new Vector2(330f, 0f));
			CreateAnchoredText(obj5.transform, font, "Code Types", 24, (TextAnchor)4, Color.white, new Vector2(480f, 36f), new Vector2(0f, 134f));
			string value = "PUBLIC CODES - available to all players, usually one use per account.\nEVENT CODES - distributed during community events or competitions.\nGIVEAWAY CODES - shared through Discord, streams or giveaways.\nSUPPORTER CODES - reserved for eligible supporter rewards.\nLIMITED CODES - may expire, have global limits or restricted access.\nADMIN CODES - created for testing, compensation or special grants.\n\nCodes may be case-sensitive depending on configuration. Successful redemption grants items directly through the reward system.";
			CreateAnchoredText(obj5.transform, font, value, 13, (TextAnchor)0, new Color(0.86f, 0.8f, 0.68f, 1f), new Vector2(480f, 178f), new Vector2(0f, 26f));
			CreateOverlayText(CreateAnchoredPanel(obj5.transform, "Redeem_ExamplePanel", new Color(0.04f, 0.03f, 0.02f, 0.84f), new Vector2(480f, 68f), new Vector2(0f, -130f)).transform, font, "Example Public Code: Forteca-Fehu\nReward: 100 Coins, 25 Wood, 25 Stone\nAvailability: One use per Steam account", 14, (TextAnchor)4, new Color(1f, 0.86f, 0.38f, 1f));
			SetStatus(text, success: false, neutral: true);
		}

		private static bool HasRedeemCodesForDisplay()
		{
			try
			{
				if (string.IsNullOrWhiteSpace(codesPath) || !File.Exists(codesPath))
				{
					return false;
				}
				string text = File.ReadAllText(codesPath);
				if (string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				RedeemCodesData redeemCodesData = JSON.ToObject<RedeemCodesData>(text);
				return redeemCodesData != null && redeemCodesData.Codes != null && redeemCodesData.Codes.Any((RedeemCode code) => code != null && !code.Disabled);
			}
			catch
			{
				return false;
			}
		}

		internal static void ClientRequestRedeem(string code)
		{
			code = (code ?? "").Trim();
			if (string.IsNullOrEmpty(code))
			{
				SetStatus("Enter a reward code.", success: false, neutral: true);
				return;
			}
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
			if (val == null)
			{
				SetStatus("Redeem server is not available.", success: false);
				return;
			}
			SetStatus("Checking code...", success: false, neutral: true);
			if ((Object)(object)redeemButton != (Object)null)
			{
				((Selectable)redeemButton).interactable = false;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(val.m_uid, "Forteca_SR Redeem Request", new object[1] { code });
		}

		private static void OnRedeemRequestServer(long sender, string rawCode)
		{
			RegisterRpcHandlers();
			string code = NormalizeCode(rawCode);
			string peerSteamId = GetPeerSteamId(sender);
			string peerName = GetPeerName(sender);
			if (string.IsNullOrEmpty(peerSteamId))
			{
				SendResult(sender, success: false, "Unable to identify player.");
				Log("Redeem failure: unknown player for code " + code);
				return;
			}
			lock (fileLock)
			{
				EnsureServerFilesLoaded();
				CleanupInFlight();
				RedeemCode redeemCode = codesData.Codes.FirstOrDefault((RedeemCode c) => string.Equals(c.Code, code, StringComparison.OrdinalIgnoreCase));
				if (redeemCode == null)
				{
					SendResult(sender, success: false, "Code does not exist.");
					Log("Redeem failure: invalid code '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					AdminSuite.NotifyWebhook("Redeem Failure", peerName + " (" + peerSteamId + ") tried invalid code " + code);
					return;
				}
				if (redeemCode.Disabled)
				{
					SendResult(sender, success: false, "Code disabled.");
					Log("Redeem failure: disabled code '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					AdminSuite.NotifyWebhook("Redeem Failure", peerName + " (" + peerSteamId + ") tried disabled code " + code);
					return;
				}
				if (IsExpired(redeemCode))
				{
					SendResult(sender, success: false, "Code expired.");
					Log("Redeem expired: '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					AdminSuite.NotifyWebhook("Redeem Failure", peerName + " (" + peerSteamId + ") tried expired code " + code);
					return;
				}
				if (redeemCode.AllowedSteamIDs.Count > 0 && !redeemCode.AllowedSteamIDs.Contains<string>(peerSteamId, StringComparer.OrdinalIgnoreCase))
				{
					SendResult(sender, success: false, "SteamID not allowed.");
					Log("Redeem failure: restricted code '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					return;
				}
				if (redeemCode.MaxUses > 0 && redeemCode.Used >= redeemCode.MaxUses)
				{
					SendResult(sender, success: false, "Usage limit reached.");
					Log("Redeem failure: max uses reached for '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					return;
				}
				if (redeemCode.OneTimePerSteamID && redeemCode.ClaimedSteamIDs.Contains<string>(peerSteamId, StringComparer.OrdinalIgnoreCase))
				{
					SendResult(sender, success: false, "You already redeemed this code.");
					Log("Redeem duplicate claim: '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					AdminSuite.NotifyWebhook("Redeem Failure", peerName + " (" + peerSteamId + ") duplicate claim for " + code);
					return;
				}
				if (redeemCode.Rewards.Count == 0)
				{
					SendResult(sender, success: false, "Reward configuration invalid.");
					Log("Redeem failure: no rewards for '" + code + "' by " + peerName + " (" + peerSteamId + ")");
					return;
				}
				string text = FindInvalidPrefab(redeemCode);
				if (!string.IsNullOrEmpty(text))
				{
					SendResult(sender, success: false, "Reward configuration invalid.");
					Log("Redeem invalid prefab: '" + text + "' in code '" + code + "'");
					return;
				}
				string key = ClaimKey(code, peerSteamId);
				if (inFlight.ContainsKey(key))
				{
					SendResult(sender, success: false, "Reward configuration invalid.");
					return;
				}
				inFlight[key] = new InFlightRedeem
				{
					Code = code,
					SteamID = peerSteamId,
					PlayerName = peerName,
					Sender = sender,
					ExpiresUtc = DateTime.UtcNow.AddSeconds(60.0)
				};
				SendGrant(sender, redeemCode);
			}
		}

		private static void OnRedeemAckServer(long sender, string rawCode, bool delivered)
		{
			string code = NormalizeCode(rawCode);
			string peerSteamId = GetPeerSteamId(sender);
			string key = ClaimKey(code, peerSteamId);
			lock (fileLock)
			{
				if (!inFlight.TryGetValue(key, out var value) || value.Sender != sender)
				{
					SendResult(sender, success: false, "Redeem confirmation was invalid.");
					return;
				}
				inFlight.Remove(key);
				if (!delivered)
				{
					SendResult(sender, success: false, "Rewards could not be delivered.");
					Log("Redeem failure: client delivery failed for '" + code + "' by " + value.PlayerName + " (" + peerSteamId + ")");
					AdminSuite.NotifyWebhook("Redeem Failure", value.PlayerName + " (" + peerSteamId + ") delivery failed for " + code);
					return;
				}
				RedeemCode redeemCode = codesData.Codes.FirstOrDefault((RedeemCode c) => string.Equals(c.Code, code, StringComparison.OrdinalIgnoreCase));
				if (redeemCode == null)
				{
					SendResult(sender, success: false, "Code does not exist.");
					return;
				}
				if (!redeemCode.ClaimedSteamIDs.Contains<string>(peerSteamId, StringComparer.OrdinalIgnoreCase))
				{
					redeemCode.ClaimedSteamIDs.Add(peerSteamId);
				}
				redeemCode.Used++;
				claimsData.Claims.Add(new RedeemClaim
				{
					Code = redeemCode.Code,
					SteamID = peerSteamId,
					PlayerName = value.PlayerName,
					DateUtc = DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
					Result = "Claimed"
				});
				SaveServerFiles();
				SendResult(sender, success: true, "Code redeemed successfully.");
				Log("Redeem success: '" + code + "' by " + value.PlayerName + " (" + peerSteamId + ")");
				AdminSuite.NotifyWebhook("Redeem Success", value.PlayerName + " (" + peerSteamId + ") redeemed " + code);
			}
		}

		private static void OnGrantClient(long sender, ZPackage pkg)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
			if (val == null || sender != val.m_uid)
			{
				return;
			}
			string text = pkg.ReadString();
			bool flag = true;
			try
			{
				Player localPlayer = Player.m_localPlayer;
				Inventory inventory = ValheimCompat.GetInventory((Humanoid)(object)localPlayer);
				int num = pkg.ReadInt();
				for (int i = 0; i < num; i++)
				{
					RedeemReward reward = new RedeemReward
					{
						Prefab = pkg.ReadString(),
						Amount = pkg.ReadInt(),
						Quality = pkg.ReadInt(),
						Variant = pkg.ReadInt()
					};
					if (!GiveReward(localPlayer, inventory, reward))
					{
						flag = false;
					}
				}
			}
			catch
			{
				flag = false;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(val.m_uid, "Forteca_SR Redeem Ack", new object[2] { text, flag });
		}

		private static void OnRedeemResultClient(long sender, bool success, string message)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
			if (val == null || sender == val.m_uid)
			{
				if ((Object)(object)redeemButton != (Object)null)
				{
					((Selectable)redeemButton).interactable = true;
				}
				string text = FriendlyRedeemMessage(success, message);
				SetStatus(text, success);
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					((Character)localPlayer).Message((MessageType)(success ? 1 : 2), text, 0, (Sprite)null);
				}
			}
		}

		private static string FriendlyRedeemMessage(bool success, string message)
		{
			if (success)
			{
				return "Code redeemed successfully.";
			}
			string text = (message ?? "").Trim();
			switch (text)
			{
			case "Code does not exist.":
			case "Code disabled.":
			case "You already redeemed this code.":
			case "Code expired.":
			case "Usage limit reached.":
			case "SteamID not allowed.":
			case "Reward configuration invalid.":
				return text;
			default:
			{
				string text2 = text.ToLowerInvariant();
				if (text2.Contains("disabled"))
				{
					return "Code disabled.";
				}
				if (text2.Contains("expired"))
				{
					return "Code expired.";
				}
				if (text2.Contains("already"))
				{
					return "You already redeemed this code.";
				}
				if (text2.Contains("usage") || text2.Contains("maximum") || text2.Contains("max uses"))
				{
					return "Usage limit reached.";
				}
				if (text2.Contains("steamid") || text2.Contains("eligible") || text2.Contains("assigned") || text2.Contains("identify"))
				{
					return "SteamID not allowed.";
				}
				if (text2.Contains("reward") || text2.Contains("prefab") || text2.Contains("inventory") || text2.Contains("delivery") || text2.Contains("processing"))
				{
					return "Reward configuration invalid.";
				}
				return "Code does not exist.";
			}
			}
		}

		private static bool GiveReward(Player localPlayer, Inventory inventory, RedeemReward reward)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)localPlayer == (Object)null || inventory == null || reward == null || string.IsNullOrWhiteSpace(reward.Prefab) || reward.Amount <= 0)
			{
				return false;
			}
			ObjectDB instance = ObjectDB.instance;
			object obj = ((instance != null) ? instance.GetItemPrefab(reward.Prefab) : null);
			if (obj == null)
			{
				ZNetScene instance2 = ZNetScene.instance;
				obj = ((instance2 != null) ? instance2.GetPrefab(reward.Prefab) : null);
			}
			GameObject val = (GameObject)obj;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
			{
				return false;
			}
			int num = reward.Amount;
			int num2 = Mathf.Max(1, component.m_itemData.m_shared.m_maxStackSize);
			while (num > 0)
			{
				int num3 = Mathf.Min(num, num2);
				num -= num3;
				ItemData val2 = component.m_itemData.Clone();
				val2.m_dropPrefab = val;
				val2.m_stack = num3;
				val2.m_quality = Mathf.Max(1, reward.Quality);
				val2.m_variant = Mathf.Max(0, reward.Variant);
				if (inventory.CanAddItem(val2, val2.m_stack))
				{
					inventory.AddItem(val2);
					continue;
				}
				Vector3 val3 = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.25f + Vector3.up * 0.5f;
				ItemDrop.DropItem(val2, num3, val3, Quaternion.identity);
			}
			return true;
		}

		private static void SendGrant(long sender, RedeemCode redeemCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(redeemCode.Code);
			val.Write(redeemCode.Rewards.Count);
			foreach (RedeemReward reward in redeemCode.Rewards)
			{
				val.Write(reward.Prefab ?? "");
				val.Write(reward.Amount);
				val.Write(reward.Quality);
				val.Write(reward.Variant);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_SR Redeem Grant", new object[1] { val });
		}

		private static void SendResult(long sender, bool success, string message)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Forteca_SR Redeem Result", new object[2]
			{
				success,
				message ?? ""
			});
		}

		private static void EnsureServerFilesLoaded()
		{
			FortecaPaths.EnsureFreshStructure();
			Directory.CreateDirectory(dataFolder);
			Directory.CreateDirectory(Path.GetDirectoryName(claimsPath));
			if (!File.Exists(codesPath))
			{
				codesData = SampleCodes();
				SaveCodes();
			}
			else
			{
				try
				{
					string text = File.ReadAllText(codesPath);
					codesData = (string.IsNullOrWhiteSpace(text) ? SampleCodes() : JSON.ToObject<RedeemCodesData>(text));
					if ((codesData == null || codesData.Codes == null || codesData.Codes.Count == 0) && LooksLikeAnonymousFastJson(codesPath))
					{
						string text2 = Path.Combine(FortecaPaths.Root, "Redeem", "RedeemCodes.json");
						if (File.Exists(text2))
						{
							RedeemCodesData redeemCodesData = JSON.ToObject<RedeemCodesData>(File.ReadAllText(text2));
							if (redeemCodesData != null && redeemCodesData.Codes != null && redeemCodesData.Codes.Count > 0)
							{
								codesData = redeemCodesData;
								Log("Redeem fresh file contains no Codes data, using legacy readable file: " + text2);
							}
						}
					}
				}
				catch (Exception ex)
				{
					Log("Failed to parse redeem codes: " + ex.Message);
					codesData = SampleCodes();
				}
				if (codesData == null)
				{
					codesData = new RedeemCodesData();
				}
				if (codesData.Codes == null)
				{
					codesData.Codes = new List<RedeemCode>();
				}
			}
			if (!File.Exists(claimsPath))
			{
				claimsData = new RedeemClaimsData();
				SaveClaims();
				return;
			}
			try
			{
				string text3 = File.ReadAllText(claimsPath);
				claimsData = (string.IsNullOrWhiteSpace(text3) ? new RedeemClaimsData() : JSON.ToObject<RedeemClaimsData>(text3));
			}
			catch (Exception ex2)
			{
				Log("Failed to parse redeem claim history: " + ex2.Message);
				claimsData = new RedeemClaimsData();
			}
			if (claimsData == null)
			{
				claimsData = new RedeemClaimsData();
			}
			if (claimsData.Claims == null)
			{
				claimsData.Claims = new List<RedeemClaim>();
			}
		}

		private static bool LooksLikeAnonymousFastJson(string path)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
				{
					return false;
				}
				string text = File.ReadAllText(path);
				return text.Contains("$types") && text.Contains("<>f__AnonymousType") && !text.Contains("\"Codes\"");
			}
			catch
			{
				return false;
			}
		}

		private static RedeemCodesData SampleCodes()
		{
			return new RedeemCodesData
			{
				Codes = new List<RedeemCode>
				{
					new RedeemCode
					{
						Code = "FORTECA-FEHU",
						Disabled = false,
						MaxUses = 0,
						OneTimePerSteamID = true,
						Rewards = new List<RedeemReward>
						{
							new RedeemReward
							{
								Prefab = "Coins",
								Amount = 100,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "Wood",
								Amount = 25,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "Stone",
								Amount = 25,
								Quality = 1,
								Variant = 0
							}
						}
					},
					new RedeemCode
					{
						Code = "FORTECA-WELCOME",
						Disabled = false,
						MaxUses = 0,
						OneTimePerSteamID = true,
						Rewards = new List<RedeemReward>
						{
							new RedeemReward
							{
								Prefab = "Wood",
								Amount = 100,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "Stone",
								Amount = 100,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "Resin",
								Amount = 50,
								Quality = 1,
								Variant = 0
							}
						}
					},
					new RedeemCode
					{
						Code = "FORTECA-VIKING",
						Disabled = false,
						MaxUses = 0,
						OneTimePerSteamID = true,
						Rewards = new List<RedeemReward>
						{
							new RedeemReward
							{
								Prefab = "Coins",
								Amount = 250,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "CookedMeat",
								Amount = 20,
								Quality = 1,
								Variant = 0
							},
							new RedeemReward
							{
								Prefab = "Honey",
								Amount = 20,
								Quality = 1,
								Variant = 0
							}
						}
					}
				}
			};
		}

		private static void SaveServerFiles()
		{
			SaveCodes();
			SaveClaims();
		}

		private static void SaveCodes()
		{
			File.WriteAllText(codesPath, JSON.ToNiceJSON(codesData));
		}

		private static void SaveClaims()
		{
			File.WriteAllText(claimsPath, JSON.ToNiceJSON(claimsData));
		}

		private static string NormalizeCode(string code)
		{
			return (code ?? "").Trim().ToUpperInvariant();
		}

		private static string ClaimKey(string code, string steamId)
		{
			return NormalizeCode(code) + "|" + steamId;
		}

		private static bool IsExpired(RedeemCode code)
		{
			if (string.IsNullOrWhiteSpace(code.ExpirationUtc))
			{
				return false;
			}
			if (DateTime.TryParse(code.ExpirationUtc, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out var result))
			{
				return DateTime.UtcNow > result;
			}
			return false;
		}

		private static string FindInvalidPrefab(RedeemCode code)
		{
			foreach (RedeemReward reward in code.Rewards)
			{
				ObjectDB instance = ObjectDB.instance;
				object obj = ((instance != null) ? instance.GetItemPrefab(reward.Prefab) : null);
				if (obj == null)
				{
					ZNetScene instance2 = ZNetScene.instance;
					obj = ((instance2 != null) ? instance2.GetPrefab(reward.Prefab) : null);
				}
				GameObject val = (GameObject)obj;
				if ((Object)(object)val == (Object)null || (Object)(object)val.GetComponent<ItemDrop>() == (Object)null)
				{
					return reward.Prefab;
				}
			}
			return null;
		}

		private static void CleanupInFlight()
		{
			DateTime now = DateTime.UtcNow;
			foreach (string item in (from kv in inFlight
				where kv.Value.ExpiresUtc < now
				select kv.Key).ToList())
			{
				inFlight.Remove(item);
			}
		}

		private static string GetPeerSteamId(long sender)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer obj = ((instance != null) ? instance.GetPeer(sender) : null);
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				ZRpc rpc = obj.m_rpc;
				if (rpc == null)
				{
					obj2 = null;
				}
				else
				{
					ISocket socket = rpc.GetSocket();
					obj2 = ((socket != null) ? socket.GetHostName() : null);
				}
			}
			if (obj2 == null)
			{
				obj2 = "";
			}
			return (string)obj2;
		}

		private static string GetPeerName(long sender)
		{
			ZNet instance = ZNet.instance;
			return ((instance == null) ? null : instance.GetPeer(sender)?.m_playerName) ?? "";
		}

		private static void SetStatus(string message, bool success)
		{
			SetStatus(message, success, neutral: false);
		}

		private static void SetStatus(string message, bool success, bool neutral)
		{
			if ((Object)(object)statusText != (Object)null)
			{
				if (neutral)
				{
					statusText.text = "<color=yellow>" + message + "</color>";
				}
				else
				{
					statusText.text = (success ? ("<color=green>" + message + "</color>") : ("<color=red>" + message + "</color>"));
				}
			}
		}

		private static void Log(string message)
		{
			try
			{
				LogsModule.Log(message);
			}
			catch
			{
				Debug.Log((object)("[Forteca_ServerRewards Redeem] " + message));
			}
		}

		private static InputField CreateInput(Transform parent, Font font, float width, float height, string placeholderText)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			GameObject val = CreateUiObject("Redeem_CodeInput", parent);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.05f, 0.035f, 0.025f, 0.95f);
			InputField val2 = val.AddComponent<InputField>();
			Text textComponent = CreateOverlayText(val.transform, font, "", 19, (TextAnchor)3, Color.white);
			Text val3 = CreateOverlayText(val.transform, font, placeholderText, 18, (TextAnchor)3, new Color(0.75f, 0.68f, 0.58f, 0.8f));
			val2.textComponent = textComponent;
			val2.placeholder = (Graphic)val3;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = width;
			obj.preferredHeight = height;
			return val2;
		}

		private static Button CreateButton(Transform parent, Font font, string label, float width, float height)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject("Redeem_Button", parent);
			((Graphic)obj.AddComponent<Image>()).color = new Color(0.24f, 0.13f, 0.055f, 0.95f);
			Button result = obj.AddComponent<Button>();
			CreateOverlayText(obj.transform, font, label, 18, (TextAnchor)4, Color.white);
			LayoutElement obj2 = obj.AddComponent<LayoutElement>();
			obj2.preferredWidth = width;
			obj2.preferredHeight = height;
			return result;
		}

		private static GameObject CreatePanel(Transform parent, string name, Color color, float width, float height)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject(name, parent);
			((Graphic)obj.AddComponent<Image>()).color = color;
			LayoutElement obj2 = obj.AddComponent<LayoutElement>();
			obj2.preferredWidth = width;
			obj2.preferredHeight = height;
			return obj;
		}

		private static Text CreateSizedText(Transform parent, Font font, string value, int size, TextAnchor anchor, Color color, float width, float height)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Text obj = CreateText(parent, font, value, size, anchor);
			((Graphic)obj).color = color;
			LayoutElement component = ((Component)obj).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.preferredWidth = width;
				component.preferredHeight = height;
			}
			return obj;
		}

		private static GameObject CreateAnchoredPanel(Transform parent, string name, Color color, Vector2 size, Vector2 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePanel(parent, name, color, size.x, size.y);
			SetAnchoredRect(obj.GetComponent<RectTransform>(), size, position);
			return obj;
		}

		private static Text CreateAnchoredText(Transform parent, Font font, string value, int size, TextAnchor anchor, Color color, Vector2 rectSize, Vector2 position)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Text obj = CreateText(parent, font, value, size, anchor);
			((Graphic)obj).color = color;
			obj.horizontalOverflow = (HorizontalWrapMode)0;
			obj.verticalOverflow = (VerticalWrapMode)1;
			SetAnchoredRect(((Component)obj).GetComponent<RectTransform>(), rectSize, position);
			LayoutElement component = ((Component)obj).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.preferredWidth = rectSize.x;
				component.preferredHeight = rectSize.y;
			}
			return obj;
		}

		private static void SetAnchoredRect(RectTransform rect, Vector2 size, Vector2 position)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				rect.anchorMin = new Vector2(0.5f, 0.5f);
				rect.anchorMax = new Vector2(0.5f, 0.5f);
				rect.pivot = new Vector2(0.5f, 0.5f);
				rect.sizeDelta = size;
				rect.anchoredPosition = position;
				rect.offsetMin = new Vector2(position.x - size.x * 0.5f, position.y - size.y * 0.5f);
				rect.offsetMax = new Vector2(position.x + size.x * 0.5f, position.y + size.y * 0.5f);
			}
		}

		private static Text CreateOverlayText(Transform parent, Font font, string value, int size, TextAnchor anchor, Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Text obj = CreateText(parent, font, value, size, anchor);
			((Graphic)obj).color = color;
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(14f, 6f);
			component.offsetMax = new Vector2(-14f, -6f);
			LayoutElement component2 = ((Component)obj).GetComponent<LayoutElement>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			return obj;
		}

		private static Text CreateText(Transform parent, Font font, string value, int size, TextAnchor anchor)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject("Text", parent);
			Text val = obj.AddComponent<Text>();
			val.font = font;
			val.fontSize = size;
			val.alignment = anchor;
			val.supportRichText = true;
			((Graphic)val).color = Color.white;
			val.text = value;
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(8f, 4f);
			component.offsetMax = new Vector2(-8f, -4f);
			obj.AddComponent<LayoutElement>().preferredHeight = 28f;
			return val;
		}

		private static GameObject CreateUiObject(string name, Transform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			return val;
		}

		private static void Clear(Transform parent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in parent)
			{
				Transform val = item;
				list.Add(((Component)val).gameObject);
			}
			foreach (GameObject item2 in list)
			{
				Object.Destroy((Object)(object)item2);
			}
		}
	}
	internal static class SteamIdAccess
	{
		public const string BuiltInPrimary = "76561198007625196";

		public const string BuiltInSecondary = "76561199693548808";

		private static readonly HashSet<string> BuiltIns = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "76561198007625196", "76561199693548808" };

		private static readonly HashSet<string> LoggedInvalid = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static bool IsValidSteamId64(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return Regex.IsMatch(value.Trim(), "^[0-9]{17}$");
			}
			return false;
		}

		public static bool IsBuiltIn(string steamId)
		{
			if (!string.IsNullOrWhiteSpace(steamId))
			{
				return BuiltIns.Contains(steamId.Trim());
			}
			return false;
		}

		public static bool HasAdmin(string steamId)
		{
			return HasAccess(steamId, FortecaPaths.AdminUsersPath, includeBuiltIns: true);
		}

		public static bool HasPremium(string steamId)
		{
			if (!IsBuiltIn(steamId))
			{
				if (IsInAccessFile(steamId, FortecaPaths.PremiumUsersPath) && !IsInAccessFile(steamId, FortecaPaths.EpicUsersPath))
				{
					return !IsInAccessFile(steamId, FortecaPaths.LegendaryUsersPath);
				}
				return false;
			}
			return true;
		}

		public static bool HasEpic(string steamId)
		{
			if (!IsBuiltIn(steamId))
			{
				if (IsInAccessFile(steamId, FortecaPaths.EpicUsersPath))
				{
					return !IsInAccessFile(steamId, FortecaPaths.LegendaryUsersPath);
				}
				return false;
			}
			return true;
		}

		public static bool HasLegendary(string steamId)
		{
			if (!IsBuiltIn(steamId))
			{
				return IsInAccessFile(steamId, FortecaPaths.LegendaryUsersPath);
			}
			return true;
		}

		public static List<string> AdminUsers()
		{
			return AuthorizedUsers(FortecaPaths.AdminUsersPath, includeBuiltIns: true);
		}

		public static List<string> PremiumUsers()
		{
			return AuthorizedUsers(FortecaPaths.PremiumUsersPath, includeBuiltIns: false);
		}

		public static List<string> EpicUsers()
		{
			return AuthorizedUsers(FortecaPaths.EpicUsersPath, includeBuiltIns: false);
		}

		public static List<string> LegendaryUsers()
		{
			return AuthorizedUsers(FortecaPaths.LegendaryUsersPath, includeBuiltIns: false);
		}

		private static bool IsInAccessFile(string steamId, string path)
		{
			steamId = (steamId ?? "").Trim();
			if (!IsValidSteamId64(steamId))
			{
				return false;
			}
			return AuthorizedUsers(path, includeBuiltIns: false).Contains<string>(steamId, StringComparer.OrdinalIgnoreCase);
		}

		private static bool HasAccess(string steamId, string path, bool includeBuiltIns)
		{
			steamId = (steamId ?? "").Trim();
			if (!IsValidSteamId64(steamId))
			{
				return false;
			}
			if (includeBuiltIns && IsBuiltIn(steamId))
			{
				return true;
			}
			return AuthorizedUsers(path, includeBuiltIns).Contains<string>(steamId, StringComparer.OrdinalIgnoreCase);
		}

		private static List<string> AuthorizedUsers(string path, bool includeBuiltIns)
		{
			HashSet<string> hashSet = (includeBuiltIns ? new HashSet<string>(BuiltIns, StringComparer.OrdinalIgnoreCase) : new HashSet<string>(StringComparer.OrdinalIgnoreCase));
			try
			{
				FortecaPaths.EnsureTextFile(path, "# One SteamID64 per line." + Environment.NewLine);
				if (File.Exists(path))
				{
					string[] array = File.ReadAllLines(path);
					for (int i = 0; i < array.Length; i++)
					{
						string text = (array[i] ?? "").Trim();
						if (text.Length != 0 && !text.StartsWith("#"))
						{
							if (IsValidSteamId64(text))
							{
								hashSet.Add(text);
							}
							else if (LoggedInvalid.Add(path + ":" + text))
							{
								LogsModule.Log("Skipped invalid SteamID64 entry in " + path + ": " + text);
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogsModule.Log("Failed to read SteamID64 access file " + path + ": " + ex.Message);
			}
			return hashSet.OrderBy((string x) => x).ToList();
		}
	}
	internal abstract class RewardsPageBase
	{
		public string Id { get; }

		public string Title { get; }

		public bool AdminOnly { get; }

		protected RewardsPageBase(string id, string title, bool adminOnly = false)
		{
			Id = id;
			Title = title;
			AdminOnly = adminOnly;
		}

		public abstract void Render();
	}
	internal sealed class DelegateRewardsPage : RewardsPageBase
	{
		private readonly Action<RewardsPageBase> render;

		public DelegateRewardsPage(string id, string title, Action<RewardsPageBase> render, bool adminOnly = false)
			: base(id, title, adminOnly)
		{
			this.render = render;
		}

		public override void Render()
		{
			render(this);
		}
	}
	internal sealed class TabButton
	{
		private readonly Image targetImage;

		private readonly Color inactiveColor;

		private readonly Color activeColor;

		public string PageId { get; }

		public Button Button { get; }

		public TabButton(string pageId, Button button, Image targetImage, Color inactiveColor, Color activeColor)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			PageId = pageId;
			Button = button;
			this.targetImage = targetImage;
			this.inactiveColor = inactiveColor;
			this.activeColor = activeColor;
		}

		public void Bind(UnityAction action)
		{
			((UnityEventBase)Button.onClick).RemoveAllListeners();
			((UnityEvent)Button.onClick).AddListener(action);
		}

		public void SetIcon(Sprite sprite)
		{
			if ((Object)(object)sprite != (Object)null && (Object)(object)targetImage != (Object)null)
			{
				targetImage.sprite = sprite;
			}
		}

		public void SetActive(bool active)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetImage != (Object)null)
			{
				((Graphic)targetImage).color = (active ? activeColor : inactiveColor);
			}
		}
	}
	internal sealed class PageContainer
	{
		public GameObject Root { get; }

		public PageContainer(GameObject root)
		{
			Root = root;
		}

		public void Show()
		{
			Root.SetActive(true);
		}

		public void Hide()
		{
			Root.SetActive(false);
		}
	}
	internal sealed class ScrollArea
	{
		public Transform Content { get; }

		public ScrollArea(Transform content)
		{
			Content = content;
		}

		public void Clear()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in Content)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
		}
	}
	internal sealed class IconButton
	{
		public Button Button { get; }

		public Image Icon { get; }

		public IconButton(Button button, Image icon)
		{
			Button = button;
			Icon = icon;
		}
	}
	internal sealed class Header
	{
		public Text Text { get; }

		public Header(Text text)
		{
			Text = text;
		}

		public void Set(string value)
		{
			Text.text = value;
		}
	}
	internal sealed class Tooltip
	{
		public UITooltip TooltipComponent { get; }

		public Tooltip(UITooltip tooltip)
		{
			TooltipComponent = tooltip;
		}

		public void Set(string topic, string text)
		{
			TooltipComponent.m_topic = topic;
			TooltipComponent.m_text = text;
		}
	}
	internal sealed class IconRegistry
	{
		private readonly Dictionary<string, Sprite> icons = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private readonly Sprite fallback;

		public IconRegistry(Sprite fallback)
		{
			this.fallback = fallback;
		}

		public void Register(string key, Sprite sprite)
		{
			if (!string.IsNullOrEmpty(key) && (Object)(object)sprite != (Object)null)
			{
				icons[key] = sprite;
			}
		}

		public void RegisterOptionalAsset(AssetBundle bundle, string key, params string[] assetNames)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return;
			}
			foreach (string text in assetNames)
			{
				try
				{
					Sprite val = bundle.LoadAsset<Sprite>(text);
					if ((Object)(object)val != (Object)null)
					{
						Register(key, val);
						break;
					}
				}
				catch
				{
				}
			}
		}

		public Sprite Get(string key)
		{
			if (!string.IsNullOrEmpty(key) && icons.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return ExternalAssetSystem.GetIcon(key, value);
			}
			return ExternalAssetSystem.GetIcon(key, fallback);
		}
	}
}
namespace ItemManager
{
	public enum Configurability
	{
		Disabled,
		Recipe,
		Drop,
		Full
	}
	public sealed class Item
	{
		public Configurability Configurable { get; set; }

		public GameObject Prefab { get; }

		public Item(GameObject prefab)
		{
			Prefab = prefab;
		}
	}
}