using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using HarmonyLib;
using Il2Cpp;
using Il2CppFishNet;
using Il2CppFishNet.Connection;
using Il2CppFishNet.Object;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne;
using Il2CppScheduleOne.Building.Doors;
using Il2CppScheduleOne.Core.Items.Framework;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Dialogue;
using Il2CppScheduleOne.Doors;
using Il2CppScheduleOne.Economy;
using Il2CppScheduleOne.Effects;
using Il2CppScheduleOne.Employees;
using Il2CppScheduleOne.EntityFramework;
using Il2CppScheduleOne.Equipping;
using Il2CppScheduleOne.GameTime;
using Il2CppScheduleOne.Growing;
using Il2CppScheduleOne.Interaction;
using Il2CppScheduleOne.ItemFramework;
using Il2CppScheduleOne.Law;
using Il2CppScheduleOne.Levelling;
using Il2CppScheduleOne.Management;
using Il2CppScheduleOne.Map;
using Il2CppScheduleOne.Messaging;
using Il2CppScheduleOne.Misc;
using Il2CppScheduleOne.Money;
using Il2CppScheduleOne.NPCs;
using Il2CppScheduleOne.NPCs.Behaviour;
using Il2CppScheduleOne.NPCs.CharacterClasses;
using Il2CppScheduleOne.ObjectScripts;
using Il2CppScheduleOne.Packaging;
using Il2CppScheduleOne.Persistence;
using Il2CppScheduleOne.Persistence.Datas;
using Il2CppScheduleOne.PlayerScripts;
using Il2CppScheduleOne.Police;
using Il2CppScheduleOne.Product;
using Il2CppScheduleOne.Product.Packaging;
using Il2CppScheduleOne.Property;
using Il2CppScheduleOne.Quests;
using Il2CppScheduleOne.StationFramework;
using Il2CppScheduleOne.Storage;
using Il2CppScheduleOne.Tiles;
using Il2CppScheduleOne.Trash;
using Il2CppScheduleOne.UI;
using Il2CppScheduleOne.UI.ATM;
using Il2CppScheduleOne.UI.Handover;
using Il2CppScheduleOne.UI.Items;
using Il2CppScheduleOne.UI.Phone;
using Il2CppScheduleOne.UI.Phone.ContactsApp;
using Il2CppScheduleOne.UI.Phone.Delivery;
using Il2CppScheduleOne.UI.Phone.Messages;
using Il2CppScheduleOne.UI.Phone.ProductManagerApp;
using Il2CppScheduleOne.UI.Shop;
using Il2CppScheduleOne.UI.Stations;
using Il2CppScheduleOne.UI.Stations.Drying_rack;
using Il2CppScheduleOne.Variables;
using Il2CppScheduleOne.Vehicles;
using Il2CppScheduleOne.Vehicles.Modification;
using Il2CppScheduleOne.Vision;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using Lithium;
using Lithium.Helper;
using Lithium.Modules;
using Lithium.Modules.Banking;
using Lithium.Modules.BrickPress;
using Lithium.Modules.ChemistryStation;
using Lithium.Modules.Customers;
using Lithium.Modules.Customers.Architecture;
using Lithium.Modules.Customers.Behaviours;
using Lithium.Modules.Customers.BonusPayments;
using Lithium.Modules.Customers.Patches;
using Lithium.Modules.Dealers;
using Lithium.Modules.Dealers.Architecture;
using Lithium.Modules.DryingRacks;
using Lithium.Modules.EffectCombos;
using Lithium.Modules.EffectCombos.BonusPayments;
using Lithium.Modules.ElectricBill;
using Lithium.Modules.Employees;
using Lithium.Modules.Employees.ProductionOrders;
using Lithium.Modules.EndOfDayFreeze;
using Lithium.Modules.LabOven;
using Lithium.Modules.MixingStations;
using Lithium.Modules.PhoneApp;
using Lithium.Modules.PlantGrowth;
using Lithium.Modules.PlantGrowth.Behaviours;
using Lithium.Modules.Police;
using Lithium.Modules.Police.Contraband;
using Lithium.Modules.Police.PoliceEntry;
using Lithium.Modules.Police.PropertyContraband;
using Lithium.Modules.Products;
using Lithium.Modules.PropertyPrices;
using Lithium.Modules.Rent;
using Lithium.Modules.Repairs;
using Lithium.Modules.Shops;
using Lithium.Modules.StackSizes;
using Lithium.Modules.Storyline;
using Lithium.Modules.TrashGrabber;
using Lithium.Modules.Vehicles;
using Lithium.Modules.Warehouse;
using Lithium.Modules.WateringCans;
using Lithium.Modules.Weapons;
using Lithium.Util;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "Lithium", "1.4.0", "DerTomDer & YukiSora", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: MelonOptionalDependencies(new string[] { "ModManager&PhoneApp" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Lithium")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e2be586eaee486cf2bafe4d9e662842f5c3fc404")]
[assembly: AssemblyProduct("Lithium")]
[assembly: AssemblyTitle("Lithium")]
[assembly: NeutralResourcesLanguage("en-US")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Lithium
{
	public class Core : MelonMod
	{
		public static readonly List<ModuleBase> Modules = new List<ModuleBase>(27)
		{
			new ModPropertyPrices(),
			new ModPlants(),
			new ModDryingRacks(),
			new ModCustomers(),
			new ModStackSizes(),
			new ModLabOven(),
			new ModTrashGrabber(),
			new ModMixingStations(),
			new ModStoryline(),
			new ModShops(),
			new ModEmployees(),
			new ModChemistryStation(),
			new ModWateringCan(),
			new ModEffectCombos(),
			new ModVehicles(),
			new ModEndOfDayFreeze(),
			new ModProducts(),
			new ModBanking(),
			new ModElectricBill(),
			new ModRent(),
			new ModBrickPress(),
			new ModDealers(),
			new ModRepairs(),
			new ModWeapons(),
			new ModWarehouse(),
			new ModPolice(),
			new ModPhoneApp()
		};

		private bool _isFirstStart = true;

		public static Instance Logger { get; set; }

		public static bool IsInMainScene { get; private set; }

		public static T Get<T>() where T : ModuleBase
		{
			return Modules.OfType<T>().FirstOrDefault();
		}

		public override void OnInitializeMelon()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			Logger = ((MelonBase)this).LoggerInstance;
			LithiumConfig.Load();
			foreach (ModuleBase module in Modules)
			{
				Log.Info("Loading " + module.GetType().Name);
				module.Load();
			}
			Harmony val = new Harmony("com.lithium");
			val.PatchAll();
			LithiumModMenu.Initialize();
			Log.Info("Lithium initialized");
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			if (sceneName == "Main")
			{
				foreach (ModuleBase module in Modules)
				{
					Log.Info("Loading " + module.GetType().Name);
					module.Apply();
				}
				_isFirstStart = false;
				IsInMainScene = true;
			}
			else if (sceneName.Equals("Menu", StringComparison.OrdinalIgnoreCase) && !_isFirstStart)
			{
				_isFirstStart = true;
				IsInMainScene = false;
			}
		}

		public override void OnPreferencesSaved()
		{
			LithiumModMenu.OnPreferencesSaved();
		}

		public static void ReloadConfiguration()
		{
			Log.Warning("[Lithium] Reloading all configuration...");
			LithiumConfig.Load();
			foreach (ModuleBase module in Modules)
			{
				try
				{
					module.Load();
				}
				catch (Exception value)
				{
					Log.Error($"[Lithium] {module.GetType().Name}.Load() failed during reload: {value}");
				}
			}
			if (IsInMainScene)
			{
				foreach (ModuleBase module2 in Modules)
				{
					try
					{
						module2.Apply();
					}
					catch (Exception value2)
					{
						Log.Error($"[Lithium] {module2.GetType().Name}.Apply() failed during reload: {value2}");
					}
				}
			}
			Log.Warning(IsInMainScene ? "[Lithium] Configuration reloaded and reapplied." : "[Lithium] Configuration reloaded (no save loaded — runtime reapply skipped).");
		}

		public override void OnUpdate()
		{
			((MelonBase)this).OnUpdate();
			Get<ModPhoneApp>()?.DriveUpdate();
			Get<ModPolice>()?.DriveUpdate();
			Get<ModElectricBill>()?.DriveUpdate();
			Get<ModRent>()?.DriveUpdate();
			Get<ModProducts>()?.DriveUpdate();
			Get<ModEmployees>()?.DriveUpdate();
		}
	}
	public class LithiumConfig
	{
		public bool Debug = false;

		public static LithiumConfig Instance { get; private set; } = new LithiumConfig();

		private static string ConfigFolder => Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");

		private static string FilePath => Path.Combine(ConfigFolder, "Lithium.json");

		public static void Load()
		{
			try
			{
				if (File.Exists(FilePath))
				{
					JsonConvert.PopulateObject(File.ReadAllText(FilePath), (object)Instance);
				}
				Save();
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[Lithium] Failed to load Lithium.json: " + ex.Message);
			}
		}

		public static void Save()
		{
			try
			{
				Directory.CreateDirectory(ConfigFolder);
				File.WriteAllText(FilePath, JsonConvert.SerializeObject((object)Instance, (Formatting)1));
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[Lithium] Failed to save Lithium.json: " + ex.Message);
			}
		}
	}
	public static class LithiumModMenu
	{
		private sealed class Tool
		{
			public readonly string Name;

			public readonly bool RequiresSave;

			public readonly Action Run;

			public Tool(string name, bool requiresSave, Action run)
			{
				Name = name;
				RequiresSave = requiresSave;
				Run = run;
			}
		}

		private const string GeneralId = "Lithium_General";

		private static MelonPreferences_Category _generalCategory;

		private static MelonPreferences_Entry<bool> _debugEntry;

		private static readonly List<Tool> Tools = new List<Tool>();

		private static readonly List<Action> RootedHandlers = new List<Action>();

		public static void Initialize()
		{
			try
			{
				_generalCategory = MelonPreferences.CreateCategory("Lithium_General", "Lithium - General");
				_debugEntry = _generalCategory.CreateEntry<bool>("Debug", LithiumConfig.Instance.Debug, "Debug logging", "Verbose Log.Info output to the MelonLoader console.", false, false, (ValueValidator)null, (string)null);
				_debugEntry.Value = LithiumConfig.Instance.Debug;
				_generalCategory.SaveToFile(false);
				BuildToolTable();
				TryHookModManager();
				Log.Info("[Lithium] Mod Manager menu initialized.");
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] Mod Manager menu init failed: {value}");
			}
		}

		private static void BuildToolTable()
		{
			Tools.Clear();
			Tools.Add(new Tool("Reload & reapply all configs", requiresSave: false, Core.ReloadConfiguration));
			Tools.Add(new Tool("Dump rent / dead-drop info", requiresSave: true, RentDebug.Dump));
			Tools.Add(new Tool("Dump buildables / appliances", requiresSave: true, BuildablesDebug.Dump));
			Tools.Add(new Tool("Dump RV furniture", requiresSave: true, RVFurnitureDebug.Dump));
			Tools.Add(new Tool("Dump customer order patterns", requiresSave: true, OrderPatternDebug.Dump));
			Tools.Add(new Tool("Dump NPC roster", requiresSave: true, NpcRosterDebug.Dump));
			Tools.Add(new Tool("Dump police contraband scan", requiresSave: true, PoliceContrabandDebug.Dump));
			Tools.Add(new Tool("Expand Veeper storage", requiresSave: true, ExpandVeeperStorage));
			Tools.Add(new Tool("Toggle rent lockout (test)", requiresSave: true, delegate
			{
				Core.Get<ModRent>()?.DebugToggleLockout();
			}));
		}

		public static void OnPreferencesSaved()
		{
			if (_debugEntry != null && _debugEntry.Value != LithiumConfig.Instance.Debug)
			{
				LithiumConfig.Instance.Debug = _debugEntry.Value;
				LithiumConfig.Save();
				Log.Warning("[Lithium] Debug logging " + (_debugEntry.Value ? "enabled" : "disabled") + " via Mod Manager.");
			}
		}

		private static void TryHookModManager()
		{
			//IL_006e: 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_0083: Expected O, but got Unknown
			try
			{
				Type type = AccessTools.TypeByName("ModManagerPhoneApp.ModSettingsAppCreator");
				if (type == null)
				{
					Log.Info("[Lithium] ModManager app not installed — tool buttons unavailable.");
					return;
				}
				MethodInfo methodInfo = AccessTools.Method(type, "PopulateModSettings", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Log.Warning("[Lithium] ModManager.PopulateModSettings not found — tool buttons unavailable.");
					return;
				}
				MethodInfo method = typeof(LithiumModMenu).GetMethod("InjectToolButtons", BindingFlags.Static | BindingFlags.NonPublic);
				new Harmony("com.lithium.modmenu").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Log.Info("[Lithium] ModManager tool-button hook applied.");
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] Could not hook the ModManager UI: " + ex.Message);
			}
		}

		private static void InjectToolButtons(object __instance, MelonBase __0)
		{
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object obj;
				if (__0 == null)
				{
					obj = null;
				}
				else
				{
					MelonInfoAttribute info = __0.Info;
					obj = ((info != null) ? info.Name : null);
				}
				if ((string?)obj != "Lithium")
				{
					return;
				}
				GameObject value = Traverse.Create(__instance).Field("modManagerAppInstance").GetValue<GameObject>();
				if ((Object)(object)value == (Object)null)
				{
					return;
				}
				Transform val = value.transform.Find("RightPanel/ConfigPanel/Viewport/Content");
				Transform val2 = value.transform.Find("RightPanel/SaveButton");
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					return;
				}
				RootedHandlers.Clear();
				GameObject value2 = Traverse.Create(__instance).Field("categoryTemplate").GetValue<GameObject>();
				if ((Object)(object)value2 != (Object)null)
				{
					GameObject val3 = Object.Instantiate<GameObject>(value2, val);
					((Object)val3).name = "Lithium_ToolsHeader";
					Transform val4 = val3.transform.Find("Title");
					if ((Object)(object)val4 != (Object)null)
					{
						TMP_Text component = ((Component)val4).GetComponent<TMP_Text>();
						if ((Object)(object)component != (Object)null)
						{
							component.SetText("Debug Tools (press to run)");
						}
					}
					val3.SetActive(true);
				}
				foreach (Tool tool in Tools)
				{
					GameObject val5 = Object.Instantiate<GameObject>(((Component)val2).gameObject, val);
					((Object)val5).name = "Lithium_Tool_" + tool.Name;
					val5.transform.localScale = Vector3.one;
					Button component2 = val5.GetComponent<Button>();
					if ((Object)(object)component2 == (Object)null)
					{
						Object.Destroy((Object)(object)val5);
						continue;
					}
					((UnityEventBase)component2.onClick).RemoveAllListeners();
					TMP_Text componentInChildren = val5.GetComponentInChildren<TMP_Text>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.SetText(tool.Name);
						componentInChildren.enableAutoSizing = true;
						componentInChildren.fontSizeMin = 6f;
					}
					LayoutElement val6 = val5.GetComponent<LayoutElement>();
					if ((Object)(object)val6 == (Object)null)
					{
						val6 = val5.AddComponent<LayoutElement>();
					}
					val6.minHeight = 48f;
					val6.preferredHeight = 48f;
					val6.flexibleWidth = 1f;
					Tool captured = tool;
					Action action = delegate
					{
						RunTool(captured);
					};
					RootedHandlers.Add(action);
					((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit(action));
					val5.SetActive(true);
				}
			}
			catch (Exception value3)
			{
				Log.Error($"[Lithium] Injecting tool buttons failed: {value3}");
			}
		}

		private static void RunTool(Tool tool)
		{
			if (tool.RequiresSave && !Core.IsInMainScene)
			{
				Log.Warning("[Lithium] '" + tool.Name + "' needs a loaded save — load a game first.");
				return;
			}
			try
			{
				Log.Warning("[Lithium] Running '" + tool.Name + "' from Mod Manager.");
				tool.Run();
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] '{tool.Name}' failed: {value}");
			}
		}

		private static void ExpandVeeperStorage()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			LandVehicle[] array = (from v in (IEnumerable<LandVehicle>)NetworkSingleton<VehicleManager>.Instance.AllVehicles.ToArray()
				where v.IsPlayerOwned
				where v.VehicleCode == "veeper"
				select v).ToArray();
			LandVehicle[] array2 = array;
			foreach (LandVehicle val in array2)
			{
				val.Storage.SlotCount = 20;
				for (int num2 = val.Storage.ItemSlots.Count; num2 <= val.Storage.SlotCount; num2++)
				{
					val.Storage.ItemSlots.Add(new ItemSlot());
				}
			}
		}
	}
	public static class Log
	{
		public static bool DebugEnabled => LithiumConfig.Instance.Debug;

		public static void Info(string message)
		{
			if (LithiumConfig.Instance.Debug)
			{
				MelonLogger.Msg(message);
			}
		}

		public static void Warning(string message)
		{
			MelonLogger.Warning(message);
		}

		public static void Error(string message)
		{
			MelonLogger.Error(message);
		}
	}
}
namespace Lithium.Util
{
	public static class DeliveryUtils
	{
		public static void ApplyDeliveryOverrides()
		{
			Dictionary<string, DeliveryShop> dictionary = (from s in ((IEnumerable<DeliveryShop>)Object.FindObjectsOfType<DeliveryShop>(true)).ToList()
				where (Object)(object)s != (Object)null && (Object)(object)s.MatchingShop != (Object)null
				select s).ToDictionary((DeliveryShop s) => s.MatchingShop.ShopName, (DeliveryShop s) => s);
			ModShopsConfiguration configuration = Core.Get<ModShops>().Configuration;
			foreach (KeyValuePair<string, DeliverySettings> delivery in configuration.Deliveries)
			{
				if (!dictionary.TryGetValue(delivery.Key, out var value))
				{
					continue;
				}
				bool flag;
				switch (delivery.Value.Availability)
				{
				case DeliveryAvailabilitySettings.Unchanged:
					switch (value.MatchingShop.ShopName)
					{
					case "Albert Hoover":
					{
						Albert val3 = Object.FindObjectOfType<Albert>();
						value.AvailableByDefault = ((NPC)val3).RelationData.RelationDelta > Supplier.DELIVERY_RELATIONSHIP_REQUIREMENT;
						break;
					}
					case "Shirley Watts":
					{
						Shirley val2 = Object.FindObjectOfType<Shirley>();
						value.AvailableByDefault = ((NPC)val2).RelationData.RelationDelta > Supplier.DELIVERY_RELATIONSHIP_REQUIREMENT;
						break;
					}
					case "Salvador Moreno":
					{
						Salvador val = Object.FindObjectOfType<Salvador>();
						value.AvailableByDefault = ((NPC)val).RelationData.RelationDelta > Supplier.DELIVERY_RELATIONSHIP_REQUIREMENT;
						break;
					}
					}
					continue;
				case DeliveryAvailabilitySettings.Never:
					flag = false;
					break;
				case DeliveryAvailabilitySettings.Always:
					flag = true;
					break;
				case DeliveryAvailabilitySettings.AfterReachingXP:
					flag = NetworkSingleton<LevelManager>.Instance.TotalXP >= delivery.Value.XPRequirement;
					break;
				default:
					throw new ArgumentOutOfRangeException();
				}
				value.AvailableByDefault = flag;
				if ((Object)(object)value.DeliveryFeeLabel != (Object)null)
				{
					value.DeliveryFeeLabel.text = $"${delivery.Value.DeliveryFee}";
				}
				((Component)value).gameObject.SetActive(flag);
			}
		}
	}
	public static class SuccessChanceCalculator
	{
		public static float CalculateSuccess(EDrugType drugType, EQuality quality, float qualityLevelModifier, ECustomerStandard standard, string[] desires, string[] effects, CustomerAffinityData affinities, bool includeDrugPreference, float baseAcceptance, bool requireEffectMatch, int maxQualityOverDeliveryLevels, float drugAffinitySharpness)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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)
			//IL_0128: Expected I4, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			float num2;
			if (desires.Length != 0)
			{
				int num = 0;
				foreach (string item in desires.Where((string d) => !string.IsNullOrEmpty(d)))
				{
					num += (((ReadOnlySpan<string>)effects).Contains(item) ? 1 : 0);
				}
				if (requireEffectMatch && num == 0)
				{
					Log.Info("Sample offering: covers no desired effects - rejected (effect match required).");
					return 0f;
				}
				num2 = (float)num / (float)desires.Length;
				Log.Info($"Sample offering: Covered {num} desires. Base acceptance {num2 * 100f:F1}%");
			}
			else
			{
				Log.Info("Sample offering: No desired. Base acceptance 100%");
				num2 = 1f;
			}
			int num3 = quality - standard;
			int num4 = ((num3 > 0) ? Math.Min(num3, maxQualityOverDeliveryLevels) : num3);
			Log.Info($"Sample offering: Quality difference {num3} levels (effective {num4})");
			num2 += qualityLevelModifier * (float)num4;
			Log.Info($"Adjusted acceptance: {num2 * 100f:F1}%");
			if (includeDrugPreference)
			{
				Enumerator<ProductTypeAffinity> enumerator2 = affinities.ProductAffinities.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					ProductTypeAffinity current2 = enumerator2.Current;
					if (current2.DrugType == drugType)
					{
						float affinity = current2.Affinity;
						float num5 = ((affinity <= 0f) ? 0f : Mathf.Pow(Mathf.Clamp01(affinity), drugAffinitySharpness));
						Log.Info($"Sample offering: Drug affinity {affinity:0.##} -> factor {num5 * 100f:F1}%");
						num2 *= num5;
						break;
					}
				}
			}
			num2 += baseAcceptance;
			Log.Info($"Sample offering: Final acceptance is {Mathf.Clamp01(num2):F1}%");
			return Mathf.Clamp01(num2);
		}
	}
	public class WeightedNormalizer
	{
		private readonly List<float> _weights = new List<float>();

		private readonly List<float> _values = new List<float>();

		private readonly List<float> _cdf = new List<float>();

		private bool _isInitialized;

		public void Add(float weight, float value)
		{
			if (weight < 0f)
			{
				throw new ArgumentOutOfRangeException("weight", "Weight must be non-negative.");
			}
			_weights.Add(weight);
			_values.Add(value);
			_isInitialized = false;
		}

		private void Initialize()
		{
			_cdf.Clear();
			float num = _weights.Sum();
			if (num == 0f)
			{
				_cdf.Clear();
				_cdf.Add(1f);
				_isInitialized = true;
				return;
			}
			float num2 = 0f;
			foreach (float weight in _weights)
			{
				num2 += weight / num;
				_cdf.Add(num2);
			}
			_isInitialized = true;
		}

		public float Evaluate(float n)
		{
			if (!_isInitialized)
			{
				Initialize();
			}
			if (_values.Count == 0)
			{
				throw new InvalidOperationException("No values added to normalize.");
			}
			float num = n;
			float num2 = num;
			if (!(num2 <= 0f))
			{
				if (num2 >= 1f)
				{
					List<float> values = _values;
					return values[values.Count - 1];
				}
				int num3 = _cdf.FindIndex((float x) => x > n);
				switch (num3)
				{
				case -1:
				{
					List<float> values2 = _values;
					return values2[values2.Count - 1];
				}
				case 0:
					return _values[0];
				default:
				{
					int index = num3 - 1;
					float num4 = _cdf[index];
					float num5 = _cdf[num3];
					float num6 = (n - num4) / (num5 - num4);
					float num7 = _values[index];
					float num8 = _values[num3];
					return num7 + (num8 - num7) * num6;
				}
				}
			}
			return _values[0];
		}
	}
	public class PickerEmptyException : Exception
	{
	}
	public class WeightedPicker<T>
	{
		private readonly Random _random;

		private bool _hasChanged;

		private readonly Dictionary<T, float> _dictionary = new Dictionary<T, float>();

		private double _totalWeight;

		public int Count => _dictionary.Count;

		public float this[T key]
		{
			get
			{
				return _dictionary[key];
			}
			set
			{
				_dictionary[key] = value;
				_hasChanged = true;
			}
		}

		public WeightedPicker(Random random)
		{
			_random = random;
		}

		public WeightedPicker()
			: this(new Random(Guid.NewGuid().GetHashCode()))
		{
		}

		public T Pick()
		{
			if (_hasChanged)
			{
				Rebuild();
			}
			float value = (float)_random.Next((int)(_totalWeight * 100.0)) / 100f;
			return PickManually(value);
		}

		public T PickManually(float value)
		{
			if (_hasChanged)
			{
				Rebuild();
			}
			value = Math.Min((float)_totalWeight, Math.Max(0f, value));
			float num = 0f;
			KeyValuePair<T, float>? keyValuePair = null;
			foreach (KeyValuePair<T, float> item in _dictionary)
			{
				if (num > value)
				{
					break;
				}
				keyValuePair = item;
				num += item.Value;
			}
			if (!keyValuePair.HasValue)
			{
				throw new PickerEmptyException();
			}
			return keyValuePair.Value.Key;
		}

		private void Rebuild()
		{
			_totalWeight = _dictionary.Values.Sum();
			_hasChanged = false;
		}

		public void Add(T value, float weight)
		{
			_dictionary.Add(value, weight);
			_hasChanged = true;
		}

		public void AddRange(IEnumerable<KeyValuePair<T, float>> entries)
		{
			foreach (KeyValuePair<T, float> entry in entries)
			{
				_dictionary.Add(entry.Key, entry.Value);
			}
			_hasChanged = true;
		}

		public bool Remove(T key)
		{
			_hasChanged = true;
			return _dictionary.Remove(key);
		}

		public void Clear()
		{
			_dictionary.Clear();
			_hasChanged = true;
		}
	}
}
namespace Lithium.Modules
{
	public abstract class ModuleBase
	{
		public abstract void Load();

		public abstract void Apply();
	}
	public abstract class ModuleBase<TConfiguration> : ModuleBase where TConfiguration : ModuleConfiguration
	{
		public TConfiguration Configuration { get; private set; }

		protected virtual void OnBeforeConfigurationLoaded()
		{
		}

		public override void Load()
		{
			Configuration = Activator.CreateInstance<TConfiguration>();
			OnBeforeConfigurationLoaded();
			Configuration.LoadConfiguration();
			Configuration.Validate();
		}
	}
	public abstract class ModuleConfiguration
	{
		private static readonly string ConfigFolder = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");

		[JsonProperty(Order = -500)]
		public bool Enabled;

		[JsonIgnore]
		public abstract string Name { get; }

		public string GetConfigFile()
		{
			return Path.Combine(ConfigFolder, Name + ".json");
		}

		public virtual void Validate()
		{
		}

		public void SaveConfiguration()
		{
			if (!Directory.Exists(ConfigFolder))
			{
				Directory.CreateDirectory(ConfigFolder);
			}
			string configFile = GetConfigFile();
			string contents = JsonConvert.SerializeObject((object)this, (Formatting)1);
			File.WriteAllText(configFile, contents);
		}

		public void LoadConfiguration()
		{
			string configFile = GetConfigFile();
			if (File.Exists(configFile))
			{
				string text = File.ReadAllText(configFile);
				JsonConvert.PopulateObject(text, (object)this);
				SaveConfiguration();
			}
			else
			{
				SaveConfiguration();
			}
		}
	}
}
namespace Lithium.Modules.Products
{
	public class ModProductsConfiguration : ModuleConfiguration
	{
		public override string Name => "Products";

		public bool ShowMixRecipes { get; set; } = true;

		public string MixesHeader { get; set; } = "Mix recipes:";

		public string Arrow { get; set; } = "→";

		public string Bullet { get; set; } = "• ";

		public int MaxLines { get; set; } = 0;

		public float FontSize { get; set; } = 0f;

		public float IconSize { get; set; } = 24f;

		public float RowHeight { get; set; } = 28f;

		public bool EnableListFilter { get; set; } = true;

		public string SearchPlaceholder { get; set; } = "Search products...";

		public string EffectsButtonLabel { get; set; } = "Effects";

		public ModProductsConfiguration()
		{
			Enabled = true;
		}
	}
	public class ModProducts : ModuleBase<ModProductsConfiguration>
	{
		public override void Apply()
		{
			ProductListFilter.Reset();
		}

		public void DriveUpdate()
		{
			ProductListFilter.DriveVisibility();
		}
	}
	internal static class ProductFilterUi
	{
		private static Font _font;

		public static UnityAction UA(Action a)
		{
			return UnityAction.op_Implicit(a);
		}

		public static UnityAction<string> UA(Action<string> a)
		{
			return UnityAction<string>.op_Implicit(a);
		}

		public static Font ResolveFont()
		{
			if ((Object)(object)_font != (Object)null)
			{
				return _font;
			}
			Il2CppArrayBase<Text> val = Object.FindObjectsOfType<Text>(true);
			if (val != null)
			{
				foreach (Text item in val)
				{
					if ((Object)(object)item != (Object)null && (Object)(object)item.font != (Object)null)
					{
						_font = item.font;
						break;
					}
				}
			}
			if ((Object)(object)_font == (Object)null)
			{
				_font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf") ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
			return _font;
		}

		public static void SetAnchored(RectTransform rt, Vector2 anchor, Vector2 pivot, Vector2 size, Vector2 pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = anchor;
			rt.anchorMax = anchor;
			rt.pivot = pivot;
			rt.sizeDelta = size;
			rt.anchoredPosition = pos;
		}

		public static GameObject MakeImage(Transform parent, string name, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		public static Text MakeText(Transform parent, string name, string text, int fontSize, Color color, TextAnchor anchor)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			Text val3 = val.AddComponent<Text>();
			val3.font = ResolveFont();
			val3.fontSize = fontSize;
			((Graphic)val3).color = color;
			val3.alignment = anchor;
			val3.supportRichText = true;
			val3.horizontalOverflow = (HorizontalWrapMode)1;
			val3.verticalOverflow = (VerticalWrapMode)1;
			val3.text = text;
			return val3;
		}

		public static Button MakeButton(Transform parent, string name, string label, int fontSize, Color bgColor, Color textColor, Action onClick, out Image bg, out Text labelText)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: 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_005d: 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_007c: 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)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			bg = val.AddComponent<Image>();
			((Graphic)bg).color = bgColor;
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)bg;
			labelText = MakeText(val.transform, "Label", label, fontSize, textColor, (TextAnchor)4);
			RectTransform rectTransform = ((Graphic)labelText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			if (onClick != null)
			{
				((UnityEvent)val3.onClick).AddListener(UA(onClick));
			}
			return val3;
		}

		public static InputField CloneSearchInput(InputField template, string placeholder)
		{
			if ((Object)(object)template == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject);
			InputField component = val.GetComponent<InputField>();
			component.contentType = (ContentType)0;
			component.characterValidation = (CharacterValidation)0;
			component.characterLimit = 0;
			component.lineType = (LineType)0;
			component.SetTextWithoutNotify(string.Empty);
			if ((Object)(object)component.placeholder != (Object)null)
			{
				Text val2 = ((Il2CppObjectBase)component.placeholder).TryCast<Text>();
				if ((Object)(object)val2 != (Object)null)
				{
					val2.text = placeholder;
					val2.fontStyle = (FontStyle)2;
				}
			}
			return component;
		}

		public static RectTransform MakeScrollList(Transform parent, Vector2 anchor, Vector2 pivot, Vector2 size, Vector2 pos, Color background)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0022: 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_002f: 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_0031: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00ae: 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_00d2: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0136: 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)
			GameObject val = new GameObject("ScrollList");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			SetAnchored(val2, anchor, pivot, size, pos);
			((Graphic)val.AddComponent<Image>()).color = background;
			GameObject val3 = new GameObject("Viewport");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			((Transform)val4).SetParent(val.transform, false);
			val3.transform.localScale = Vector3.one;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = Color.white;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			GameObject val5 = new GameObject("Content");
			RectTransform val6 = val5.AddComponent<RectTransform>();
			((Transform)val6).SetParent(val3.transform, false);
			val5.transform.localScale = Vector3.one;
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			val6.sizeDelta = Vector2.zero;
			ScrollRect val7 = val.AddComponent<ScrollRect>();
			val7.horizontal = false;
			val7.vertical = true;
			val7.movementType = (MovementType)2;
			val7.scrollSensitivity = 24f;
			val7.viewport = val4;
			val7.content = val6;
			return val6;
		}
	}
	internal static class ProductListFilter
	{
		private sealed class EffectOption
		{
			public string Id;

			public string Name;

			public Image Background;

			public Text Label;
		}

		private const float BarHeight = 46f;

		private const float RowHeight = 28f;

		private static readonly Color BarColor = new Color(0.1f, 0.1f, 0.12f, 0.95f);

		private static readonly Color PanelColor = new Color(0.08f, 0.08f, 0.1f, 0.98f);

		private static readonly Color ButtonColor = new Color(0.2f, 0.2f, 0.24f, 1f);

		private static readonly Color RowColor = new Color(0.16f, 0.16f, 0.2f, 1f);

		private static readonly Color RowSelectedColor = new Color(0.2f, 0.45f, 0.3f, 1f);

		private static readonly Color TextColor = Color.white;

		private static ProductManagerApp _app;

		private static int _appId;

		private static bool _built;

		private static GameObject _bar;

		private static InputField _searchInput;

		private static Text _effectsButtonLabel;

		private static GameObject _effectsPanel;

		private static string _nameFilter = string.Empty;

		private static readonly HashSet<string> _selectedEffectIds = new HashSet<string>();

		private static readonly List<EffectOption> _effectOptions = new List<EffectOption>();

		public static bool Enabled
		{
			get
			{
				ModProducts modProducts = Core.Get<ModProducts>();
				return modProducts != null && modProducts.Configuration.Enabled && modProducts.Configuration.EnableListFilter;
			}
		}

		public static void Reset()
		{
			_app = null;
			_appId = 0;
			_built = false;
			_bar = null;
			_searchInput = null;
			_effectsButtonLabel = null;
			_effectsPanel = null;
			_nameFilter = string.Empty;
			_selectedEffectIds.Clear();
			_effectOptions.Clear();
		}

		public static void EnsureBuilt(ProductManagerApp app)
		{
			if (!Enabled || (Object)(object)app == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)app).GetInstanceID();
			if (_built && _appId == instanceID)
			{
				return;
			}
			if (_appId != instanceID)
			{
				Reset();
			}
			try
			{
				Build(app);
				_app = app;
				_appId = instanceID;
				_built = true;
				ApplyFilter();
				SetVisible(((App<ProductManagerApp>)(object)app).isOpen);
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] Products filter build failed: {value}");
			}
		}

		public static void DriveVisibility()
		{
			if (_built && !((Object)(object)_bar == (Object)null) && !((Object)(object)_app == (Object)null))
			{
				if (!Enabled)
				{
					SetVisible(visible: false);
				}
				else
				{
					SetVisible(((App<ProductManagerApp>)(object)_app).isOpen);
				}
			}
		}

		public static void SetVisible(bool visible)
		{
			if ((Object)(object)_bar != (Object)null && _bar.activeSelf != visible)
			{
				_bar.SetActive(visible);
			}
			if (!visible && (Object)(object)_effectsPanel != (Object)null && _effectsPanel.activeSelf)
			{
				_effectsPanel.SetActive(false);
			}
		}

		private static void Build(ProductManagerApp app)
		{
			//IL_003d: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_0130: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: 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_026c: 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)
			ProductFilterUi.ResolveFont();
			RectTransform appContainer = ((App<ProductManagerApp>)(object)app).appContainer;
			if ((Object)(object)appContainer == (Object)null)
			{
				Log.Warning("[Lithium] Products filter: app container missing; skipping.");
				return;
			}
			ModProductsConfiguration configuration = Core.Get<ModProducts>().Configuration;
			GameObject val = (_bar = ProductFilterUi.MakeImage((Transform)(object)appContainer, "LithiumProductFilterBar", BarColor));
			RectTransform component = val.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, 46f);
			component.anchoredPosition = Vector2.zero;
			InputField template = (((Object)(object)app.DetailPanel != (Object)null) ? app.DetailPanel.ValueLabel : null);
			_searchInput = ProductFilterUi.CloneSearchInput(template, configuration.SearchPlaceholder);
			if ((Object)(object)_searchInput != (Object)null)
			{
				((Component)_searchInput).gameObject.SetActive(true);
				((Component)_searchInput).transform.SetParent(val.transform, false);
				((Component)_searchInput).transform.localScale = Vector3.one;
				RectTransform component2 = ((Component)_searchInput).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 0f);
				component2.anchorMax = new Vector2(0.62f, 1f);
				component2.offsetMin = new Vector2(6f, 6f);
				component2.offsetMax = new Vector2(-4f, -6f);
				((UnityEvent<string>)(object)_searchInput.onValueChanged).AddListener(ProductFilterUi.UA(OnNameChanged));
			}
			else
			{
				Log.Warning("[Lithium] Products filter: no InputField template to clone; search unavailable.");
			}
			Image bg;
			Button val2 = ProductFilterUi.MakeButton(val.transform, "EffectsButton", configuration.EffectsButtonLabel, 16, ButtonColor, TextColor, ToggleEffectsPanel, out bg, out _effectsButtonLabel);
			RectTransform component3 = ((Component)val2).GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.64f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.offsetMin = new Vector2(4f, 6f);
			component3.offsetMax = new Vector2(-6f, -6f);
			BuildEffectsPanel(appContainer, configuration);
			UpdateEffectsButtonLabel();
		}

		private static void BuildEffectsPanel(RectTransform container, ModProductsConfiguration config)
		{
			//IL_0012: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_00a4: 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_00d0: 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_00fc: 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_0160: 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_018e: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_0238: 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_0266: 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_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: 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_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: 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_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			_effectOptions.Clear();
			_effectsPanel = ProductFilterUi.MakeImage((Transform)(object)container, "LithiumEffectsPanel", PanelColor);
			RectTransform component = _effectsPanel.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.4f, 0.08f);
			component.anchorMax = new Vector2(0.99f, 0.86f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Text val = ProductFilterUi.MakeText(_effectsPanel.transform, "Title", "Effects (must have all)", 15, TextColor, (TextAnchor)3);
			RectTransform rectTransform = ((Graphic)val).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0.7f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.sizeDelta = new Vector2(0f, 26f);
			rectTransform.anchoredPosition = new Vector2(8f, -4f);
			Image bg;
			Text labelText;
			Button val2 = ProductFilterUi.MakeButton(_effectsPanel.transform, "ClearButton", "Clear", 14, ButtonColor, TextColor, ClearEffects, out bg, out labelText);
			RectTransform component2 = ((Component)val2).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.72f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(1f, 1f);
			component2.sizeDelta = new Vector2(0f, 24f);
			component2.anchoredPosition = new Vector2(-6f, -5f);
			RectTransform val3 = ProductFilterUi.MakeScrollList(_effectsPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-12f, -36f), new Vector2(0f, 6f), PanelColor);
			RectTransform component3 = ((Component)((Transform)val3).parent.parent).GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.offsetMin = new Vector2(6f, 6f);
			component3.offsetMax = new Vector2(-6f, -34f);
			List<EffectOption> list = GatherEffects();
			val3.sizeDelta = new Vector2(0f, (float)list.Count * 28f);
			for (int i = 0; i < list.Count; i++)
			{
				EffectOption opt = list[i];
				Image bg2;
				Text labelText2;
				Button val4 = ProductFilterUi.MakeButton((Transform)(object)val3, "Effect_" + opt.Id, opt.Name, 14, RowColor, TextColor, delegate
				{
					ToggleEffect(opt.Id);
				}, out bg2, out labelText2);
				labelText2.alignment = (TextAnchor)3;
				RectTransform rectTransform2 = ((Graphic)labelText2).rectTransform;
				rectTransform2.offsetMin = new Vector2(8f, 0f);
				rectTransform2.offsetMax = new Vector2(-4f, 0f);
				RectTransform component4 = ((Component)val4).GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0f, 1f);
				component4.anchorMax = new Vector2(1f, 1f);
				component4.pivot = new Vector2(0.5f, 1f);
				component4.sizeDelta = new Vector2(0f, 26f);
				component4.anchoredPosition = new Vector2(0f, (float)(-i) * 28f);
				opt.Background = bg2;
				opt.Label = labelText2;
				_effectOptions.Add(opt);
			}
			_effectsPanel.SetActive(false);
		}

		private static List<EffectOption> GatherEffects()
		{
			Dictionary<string, EffectOption> dictionary = new Dictionary<string, EffectOption>();
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance != (Object)null && instance.AllProducts != null)
			{
				List<ProductDefinition> allProducts = instance.AllProducts;
				for (int i = 0; i < allProducts.Count; i++)
				{
					ProductDefinition val = allProducts[i];
					if ((Object)(object)val == (Object)null || ((PropertyItemDefinition)val).Properties == null)
					{
						continue;
					}
					for (int j = 0; j < ((PropertyItemDefinition)val).Properties.Count; j++)
					{
						Effect val2 = ((PropertyItemDefinition)val).Properties[j];
						if (!((Object)(object)val2 == (Object)null) && !string.IsNullOrEmpty(val2.ID) && !dictionary.ContainsKey(val2.ID))
						{
							dictionary[val2.ID] = new EffectOption
							{
								Id = val2.ID,
								Name = (string.IsNullOrEmpty(val2.Name) ? val2.ID : val2.Name)
							};
						}
					}
				}
			}
			return dictionary.Values.OrderBy<EffectOption, string>((EffectOption o) => o.Name, StringComparer.OrdinalIgnoreCase).ToList();
		}

		private static void OnNameChanged(string value)
		{
			_nameFilter = (value ?? string.Empty).Trim();
			ApplyFilter();
		}

		private static void ToggleEffectsPanel()
		{
			if (!((Object)(object)_effectsPanel == (Object)null))
			{
				_effectsPanel.SetActive(!_effectsPanel.activeSelf);
			}
		}

		private static void ToggleEffect(string id)
		{
			if (!_selectedEffectIds.Remove(id))
			{
				_selectedEffectIds.Add(id);
			}
			RefreshEffectVisuals();
			UpdateEffectsButtonLabel();
			ApplyFilter();
		}

		private static void ClearEffects()
		{
			if (_selectedEffectIds.Count != 0)
			{
				_selectedEffectIds.Clear();
				RefreshEffectVisuals();
				UpdateEffectsButtonLabel();
				ApplyFilter();
			}
		}

		private static void RefreshEffectVisuals()
		{
			//IL_004a: 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)
			foreach (EffectOption effectOption in _effectOptions)
			{
				if ((Object)(object)effectOption.Background != (Object)null)
				{
					((Graphic)effectOption.Background).color = (_selectedEffectIds.Contains(effectOption.Id) ? RowSelectedColor : RowColor);
				}
				if ((Object)(object)effectOption.Label != (Object)null)
				{
					effectOption.Label.text = (_selectedEffectIds.Contains(effectOption.Id) ? "✓ " : "") + effectOption.Name;
				}
			}
		}

		private static void UpdateEffectsButtonLabel()
		{
			if (!((Object)(object)_effectsButtonLabel == (Object)null))
			{
				string effectsButtonLabel = Core.Get<ModProducts>().Configuration.EffectsButtonLabel;
				_effectsButtonLabel.text = ((_selectedEffectIds.Count > 0) ? $"{effectsButtonLabel} ({_selectedEffectIds.Count})" : effectsButtonLabel);
			}
		}

		public static void ApplyFilter()
		{
			if (!_built || (Object)(object)_app == (Object)null)
			{
				return;
			}
			try
			{
				if (_app.FavouritesContainer != null)
				{
					FilterContainer(_app.FavouritesContainer.Container);
				}
				List<ProductTypeContainer> productTypeContainers = _app.ProductTypeContainers;
				if (productTypeContainers != null)
				{
					for (int i = 0; i < productTypeContainers.Count; i++)
					{
						ProductTypeContainer val = productTypeContainers[i];
						if (val != null)
						{
							FilterContainer(val.Container);
						}
					}
				}
				RebuildLayout();
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] Products filter apply failed: {value}");
			}
		}

		private static void RebuildLayout()
		{
			if (!((App<ProductManagerApp>)(object)_app).isOpen)
			{
				return;
			}
			_app.DelayedRebuildLayout();
			Il2CppArrayBase<VerticalLayoutGroup> componentsInChildren = ((Component)_app).GetComponentsInChildren<VerticalLayoutGroup>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			foreach (VerticalLayoutGroup item in componentsInChildren)
			{
				if (!((Object)(object)item == (Object)null))
				{
					((Behaviour)item).enabled = false;
					((Behaviour)item).enabled = true;
				}
			}
		}

		private static void FilterContainer(RectTransform container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			int childCount = ((Transform)container).childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = ((Transform)container).GetChild(i);
				if ((Object)(object)child == (Object)null)
				{
					continue;
				}
				ProductEntry component = ((Component)child).GetComponent<ProductEntry>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component.Definition == (Object)null))
				{
					bool flag = Matches(component.Definition);
					if (((Component)child).gameObject.activeSelf != flag)
					{
						((Component)child).gameObject.SetActive(flag);
					}
				}
			}
		}

		private static bool Matches(ProductDefinition def)
		{
			if (_nameFilter.Length > 0)
			{
				string name = ((BaseItemDefinition)def).Name;
				if (string.IsNullOrEmpty(name) || name.IndexOf(_nameFilter, StringComparison.OrdinalIgnoreCase) < 0)
				{
					return false;
				}
			}
			if (_selectedEffectIds.Count > 0)
			{
				if (((PropertyItemDefinition)def).Properties == null)
				{
					return false;
				}
				foreach (string selectedEffectId in _selectedEffectIds)
				{
					if (!HasEffect(def, selectedEffectId))
					{
						return false;
					}
				}
			}
			return true;
		}

		private static bool HasEffect(ProductDefinition def, string effectId)
		{
			List<Effect> properties = ((PropertyItemDefinition)def).Properties;
			for (int i = 0; i < properties.Count; i++)
			{
				Effect val = properties[i];
				if ((Object)(object)val != (Object)null && val.ID == effectId)
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace Lithium.Modules.Products.Patches
{
	[HarmonyPatch(typeof(ItemInfoPanel), "Open", new Type[]
	{
		typeof(ItemInstance),
		typeof(RectTransform)
	})]
	internal static class ProductInfoPanelMixesPatch
	{
		private readonly struct MixRow
		{
			public readonly Sprite MixerIcon;

			public readonly Sprite ResultIcon;

			public readonly string ResultName;

			public MixRow(Sprite mixerIcon, Sprite resultIcon, string resultName)
			{
				MixerIcon = mixerIcon;
				ResultIcon = resultIcon;
				ResultName = resultName;
			}
		}

		private const string RootName = "LithiumMixes";

		private const float TopMargin = 4f;

		private const float HeaderHeight = 16f;

		private const float LeftPad = 6f;

		private static readonly Dictionary<int, string> _lastProduct = new Dictionary<int, string>();

		[HarmonyPostfix]
		private static void Postfix(ItemInfoPanel __instance, ItemInstance item)
		{
			ModProductsConfiguration configuration = Core.Get<ModProducts>().Configuration;
			if (!configuration.Enabled || !configuration.ShowMixRecipes)
			{
				return;
			}
			try
			{
				ItemInfoContent content = __instance.content;
				if ((Object)(object)content == (Object)null)
				{
					return;
				}
				ProductItemInfoContent val = ((Il2CppObjectBase)content).TryCast<ProductItemInfoContent>();
				if ((Object)(object)val == (Object)null || (Object)(object)((ItemInfoContent)val).DescriptionLabel == (Object)null)
				{
					return;
				}
				int instanceID = ((Object)content).GetInstanceID();
				Transform val2 = ((Component)content).transform.Find("LithiumMixes");
				ItemDefinition val3 = ((item != null) ? item.Definition : null);
				ProductDefinition val4 = (((Object)(object)val3 != (Object)null) ? ((Il2CppObjectBase)val3).TryCast<ProductDefinition>() : null);
				List<MixRow> list = (((Object)(object)val4 != (Object)null) ? BuildForwardRecipes(val4, configuration) : new List<MixRow>());
				string text = (((Object)(object)val4 != (Object)null) ? ((BaseItemDefinition)val4).ID : "");
				float num = MeasureEffectsBottom(content, val);
				if (list.Count == 0)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						((Component)val2).gameObject.SetActive(false);
					}
					_lastProduct[instanceID] = "";
					ResizePanel(__instance, content, content.Height);
					return;
				}
				float num2 = ((configuration.RowHeight > 0f) ? configuration.RowHeight : 28f);
				float iconSize = ((configuration.IconSize > 0f) ? configuration.IconSize : 24f);
				float num3 = 16f + (float)list.Count * num2 + 4f;
				float height = num + 4f + num3;
				if ((Object)(object)val2 == (Object)null || _lastProduct.GetValueOrDefault(instanceID) != text)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
					}
					RectTransform val5 = BuildRows(content, ((ItemInfoContent)val).DescriptionLabel, list, num, num3, num2, iconSize, configuration);
					_lastProduct[instanceID] = text;
				}
				else
				{
					RectTransform val5 = ((Il2CppObjectBase)val2).TryCast<RectTransform>() ?? ((Component)val2).GetComponent<RectTransform>();
					((Component)val5).gameObject.SetActive(true);
				}
				ResizePanel(__instance, content, height);
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] Products tooltip failed for {((item != null && (Object)(object)item.Definition != (Object)null) ? ((BaseItemDefinition)item.Definition).ID : "?")}: {value}");
			}
		}

		private static RectTransform BuildRows(ItemInfoContent content, TextMeshProUGUI template, List<MixRow> rows, float topOffset, float blockHeight, float rowHeight, float iconSize, ModProductsConfiguration config)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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_0058: 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_0084: 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)
			GameObject val = new GameObject("LithiumMixes");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(((Component)content).transform, false);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.sizeDelta = new Vector2(0f, blockHeight);
			val2.anchoredPosition = new Vector2(0f, 0f - (topOffset + 4f));
			val.transform.localScale = Vector3.one;
			float fontSize = ((config.FontSize > 0f) ? config.FontSize : ((TMP_Text)template).fontSize);
			MakeText((Transform)(object)val2, template, "<b>" + config.MixesHeader + "</b>", 6f, 0f, 160f, 16f, fontSize, (TextAlignmentOptions)257);
			float num = 12f;
			float num2 = 2f;
			float num3 = 6f;
			float num4 = num3 + iconSize + num2;
			float num5 = num4 + num + num2;
			float x = num5 + iconSize + num2;
			for (int i = 0; i < rows.Count; i++)
			{
				MixRow mixRow = rows[i];
				float num6 = 0f - (16f + (float)i * rowHeight);
				float y = num6 - (rowHeight - iconSize) * 0.5f;
				MakeIcon((Transform)(object)val2, mixRow.MixerIcon, num3, y, iconSize);
				MakeText((Transform)(object)val2, template, config.Arrow, num4, num6, num, rowHeight, fontSize, (TextAlignmentOptions)4098);
				MakeIcon((Transform)(object)val2, mixRow.ResultIcon, num5, y, iconSize);
				MakeText((Transform)(object)val2, template, mixRow.ResultName, x, num6, 200f, rowHeight, fontSize, (TextAlignmentOptions)4097);
			}
			return val2;
		}

		private static void MakeIcon(Transform parent, Sprite sprite, float x, float y, float size)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)sprite == (Object)null))
			{
				GameObject val = new GameObject("Icon");
				RectTransform val2 = val.AddComponent<RectTransform>();
				((Transform)val2).SetParent(parent, false);
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.sizeDelta = new Vector2(size, size);
				val2.anchoredPosition = new Vector2(x, y);
				val.transform.localScale = Vector3.one;
				Image val3 = val.AddComponent<Image>();
				val3.sprite = sprite;
				val3.preserveAspect = true;
			}
		}

		private static void MakeText(Transform parent, TextMeshProUGUI template, string text, float x, float y, float w, float h, float fontSize, TextAlignmentOptions align)
		{
			//IL_0020: 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_005a: 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_0080: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent);
			((Object)val).name = "Text";
			val.transform.localScale = Vector3.one;
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			RectTransform rectTransform = ((TMP_Text)component).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.sizeDelta = new Vector2(w, h);
			rectTransform.anchoredPosition = new Vector2(x, y);
			((TMP_Text)component).enableWordWrapping = false;
			((TMP_Text)component).alignment = align;
			if (fontSize > 0f)
			{
				((TMP_Text)component).fontSize = fontSize;
			}
			((TMP_Text)component).text = text;
			val.SetActive(true);
		}

		private static float MeasureEffectsBottom(ItemInfoContent content, ProductItemInfoContent productContent)
		{
			//IL_0034: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)content).GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return content.Height;
			}
			Il2CppStructArray<Vector3> val = new Il2CppStructArray<Vector3>(4L);
			component.GetWorldCorners(val);
			float y = ((Il2CppArrayBase<Vector3>)(object)val)[1].y;
			float num = y;
			bool flag = false;
			List<TextMeshProUGUI> propertyLabels = productContent.PropertyLabels;
			if (propertyLabels != null)
			{
				for (int i = 0; i < propertyLabels.Count; i++)
				{
					TextMeshProUGUI val2 = propertyLabels[i];
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && !string.IsNullOrWhiteSpace(((TMP_Text)val2).text))
					{
						Il2CppStructArray<Vector3> val3 = new Il2CppStructArray<Vector3>(4L);
						((TMP_Text)val2).rectTransform.GetWorldCorners(val3);
						float num2 = Mathf.Min(((Il2CppArrayBase<Vector3>)(object)val3)[0].y, ((Il2CppArrayBase<Vector3>)(object)val3)[3].y);
						if (!flag || num2 < num)
						{
							num = num2;
							flag = true;
						}
					}
				}
			}
			if (!flag)
			{
				return content.Height;
			}
			float num3 = y - num;
			float y2 = ((Component)content).transform.lossyScale.y;
			return (y2 > 0.0001f) ? (num3 / y2) : num3;
		}

		private static void ResizePanel(ItemInfoPanel panel, ItemInfoContent content, float height)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			content.Height = height;
			RectTransform container = panel.Container;
			if ((Object)(object)container != (Object)null)
			{
				container.sizeDelta = new Vector2(container.sizeDelta.x, height);
			}
		}

		private static List<MixRow> BuildForwardRecipes(ProductDefinition product, ModProductsConfiguration config)
		{
			List<MixRow> list = new List<MixRow>();
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance == (Object)null || instance.mixRecipes == null)
			{
				return list;
			}
			HashSet<string> hashSet = new HashSet<string>();
			if (instance.ValidMixIngredients != null)
			{
				for (int i = 0; i < instance.ValidMixIngredients.Count; i++)
				{
					PropertyItemDefinition val = instance.ValidMixIngredients[i];
					if ((Object)(object)val != (Object)null)
					{
						hashSet.Add(((BaseItemDefinition)val).ID);
					}
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (ProductDefinition item3 in ProductManager.DiscoveredProducts.ToList<ProductDefinition>())
			{
				if ((Object)(object)item3 != (Object)null)
				{
					hashSet2.Add(((BaseItemDefinition)item3).ID);
				}
			}
			List<StationRecipe> mixRecipes = instance.mixRecipes;
			for (int j = 0; j < mixRecipes.Count; j++)
			{
				StationRecipe val2 = mixRecipes[j];
				if ((Object)(object)val2 == (Object)null || val2.Ingredients == null || val2.Product == null || (Object)(object)val2.Product.Item == (Object)null || val2.Ingredients.Count < 2)
				{
					continue;
				}
				ItemDefinition val3 = null;
				ItemDefinition val4 = null;
				for (int k = 0; k < val2.Ingredients.Count; k++)
				{
					ItemDefinition item = val2.Ingredients[k].Item;
					if (!((Object)(object)item == (Object)null))
					{
						if ((Object)(object)val3 == (Object)null && hashSet.Contains(((BaseItemDefinition)item).ID))
						{
							val3 = item;
						}
						else
						{
							val4 = item;
						}
					}
				}
				if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || ((BaseItemDefinition)val4).ID != ((BaseItemDefinition)product).ID)
				{
					continue;
				}
				ItemDefinition item2 = val2.Product.Item;
				if (!(((BaseItemDefinition)item2).ID == ((BaseItemDefinition)product).ID) && hashSet2.Contains(((BaseItemDefinition)item2).ID))
				{
					list.Add(new MixRow(((BaseItemDefinition)val3).Icon, ((BaseItemDefinition)item2).Icon, ((BaseItemDefinition)item2).Name));
					if (config.MaxLines > 0 && list.Count >= config.MaxLines)
					{
						break;
					}
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(ProductManagerApp))]
	internal static class ProductManagerAppFilterPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(ProductManagerApp __instance)
		{
			ProductListFilter.EnsureBuilt(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetOpen")]
		private static void SetOpenPostfix(ProductManagerApp __instance, bool open)
		{
			if (!open)
			{
				ProductListFilter.SetVisible(visible: false);
				return;
			}
			ProductListFilter.EnsureBuilt(__instance);
			ProductListFilter.ApplyFilter();
			ProductListFilter.SetVisible(visible: true);
		}

		[HarmonyPostfix]
		[HarmonyPatch("CreateEntry", new Type[] { typeof(ProductDefinition) })]
		private static void CreateEntryPostfix()
		{
			ProductListFilter.ApplyFilter();
		}
	}
}
namespace Lithium.Modules.MixingStations
{
	public class ModMixingStationsConfiguration : ModuleConfiguration
	{
		public override string Name => "MixingStation";

		public int InputCapacity { get; set; } = 20;

		public int MixTimePerItem { get; set; } = 15;

		public int Mk2InputCapacity { get; set; } = 20;

		public int Mk2MixTimePerItem { get; set; } = 15;
	}
	public class ModMixingStations : ModuleBase<ModMixingStationsConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.MixingStations.Patches
{
	[HarmonyPatch(typeof(MixingStation), "Start")]
	public class MixingStationCapacityPatch
	{
		[HarmonyPostfix]
		public static void MixingStationCapacity(MixingStation __instance)
		{
			ModMixingStationsConfiguration configuration = Core.Get<ModMixingStations>().Configuration;
			if (configuration.Enabled)
			{
				bool flag = (Object)(object)((Il2CppObjectBase)__instance).TryCast<MixingStationMk2>() != (Object)null;
				__instance.MaxMixQuantity = (flag ? configuration.Mk2InputCapacity : configuration.InputCapacity);
			}
		}
	}
	[HarmonyPatch(typeof(MixingStation), "Start")]
	public class MixingStationDurationPatch
	{
		[HarmonyPostfix]
		public static void Postfix(MixingStation __instance)
		{
			ModMixingStationsConfiguration configuration = Core.Get<ModMixingStations>().Configuration;
			if (configuration.Enabled)
			{
				bool flag = (Object)(object)((Il2CppObjectBase)__instance).TryCast<MixingStationMk2>() != (Object)null;
				__instance.MixTimePerItem = Mathf.Max(1, flag ? configuration.Mk2MixTimePerItem : configuration.MixTimePerItem);
			}
		}
	}
}
namespace Lithium.Modules.TrashGrabber
{
	public class ModTrashGrabberConfiguration : ModuleConfiguration
	{
		public override string Name => "TrashGrabber";

		public int CustomCapacity { get; set; } = 20;
	}
	public class ModTrashGrabber : ModuleBase<ModTrashGrabberConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.TrashGrabber.Patches
{
	[HarmonyPatch(typeof(Equippable_TrashGrabber), "GetCapacity")]
	public static class EquippableTrashGrabberGetCapacityPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ref int __result, Equippable_TrashGrabber __instance)
		{
			ModTrashGrabberConfiguration configuration = Core.Get<ModTrashGrabber>().Configuration;
			if (configuration.Enabled)
			{
				__result = configuration.CustomCapacity - __instance.trashGrabberInstance.GetTotalSize();
			}
		}
	}
	[HarmonyPatch(typeof(Equippable_TrashGrabber), "Update")]
	public static class EquippableTrashGrabberRefreshVisualsPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Equippable_TrashGrabber __instance)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_009d: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			ModTrashGrabberConfiguration configuration = Core.Get<ModTrashGrabber>().Configuration;
			if (configuration.Enabled && __instance.trashGrabberInstance != null && !((Object)(object)__instance.TrashContent == (Object)null))
			{
				int num = ((configuration.CustomCapacity > 0) ? configuration.CustomCapacity : 20);
				float num2 = Mathf.Clamp01((float)__instance.trashGrabberInstance.GetTotalSize() / (float)num);
				__instance.TrashContent.localPosition = Vector3.Lerp(__instance.TrashContent_Min.localPosition, __instance.TrashContent_Max.localPosition, num2);
				__instance.TrashContent.localScale = Vector3.Lerp(__instance.TrashContent_Min.localScale, __instance.TrashContent_Max.localScale, num2);
				((Component)__instance.TrashContent).gameObject.SetActive(num2 > 0f);
			}
		}
	}
	[HarmonyPatch(typeof(TrashGrabberItemUI), "UpdateUI")]
	public static class TrashGrabberItemUIPatch
	{
		[HarmonyPostfix]
		public static void Postfix(TrashGrabberItemUI __instance)
		{
			ModTrashGrabberConfiguration configuration = Core.Get<ModTrashGrabber>().Configuration;
			if (configuration.Enabled && !((ItemUI)__instance).Destroyed && __instance.trashGrabberInstance != null && !((Object)(object)__instance.ValueLabel == (Object)null))
			{
				int num = ((configuration.CustomCapacity > 0) ? configuration.CustomCapacity : 20);
				int num2 = Mathf.FloorToInt(Mathf.Clamp01((float)__instance.trashGrabberInstance.GetTotalSize() / (float)num) * 100f);
				((TMP_Text)__instance.ValueLabel).text = num2 + "%";
			}
		}
	}
	[HarmonyPatch(typeof(TrashItem), "Interacted")]
	public class TrashItemInteractedPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(TrashItem __instance)
		{
			if (!Core.Get<ModTrashGrabber>().Configuration.Enabled)
			{
				return true;
			}
			if (Equippable_TrashGrabber.IsEquipped && __instance.CanGoInContainer && Equippable_TrashGrabber.Instance.GetCapacity() > 0)
			{
				Equippable_TrashGrabber.Instance.PickupTrash(__instance);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TrashItem), "Hovered")]
	public class TrashItemHoveredPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(TrashItem __instance)
		{
			if (!Core.Get<ModTrashGrabber>().Configuration.Enabled)
			{
				return true;
			}
			if (Equippable_TrashGrabber.IsEquipped && __instance.CanGoInContainer)
			{
				InteractableObject intObj = __instance.Draggable.IntObj;
				if (Equippable_TrashGrabber.Instance.GetCapacity() > 0)
				{
					intObj.SetMessage("Pick up");
					intObj.SetInteractableState((EInteractableState)0);
				}
				else
				{
					intObj.SetMessage("Bin is full");
					intObj.SetInteractableState((EInteractableState)1);
				}
			}
			return false;
		}
	}
}
namespace Lithium.Modules.StackSizes
{
	public class ModStackSizesConfiguration : ModuleConfiguration
	{
		public override string Name => "StackSizes";

		public bool ExperimentalCashStacking { get; set; } = false;

		public int CashMaxBalance { get; set; } = 100000;

		public Dictionary<EItemCategory, int> CategorySizes { get; set; } = new Dictionary<EItemCategory, int>
		{
			{
				(EItemCategory)0,
				20
			},
			{
				(EItemCategory)1,
				20
			},
			{
				(EItemCategory)2,
				20
			},
			{
				(EItemCategory)3,
				10
			},
			{
				(EItemCategory)4,
				10
			},
			{
				(EItemCategory)5,
				10
			},
			{
				(EItemCategory)6,
				1000
			},
			{
				(EItemCategory)7,
				20
			},
			{
				(EItemCategory)8,
				20
			},
			{
				(EItemCategory)9,
				20
			},
			{
				(EItemCategory)10,
				10
			},
			{
				(EItemCategory)11,
				10
			},
			{
				(EItemCategory)12,
				10
			}
		};

		public Dictionary<string, int> ItemOverrides { get; set; } = new Dictionary<string, int>();

		public List<string> IgnoredItems { get; set; } = new List<string>();
	}
	public class ModStackSizes : ModuleBase<ModStackSizesConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
	public static class ItemRegistry
	{
		public static List<ItemDefinition> AllItemDefinitions = new List<ItemDefinition>();

		public static void UpdateEntireRegistry()
		{
			foreach (ItemDefinition allItemDefinition in AllItemDefinitions)
			{
				UpdateItemDefinition(allItemDefinition);
			}
		}

		public static void UpdateItemDefinition(ItemDefinition itemDefinition)
		{
			//IL_0063: 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)
			ModStackSizesConfiguration configuration = Core.Get<ModStackSizes>().Configuration;
			if (configuration.Enabled && !configuration.IgnoredItems.Contains(((BaseItemDefinition)itemDefinition).ID))
			{
				if (configuration.ItemOverrides.TryGetValue(((BaseItemDefinition)itemDefinition).ID, out var value))
				{
					((BaseItemDefinition)itemDefinition).StackLimit = value;
					return;
				}
				if (configuration.CategorySizes.TryGetValue(((BaseItemDefinition)itemDefinition).Category, out value))
				{
					((BaseItemDefinition)itemDefinition).StackLimit = value;
					return;
				}
				Log.Warning($"Found item for category {((BaseItemDefinition)itemDefinition).Category}, but no category value");
			}
		}
	}
}
namespace Lithium.Modules.StackSizes.Patches
{
	internal static class CashStackingConfig
	{
		public static float DragAmount;

		public static bool DragActive;

		private static float _lastScrollTime;

		private static int _lastStepFrame = -1;

		private static readonly int[] Ladder = BuildLadder();

		public static bool TryGet(out float cap)
		{
			cap = 0f;
			ModStackSizes modStackSizes = Core.Get<ModStackSizes>();
			if (modStackSizes == null || !modStackSizes.Configuration.Enabled || !modStackSizes.Configuration.ExperimentalCashStacking)
			{
				return false;
			}
			cap = modStackSizes.Configuration.CashMaxBalance;
			return true;
		}

		public static bool BeginScrollTick()
		{
			int frameCount = Time.frameCount;
			if (frameCount == _lastStepFrame)
			{
				return false;
			}
			_lastStepFrame = frameCount;
			return true;
		}

		private static int[] BuildLadder()
		{
			List<int> list = new List<int> { 1, 5 };
			for (long num = 10L; num <= 100000000; num *= 10)
			{
				list.Add((int)num);
				list.Add((int)(2 * num));
				list.Add((int)(5 * num));
			}
			return list.ToArray();
		}

		public static int SnapToLadder(float value)
		{
			int result = Ladder[0];
			for (int i = 0; i < Ladder.Length && (float)Ladder[i] <= value; i++)
			{
				result = Ladder[i];
			}
			return result;
		}

		public static int AcceleratedStep(float amount)
		{
			float unscaledTime = Time.unscaledTime;
			float num = Mathf.Max(unscaledTime - _lastScrollTime, 0.0001f);
			_lastScrollTime = unscaledTime;
			float num2 = Mathf.Clamp01((0.18f - num) / 0.16f);
			float num3 = num2 * num2 * num2;
			float num4 = Mathf.Max(5f, amount * 0.33f);
			return SnapToLadder(Mathf.Lerp(1f, num4, num3));
		}

		public static float SourceMax(CashInstance source, float cap)
		{
			float num = ((source != null) ? source.Balance : cap);
			return Mathf.Min(cap, num);
		}
	}
	[HarmonyPatch(typeof(ItemUIManager), "StartDragCash")]
	public class CashDragStartPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemUIManager __instance)
		{
			if (CashStackingConfig.TryGet(out var _))
			{
				CashStackingConfig.DragAmount = Mathf.Max(1f, Mathf.Round(__instance.draggedCashAmount));
				CashStackingConfig.DragActive = true;
			}
		}
	}
	public struct CashCombineState
	{
		public bool Valid;

		public CashInstance Target;

		public CashInstance Source;

		public float TargetBefore;

		public float SourceBefore;

		public float Dragged;
	}
	[HarmonyPatch(typeof(ItemUIManager), "EndCashDrag")]
	public class CashDragEndPatch
	{
		[HarmonyPrefix]
		public static void Prefix(ItemUIManager __instance, out CashCombineState __state)
		{
			__state = default(CashCombineState);
			if (!CashStackingConfig.TryGet(out var _) || !__instance.isDraggingCash)
			{
				return;
			}
			ItemSlotUI hoveredSlot = __instance.HoveredSlot;
			ItemSlotUI draggedSlot = __instance.draggedSlot;
			if (!((Object)(object)hoveredSlot == (Object)null) && hoveredSlot.assignedSlot != null && !((Object)(object)draggedSlot == (Object)null) && draggedSlot.assignedSlot != null)
			{
				CashInstance val = ((hoveredSlot.assignedSlot.ItemInstance != null) ? ((Il2CppObjectBase)hoveredSlot.assignedSlot.ItemInstance).TryCast<CashInstance>() : null);
				CashInstance val2 = ((draggedSlot.assignedSlot.ItemInstance != null) ? ((Il2CppObjectBase)draggedSlot.assignedSlot.ItemInstance).TryCast<CashInstance>() : null);
				if (val != null && val2 != null && !(((Il2CppObjectBase)val).Pointer == ((Il2CppObjectBase)val2).Pointer))
				{
					__state = new CashCombineState
					{
						Valid = true,
						Target = val,
						Source = val2,
						TargetBefore = val.Balance,
						SourceBefore = val2.Balance,
						Dragged = __instance.draggedCashAmount
					};
				}
			}
		}

		[HarmonyPostfix]
		public static void Postfix(CashCombineState __state)
		{
			CashStackingConfig.DragActive = false;
			if (!__state.Valid || !CashStackingConfig.TryGet(out var cap))
			{
				return;
			}
			float num = cap - __state.TargetBefore;
			if (!(num <= 0f))
			{
				float num2 = Mathf.Min(Mathf.Min(__state.Dragged, num), __state.SourceBefore);
				float num3 = __state.Target.Balance - __state.TargetBefore;
				float num4 = num2 - num3;
				if (!(num4 <= 0.001f))
				{
					__state.Target.ChangeBalance(num4);
					__state.Source.ChangeBalance(0f - num4);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemUIManager), "AddCashAmount")]
	public class CashDragAddPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemUIManager __instance, CashInstance __0)
		{
			if (CashStackingConfig.TryGet(out var cap) && __instance.isDraggingCash)
			{
				float num = CashStackingConfig.SourceMax(__0, cap);
				if (CashStackingConfig.BeginScrollTick())
				{
					int num2 = CashStackingConfig.AcceleratedStep(CashStackingConfig.DragAmount);
					float num3 = CashStackingConfig.DragAmount + (float)num2;
					CashStackingConfig.DragAmount = ((num3 >= num) ? num : Mathf.Round(num3));
				}
				__instance.draggedCashAmount = CashStackingConfig.DragAmount;
			}
		}
	}
	[HarmonyPatch(typeof(ItemUIManager), "SubtractCashAmount")]
	public class CashDragSubtractPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemUIManager __instance, CashInstance __0)
		{
			if (CashStackingConfig.TryGet(out var _) && __instance.isDraggingCash)
			{
				if (CashStackingConfig.BeginScrollTick())
				{
					int num = CashStackingConfig.AcceleratedStep(CashStackingConfig.DragAmount);
					CashStackingConfig.DragAmount = Mathf.Max(1f, Mathf.Round(CashStackingConfig.DragAmount - (float)num));
				}
				__instance.draggedCashAmount = CashStackingConfig.DragAmount;
			}
		}
	}
	[HarmonyPatch(typeof(ItemUIManager), "UpdateCashDragAmount")]
	public class CashDragUpdatePatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemUIManager __instance, CashInstance __0)
		{
			if (CashStackingConfig.TryGet(out var cap) && __instance.isDraggingCash && CashStackingConfig.DragActive)
			{
				CashStackingConfig.DragAmount = Mathf.Min(CashStackingConfig.DragAmount, CashStackingConfig.SourceMax(__0, cap));
				__instance.draggedCashAmount = CashStackingConfig.DragAmount;
			}
		}
	}
	[HarmonyPatch(typeof(CashInstance), "SetBalance")]
	public class CashSetBalancePatch
	{
		[HarmonyPostfix]
		public static void Postfix(CashInstance __instance, float __0)
		{
			if (CashStackingConfig.TryGet(out var cap))
			{
				float num = Mathf.Min(__0, cap);
				if (__instance.Balance < num)
				{
					__instance.Balance = num;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CashInstance), "ChangeBalance")]
	public class CashChangeBalancePatch
	{
		[HarmonyPrefix]
		public static void Prefix(CashInstance __instance, out float __state)
		{
			__state = __instance.Balance;
		}

		[HarmonyPostfix]
		public static void Postfix(CashInstance __instance, float __0, float __state)
		{
			if (CashStackingConfig.TryGet(out var cap))
			{
				float num = Mathf.Min(__state + __0, cap);
				if (num > __instance.Balance)
				{
					__instance.Balance = num;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemUIManager), "CanCashBeDraggedIntoSlot")]
	public class CashCanDragIntoSlotPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemSlotUI __0, ref bool __result)
		{
			if (!__result && CashStackingConfig.TryGet(out var _) && !((Object)(object)__0 == (Object)null) && __0.assignedSlot != null)
			{
				ItemSlot assignedSlot = __0.assignedSlot;
				CashInstance val = ((assignedSlot.ItemInstance != null) ? ((Il2CppObjectBase)assignedSlot.ItemInstance).TryCast<CashInstance>() : null);
				if (val != null || (assignedSlot.ItemInstance == null && assignedSlot.CanSlotAcceptCash()))
				{
					__result = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemSlot), "GetCapacityForItem")]
	public class CashSlotCapacityPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemSlot __instance, ItemInstance __0, ref int __result)
		{
			if (!CashStackingConfig.TryGet(out var cap))
			{
				return;
			}
			CashInstance val = ((__0 != null) ? ((Il2CppObjectBase)__0).TryCast<CashInstance>() : null);
			if (val == null)
			{
				return;
			}
			CashInstance val2 = ((__instance.ItemInstance != null) ? ((Il2CppObjectBase)__instance.ItemInstance).TryCast<CashInstance>() : null);
			if (val2 != null || (__instance.ItemInstance == null && __instance.CanSlotAcceptCash()))
			{
				float num = ((val2 != null) ? val2.Balance : 0f);
				int num2 = Mathf.Max(0, Mathf.FloorToInt(cap - num));
				if (num2 > __result)
				{
					__result = num2;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemInstance), "CanStackWith")]
	public class CashCanStackPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemInstance __instance, ItemInstance __0, ref bool __result)
		{
			if (!__result && CashStackingConfig.TryGet(out var _))
			{
				CashInstance val = ((__instance != null) ? ((Il2CppObjectBase)__instance).TryCast<CashInstance>() : null);
				CashInstance val2 = ((__0 != null) ? ((Il2CppObjectBase)__0).TryCast<CashInstance>() : null);
				if (val != null && val2 != null)
				{
					__result = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Registry), "AddToRegistry")]
	public class RegistryAddToRegistryPatch
	{
		[HarmonyPostfix]
		public static void RegistryAddToRegistry(Registry __instance, ItemDefinition item)
		{
			CollectionExtensions.AddItem<ItemDefinition>((IEnumerable<ItemDefinition>)ItemRegistry.AllItemDefinitions, item);
			ItemRegistry.UpdateItemDefinition(item);
		}
	}
	[HarmonyPatch(typeof(Registry), "Start")]
	public class RegistryStartPatch
	{
		[HarmonyPostfix]
		public static void RegistryStart(Registry __instance)
		{
			ModStackSizesConfiguration configuration = Core.Get<ModStackSizes>().Configuration;
			if (configuration.Enabled)
			{
				List<ItemRegister> list = new List<ItemRegister>();
				Enumerator<ItemRegister> enumerator = __instance.ItemRegistry.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ItemRegister current = enumerator.Current;
					list.Add(current);
				}
				ItemRegistry.AllItemDefinitions = list.Select((ItemRegister itemRegister) => itemRegister.Definition).ToList();
				ItemRegistry.UpdateEntireRegistry();
			}
		}
	}
}
namespace Lithium.Modules.PhoneApp
{
	public class ModPhoneAppConfiguration : ModuleConfiguration
	{
		public override string Name => "PhoneApp";

		public ModPhoneAppConfiguration()
		{
			Enabled = true;
		}
	}
	public class ModPhoneApp : ModuleBase<ModPhoneAppConfiguration>
	{
		private LithiumPhoneApp _app;

		public override void Apply()
		{
			if (base.Configuration.Enabled && (_app == null || !_app.IsAlive))
			{
				_app = new LithiumPhoneApp();
				MelonCoroutines.Start(_app.BuildWhenReady());
			}
		}

		public void DriveUpdate()
		{
			if (base.Configuration.Enabled)
			{
				_app?.Update();
			}
		}
	}
	internal sealed class LithiumPhoneApp
	{
		private readonly struct TableCell
		{
			public readonly string Text;

			public readonly float XMin;

			public readonly float XMax;

			public readonly TextAnchor Anchor;

			public TableCell(string text, float xMin, float xMax, TextAnchor anchor)
			{
				//IL_0017: 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)
				Text = text;
				XMin = xMin;
				XMax = xMax;
				Anchor = anchor;
			}
		}

		private const string IconObjectName = "LithiumPhoneIcon";

		private const float Pad = 14f;

		private const float RefreshInterval = 0.5f;

		private static readonly Color Background = Color32.op_Implicit(new Color32((byte)18, (byte)18, (byte)22, byte.MaxValue));

		private static readonly Color HeaderColor = new Color(0.7f, 0.8f, 1f);

		private static readonly Color Gray = new Color(0.72f, 0.72f, 0.74f);

		private static readonly Color Red = new Color(1f, 0.32f, 0.32f);

		private static readonly Color IconColor = new Color(0.46f, 0.4f, 0.9f);

		private const string Green = "#3CCB5A";

		private const string RedHex = "#FF5151";

		private const string Dim = "#9AA0A6";

		private static readonly Color TabSelected = new Color(0.34f, 0.3f, 0.62f, 1f);

		private static readonly Color TabUnselected = new Color(0.15f, 0.15f, 0.19f, 1f);

		private GameObject _appContainer;

		private GameObject _icon;

		private GameObject _bodyContent;

		private RectTransform _bodyContentRect;

		private Dropdown _dropdown;

		private Font _font;

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

		private readonly List<Image> _tabBackgrounds = new List<Image>();

		private readonly List<Text> _tabLabels = new List<Text>();

		private int _tabIndex;

		private DailyOrdersPage _daily;

		private bool _isOpen;

		private bool _wasPhoneOpen;

		private float _lastRefresh;

		private float _y;

		private bool _rentEnabled;

		private List<ModRent.RentAppView> _locations = new List<ModRent.RentAppView>();

		private int _selectedIndex;

		public bool IsAlive => (Object)(object)_appContainer != (Object)null;

		public IEnumerator BuildWhenReady()
		{
			float waited = 0f;
			while ((!PlayerSingleton<HomeScreen>.InstanceExists || !PlayerSingleton<AppsCanvas>.InstanceExists) && waited < 30f)
			{
				yield return (object)new WaitForSeconds(0.2f);
				waited += 0.2f;
			}
			if (!PlayerSingleton<HomeScreen>.InstanceExists || !PlayerSingleton<AppsCanvas>.InstanceExists)
			{
				Log.Warning("[PhoneApp] Phone UI not ready after 30s; app not created.");
				yield break;
			}
			try
			{
				Build();
				Log.Info("[PhoneApp] Lithium app created.");
			}
			catch (Exception value)
			{
				Log.Error($"[PhoneApp] Build failed: {value}");
			}
		}

		private void Build()
		{
			//IL_0022: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			_font = PhoneAppFont.Resolve();
			_appContainer = PhoneAppBuilder.MakePanel("LithiumPhoneApp");
			PhoneAppBuilder.MakeBackground(_appContainer, Background);
			Text val = PhoneAppBuilder.MakeText(_appContainer.transform, _font, "Header", 40, HeaderColor, (TextAnchor)4, wrap: false);
			val.fontStyle = (FontStyle)1;
			val.text = "Lithium";
			SetRect(((Graphic)val).rectTransform, 0.05f, 0.92f, 0.95f, 0.985f);
			GameObject val2 = MakePage("PageProperty");
			GameObject val3 = MakePage("PageDaily");
			BuildTabBar(("Property", val2), ("Daily", val3));
			_dropdown = PhoneAppBuilder.CloneDropdown();
			if ((Object)(object)_dropdown != (Object)null)
			{
				((Component)_dropdown).transform.SetParent(val2.transform, false);
				((Component)_dropdown).transform.localScale = Vector3.one;
				SetRect(((Component)_dropdown).GetComponent<RectTransform>(), 0.05f, 0.775f, 0.95f, 0.845f);
				((UnityEvent<int>)(object)_dropdown.onValueChanged).AddListener(PhoneAppBuilder.UA(OnDropdownChanged));
			}
			else
			{
				Log.Warning("[PhoneApp] Could not clone a phone dropdown; selector unavailable.");
			}
			CreateBody(val2);
			_daily = new DailyOrdersPage();
			GameObject val4 = _daily.Build(val3.transform, _font);
			SetRect(val4.GetComponent<RectTransform>(), 0.04f, 0.03f, 0.96f, 0.845f);
			SelectTab(0, refresh: false);
			_appContainer.SetActive(false);
			_icon = PhoneAppBuilder.MakeIcon("LithiumPhoneIcon", "Lithium", PhoneAppBuilder.LoadIconOrDefault(IconColor), OnIconClicked);
		}

		private GameObject MakePage(string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(_appContainer.transform, false);
			val.transform.localScale = Vector3.one;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			_pages.Add(val);
			return val;
		}

		private void BuildTabBar(params (string Label, GameObject Page)[] tabs)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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)
			//IL_00e2: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Tabs");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(_appContainer.transform, false);
			val.transform.localScale = Vector3.one;
			SetRect(val2, 0.05f, 0.85f, 0.95f, 0.915f);
			float num = 1f / (float)tabs.Length;
			for (int i = 0; i < tabs.Length; i++)
			{
				int index = i;
				Image bg;
				Text labelText;
				Button val3 = PhoneAppBuilder.MakeButton(val.transform, _font, "Tab" + tabs[i].Label, tabs[i].Label, 26, TabUnselected, Color.white, delegate
				{
					OnTabClicked(index);
				}, out bg, out labelText);
				RectTransform component = ((Component)val3).GetComponent<RectTransform>();
				component.anchorMin = new Vector2((float)i * num, 0f);
				component.anchorMax = new Vector2((float)(i + 1) * num, 1f);
				component.offsetMin = new Vector2((i == 0) ? 0f : 3f, 0f);
				component.offsetMax = new Vector2((i == tabs.Length - 1) ? 0f : (-3f), 0f);
				_tabBackgrounds.Add(bg);
				_tabLabels.Add(labelText);
			}
		}

		private void OnTabClicked(int index)
		{
			if (_tabIndex != index)
			{
				SelectTab(index, _isOpen);
			}
		}

		private void SelectTab(int index, bool refresh)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			_tabIndex = index;
			for (int i = 0; i < _pages.Count; i++)
			{
				_pages[i].SetActive(i == index);
			}
			for (int j = 0; j < _tabBackgrounds.Count; j++)
			{
				((Graphic)_tabBackgrounds[j]).color = ((j == index) ? TabSelected : TabUnselected);
				((Graphic)_tabLabels[j]).color = ((j == index) ? Color.white : Gray);
			}
			if (refresh)
			{
				if (index == 0)
				{
					RebuildBody(refreshElectric: true);
				}
				else
				{
					_daily.Rebuild();
				}
			}
		}

		private void CreateBody(GameObject page)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0027: 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_0058: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0150: 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)
			GameObject val = new GameObject("Body");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(page.transform, false);
			val.transform.localScale = Vector3.one;
			SetRect(val2, 0.04f, 0.03f, 0.96f, 0.755f);
			GameObject val3 = new GameObject("Viewport");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			((Transform)val4).SetParent(val.transform, false);
			val3.transform.localScale = Vector3.one;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = Color.white;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			GameObject val5 = new GameObject("Content");
			_bodyContentRect = val5.AddComponent<RectTransform>();
			((Transform)_bodyContentRect).SetParent(val3.transform, false);
			val5.transform.localScale = Vector3.one;
			_bodyContentRect.anchorMin = new Vector2(0f, 1f);
			_bodyContentRect.anchorMax = new Vector2(1f, 1f);
			_bodyContentRect.pivot = new Vector2(0.5f, 1f);
			_bodyContentRect.sizeDelta = Vector2.zero;
			_bodyContent = val5;
			ScrollRect val6 = val.AddComponent<ScrollRect>();
			val6.horizontal = false;
			val6.vertical = true;
			val6.movementType = (MovementType)2;
			val6.scrollSensitivity = 24f;
			val6.viewport = val4;
			val6.content = _bodyContentRect;
		}

		private void OnIconClicked()
		{
			if (_isOpen)
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		private void Open()
		{
			if (!_isOpen && !((Object)(object)Phone.ActiveApp != (Object)null) && !((Object)(object)_appContainer == (Object)null))
			{
				RefreshLocations();
				_isOpen = true;
				_appContainer.SetActive(true);
				Phone.ActiveApp = _appContainer;
				PlayerSingleton<HomeScreen>.Instance.SetIsOpen(false);
				PlayerSingleton<AppsCanvas>.Instance.SetIsOpen(true);
				PlayerSingleton<Phone>.Instance.SetIsHorizontal(false);
				PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(1f);
				SelectTab(_tabIndex, refresh: true);
			}
		}

		private void Close()
		{
			if (_isOpen)
			{
				_isOpen = false;
				if ((Object)(object)_appContainer != (Object)null)
				{
					_appContainer.SetActive(false);
				}
				if ((Object)(object)Phone.ActiveApp == (Object)(object)_appContainer)
				{
					Phone.ActiveApp = null;
				}
				if (PlayerSingleton<HomeScreen>.InstanceExists)
				{
					PlayerSingleton<HomeScreen>.Instance.SetIsOpen(true);
				}
				if (PlayerSingleton<Phone>.InstanceExists)
				{
					PlayerSingleton<Phone>.Instance.SetIsHorizontal(false);
					PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(1f);
				}
			}
		}

		public void Update()
		{
			if ((Object)(object)_appContainer == (Object)null)
			{
				return;
			}
			bool flag = PlayerSingleton<Phone>.InstanceExists && PlayerSingleton<Phone>.Instance.IsOpen;
			if (_isOpen && !flag)
			{
				Close();
				_wasPhoneOpen = false;
				return;
			}
			_wasPhoneOpen = flag;
			if (!_isOpen)
			{
				return;
			}
			if (flag && Input.GetMouseButtonDown(0) && IsHoveringHomeButton())
			{
				Close();
			}
			else if (Time.time - _lastRefresh >= 0.5f)
			{
				_lastRefresh = Time.time;
				if (_tabIndex == 0)
				{
					RebuildBody(refreshElectric: false);
				}
				else if (_daily.NeedsRefresh)
				{
					_daily.Rebuild();
				}
			}
		}

		private static bool IsHoveringHomeButton()
		{
			//IL_0037: 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)
			GameplayMenu val = (Singleton<GameplayMenu>.InstanceExists ? Singleton<GameplayMenu>.Instance : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.OverlayCamera == (Object)null)
			{
				return false;
			}
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val.OverlayCamera.ScreenPointToRay(Input.mousePosition), ref val2, 2f, 1 << LayerMask.NameToLayer("Overlay")))
			{
				return (Object)(object)((RaycastHit)(ref val2)).collider != (Object)null && ((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "Button";
			}
			return false;
		}

		private void RefreshLocations()
		{
			//IL_00f9: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			ModRent modRent = Core.Get<ModRent>();
			_rentEnabled = modRent?.Configuration.Enabled ?? false;
			_locations = ((modRent != null) ? modRent.GetAppViews() : new List<ModRent.RentAppView>());
			string text = ((_selectedIndex >= 0 && _selectedIndex < _locations.Count) ? _locations[_selectedIndex].PropertyName : null);
			_selectedIndex = 0;
			if (text != null)
			{
				for (int i = 0; i < _locations.Count; i++)
				{
					if (_locations[i].PropertyName == text)
					{
						_selectedIndex = i;
						break;
					}
				}
			}
			if ((Object)(object)_dropdown == (Object)null)
			{
				return;
			}
			List<OptionData> val = new List<OptionData>();
			foreach (ModRent.RentAppView location in _locations)
			{
				val.Add(new OptionData
				{
					text = location.PropertyName,
					image = ResolveMugshot(location.ContactName)
				});
			}
			_dropdown.ClearOptions();
			_dropdown.AddOptions(val);
			if (_locations.Count > 0)
			{
				_dropdown.value = _selectedIndex;
				_dropdown.RefreshShownValue();
			}
		}

		private static Sprite ResolveMugshot(string contactName)
		{
			if (string.IsNullOrEmpty(contactName) || contactName == "—")
			{
				return null;
			}
			try
			{
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				if (nPCRegistry == null)
				{
					return null;
				}
				Enumerator<NPC> enumerator = nPCRegistry.GetEnumerator();
				while (enumerator.MoveNext())
				{
					NPC current = enumerator.Current;
					if ((Object)(object)current != (Object)null && string.Equals(current.fullName, contactName, StringComparison.OrdinalIgnoreCase))
					{
						return current.MugshotSprite;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[PhoneApp] Mugshot lookup failed for '" + contactName + "': " + ex.Message);
			}
			return null;
		}

		private void OnDropdownChanged(int index)
		{
			_selectedIndex = index;
			RebuildBody(refreshElectric: true);
		}

		private void RebuildBody(bool refreshElectric)
		{
			//IL_00f3: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: 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_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_bodyContent == (Object)null)
			{
				return;
			}
			ClearChildren(_bodyContent.transform);
			_y = -6f;
			ModRent.RentAppView rentAppView = ((_selectedIndex >= 0 && _selectedIndex < _locations.Count) ? _locations[_selectedIndex] : null);
			if (rentAppView == null)
			{
				AddLine(_rentEnabled ? "No rent-enabled properties." : "Rent module is disabled.", 28, Gray, 40f);
				FinishBody();
				return;
			}
			if (rentAppView.LockedOut)
			{
				AddLine("<b><color=#FF5151>⚠ LOCKED OUT — rent unpaid. Pay to restore access.</color></b>", 28, Red, 44f);
				_y -= 4f;
			}
			AddLine("<b>" + rentAppView.PropertyName + "</b>", 34, Color.white, 46f);
			string value = (rentAppView.FirstWeek ? "  <color=#9AA0A6>· first week</color>" : "");
			string value2 = (rentAppView.Paid ? "<color=#3CCB5A>PAID</color>" : "<color=#FF5151>UNPAID</color>");
			AddLine($"Rent: {value2}   <color={"#9AA0A6"}>(${rentAppView.WeeklyRent:N0}/wk)</color>{value}", 28, Color.white, 38f);
			if (!rentAppView.Paid)
			{
				AddLine($"Outstanding: <color={"#FF5151"}>${rentAppView.Owed:N0}</color>", 28, Color.white, 36f);
				if (rentAppView.HasOwedDue)
				{
					string value3 = ((rentAppView.DaysOverdue > 0) ? $"<color={"#FF5151"}>({rentAppView.DaysOverdue} day{((rentAppView.DaysOverdue == 1) ? "" : "s")} overdue)</color>" : "<color=#9AA0A6>(today)</color>");
					AddLine($"Due: {rentAppView.OwedDueWeekday} {value3}", 28, Color.white, 36f);
				}
			}
			else if (rentAppView.HasNextDue)
			{
				string value4 = ((rentAppView.DaysUntilDue == 1) ? "day" : "days");
				AddLine($"Next due: {rentAppView.NextDueWeekday} <color={"#9AA0A6"}>(in {rentAppView.DaysUntilDue} {value4})</color>", 28, Color.white, 36f);
			}
			AddLine("<color=#9AA0A6>Contact:</color> " + rentAppView.ContactName, 26, Gray, 34f);
			AddLine("<color=#9AA0A6>Dead drop:</color> " + rentAppView.DeadDropName, 26, Gray, 34f);
			_y -= 12f;
			AddLine("<b>Electricity — this week</b>", 30, HeaderColor, 42f);
			ModElectricBill.ElectricAppView electricAppView = Core.Get<ModElectricBill>()?.GetAppView(rentAppView.PropertyCode, refreshElectric);
			if (electricAppView == null || !electricAppView.ModuleEnabled)
			{
				AddLine("Electric bill module is disabled.", 26, Gray, 34f);
				FinishBody();
				return;
			}
			if (electricAppView.PoweredOff)
			{
				AddLine($"<color={"#FF5151"}>POWER CUT — ${electricAppView.OutstandingBill:N0} unpaid. Pay at the dead drop.</color>", 28, Red, 36f);
			}
			else if (electricAppView.OutstandingBill > 0f)
			{
				AddLine($"Bill due: <color={"#FF5151"}>${electricAppView.OutstandingBill:N0}</color> <color={"#9AA0A6"}>— pay in cash at the dead drop</color>", 28, Color.white, 36f);
			}
			if (electricAppView.Lines.Count == 0)
			{
				AddLine("No metered appliances here.", 24, Gray, 32f);
				FinishBody();
				return;
			}
			AddRow(true, Cell("Source", 0f, 0.55f, (TextAnchor)3), Cell("Qty", 0.55f, 0.72f, (TextAnchor)5), Cell("Cost", 0.72f, 1f, (TextAnchor)5));
			foreach (ModElectricBill.ApplianceLine line in electricAppView.Lines)
			{
				AddRow(false, Cell(line.Name, 0f, 0.55f, (TextAnchor)3), Cell(line.Count.ToString(), 0.55f, 0.72f, (TextAnchor)5), Cell($"${line.AccruedCost:N2}", 0.72f, 1f, (TextAnchor)5));
			}
			AddRow(true, Cell("Total", 0f, 0.55f, (TextAnchor)3), Cell("", 0.55f, 0.72f, (TextAnchor)5), Cell($"${electricAppView.TotalAccrued:N2}", 0.72f, 1f, (TextAnchor)5));
			_y -= 12f;
			AddLine("<b>Week estimate</b>", 28, HeaderColor, 38f);
			AddRow(true, Cell("Source", 0f, 0.5f, (TextAnchor)3), Cell("Now", 0.5f, 0.74f, (TextAnchor)5), Cell("~$/wk", 0.74f, 1f, (TextAnchor)5));
			foreach (ModElectricBill.ApplianceLine line2 in electricAppView.Lines)
			{
				AddRow(false, Cell(line2.Name, 0f, 0.5f, (TextAnchor)3), Cell($"{line2.CurrentWatts:N0}W", 0.5f, 0.74f, (TextAnchor)5), Cell($"${line2.ProjectedCost:N2}", 0.74f, 1f, (TextAnchor)5));
			}
			AddRow(true, Cell("Total", 0f, 0.5f, (TextAnchor)3), Cell($"{electricAppView.TotalWatts:N0}W", 0.5f, 0.74f, (TextAnchor)5), Cell($"${electricAppView.TotalProjected:N2}", 0.74f, 1f, (TextAnchor)5));
			FinishBody();
		}

		private void FinishBody()
		{
			//IL_001b: 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)
			float num = 0f - _y + 14f;
			_bodyContentRect.sizeDelta = new Vector2(_bodyContentRect.sizeDelta.x, num);
		}

		private void AddLine(string text, int fontSize, Color color, float height)
		{
			//IL_0018: 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_005f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			Text val = PhoneAppBuilder.MakeText(_bodyContent.transform, _font, "Line", fontSize, color, (TextAnchor)0, wrap: true);
			RectTransform rectTransform = ((Graphic)val).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.sizeDelta = new Vector2(-28f, height);
			rectTransform.anchoredPosition = new Vector2(0f, _y);
			val.text = text;
			_y -= height;
		}

		private static TableCell Cell(string text, float xMin, float xMax, TextAnchor anchor)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new TableCell(text, xMin, xMax, anchor);
		}

		private void AddRow(bool header, params TableCell[] cells)
		{
			//IL_000b: 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_0010: 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_001c: Expected O, but got Unknown
			//IL_003c: 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_0068: 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_0094: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Invalid comparison between Unknown and I4
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_0112: 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)
			Color color = (header ? HeaderColor : Color.white);
			GameObject val = new GameObject("Row");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(_bodyContent.transform, false);
			val.transform.localScale = Vector3.one;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.sizeDelta = new Vector2(-28f, 32f);
			val2.anchoredPosition = new Vector2(0f, _y);
			for (int i = 0; i < cells.Length; i++)
			{
				TableCell tableCell = cells[i];
				float leftInset = (((int)tableCell.Anchor == 3) ? 6f : 0f);
				float rightInset = (((int)tableCell.Anchor == 5) ? 6f : 0f);
				MakeCell((Transform)(object)val2, tableCell.XMin, tableCell.XMax, tableCell.Text, tableCell.Anchor, 24, color, leftInset, rightInset);
			}
			_y -= 32f;
		}

		private void MakeCell(Transform row, float xMin, float xMax, string text, TextAnchor anchor, int fontSize, Color color, float leftInset, float rightInset)
		{
			//IL_000f: 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_0028: 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_004d: 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)
			Text val = PhoneAppBuilder.MakeText(row, _font, "Cell", fontSize, color, anchor, wrap: false);
			RectTransform rectTransform = ((Graphic)val).rectTransform;
			rectTransform.anchorMin = new Vector2(xMin, 0f);
			rectTransform.anchorMax = new Vector2(xMax, 1f);
			rectTransform.offsetMin = new Vector2(leftInset, 0f);
			rectTransform.offsetMax = new Vector2(0f - rightInset, 0f);
			val.text = text;
		}

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

		private static void SetRect(RectTransform rt, float xMin, float yMin, float xMax, float yMax)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			rt.anchorMin = new Vector2(xMin, yMin);
			rt.anchorMax = new Vector2(xMax, yMax);
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}
	}
	internal static class PhoneAppBuilder
	{
		public static UnityAction UA(Action a)
		{
			return UnityAction.op_Implicit(a);
		}

		public static UnityAction<int> UA(Action<int> a)
		{
			return UnityAction<int>.op_Implicit(a);
		}

		public static Text MakeText(Transform parent, Font font, string name, int fontSize, Color color, TextAnchor anchor, bool wrap)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			Text val3 = val.AddComponent<Text>();
			val3.font = font;
			val3.fontSize = fontSize;
			((Graphic)val3).color = color;
			val3.alignment = anchor;
			val3.supportRichText = true;
			val3.horizontalOverflow = (HorizontalWrapMode)(!wrap);
			val3.verticalOverflow = (VerticalWrapMode)1;
			return val3;
		}

		public static Button MakeButton(Transform parent, Font font, string name, string label, int fontSize, Color bgColor, Color textColor, Action onClick, out Image bg, out Text labelText)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: 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_005e: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			bg = val.AddComponent<Image>();
			((Graphic)bg).color = bgColor;
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)bg;
			labelText = MakeText(val.transform, font, "Label", fontSize, textColor, (TextAnchor)4, wrap: false);
			RectTransform rectTransform = ((Graphic)labelText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			labelText.text = label;
			if (onClick != null)
			{
				((UnityEvent)val3.onClick).AddListener(UA(onClick));
			}
			return val3;
		}

		public static GameObject MakePanel(string name)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002e: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_006a: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			AppsCanvas instance = PlayerSingleton<AppsCanvas>.Instance;
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(((Component)instance.canvas).transform, false);
			val.transform.localScale = Vector3.one;
			RectTransform val3 = FindAppRect(instance);
			if ((Object)(object)val3 != (Object)null)
			{
				val2.anchorMin = val3.anchorMin;
				val2.anchorMax = val3.anchorMax;
				val2.anchoredPosition = val3.anchoredPosition;
				val2.sizeDelta = val3.sizeDelta;
				val2.pivot = val3.pivot;
				((Transform)val2).localRotation = ((Transform)val3).localRotation;
				((Transform)val2).localScale = ((Transform)val3).localScale;
			}
			else
			{
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
			}
			return val;
		}

		private static RectTransform FindAppRect(AppsCanvas canvas)
		{
			string[] array = new string[3] { "DealerManagement", "Delivery", "ProductManager" };
			foreach (string text in array)
			{
				Transform val = ((Component)canvas.canvas).transform.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					return ((Component)val).GetComponent<RectTransform>();
				}
			}
			return null;
		}

		public static void MakeBackground(GameObject parent, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0027: 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_003f: 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_0057: 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 = new GameObject("Background");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent.transform, false);
			val.transform.localScale = Vector3.one;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Graphic)val.AddComponent<Image>()).color = color;
		}

		public static Dropdown CloneDropdown()
		{
			//IL_006c: 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)
			GameObject val = FindAndClone<Dropdown>("Delivery");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Dropdown component = val.GetComponent<Dropdown>();
			component.ClearOptions();
			Image val2 = FindCaptionImage(component);
			if ((Object)(object)val2 != (Object)null)
			{
				component.captionImage = val2;
				val2.preserveAspect = true;
			}
			if ((Object)(object)component.captionText != (Object)null)
			{
				((Graphic)component.captionText).color = Color.white;
				component.captionText.resizeTextForBestFit = true;
				component.captionText.resizeTextMinSize = 16;
				component.captionText.resizeTextMaxSize = 28;
			}
			if ((Object)(object)component.itemText != (Object)null)
			{
				((Graphic)component.itemText).color = Color.white;
				component.itemText.fontSize = 26;
			}
			return component;
		}

		private static Image FindCaptionImage(Dropdown dd)
		{
			RectTransform template = dd.template;
			Il2CppArrayBase<Image> componentsInChildren = ((Component)dd).GetComponentsInChildren<Image>(true);
			if (componentsInChildren == null)
			{
				return null;
			}
			foreach (Image item in componentsInChildren)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)((Component)item).gameObject == (Object)(object)((Component)dd).gameObject || ((Object)(object)template != (Object)null && ((Component)item).transform.IsChildOf(((Component)template).transform)) || ((Object)item).name == "Arrow")
				{
					continue;
				}
				return item;
			}
			return null;
		}

		private static GameObject FindAndClone<T>(string preferredApp) where T : Component
		{
			AppsCanvas val = (PlayerSingleton<AppsCanvas>.InstanceExists ? PlayerSingleton<AppsCanvas>.Instance : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = ((Component)val.canvas).transform.Find(preferredApp);
			if ((Object)(object)val2 != (Object)null)
			{
				T componentInChildren = ((Component)val2).GetComponentInChildren<T>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					return Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject);
				}
			}
			int childCount = ((Component)val.canvas).transform.childCount;
			for (int i = 0; i < childCount; i++)
			{
				T componentInChildren2 = ((Component)((Component)val.canvas).transform.GetChild(i)).GetComponentInChildren<T>(true);
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					return Object.Instantiate<GameObject>(((Component)componentInChildren2).gameObject);
				}
			}
			return null;
		}

		public static GameObject MakeIcon(string iconObjectName, string label, Sprite sprite, Action onClick)
		{
			HomeScreen instance = PlayerSingleton<HomeScreen>.Instance;
			GameObject val = Object.Instantiate<GameObject>(instance.appIconPrefab, (Transform)(object)instance.appIconContainer);
			((Object)val).name = iconObjectName;
			Transform val2 = val.transform.Find("Label");
			if ((Object)(object)val2 != (Object)null)
			{
				Text component = ((Component)val2).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.text = label;
				}
			}
			Transform val3 = val.transform.Find("Mask/Image");
			if ((Object)(object)val3 != (Object)null)
			{
				Image component2 = ((Component)val3).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null && (Object)(object)sprite != (Object)null)
				{
					component2.sprite = sprite;
				}
			}
			Transform val4 = val.transform.Find("Notifications");
			if ((Object)(object)val4 != (Object)null)
			{
				((Component)val4).gameObject.SetActive(false);
			}
			Button component3 = val.GetComponent<Button>();
			if ((Object)(object)component3 != (Object)null)
			{
				((UnityEvent)component3.onClick).AddListener(UA(onClick));
			}
			return val;
		}

		public static Sprite LoadIconOrDefault(Color fallback)
		{
			//IL_00a8: 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_0033: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string path = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium", "PhoneAppIcon.png");
				if (File.Exists(path))
				{
					byte[] array = File.ReadAllBytes(path);
					Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
					if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array)) && ((Texture)val).width > 2)
					{
						((Texture)val).filterMode = (FilterMode)1;
						((Texture)val).wrapMode = (TextureWrapMode)1;
						return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
					}
				}
			}
			catch
			{
			}
			return CircleSprite(fallback);
		}

		public static Sprite CircleSprite(Color fill)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_00b3: 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_004e: 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_0067: 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(64, 64)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(32f, 32f);
			Il2CppStructArray<Color> val3 = new Il2CppStructArray<Color>(4096L);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					((Il2CppArrayBase<Color>)(object)val3)[i * 64 + j] = ((Vector2.Distance(new Vector2((float)j, (float)i), val2) <= 30f) ? fill : Color.clear);
				}
			}
			val.SetPixels(val3);
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class PhoneAppFont
	{
		private static Font _cached;

		public static Font Resolve()
		{
			if ((Object)(object)_cached != (Object)null)
			{
				return _cached;
			}
			AppsCanvas val = (PlayerSingleton<AppsCanvas>.InstanceExists ? PlayerSingleton<AppsCanvas>.Instance : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.canvas != (Object)null)
			{
				_cached = FirstFont(((Component)val.canvas).GetComponentsInChildren<Text>(true));
			}
			if ((Object)(object)_cached == (Object)null)
			{
				_cached = FirstFont(Object.FindObjectsOfType<Text>(true));
			}
			if ((Object)(object)_cached == (Object)null)
			{
				_cached = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf") ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
			return _cached;
		}

		private static Font FirstFont(Il2CppArrayBase<Text> texts)
		{
			if (texts == null)
			{
				return null;
			}
			foreach (Text text in texts)
			{
				if ((Object)(object)text != (Object)null && (Object)(object)text.font != (Object)null)
				{
					return text.font;
				}
			}
			return null;
		}
	}
	internal sealed class DailyOrdersPage
	{
		private sealed class Row
		{
			public string Name;

			public Sprite Mugshot;

			public EQuality Quality;

			public int QuantityLevel;

			public int OrderTime;

			public bool Done;

			public bool Shifted;
		}

		private const float Pad = 14f;

		private const float RowHeight = 60f;

		private const float RowStep = 66f;

		private const float MugshotSize = 48f;

		private const float StarSize = 28f;

		private const float StarStep = 32f;

		private static readonly Color RowColor = new Color(0.13f, 0.13f, 0.16f, 0.85f);

		private static readonly Color HeaderColor = new Color(0.7f, 0.8f, 1f);

		private static readonly Color Gray = new Color(0.72f, 0.72f, 0.74f);

		private const float DoneAlpha = 0.42f;

		private const string DoneCheckHex = "#82E07A";

		private const string ShiftedTagHex = "#9FB7E0";

		private GameObject _content;

		private RectTransform _contentRect;

		private Font _font;

		private Sprite _starSprite;

		private EDay _builtDay;

		private bool _built;

		private float _y;

		public bool NeedsRefresh
		{
			get
			{
				//IL_001f: 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)
				if (!_built || (Object)(object)NetworkSingleton<TimeManager>.Instance == (Object)null)
				{
					return false;
				}
				return GameDay.CurrentDay != _builtDay;
			}
		}

		public GameObject Build(Transform parent, Font font)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0029: 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_003f: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_008a: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00e6: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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)
			_font = font;
			GameObject val = new GameObject("DailyList");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			GameObject val3 = new GameObject("Viewport");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			((Transform)val4).SetParent(val.transform, false);
			val3.transform.localScale = Vector3.one;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = Color.white;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			GameObject val5 = new GameObject("Content");
			_contentRect = val5.AddComponent<RectTransform>();
			((Transform)_contentRect).SetParent(val3.transform, false);
			val5.transform.localScale = Vector3.one;
			_contentRect.anchorMin = new Vector2(0f, 1f);
			_contentRect.anchorMax = new Vector2(1f, 1f);
			_contentRect.pivot = new Vector2(0.5f, 1f);
			_contentRect.sizeDelta = Vector2.zero;
			_content = val5;
			ScrollRect val6 = val.AddComponent<ScrollRect>();
			val6.horizontal = false;
			val6.vertical = true;
			val6.movementType = (MovementType)2;
			val6.scrollSensitivity = 24f;
			val6.viewport = val4;
			val6.content = _contentRect;
			return val;
		}

		public void Rebuild()
		{
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: 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)
			//IL_0067: 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_006a: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_content == (Object)null)
			{
				return;
			}
			for (int num = _content.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)_content.transform.GetChild(num)).gameObject);
			}
			_y = -6f;
			try
			{
				EDay val = (_builtDay = GameDay.CurrentDay);
				_built = true;
				List<Row> list = GatherToday(val);
				int num2 = list.Count((Row r) => r.Done);
				string value = ((num2 > 0) ? $" · {num2} done" : string.Empty);
				AddLine($"<b>Ordering today ({list.Count}) — {val}{value}</b>", 30, HeaderColor, 40f);
				AddLine("Stars: count = order size, colour = desired quality", 20, Gray, 28f);
				_y -= 6f;
				if (list.Count == 0)
				{
					AddLine("No customers will order today.", 26, Gray, 36f);
				}
				else
				{
					foreach (Row item in list)
					{
						AddRow(item);
					}
				}
			}
			catch (Exception value2)
			{
				Log.Error($"[PhoneApp] Daily list rebuild failed: {value2}");
				AddLine("Could not read customer data.", 26, Gray, 36f);
			}
			_contentRect.sizeDelta = new Vector2(_contentRect.sizeDelta.x, 0f - _y + 14f);
		}

		private static List<Row> GatherToday(EDay today)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			List<Row> list = new List<Row>();
			foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.CustomerData == (Object)null) && !((Object)(object)item.NPC == (Object)null))
				{
					CustomerData customerData = item.CustomerData;
					string name = ((Object)customerData).name;
					float num = ((item.NPC.RelationData != null) ? (item.NPC.RelationData.RelationDelta / 5f) : 0f);
					List<EDay> list2 = customerData.GetOrderDays(item.CurrentAddiction, num).ToList<EDay>();
					bool flag = list2.Contains(today);
					bool flag2 = DailyOrderTracker.CaughtUpToday(name);
					bool flag3 = DailyOrderTracker.CompletedToday(name);
					if (flag || flag2 || flag3)
					{
						list.Add(new Row
						{
							Name = item.NPC.fullName,
							Mugshot = item.NPC.MugshotSprite,
							Quality = CorrespondingQuality(customerData.Standards),
							QuantityLevel = ((list2.Count >= 3) ? 1 : ((list2.Count == 2) ? 2 : 3)),
							OrderTime = customerData.OrderTime,
							Done = flag3,
							Shifted = (flag2 && !flag)
						});
					}
				}
			}
			list.Sort(delegate(Row a, Row b)
			{
				if (a.Done != b.Done)
				{
					return a.Done ? 1 : (-1);
				}
				return (a.OrderTime != b.OrderTime) ? a.OrderTime.CompareTo(b.OrderTime) : string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase);
			});
			return list;
		}

		private static EQuality CorrespondingQuality(ECustomerStandard standards)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			//IL_0021: 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_0029: 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_0031: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			EQuality result = (EQuality)((int)standards switch
			{
				0 => 0, 
				1 => 1, 
				2 => 2, 
				3 => 3, 
				4 => 4, 
				_ => 2, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private static Color QualityColor(EQuality quality)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			//IL_002e: 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_0038: 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_004e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008a: 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_00a3: 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_00ad: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			Color result = (Color)((int)quality switch
			{
				0 => Color32.op_Implicit(new Color32((byte)125, (byte)50, (byte)50, byte.MaxValue)), 
				1 => Color32.op_Implicit(new Color32((byte)80, (byte)145, (byte)50, byte.MaxValue)), 
				2 => Color32.op_Implicit(new Color32((byte)100, (byte)190, byte.MaxValue, byte.MaxValue)), 
				3 => Color32.op_Implicit(new Color32((byte)225, (byte)75, byte.MaxValue, byte.MaxValue)), 
				4 => Color32.op_Implicit(new Color32(byte.MaxValue, (byte)200, (byte)50, byte.MaxValue)), 
				_ => Color.white, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private static string QualityHex(EQuality quality)
		{
			//IL_0005: 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)
			return "#" + ColorUtility.ToHtmlStringRGB(QualityColor(quality));
		}

		private Sprite ResolveStarSprite()
		{
			if ((Object)(object)_starSprite != (Object)null)
			{
				return _starSprite;
			}
			try
			{
				if (PlayerSingleton<MessagesApp>.InstanceExists)
				{
					Image standardsStar = PlayerSingleton<MessagesApp>.Instance.standardsStar;
					if ((Object)(object)standardsStar != (Object)null)
					{
						_starSprite = standardsStar.sprite;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[PhoneApp] Could not resolve standards star sprite: " + ex.Message);
			}
			return _starSprite;
		}

		private void AddRow(Row row)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_009b: 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_0206: 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_023e: 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_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0137: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: 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_0319: Expected O, but got Unknown
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("CustomerRow");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(_content.transform, false);
			val.transform.localScale = Vector3.one;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.sizeDelta = new Vector2(-28f, 60f);
			val2.anchoredPosition = new Vector2(0f, _y);
			float num = (row.Done ? 0.42f : 1f);
			((Graphic)val.AddComponent<Image>()).color = new Color(RowColor.r, RowColor.g, RowColor.b, RowColor.a * num);
			if ((Object)(object)row.Mugshot != (Object)null)
			{
				GameObject val3 = new GameObject("Mugshot");
				RectTransform val4 = val3.AddComponent<RectTransform>();
				((Transform)val4).SetParent(val.transform, false);
				val3.transform.localScale = Vector3.one;
				val4.anchorMin = new Vector2(0f, 0.5f);
				val4.anchorMax = new Vector2(0f, 0.5f);
				val4.pivot = new Vector2(0f, 0.5f);
				val4.sizeDelta = new Vector2(48f, 48f);
				val4.anchoredPosition = new Vector2(6f, 0f);
				Image val5 = val3.AddComponent<Image>();
				val5.sprite = row.Mugshot;
				val5.preserveAspect = true;
				((Graphic)val5).color = new Color(1f, 1f, 1f, num);
			}
			Text val6 = PhoneAppBuilder.MakeText(val.transform, _font, "Name", 26, Color.white, (TextAnchor)3, wrap: false);
			RectTransform rectTransform = ((Graphic)val6).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.offsetMin = new Vector2(64f, 0f);
			rectTransform.offsetMax = new Vector2(-106f, 0f);
			((Graphic)val6).color = new Color(1f, 1f, 1f, num);
			if (row.Done)
			{
				val6.text = "<color=#82E07A>✓</color> " + row.Name;
			}
			else if (row.Shifted)
			{
				val6.text = row.Name + "  <size=18><color=#9FB7E0>(shifted)</color></size>";
			}
			else
			{
				val6.text = row.Name;
			}
			Sprite val7 = ResolveStarSprite();
			if ((Object)(object)val7 != (Object)null)
			{
				for (int i = 0; i < row.QuantityLevel; i++)
				{
					GameObject val8 = new GameObject("Star");
					RectTransform val9 = val8.AddComponent<RectTransform>();
					((Transform)val9).SetParent(val.transform, false);
					val8.transform.localScale = Vector3.one;
					val9.anchorMin = new Vector2(1f, 0.5f);
					val9.anchorMax = new Vector2(1f, 0.5f);
					val9.pivot = new Vector2(1f, 0.5f);
					val9.sizeDelta = new Vector2(28f, 28f);
					val9.anchoredPosition = new Vector2(-6f - (float)i * 32f, 0f);
					Image val10 = val8.AddComponent<Image>();
					val10.sprite = val7;
					val10.preserveAspect = true;
					Color val11 = QualityColor(row.Quality);
					((Graphic)val10).color = new Color(val11.r, val11.g, val11.b, num);
				}
			}
			else
			{
				Text val12 = PhoneAppBuilder.MakeText(val.transform, _font, "Stars", 30, Color.white, (TextAnchor)5, wrap: false);
				RectTransform rectTransform2 = ((Graphic)val12).rectTransform;
				rectTransform2.anchorMin = new Vector2(0.6f, 0f);
				rectTransform2.anchorMax = new Vector2(1f, 1f);
				rectTransform2.offsetMin = Vector2.zero;
				rectTransform2.offsetMax = new Vector2(-6f, 0f);
				((Graphic)val12).color = new Color(1f, 1f, 1f, num);
				val12.text = $"<color={QualityHex(row.Quality)}>{new string('★', row.QuantityLevel)}</color>";
			}
			_y -= 66f;
		}

		private void AddLine(string text, int fontSize, Color color, float height)
		{
			//IL_0018: 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_005f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			Text val = PhoneAppBuilder.MakeText(_content.transform, _font, "Line", fontSize, color, (TextAnchor)0, wrap: true);
			RectTransform rectTransform = ((Graphic)val).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.sizeDelta = new Vector2(-28f, height);
			rectTransform.anchoredPosition = new Vector2(0f, _y);
			val.text = text;
			_y -= height;
		}
	}
}
namespace Lithium.Modules.PlantGrowth
{
	public class WeightedFloat
	{
		public float Weight;

		public float Value;

		[JsonConstructor]
		public WeightedFloat(float weight, float value)
		{
			Weight = weight;
			Value = value;
		}
	}
	public class ModPlantsConfiguration : ModuleConfiguration
	{
		public float GrowthModifier = 0.7f;

		public float WaterDrainModifier = 4f;

		public List<WeightedFloat> RandomYieldsPerBudModifier = DefaultResultsPerBud();

		public List<WeightedFloat> RandomYieldModifiers = DefaultYieldModifiers();

		public List<WeightedFloat> RandomQualityModifiers = DefaultQualityModifiers();

		[JsonIgnore]
		public WeightedPicker<float> RandomYieldPerBudPicker;

		[JsonIgnore]
		public WeightedNormalizer RandomYieldModifierPicker;

		[JsonIgnore]
		public WeightedNormalizer RandomYieldQualityPicker;

		public override string Name => "Plants";

		public static List<WeightedFloat> DefaultResultsPerBud()
		{
			return new List<WeightedFloat>(3)
			{
				new WeightedFloat(80f, 1f),
				new WeightedFloat(17f, 2f),
				new WeightedFloat(3f, 3f)
			};
		}

		public static List<WeightedFloat> DefaultYieldModifiers()
		{
			return new List<WeightedFloat>(6)
			{
				new WeightedFloat(2f, 0.5f),
				new WeightedFloat(10f, 0.75f),
				new WeightedFloat(13f, 1f),
				new WeightedFloat(50f, 1f),
				new WeightedFloat(15f, 1.25f),
				new WeightedFloat(8f, 2f)
			};
		}

		public static List<WeightedFloat> DefaultQualityModifiers()
		{
			return new List<WeightedFloat>(6)
			{
				new WeightedFloat(2f, -0.3f),
				new WeightedFloat(10f, -0.15f),
				new WeightedFloat(13f, 0f),
				new WeightedFloat(50f, 0f),
				new WeightedFloat(13f, 0.15f),
				new WeightedFloat(10f, 0.3f)
			};
		}

		public override void Validate()
		{
			GrowthModifier = ConfigValidator.AtLeast(Name, "GrowthModifier", GrowthModifier, 0.001f);
			WaterDrainModifier = ConfigValidator.AtLeast(Name, "WaterDrainModifier", WaterDrainModifier, 0f);
		}
	}
	public class ModPlants : ModuleBase<ModPlantsConfiguration>
	{
		public ModPlants()
		{
			ClassInjector.RegisterTypeInIl2Cpp<PlantModified>();
			ClassInjector.RegisterTypeInIl2Cpp<PlantBaseQuality>();
			ClassInjector.RegisterTypeInIl2Cpp<PotBaseValues>();
		}

		protected override void OnBeforeConfigurationLoaded()
		{
			base.OnBeforeConfigurationLoaded();
			base.Configuration.RandomYieldsPerBudModifier.Clear();
			base.Configuration.RandomYieldModifiers.Clear();
			base.Configuration.RandomQualityModifiers.Clear();
		}

		public override void Load()
		{
			base.Load();
			bool flag = false;
			if (IsInvalid(base.Configuration.RandomYieldsPerBudModifier))
			{
				base.Configuration.RandomYieldsPerBudModifier = ModPlantsConfiguration.DefaultResultsPerBud();
				flag = true;
			}
			if (IsInvalid(base.Configuration.RandomYieldModifiers))
			{
				base.Configuration.RandomYieldModifiers = ModPlantsConfiguration.DefaultYieldModifiers();
				flag = true;
			}
			if (IsInvalid(base.Configuration.RandomQualityModifiers))
			{
				base.Configuration.RandomQualityModifiers = ModPlantsConfiguration.DefaultQualityModifiers();
				flag = true;
			}
			if (flag)
			{
				base.Configuration.SaveConfiguration();
			}
			base.Configuration.RandomYieldPerBudPicker = new WeightedPicker<float>();
			base.Configuration.RandomYieldPerBudPicker.AddRange(base.Configuration.RandomYieldsPerBudModifier.Select((WeightedFloat p) => new KeyValuePair<float, float>(p.Value, p.Weight)));
			base.Configuration.RandomYieldModifierPicker = new WeightedNormalizer();
			foreach (WeightedFloat randomYieldModifier in base.Configuration.RandomYieldModifiers)
			{
				base.Configuration.RandomYieldModifierPicker.Add(randomYieldModifier.Weight, randomYieldModifier.Value);
			}
			base.Configuration.RandomYieldQualityPicker = new WeightedNormalizer();
			foreach (WeightedFloat randomQualityModifier in base.Configuration.RandomQualityModifiers)
			{
				base.Configuration.RandomYieldQualityPicker.Add(randomQualityModifier.Weight, randomQualityModifier.Value);
			}
		}

		private static bool IsInvalid(List<WeightedFloat> list)
		{
			return list == null || list.Count == 0 || list.Sum((WeightedFloat e) => e.Weight) <= 0f;
		}

		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
	public static class HarvestQuality
	{
		public static float ComputeBaseQuality(Plant plant)
		{
			float num = Plant.BaseQualityLevel;
			Pot val = (((Object)(object)plant != (Object)null) ? plant.Pot : null);
			if ((Object)(object)val != (Object)null && ((GrowContainer)val).AppliedAdditives != null)
			{
				foreach (AdditiveDefinition item in ((GrowContainer)val).AppliedAdditives.ToList<AdditiveDefinition>())
				{
					if ((Object)(object)item != (Object)null)
					{
						num += item.QualityChange;
					}
				}
			}
			return Mathf.Clamp01(num);
		}
	}
}
namespace Lithium.Modules.PlantGrowth.Patches
{
	[HarmonyPatch(typeof(HarvestPotBehaviour), "GetQuantityToHarvest")]
	public class HarvestPotBehaviourYieldPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ref int __result)
		{
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (configuration.Enabled && InstanceFinder.IsServer && __result > 0)
			{
				__result = Math.Max(1, (int)((float)__result * configuration.RandomYieldPerBudPicker.Pick()));
			}
		}
	}
	[HarmonyPatch(typeof(Plant), "SetNormalizedGrowthProgress")]
	public class PlantGrowthDonePatch
	{
		[HarmonyPrefix]
		public static void Prefix(Plant __instance, float progress)
		{
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (configuration.Enabled && InstanceFinder.IsServer && !((Object)(object)__instance == (Object)null) && !(progress < 1f) && !(__instance.NormalizedGrowthProgress >= 1f) && !((Object)(object)((Component)__instance).GetComponent<PlantModified>() != (Object)null))
			{
				((Component)__instance).gameObject.AddComponent<PlantModified>();
				__instance.YieldMultiplier *= configuration.RandomYieldModifierPicker.Evaluate(Random.value);
			}
		}
	}
	[HarmonyPatch(typeof(PlantHarvestable), "Harvest")]
	public class PlantHarvestablePatch
	{
		private static readonly Dictionary<object, bool> SkipFlags = new Dictionary<object, bool>();

		private static readonly Dictionary<object, bool> GenerateFlags = new Dictionary<object, bool>();

		internal static bool PlayerHarvestInProgress;

		[HarmonyPrefix]
		public static bool Prefix(PlantHarvestable __instance)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (!configuration.Enabled)
			{
				return true;
			}
			PlayerHarvestInProgress = true;
			Plant componentInParent = ((Component)__instance).GetComponentInParent<Plant>();
			float num = HarvestQuality.ComputeBaseQuality(componentInParent);
			PlantBaseQuality plantBaseQuality = default(PlantBaseQuality);
			if (!((Component)componentInParent).TryGetComponent<PlantBaseQuality>(ref plantBaseQuality))
			{
				plantBaseQuality = ((Component)componentInParent).gameObject.AddComponent<PlantBaseQuality>();
				plantBaseQuality.Quality = num;
				plantBaseQuality.NeedsNotification = true;
			}
			if (!GenerateFlags.ContainsKey(__instance))
			{
				float num2 = configuration.RandomYieldQualityPicker.Evaluate(Random.value);
				componentInParent.QualityLevel = Mathf.Clamp01(num + num2);
				__instance.ProductQuantity = (int)configuration.RandomYieldPerBudPicker.Pick();
				GenerateFlags[__instance] = true;
			}
			QualityItemInstance val = new QualityItemInstance((ItemDefinition)(object)__instance.Product, __instance.ProductQuantity, ItemQuality.GetQuality(componentInParent.QualityLevel));
			if (!PlayerSingleton<PlayerInventory>.Instance.CanItemFitInInventory((ItemInstance)(object)val, 1))
			{
				SkipFlags[__instance] = true;
				return false;
			}
			SkipFlags.Remove(__instance);
			return true;
		}

		[HarmonyPostfix]
		public static void Postfix(PlantHarvestable __instance)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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)
			PlayerHarvestInProgress = false;
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (!configuration.Enabled || SkipFlags.ContainsKey(__instance) || !GenerateFlags.Remove(__instance))
			{
				return;
			}
			Plant componentInParent = ((Component)__instance).GetComponentInParent<Plant>();
			PlantBaseQuality plantBaseQuality = default(PlantBaseQuality);
			if (((Component)componentInParent).TryGetComponent<PlantBaseQuality>(ref plantBaseQuality))
			{
				if (plantBaseQuality.NeedsNotification)
				{
					EQuality quality = ItemQuality.GetQuality(componentInParent.QualityLevel);
					Singleton<NotificationsManager>.Instance.SendNotification($"{__instance.ProductQuantity}x {((BaseItemDefinition)componentInParent.SeedDefinition).Name}", $"{quality:G} quality", ((BaseItemDefinition)componentInParent.SeedDefinition).Icon, 2f, false);
					plantBaseQuality.NeedsNotification = false;
				}
				componentInParent.QualityLevel = plantBaseQuality.Quality;
				Object.Destroy((Object)(object)plantBaseQuality);
			}
		}
	}
	[HarmonyPatch]
	public class PlantGetHarvestedProductPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(WeedPlant), "GetHarvestedProduct", new Type[1] { typeof(int) }, (Type[])null);
			yield return AccessTools.Method(typeof(CocaPlant), "GetHarvestedProduct", new Type[1] { typeof(int) }, (Type[])null);
		}

		[HarmonyPrefix]
		public static void Prefix(Plant __instance, out float __state)
		{
			__state = float.NaN;
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (configuration.Enabled && InstanceFinder.IsServer && !PlantHarvestablePatch.PlayerHarvestInProgress)
			{
				float num = HarvestQuality.ComputeBaseQuality(__instance);
				float num2 = configuration.RandomYieldQualityPicker.Evaluate(Random.value);
				__state = num;
				__instance.QualityLevel = Mathf.Clamp01(num + num2);
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Plant __instance, float __state)
		{
			if (!float.IsNaN(__state))
			{
				__instance.QualityLevel = __state;
			}
		}
	}
	[HarmonyPatch(typeof(Pot), "Start")]
	public class PotStartPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Pot __instance)
		{
			if (Core.Get<ModPlants>().Configuration.Enabled)
			{
				((Component)__instance).gameObject.AddComponent<PotBaseValues>().Init(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Pot), "OnMinPass")]
	public class PotMinPassPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Pot __instance)
		{
			ModPlantsConfiguration configuration = Core.Get<ModPlants>().Configuration;
			if (configuration.Enabled && !((Object)(object)__instance == (Object)null))
			{
				PotBaseValues component = ((Component)__instance).gameObject.GetComponent<PotBaseValues>();
				if (!((Object)(object)component == (Object)null))
				{
					((GrowContainer)__instance)._moistureDrainPerHour = component.BaseWaterDrainPerHour * configuration.WaterDrainModifier;
					__instance.GrowSpeedMultiplier = component.BaseGrowSpeedMultiplier * Mathf.Max(0.001f, configuration.GrowthModifier);
				}
			}
		}
	}
}
namespace Lithium.Modules.PlantGrowth.Behaviours
{
	public class PlantBaseQuality : MonoBehaviour
	{
		public float Quality;

		public bool NeedsNotification;
	}
	public class PlantModified : MonoBehaviour
	{
	}
	public class PotBaseValues : MonoBehaviour
	{
		public float BaseWaterDrainPerHour;

		public float BaseGrowSpeedMultiplier;

		public void Init(Pot pot)
		{
			BaseWaterDrainPerHour = ((GrowContainer)pot)._moistureDrainPerHour;
			BaseGrowSpeedMultiplier = pot.GrowSpeedMultiplier;
		}
	}
}
namespace Lithium.Modules.Storyline
{
	public class ModStorylineConfiguration : ModuleConfiguration
	{
		public override string Name => "Storyline";

		public bool PreventRVExplosion { get; set; } = true;

		public bool PreventFurnitureLooting { get; set; } = true;
	}
	public class ModStoryline : ModuleBase<ModStorylineConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
	public static class RVFurnitureDebug
	{
		public static void Dump()
		{
			//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)
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("==================================================================");
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(36, 1, stringBuilder2);
				handler.AppendLiteral("=== Lithium RV furniture dump @ ");
				handler.AppendFormatted(DateTime.Now, "yyyy-MM-dd HH:mm:ss");
				handler.AppendLiteral(" ===");
				stringBuilder3.AppendLine(ref handler);
				stringBuilder.AppendLine("==================================================================");
				BuildableItem[] array = Il2CppArrayBase<BuildableItem>.op_Implicit(Object.FindObjectsOfType<BuildableItem>(true));
				List<BuildableItem> list = new List<BuildableItem>();
				BuildableItem[] array2 = array;
				foreach (BuildableItem val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !val.isGhost && !val.IsDestroyed)
					{
						Property parentProperty = val.ParentProperty;
						if (!((Object)(object)parentProperty == (Object)null) && !((Object)(object)((Il2CppObjectBase)parentProperty).TryCast<RV>() == (Object)null))
						{
							list.Add(val);
						}
					}
				}
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(20, 1, stringBuilder2);
				handler.AppendLiteral("RV furniture count: ");
				handler.AppendFormatted(list.Count);
				stringBuilder4.AppendLine(ref handler);
				stringBuilder.AppendLine();
				foreach (BuildableItem item in list)
				{
					ItemInstance itemInstance = item.ItemInstance;
					string value = ((itemInstance != null) ? ((BaseItemInstance)itemInstance).ID : null) ?? "(null id)";
					string value2 = ((itemInstance != null) ? ((BaseItemInstance)itemInstance).Name : null) ?? "(null)";
					string value3 = ((object)item.GUID/*cast due to .constrained prefix*/).ToString();
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder5 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(18, 3, stringBuilder2);
					handler.AppendLiteral("id=");
					handler.AppendFormatted<string>(value, -28);
					handler.AppendLiteral(" guid=");
					handler.AppendFormatted(value3);
					handler.AppendLiteral("  name=\"");
					handler.AppendFormatted(value2);
					handler.AppendLiteral("\"");
					stringBuilder5.AppendLine(ref handler);
				}
				stringBuilder.AppendLine();
				string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "RVFurniture.txt");
				File.AppendAllText(text2, stringBuilder.ToString());
				Log.Warning($"[Storyline] Appended RV furniture dump ({list.Count} items) to {text2}");
			}
			catch (Exception value4)
			{
				Log.Error($"[Storyline] RV furniture dump failed: {value4}");
			}
		}
	}
}
namespace Lithium.Modules.Storyline.Patches
{
	[HarmonyPatch(typeof(RV), "BlowUp")]
	public class RVBlowUpPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(RV __instance)
		{
			return RVExplosionPrevention.Handle(__instance);
		}
	}
	[HarmonyPatch(typeof(RV), "SetDestroyed")]
	public class RVSetDestroyedPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(RV __instance)
		{
			return RVExplosionPrevention.Handle(__instance);
		}
	}
	internal static class RVExplosionPrevention
	{
		public static bool Handle(RV __instance)
		{
			ModStorylineConfiguration configuration = Core.Get<ModStoryline>().Configuration;
			if (!configuration.Enabled || !configuration.PreventRVExplosion)
			{
				return true;
			}
			GameObject childGameObject = GetChildGameObject(((Component)__instance).gameObject, "Destroyed RV");
			if ((Object)(object)childGameObject != (Object)null)
			{
				childGameObject.SetActive(true);
				GameObject childGameObject2 = GetChildGameObject(childGameObject, "CartelNote");
				if ((Object)(object)childGameObject2 != (Object)null)
				{
					childGameObject2.SetActive(true);
				}
				GameObject childGameObject3 = GetChildGameObject(childGameObject, "destroyed rv");
				if ((Object)(object)childGameObject3 != (Object)null)
				{
					childGameObject3.SetActive(false);
				}
			}
			else
			{
				Log.Info("Destroyed RV not found");
			}
			return false;
		}

		private static GameObject GetChildGameObject(GameObject obj, string childName)
		{
			Transform val = obj.transform.Find(childName);
			return ((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null;
		}
	}
	[HarmonyPatch(typeof(BuildableItem), "CanBePickedUp")]
	public class RVFurniturePickupPatch
	{
		private static readonly HashSet<string> StarterFurnitureGuids = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "98648644-f1a1-4106-9197-cec0c7ed1a73", "6544dc8e-adcd-4cd5-bf1f-8f579c04da6c", "7ba51973-2431-4e48-96da-79539be4c90f", "4b341e8d-8538-428c-8694-399a328f06b9", "011cc508-c95a-409d-b2fb-37bf19b8f110", "78ec1f47-07da-424d-82a9-1e83dad20de3", "46b275ec-6cfd-4263-aa6d-6fe8c76b1e52", "4915398b-5135-4d64-8887-0faa09392534", "3a757d1a-2278-4431-8517-a64c74c6391f" };

		[HarmonyPrefix]
		public static bool Prefix(BuildableItem __instance, ref string reason, ref bool __result)
		{
			//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)
			ModStorylineConfiguration configuration = Core.Get<ModStoryline>().Configuration;
			if (!configuration.Enabled || !configuration.PreventFurnitureLooting || configuration.PreventRVExplosion)
			{
				return true;
			}
			Property parentProperty = __instance.ParentProperty;
			if ((Object)(object)parentProperty == (Object)null || (Object)(object)((Il2CppObjectBase)parentProperty).TryCast<RV>() == (Object)null)
			{
				return true;
			}
			if (!StarterFurnitureGuids.Contains(((object)__instance.GUID/*cast due to .constrained prefix*/).ToString()))
			{
				return true;
			}
			reason = "Can't take the RV's furniture";
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Quest_WelcomeToHylandPoint), "BlowupRV")]
	public class QuestWelcomeToHylandPointPatch
	{
		[HarmonyPrefix]
		public static bool DisableRVExplosion(Quest_WelcomeToHylandPoint __instance)
		{
			ModStorylineConfiguration configuration = Core.Get<ModStoryline>().Configuration;
			if (!configuration.Enabled || !configuration.PreventRVExplosion)
			{
				return true;
			}
			return false;
		}
	}
}
namespace Lithium.Modules.ElectricBill
{
	public static class BuildablesDebug
	{
		private sealed class Entry
		{
			public string Name;

			public string Category;

			public int Count;
		}

		public static void Dump()
		{
			//IL_01b7: 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)
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== Lithium Buildables (player-built, by property) ===");
				BuildableItem[] array = Il2CppArrayBase<BuildableItem>.op_Implicit(Object.FindObjectsOfType<BuildableItem>(true));
				Dictionary<string, SortedDictionary<string, Entry>> dictionary = new Dictionary<string, SortedDictionary<string, Entry>>();
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
				int num = 0;
				BuildableItem[] array2 = array;
				foreach (BuildableItem val in array2)
				{
					if ((Object)(object)val == (Object)null || val.isGhost || val.IsDestroyed)
					{
						continue;
					}
					ItemInstance itemInstance = val.ItemInstance;
					if (itemInstance != null)
					{
						Property parentProperty = val.ParentProperty;
						string key;
						string value;
						if ((Object)(object)parentProperty == (Object)null)
						{
							key = "(no property)";
							value = "(no property)";
							num++;
						}
						else
						{
							key = (string.IsNullOrEmpty(parentProperty.PropertyCode) ? parentProperty.PropertyName : parentProperty.PropertyCode);
							string value2 = (parentProperty.IsOwned ? "* " : "  ");
							value = $"{value2}\"{parentProperty.PropertyName}\"  code={parentProperty.PropertyCode}";
						}
						dictionary2[key] = value;
						if (!dictionary.TryGetValue(key, out var value3))
						{
							value3 = (dictionary[key] = new SortedDictionary<string, Entry>(StringComparer.OrdinalIgnoreCase));
						}
						string key2 = ((BaseItemInstance)itemInstance).ID ?? "(null id)";
						if (!value3.TryGetValue(key2, out var value4))
						{
							Entry obj = new Entry
							{
								Name = ((BaseItemInstance)itemInstance).Name,
								Category = ((object)((BaseItemInstance)itemInstance).Category/*cast due to .constrained prefix*/).ToString()
							};
							value4 = (value3[key2] = obj);
						}
						value4.Count++;
					}
				}
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(44, 2, stringBuilder2);
				handler.AppendLiteral("Total buildables: ");
				handler.AppendFormatted(array.Length);
				handler.AppendLiteral("  (orphaned/no-property: ");
				handler.AppendFormatted(num);
				handler.AppendLiteral(")");
				stringBuilder3.AppendLine(ref handler);
				stringBuilder.AppendLine("* = owned property. Price each appliance in the ElectricBill config by its id.");
				stringBuilder.AppendLine();
				foreach (KeyValuePair<string, SortedDictionary<string, Entry>> item in dictionary)
				{
					stringBuilder.AppendLine(dictionary2[item.Key]);
					int num2 = 0;
					foreach (KeyValuePair<string, Entry> item2 in item.Value)
					{
						Entry value5 = item2.Value;
						num2 += value5.Count;
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder4 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(29, 4, stringBuilder2);
						handler.AppendLiteral("    ");
						handler.AppendFormatted(value5.Count, 3);
						handler.AppendLiteral("x  id=");
						handler.AppendFormatted<string>(item2.Key, -28);
						handler.AppendLiteral(" name=\"");
						handler.AppendFormatted(value5.Name);
						handler.AppendLiteral("\"  category=");
						handler.AppendFormatted(value5.Category);
						stringBuilder4.AppendLine(ref handler);
					}
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder5 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(23, 1, stringBuilder2);
					handler.AppendLiteral("    -- ");
					handler.AppendFormatted(num2);
					handler.AppendLiteral(" buildable(s) --");
					stringBuilder5.AppendLine(ref handler);
					stringBuilder.AppendLine();
				}
				string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "Buildables.txt");
				File.WriteAllText(text2, stringBuilder.ToString());
				Log.Warning("[ElectricBill] Wrote buildables dump to " + text2);
			}
			catch (Exception value6)
			{
				Log.Error($"[ElectricBill] Buildables dump failed: {value6}");
			}
		}
	}
	public class ElectricBillApplianceConfig
	{
		[JsonProperty(Order = 1)]
		public float StandbyWatts;

		[JsonProperty(Order = 2)]
		public float InUseWatts;

		public ElectricBillApplianceConfig()
		{
		}

		public ElectricBillApplianceConfig(float standby, float inUse)
		{
			StandbyWatts = standby;
			InUseWatts = inUse;
		}
	}
	public class ModElectricBillConfiguration : ModuleConfiguration
	{
		[JsonProperty(Order = 1)]
		public int BillingIntervalDays = 7;

		[JsonProperty(Order = 2)]
		public float RatePerKwh = 2f;

		[JsonProperty(Order = 3)]
		public Dictionary<string, ElectricBillApplianceConfig> Appliances = new Dictionary<string, ElectricBillApplianceConfig>
		{
			["floorlamp"] = new ElectricBillApplianceConfig(0f, 12f),
			["antiquewalllamp"] = new ElectricBillApplianceConfig(0f, 10f),
			["modernwalllamp"] = new ElectricBillApplianceConfig(0f, 10f),
			["ledgrowlight"] = new ElectricBillApplianceConfig(5f, 200f),
			["fullspectrumgrowlight"] = new ElectricBillApplianceConfig(8f, 450f),
			["halogengrowlight"] = new ElectricBillApplianceConfig(10f, 600f),
			["bigsprinkler"] = new ElectricBillApplianceConfig(2f, 40f),
			["chemistrystation"] = new ElectricBillApplianceConfig(15f, 1500f),
			["laboven"] = new ElectricBillApplianceConfig(20f, 2200f),
			["mixingstation"] = new ElectricBillApplianceConfig(10f, 500f),
			["mixingstationmk2"] = new ElectricBillApplianceConfig(15f, 800f),
			["cauldron"] = new ElectricBillApplianceConfig(12f, 1200f),
			["packagingstation"] = new ElectricBillApplianceConfig(8f, 300f),
			["packagingstationmk2"] = new ElectricBillApplianceConfig(10f, 450f),
			["launderingstation"] = new ElectricBillApplianceConfig(5f, 250f)
		};

		[JsonProperty(Order = 4)]
		public ElectricBillApplianceConfig BuiltInLight = new ElectricBillApplianceConfig(0f, 40f);

		public override string Name => "ElectricBill";

		public override void Validate()
		{
			BillingIntervalDays = ConfigValidator.AtLeast(Name, "BillingIntervalDays", BillingIntervalDays, 1);
			RatePerKwh = ConfigValidator.AtLeast(Name, "RatePerKwh", RatePerKwh, 0f);
			BuiltInLight.StandbyWatts = ConfigValidator.AtLeast(Name, "BuiltInLight.StandbyWatts", BuiltInLight.StandbyWatts, 0f);
			BuiltInLight.InUseWatts = ConfigValidator.AtLeast(Name, "BuiltInLight.InUseWatts", BuiltInLight.InUseWatts, 0f);
			foreach (string item in new List<string>(Appliances.Keys))
			{
				ElectricBillApplianceConfig electricBillApplianceConfig = Appliances[item];
				electricBillApplianceConfig.StandbyWatts = ConfigValidator.AtLeast(Name, "Appliances[" + item + "].StandbyWatts", electricBillApplianceConfig.StandbyWatts, 0f);
				electricBillApplianceConfig.InUseWatts = ConfigValidator.AtLeast(Name, "Appliances[" + item + "].InUseWatts", electricBillApplianceConfig.InUseWatts, 0f);
			}
		}
	}
	public class ModElectricBill : ModuleBase<ModElectricBillConfiguration>
	{
		private readonly struct ApplianceRef
		{
			public readonly BuildableItem Item;

			public readonly string Id;

			public readonly string Guid;

			public ApplianceRef(BuildableItem item, string id, string guid)
			{
				Item = item;
				Id = id;
				Guid = guid;
			}
		}

		public sealed class CashPaymentResult
		{
			public float Paid;

			public float Remaining;

			public bool Cleared;

			public bool PowerRestored;
		}

		public sealed class ApplianceLine
		{
			public string Name;

			public int Count;

			public float CurrentWatts;

			public float AccruedCost;

			public float ProjectedCost;
		}

		public sealed class ElectricAppView
		{
			public bool ModuleEnabled;

			public bool PoweredOff;

			public float OutstandingBill;

			public float TotalWatts;

			public float TotalAccrued;

			public float TotalProjected;

			public List<ApplianceLine> Lines = new List<ApplianceLine>();
		}

		private static readonly SaveSlotStore<ElectricBillState> Store = new SaveSlotStore<ElectricBillState>("ElectricBill", "electric bill state");

		private static readonly HashSet<string> PowerCutCodes = new HashSet<string>();

		private readonly Dictionary<string, List<ApplianceRef>> _appliancesByCode = new Dictionary<string, List<ApplianceRef>>();

		private readonly Dictionary<string, List<ModularSwitch>> _switchesByCode = new Dictionary<string, List<ModularSwitch>>();

		private readonly Dictionary<string, Property> _ownedByCode = new Dictionary<string, Property>();

		private const string BuiltInLightId = "builtinlight";

		private const string BuiltInLightName = "Built-in lights";

		private int _lastElapsedDay = -1;

		private int _minutesSincePersist;

		private bool _initialised;

		private int _lastMinSum = -1;

		private float _eodRealAccum;

		private bool _pendingSkipResync;

		public static bool IsPowerCut(string propertyCode)
		{
			return !string.IsNullOrEmpty(propertyCode) && PowerCutCodes.Contains(propertyCode);
		}

		public float GetOutstandingBill(string propertyCode)
		{
			if (!base.Configuration.Enabled || string.IsNullOrEmpty(propertyCode) || !InstanceFinder.IsServer)
			{
				return 0f;
			}
			ElectricBillState value;
			return Store.TryGet(propertyCode, out value) ? value.OutstandingBill : 0f;
		}

		public float BillNowWithRent(Property prop)
		{
			if (!base.Configuration.Enabled || (Object)(object)prop == (Object)null || !InstanceFinder.IsServer)
			{
				return 0f;
			}
			string propertyCode = prop.PropertyCode;
			if (string.IsNullOrEmpty(propertyCode) || (Object)(object)((Il2CppObjectBase)prop).TryCast<RV>() != (Object)null)
			{
				return 0f;
			}
			try
			{
				ElectricBillState orCreate = GetOrCreate(propertyCode);
				int num = (((Object)(object)NetworkSingleton<TimeManager>.Instance != (Object)null) ? NetworkSingleton<TimeManager>.Instance.ElapsedDays : orCreate.LastBilledDay);
				if (orCreate.LastBilledDay != num)
				{
					BillOnce(prop, orCreate);
					orCreate.LastBilledDay = num;
					Store.Set(propertyCode, orCreate);
					PublishElectric(propertyCode, orCreate);
				}
				return orCreate.OutstandingBill;
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Bill-with-rent failed: " + ex.Message);
				return 0f;
			}
		}

		public CashPaymentResult ApplyCashPayment(Property prop, float amount, bool announce = true)
		{
			CashPaymentResult cashPaymentResult = new CashPaymentResult();
			if (!base.Configuration.Enabled || (Object)(object)prop == (Object)null || amount <= 0f || !InstanceFinder.IsServer)
			{
				return cashPaymentResult;
			}
			string propertyCode = prop.PropertyCode;
			if (string.IsNullOrEmpty(propertyCode) || !Store.TryGet(propertyCode, out var value) || value.OutstandingBill <= 0f)
			{
				return cashPaymentResult;
			}
			cashPaymentResult.Paid = Math.Min(value.OutstandingBill, amount);
			value.OutstandingBill = Math.Max(0f, value.OutstandingBill - amount);
			if (value.OutstandingBill < 0.01f)
			{
				value.OutstandingBill = 0f;
				cashPaymentResult.Cleared = true;
				if (value.PoweredOff)
				{
					RestorePower(prop, value);
					cashPaymentResult.PowerRestored = true;
				}
				if (announce)
				{
					ElectricBillNotifier.Send("Power bill paid", $"{prop.PropertyName}: ${cashPaymentResult.Paid:N2} settled in cash");
				}
			}
			else if (announce)
			{
				ElectricBillNotifier.Send("Power bill — partial", $"{prop.PropertyName}: ${cashPaymentResult.Paid:N2} paid, ${value.OutstandingBill:N2} left");
			}
			cashPaymentResult.Remaining = value.OutstandingBill;
			Store.Set(propertyCode, value);
			PublishElectric(propertyCode, value);
			return cashPaymentResult;
		}

		public ElectricAppView GetAppView(string propertyCode, bool refresh)
		{
			ElectricAppView electricAppView = new ElectricAppView
			{
				ModuleEnabled = base.Configuration.Enabled
			};
			if (!base.Configuration.Enabled || string.IsNullOrEmpty(propertyCode))
			{
				return electricAppView;
			}
			try
			{
				if (refresh || _ownedByCode.Count == 0)
				{
					RefreshApplianceCache();
				}
				Store.TryGet(propertyCode, out var value);
				if (value != null)
				{
					electricAppView.PoweredOff = value.PoweredOff;
					electricAppView.OutstandingBill = value.OutstandingBill;
				}
				else if (!InstanceFinder.IsServer)
				{
					electricAppView.PoweredOff = HostStateSync.GetBool("bill_cut_" + propertyCode);
					electricAppView.OutstandingBill = HostStateSync.GetNumber("bill_outstanding_" + propertyCode);
				}
				float num = (float)base.Configuration.BillingIntervalDays * 24f;
				Dictionary<string, ApplianceLine> dictionary = new Dictionary<string, ApplianceLine>();
				if (_appliancesByCode.TryGetValue(propertyCode, out var value2))
				{
					foreach (ApplianceRef item in value2)
					{
						if (!((Object)(object)item.Item == (Object)null) && base.Configuration.Appliances.TryGetValue(item.Id, out var value3))
						{
							float num2 = (ApplianceStateResolver.IsActive(item.Id, item.Item) ? value3.InUseWatts : value3.StandbyWatts);
							ApplianceLine line = GetLine(dictionary, item.Id, ApplianceDisplayName(item));
							line.Count++;
							line.CurrentWatts += num2;
						}
					}
				}
				if (_switchesByCode.TryGetValue(propertyCode, out var value4))
				{
					foreach (ModularSwitch item2 in value4)
					{
						if (!((Object)(object)item2 == (Object)null))
						{
							int num3 = CountLights(item2);
							float num4 = (item2.isOn ? base.Configuration.BuiltInLight.InUseWatts : base.Configuration.BuiltInLight.StandbyWatts);
							ApplianceLine line2 = GetLine(dictionary, "builtinlight", "Built-in lights");
							line2.Count += num3;
							line2.CurrentWatts += (float)num3 * num4;
						}
					}
				}
				foreach (KeyValuePair<string, ApplianceLine> item3 in dictionary)
				{
					ApplianceLine value5 = item3.Value;
					value5.ProjectedCost = value5.CurrentWatts * num / 1000f * base.Configuration.RatePerKwh;
					if (value != null && value.AccruedByAppliance.TryGetValue(item3.Key, out var value6))
					{
						value5.AccruedCost = value6 / 60f / 1000f * base.Configuration.RatePerKwh;
					}
					electricAppView.TotalWatts += value5.CurrentWatts;
					electricAppView.TotalAccrued += value5.AccruedCost;
					electricAppView.TotalProjected += value5.ProjectedCost;
					electricAppView.Lines.Add(value5);
				}
				electricAppView.Lines.Sort((ApplianceLine a, ApplianceLine b) => b.ProjectedCost.CompareTo(a.ProjectedCost));
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] App view build failed: " + ex.Message);
			}
			return electricAppView;
		}

		private static ApplianceLine GetLine(Dictionary<string, ApplianceLine> grouped, string id, string name)
		{
			if (!grouped.TryGetValue(id, out var value))
			{
				value = (grouped[id] = new ApplianceLine
				{
					Name = name
				});
			}
			return value;
		}

		private static string ApplianceDisplayName(ApplianceRef app)
		{
			try
			{
				ItemInstance val = (((Object)(object)app.Item != (Object)null) ? app.Item.ItemInstance : null);
				if (val != null && !string.IsNullOrEmpty(((BaseItemInstance)val).Name))
				{
					return ((BaseItemInstance)val).Name;
				}
			}
			catch
			{
			}
			return app.Id;
		}

		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
				Store.Unload();
				PowerCutCodes.Clear();
				_appliancesByCode.Clear();
				_ownedByCode.Clear();
				_lastElapsedDay = -1;
				_minutesSincePersist = 0;
				_lastMinSum = -1;
				_eodRealAccum = 0f;
				_pendingSkipResync = false;
				_initialised = false;
			}
		}

		public void DriveUpdate()
		{
			if (!base.Configuration.Enabled || !InstanceFinder.IsServer)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			int elapsedDays = instance.ElapsedDays;
			if (!_initialised)
			{
				RefreshApplianceCache();
				RebuildCutFromState();
				PublishElectricAll();
				_lastElapsedDay = elapsedDays;
				_lastMinSum = instance.GetTotalMinSum();
				_eodRealAccum = 0f;
				_pendingSkipResync = false;
				_initialised = true;
				return;
			}
			int totalMinSum = instance.GetTotalMinSum();
			if (_pendingSkipResync)
			{
				_pendingSkipResync = false;
				_lastMinSum = totalMinSum;
				_eodRealAccum = 0f;
			}
			else if (instance.IsEndOfDay)
			{
				if (!EndOfDayFreezeActive() && Time.timeScale > 0f)
				{
					AccrueEndOfDayRealtime(instance);
				}
				_lastMinSum = totalMinSum;
			}
			else
			{
				_eodRealAccum = 0f;
				int num = totalMinSum - _lastMinSum;
				if (num > 0)
				{
					AccrueMinutes(num);
				}
				_lastMinSum = totalMinSum;
			}
			if (elapsedDays != _lastElapsedDay)
			{
				_lastElapsedDay = elapsedDays;
				RefreshApplianceCache();
				RebuildCutFromState();
				ProcessDayRollover(elapsedDays);
				PersistAll();
			}
		}

		private void AccrueEndOfDayRealtime(TimeManager time)
		{
			float minuteDuration = TimeManager.MinuteDuration;
			float num = time.TimeSpeedMultiplier * Time.timeScale;
			if (!(minuteDuration <= 0f) && !(num <= 0f))
			{
				float num2 = minuteDuration / num;
				_eodRealAccum += Time.unscaledDeltaTime;
				int num3 = (int)(_eodRealAccum / num2);
				if (num3 > 0)
				{
					_eodRealAccum -= (float)num3 * num2;
					AccrueMinutes(num3);
				}
			}
		}

		private void AccrueMinutes(int mins)
		{
			if (mins <= 0)
			{
				return;
			}
			foreach (string key in _ownedByCode.Keys)
			{
				ElectricBillState orCreate = GetOrCreate(key);
				if (orCreate.PoweredOff)
				{
					if (_appliancesByCode.TryGetValue(key, out var value))
					{
						EnforceCut(value);
					}
				}
				else
				{
					AccrueProperty(key, orCreate, mins);
				}
			}
			_minutesSincePersist += mins;
			if (_minutesSincePersist >= 60)
			{
				PersistAll();
				_minutesSincePersist = 0;
			}
		}

		private void AccrueProperty(string code, ElectricBillState state, float minutes)
		{
			if (_appliancesByCode.TryGetValue(code, out var value))
			{
				foreach (ApplianceRef item in value)
				{
					if (!((Object)(object)item.Item == (Object)null) && base.Configuration.Appliances.TryGetValue(item.Id, out var value2))
					{
						float num = (ApplianceStateResolver.IsActive(item.Id, item.Item) ? value2.InUseWatts : value2.StandbyWatts);
						AddAccrual(state, item.Id, num * minutes);
					}
				}
			}
			if (_switchesByCode.TryGetValue(code, out var value3))
			{
				float num2 = BuiltInLightWatts(value3);
				if (num2 > 0f)
				{
					AddAccrual(state, "builtinlight", num2 * minutes);
				}
			}
		}

		private static void AddAccrual(ElectricBillState state, string id, float wattMinutes)
		{
			state.AccruedWattMinutes += wattMinutes;
			state.AccruedByAppliance.TryGetValue(id, out var value);
			state.AccruedByAppliance[id] = value + wattMinutes;
		}

		private float BuiltInLightWatts(List<ModularSwitch> switches)
		{
			float num = 0f;
			foreach (ModularSwitch @switch in switches)
			{
				if (!((Object)(object)@switch == (Object)null))
				{
					float num2 = (@switch.isOn ? base.Configuration.BuiltInLight.InUseWatts : base.Configuration.BuiltInLight.StandbyWatts);
					num += (float)CountLights(@switch) * num2;
				}
			}
			return num;
		}

		private static int CountLights(ModularSwitch sw)
		{
			try
			{
				int num = ((Il2CppArrayBase<ToggleableLight>)(object)sw.LightsToControl)?.Length ?? 0;
				return (num <= 0) ? 1 : num;
			}
			catch
			{
				return 1;
			}
		}

		public void AccrueTimeSkip(int minutes)
		{
			if (!base.Configuration.Enabled || minutes <= 0 || !_initialised)
			{
				return;
			}
			_pendingSkipResync = true;
			try
			{
				foreach (string key in _ownedByCode.Keys)
				{
					ElectricBillState orCreate = GetOrCreate(key);
					if (!orCreate.PoweredOff)
					{
						AccrueProperty(key, orCreate, minutes);
					}
				}
				PersistAll();
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Time-skip accrual failed: " + ex.Message);
			}
		}

		private static bool EndOfDayFreezeActive()
		{
			return Core.Get<ModEndOfDayFreeze>()?.Configuration.Enabled ?? false;
		}

		private void EnforceCut(List<ApplianceRef> appliances)
		{
			foreach (ApplianceRef appliance in appliances)
			{
				if (!((Object)(object)appliance.Item == (Object)null) && ApplianceStateResolver.IsLight(appliance.Id) && ApplianceStateResolver.IsActive(appliance.Id, appliance.Item))
				{
					ApplianceStateResolver.ForceOff(appliance.Id, appliance.Item);
				}
			}
		}

		private void ProcessDayRollover(int today)
		{
			foreach (KeyValuePair<string, Property> item in _ownedByCode)
			{
				string key = item.Key;
				Property value = item.Value;
				ElectricBillState orCreate = GetOrCreate(key);
				if (orCreate.LastBilledDay < 0)
				{
					orCreate.LastBilledDay = today;
					Store.Set(key, orCreate);
					PublishElectric(key, orCreate);
					continue;
				}
				int num = (today - orCreate.LastBilledDay) / base.Configuration.BillingIntervalDays;
				if (num >= 1)
				{
					orCreate.LastBilledDay += num * base.Configuration.BillingIntervalDays;
					BillOnce(value, orCreate);
				}
				Store.Set(key, orCreate);
				PublishElectric(key, orCreate);
			}
		}

		private static void PublishElectric(string code, ElectricBillState state)
		{
			if (!string.IsNullOrEmpty(code) && state != null)
			{
				HostStateSync.SetBool("bill_cut_" + code, state.PoweredOff);
				HostStateSync.SetNumber("bill_outstanding_" + code, state.OutstandingBill);
			}
		}

		private void PublishElectricAll()
		{
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			foreach (string key in _ownedByCode.Keys)
			{
				if (Store.TryGet(key, out var value))
				{
					PublishElectric(key, value);
				}
			}
		}

		private void BillOnce(Property prop, ElectricBillState state)
		{
			float num = state.AccruedWattMinutes / 60f / 1000f;
			float num2 = num * base.Configuration.RatePerKwh;
			state.AccruedWattMinutes = 0f;
			state.AccruedByAppliance.Clear();
			bool flag = state.OutstandingBill > 0.01f;
			state.OutstandingBill += num2;
			if (state.OutstandingBill < 0.01f)
			{
				state.OutstandingBill = 0f;
			}
			else if (flag && !state.PoweredOff)
			{
				CutPower(prop, state);
				ElectricBillNotifier.Send("Power cut off", $"{prop.PropertyName}: ${state.OutstandingBill:N2} unpaid. Settle it in cash at the dead drop.");
			}
			else
			{
				ElectricBillNotifier.Send("Power bill due", $"{prop.PropertyName}: ${state.OutstandingBill:N2}. Pay it in cash at the dead drop with your rent.");
			}
		}

		private void CutPower(Property prop, ElectricBillState state)
		{
			string propertyCode = prop.PropertyCode;
			state.PoweredOff = true;
			PowerCutCodes.Add(propertyCode);
			state.LightStatesAtCutoff.Clear();
			if (_appliancesByCode.TryGetValue(propertyCode, out var value))
			{
				foreach (ApplianceRef item in value)
				{
					if (!((Object)(object)item.Item == (Object)null))
					{
						if (ApplianceStateResolver.IsLight(item.Id))
						{
							state.LightStatesAtCutoff[item.Guid] = ApplianceStateResolver.IsActive(item.Id, item.Item);
						}
						ApplianceStateResolver.ForceOff(item.Id, item.Item);
					}
				}
			}
			Log.Info($"[ElectricBill] Power cut at {prop.PropertyName} ({propertyCode}).");
		}

		private void RestorePower(Property prop, ElectricBillState state)
		{
			string propertyCode = prop.PropertyCode;
			state.PoweredOff = false;
			PowerCutCodes.Remove(propertyCode);
			if (_appliancesByCode.TryGetValue(propertyCode, out var value))
			{
				foreach (ApplianceRef item in value)
				{
					if (!((Object)(object)item.Item == (Object)null) && ApplianceStateResolver.IsLight(item.Id) && state.LightStatesAtCutoff.TryGetValue(item.Guid, out var value2) && value2)
					{
						ApplianceStateResolver.Restore(item.Id, item.Item);
					}
				}
			}
			state.LightStatesAtCutoff.Clear();
			Log.Info($"[ElectricBill] Power restored at {prop.PropertyName} ({propertyCode}).");
		}

		private void RebuildCutFromState()
		{
			try
			{
				PowerCutCodes.Clear();
				foreach (KeyValuePair<string, Property> item in _ownedByCode)
				{
					string key = item.Key;
					if (!Store.TryGet(key, out var value) || !value.PoweredOff)
					{
						continue;
					}
					PowerCutCodes.Add(key);
					if (!_appliancesByCode.TryGetValue(key, out var value2))
					{
						continue;
					}
					foreach (ApplianceRef item2 in value2)
					{
						if ((Object)(object)item2.Item != (Object)null)
						{
							ApplianceStateResolver.ForceOff(item2.Id, item2.Item);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Failed to rebuild cut set: " + ex.Message);
			}
		}

		private void RefreshApplianceCache()
		{
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_appliancesByCode.Clear();
				_switchesByCode.Clear();
				_ownedByCode.Clear();
				HashSet<string> hashSet = new HashSet<string>();
				foreach (Property item in AllOwned())
				{
					if ((Object)(object)((Il2CppObjectBase)item).TryCast<RV>() != (Object)null)
					{
						continue;
					}
					string propertyCode = item.PropertyCode;
					if (string.IsNullOrEmpty(propertyCode))
					{
						continue;
					}
					hashSet.Add(propertyCode);
					_ownedByCode[propertyCode] = item;
					List<ModularSwitch> switches = item.Switches;
					if (switches == null || switches.Count <= 0)
					{
						continue;
					}
					List<ModularSwitch> list = new List<ModularSwitch>();
					Enumerator<ModularSwitch> enumerator2 = switches.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						ModularSwitch current2 = enumerator2.Current;
						if ((Object)(object)current2 != (Object)null)
						{
							list.Add(current2);
						}
					}
					if (list.Count > 0)
					{
						_switchesByCode[propertyCode] = list;
					}
				}
				BuildableItem[] array = Il2CppArrayBase<BuildableItem>.op_Implicit(Object.FindObjectsOfType<BuildableItem>(true));
				BuildableItem[] array2 = array;
				foreach (BuildableItem val in array2)
				{
					if ((Object)(object)val == (Object)null || val.isGhost || val.IsDestroyed)
					{
						continue;
					}
					ItemInstance itemInstance = val.ItemInstance;
					if (itemInstance == null)
					{
						continue;
					}
					string iD = ((BaseItemInstance)itemInstance).ID;
					if (string.IsNullOrEmpty(iD) || !base.Configuration.Appliances.ContainsKey(iD))
					{
						continue;
					}
					Property parentProperty = val.ParentProperty;
					if ((Object)(object)parentProperty == (Object)null)
					{
						continue;
					}
					string propertyCode2 = parentProperty.PropertyCode;
					if (!string.IsNullOrEmpty(propertyCode2) && hashSet.Contains(propertyCode2))
					{
						if (!_appliancesByCode.TryGetValue(propertyCode2, out var value))
						{
							value = new List<ApplianceRef>();
							_appliancesByCode[propertyCode2] = value;
						}
						value.Add(new ApplianceRef(val, iD, ((object)val.GUID/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Appliance discovery failed: " + ex.Message);
			}
		}

		private ElectricBillState GetOrCreate(string code)
		{
			if (Store.TryGet(code, out var value))
			{
				return value;
			}
			value = new ElectricBillState();
			Store.Set(code, value);
			return value;
		}

		private void PersistAll()
		{
			foreach (string key in _ownedByCode.Keys)
			{
				if (Store.TryGet(key, out var value))
				{
					Store.Set(key, value);
				}
			}
		}

		private static IEnumerable<Property> AllOwned()
		{
			HashSet<string> seen = new HashSet<string>();
			List<Property> props = Property.OwnedProperties;
			if (props != null)
			{
				Enumerator<Property> enumerator = props.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Property p = enumerator.Current;
					if (!((Object)(object)p == (Object)null))
					{
						string c = p.PropertyCode;
						if (!string.IsNullOrEmpty(c) && seen.Add(c))
						{
							yield return p;
						}
					}
				}
			}
			List<Business> businesses = Business.OwnedBusinesses;
			if (businesses == null)
			{
				yield break;
			}
			Enumerator<Business> enumerator2 = businesses.GetEnumerator();
			while (enumerator2.MoveNext())
			{
				Business b = enumerator2.Current;
				if (!((Object)(object)b == (Object)null))
				{
					Property p2 = (Property)(object)b;
					string c2 = p2.PropertyCode;
					if (!string.IsNullOrEmpty(c2) && seen.Add(c2))
					{
						yield return p2;
					}
				}
			}
		}
	}
	public class ElectricBillState
	{
		public float AccruedWattMinutes;

		public Dictionary<string, float> AccruedByAppliance = new Dictionary<string, float>();

		public int LastBilledDay = -1;

		public float OutstandingBill;

		public bool PoweredOff;

		public Dictionary<string, bool> LightStatesAtCutoff = new Dictionary<string, bool>();
	}
	public static class ApplianceStateResolver
	{
		public sealed class Behaviour
		{
			public Func<BuildableItem, bool> IsActive;

			public Action<BuildableItem> ForceOff;

			public Action<BuildableItem> Restore;

			public bool IsLight;
		}

		private static readonly Action<BuildableItem> NoOp = delegate
		{
		};

		private static readonly Dictionary<string, Behaviour> Map = Build();

		private static Dictionary<string, Behaviour> Build()
		{
			Dictionary<string, Behaviour> dictionary = new Dictionary<string, Behaviour>(StringComparer.OrdinalIgnoreCase);
			Behaviour value = new Behaviour
			{
				IsLight = true,
				IsActive = delegate(BuildableItem bi)
				{
					ToggleableItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableItem>();
					return (Object)(object)val != (Object)null && val.IsOn;
				},
				ForceOff = delegate(BuildableItem bi)
				{
					ToggleableItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableItem>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn((NetworkConnection)null, false);
					}
				},
				Restore = delegate(BuildableItem bi)
				{
					ToggleableItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableItem>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn((NetworkConnection)null, true);
					}
				}
			};
			dictionary["floorlamp"] = value;
			Behaviour value2 = (dictionary["antiquewalllamp"] = new Behaviour
			{
				IsLight = true,
				IsActive = delegate(BuildableItem bi)
				{
					ToggleableSurfaceItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableSurfaceItem>();
					return (Object)(object)val != (Object)null && val.IsOn;
				},
				ForceOff = delegate(BuildableItem bi)
				{
					ToggleableSurfaceItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableSurfaceItem>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn((NetworkConnection)null, false);
					}
				},
				Restore = delegate(BuildableItem bi)
				{
					ToggleableSurfaceItem val = ((Il2CppObjectBase)bi).TryCast<ToggleableSurfaceItem>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn((NetworkConnection)null, true);
					}
				}
			});
			dictionary["modernwalllamp"] = value2;
			Behaviour value3 = (dictionary["fullspectrumgrowlight"] = (dictionary["ledgrowlight"] = new Behaviour
			{
				IsLight = true,
				IsActive = delegate(BuildableItem bi)
				{
					GrowLight val = ((Il2CppObjectBase)bi).TryCast<GrowLight>();
					return (Object)(object)val != (Object)null && (Object)(object)val.Light != (Object)null && val.Light.isOn;
				},
				ForceOff = delegate(BuildableItem bi)
				{
					GrowLight val = ((Il2CppObjectBase)bi).TryCast<GrowLight>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn(false);
					}
				},
				Restore = delegate(BuildableItem bi)
				{
					GrowLight val = ((Il2CppObjectBase)bi).TryCast<GrowLight>();
					if ((Object)(object)val != (Object)null)
					{
						val.SetIsOn(true);
					}
				}
			}));
			dictionary["halogengrowlight"] = value3;
			dictionary["bigsprinkler"] = new Behaviour
			{
				IsActive = delegate(BuildableItem bi)
				{
					Sprinkler val = ((Il2CppObjectBase)bi).TryCast<Sprinkler>();
					return (Object)(object)val != (Object)null && val.IsSprinkling;
				},
				ForceOff = NoOp,
				Restore = NoOp
			};
			dictionary["chemistrystation"] = Machine(delegate(BuildableItem bi)
			{
				ChemistryStation val = ((Il2CppObjectBase)bi).TryCast<ChemistryStation>();
				return (Object)(object)val != (Object)null && val.CurrentCookOperation != null;
			});
			dictionary["laboven"] = Machine(delegate(BuildableItem bi)
			{
				LabOven val = ((Il2CppObjectBase)bi).TryCast<LabOven>();
				return (Object)(object)val != (Object)null && val.CurrentOperation != null;
			});
			Behaviour value4 = (dictionary["mixingstation"] = Machine(delegate(BuildableItem bi)
			{
				MixingStation val = ((Il2CppObjectBase)bi).TryCast<MixingStation>();
				return (Object)(object)val != (Object)null && val.CurrentMixOperation != null;
			}));
			dictionary["mixingstationmk2"] = value4;
			dictionary["cauldron"] = Machine(delegate(BuildableItem bi)
			{
				Cauldron val = ((Il2CppObjectBase)bi).TryCast<Cauldron>();
				return (Object)(object)val != (Object)null && val.isCooking;
			});
			Behaviour value5 = (dictionary["packagingstation"] = Machine(delegate(BuildableItem bi)
			{
				PackagingStation val = ((Il2CppObjectBase)bi).TryCast<PackagingStation>();
				return (Object)(object)val != (Object)null && ((Object)(object)val.NPCUserObject != (Object)null || (Object)(object)val.PlayerUserObject != (Object)null);
			}));
			dictionary["packagingstationmk2"] = value5;
			dictionary["launderingstation"] = Machine(delegate(BuildableItem bi)
			{
				LaunderingStation val = ((Il2CppObjectBase)bi).TryCast<LaunderingStation>();
				return (Object)(object)val != (Object)null && (Object)(object)val.Interface != (Object)null && (Object)(object)val.Interface.business != (Object)null && val.Interface.business.currentLaunderTotal > 0f;
			});
			return dictionary;
		}

		private static Behaviour Machine(Func<BuildableItem, bool> isActive)
		{
			return new Behaviour
			{
				IsActive = isActive,
				ForceOff = NoOp,
				Restore = NoOp
			};
		}

		public static bool TryGet(string itemId, out Behaviour behaviour)
		{
			if (!string.IsNullOrEmpty(itemId))
			{
				return Map.TryGetValue(itemId, out behaviour);
			}
			behaviour = null;
			return false;
		}

		public static bool IsActive(string itemId, BuildableItem bi)
		{
			try
			{
				Behaviour behaviour;
				return TryGet(itemId, out behaviour) && behaviour.IsActive(bi);
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] IsActive('" + itemId + "') failed: " + ex.Message);
				return false;
			}
		}

		public static bool IsLight(string itemId)
		{
			Behaviour behaviour;
			return TryGet(itemId, out behaviour) && behaviour.IsLight;
		}

		public static void ForceOff(string itemId, BuildableItem bi)
		{
			try
			{
				if (TryGet(itemId, out var behaviour))
				{
					behaviour.ForceOff(bi);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] ForceOff('" + itemId + "') failed: " + ex.Message);
			}
		}

		public static void Restore(string itemId, BuildableItem bi)
		{
			try
			{
				if (TryGet(itemId, out var behaviour))
				{
					behaviour.Restore(bi);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Restore('" + itemId + "') failed: " + ex.Message);
			}
		}
	}
	internal static class ElectricBillGate
	{
		public static bool IsCut(BuildableItem station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return false;
			}
			ModElectricBill modElectricBill = Core.Get<ModElectricBill>();
			if (modElectricBill == null || !modElectricBill.Configuration.Enabled)
			{
				return false;
			}
			Property parentProperty = station.ParentProperty;
			return (Object)(object)parentProperty != (Object)null && ModElectricBill.IsPowerCut(parentProperty.PropertyCode);
		}

		public static bool IsCut(Property property)
		{
			if ((Object)(object)property == (Object)null)
			{
				return false;
			}
			ModElectricBill modElectricBill = Core.Get<ModElectricBill>();
			if (modElectricBill == null || !modElectricBill.Configuration.Enabled)
			{
				return false;
			}
			return ModElectricBill.IsPowerCut(property.PropertyCode);
		}
	}
	internal static class ElectricBillNotifier
	{
		public static void Send(string title, string subtitle)
		{
			try
			{
				NotificationsManager instance = Singleton<NotificationsManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.SendNotification(title, subtitle, (Sprite)null, 6f, true);
				}
				else
				{
					Log.Info("[ElectricBill] " + title + ": " + subtitle);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Notification failed: " + ex.Message);
			}
		}
	}
}
namespace Lithium.Modules.ElectricBill.Patches
{
	[HarmonyPatch(typeof(TimeManager), "OnTimeSkip_Client")]
	public class TimeSkipBillingPatch
	{
		[HarmonyPrefix]
		public static void Prefix(int oldTime, int newTime)
		{
			try
			{
				int num = Math.Abs(TimeManager.GetMinSumFrom24HourTime(newTime) - TimeManager.GetMinSumFrom24HourTime(oldTime));
				if (num > 0)
				{
					Core.Get<ModElectricBill>()?.AccrueTimeSkip(num);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ElectricBill] Time-skip billing failed: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(ChemistryStation), "OnTimePass")]
	public class ChemistryStationFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(ChemistryStation __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
	[HarmonyPatch]
	public class MixingStationFreezePatch
	{
		public static IEnumerable<MethodBase> TargetMethods()
		{
			MethodBase mk1 = AccessTools.DeclaredMethod(typeof(MixingStation), "OnTimePass", (Type[])null, (Type[])null);
			if (mk1 != null)
			{
				yield return mk1;
			}
			MethodBase mk2 = AccessTools.DeclaredMethod(typeof(MixingStationMk2), "OnTimePass", (Type[])null, (Type[])null);
			if (mk2 != null)
			{
				yield return mk2;
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(MixingStation __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(Cauldron), "OnTimePass")]
	public class CauldronFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(Cauldron __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(LabOven), "OnTimePass")]
	public class LabOvenFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(LabOven __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
	[HarmonyPatch]
	public class PackagingStationFreezePatch
	{
		public static IEnumerable<MethodBase> TargetMethods()
		{
			MethodBase start = AccessTools.DeclaredMethod(typeof(PackagingStation), "StartTask", (Type[])null, (Type[])null);
			if (start != null)
			{
				yield return start;
			}
			MethodBase pack = AccessTools.DeclaredMethod(typeof(PackagingStation), "PackSingleInstance", (Type[])null, (Type[])null);
			if (pack != null)
			{
				yield return pack;
			}
			MethodBase startMk2 = AccessTools.DeclaredMethod(typeof(PackagingStationMk2), "StartTask", (Type[])null, (Type[])null);
			if (startMk2 != null)
			{
				yield return startMk2;
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(PackagingStation __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(Business), "MinPass")]
	public class LaunderingFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(Business __instance)
		{
			return !ElectricBillGate.IsCut((Property)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(Sprinkler), "Water")]
	public class SprinklerFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix(Sprinkler __instance)
		{
			return !ElectricBillGate.IsCut((BuildableItem)(object)__instance);
		}
	}
}
namespace Lithium.Modules.Shops
{
	public class SupplierListingOverride
	{
		public Dictionary<string, float> PriceOverrides { get; set; } = new Dictionary<string, float>();
	}
	public interface IRankRequirement
	{
		bool? RequiresRank { get; set; }

		ERank RequiredRank { get; set; }

		int RequiredRankTier { get; set; }
	}
	public class ItemListingOverride : IRankRequirement
	{
		public float Price { get; set; }

		[JsonConverter(typeof(StringEnumConverter))]
		public ERestockRate RestockRate { get; set; } = (ERestockRate)0;

		public int Stock { get; set; } = -1;

		public bool? RequiresRank { get; set; } = null;

		[JsonConverter(typeof(StringEnumConverter))]
		public ERank RequiredRank { get; set; } = (ERank)0;

		public int RequiredRankTier { get; set; } = 0;
	}
	public class AddedListing : IRankRequirement
	{
		public float Price { get; set; } = -1f;

		[JsonConverter(typeof(StringEnumConverter))]
		public ERestockRate RestockRate { get; set; } = (ERestockRate)0;

		public int Stock { get; set; } = -1;

		public bool? RequiresRank { get; set; } = null;

		[JsonConverter(typeof(StringEnumConverter))]
		public ERank RequiredRank { get; set; } = (ERank)0;

		public int RequiredRankTier { get; set; } = 0;
	}
	public class ShopListingSettings
	{
		[JsonProperty(Order = 6)]
		public Dictionary<string, ItemListingOverride> ItemOverrides = new Dictionary<string, ItemListingOverride>();

		[JsonProperty(Order = 7)]
		public Dictionary<string, AddedListing> AddedItems = new Dictionary<string, AddedListing>();

		[JsonProperty(Order = 1)]
		public bool Override { get; set; } = false;

		[JsonProperty(Order = 2)]
		public int DefaultStock { get; set; } = -1;

		[JsonConverter(typeof(StringEnumConverter))]
		[JsonProperty(Order = 3)]
		public EPaymentType PaymentType { get; set; }
	}
	public enum DeliveryAvailabilitySettings
	{
		Unchanged,
		Never,
		Always,
		AfterReachingXP
	}
	public class DeliverySettings
	{
		[JsonConverter(typeof(StringEnumConverter))]
		public DeliveryAvailabilitySettings Availability { get; set; } = DeliveryAvailabilitySettings.Unchanged;

		public float DeliveryFee { get; set; } = 200f;

		public int XPRequirement { get; set; } = 0;
	}
	public class ModShopsConfiguration : ModuleConfiguration
	{
		public ShopListingSettings ThriftyThreads = new ShopListingSettings();

		public ShopListingSettings CokeSupplier = new ShopListingSettings();

		public ShopListingSettings MethSupplier = new ShopListingSettings();

		public ShopListingSettings WeedSupplier = new ShopListingSettings();

		public ShopListingSettings ShroomSupplier = new ShopListingSettings();

		public ShopListingSettings Boutique = new ShopListingSettings();

		public ShopListingSettings DarkMarket = new ShopListingSettings();

		public ShopListingSettings GasStation = new ShopListingSettings();

		public ShopListingSettings CentralGasStation = new ShopListingSettings();

		public ShopListingSettings DansHardware = new ShopListingSettings();

		public ShopListingSettings HandyHanks = new ShopListingSettings();

		public SupplierListingOverride Albert = new SupplierListingOverride();

		public SupplierListingOverride Shirley = new SupplierListingOverride();

		public SupplierListingOverride Salvador = new SupplierListingOverride();

		public SupplierListingOverride Phil = new SupplierListingOverride();

		public override string Name => "Shops";

		public Dictionary<string, DeliverySettings> Deliveries { get; set; } = new Dictionary<string, DeliverySettings>();
	}
	public class ModShops : ModuleBase<ModShopsConfiguration>
	{
		public override void Apply()
		{
		}
	}
}
namespace Lithium.Modules.Shops.Patches
{
	[HarmonyPatch(typeof(DeliveryShop), "GetDeliveryFee")]
	public class DeliveryShopFeePatch
	{
		[HarmonyPostfix]
		public static void Postfix(DeliveryShop __instance, ref float __result)
		{
			ModShops modShops = Core.Get<ModShops>();
			if (modShops != null && modShops.Configuration.Enabled)
			{
				Dictionary<string, DeliverySettings> deliveries = modShops.Configuration.Deliveries;
				if (deliveries != null && !((Object)(object)__instance.MatchingShop == (Object)null) && deliveries.TryGetValue(__instance.MatchingShop.ShopName, out var value) && value.Availability != DeliveryAvailabilitySettings.Unchanged)
				{
					__result = value.DeliveryFee;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ShopInterface), "SetIsOpen")]
	public class ForceUpdateShopPrices
	{
		[HarmonyPostfix]
		public static void ShopInterfaceSetIsOpen(ShopInterface __instance, bool isOpen)
		{
			Enumerator<ListingUI> enumerator = __instance.listingUI.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ListingUI current = enumerator.Current;
				current.UpdateLockStatus();
				current.Update();
				current.UpdatePrice();
				current.UpdateStock();
				current.UpdateButtons();
			}
		}
	}
	[HarmonyPatch(typeof(Player), "NetworkInitialize__Late")]
	public class SupplierStartPatch
	{
		private delegate ref T ConfigRef<T>(ModShopsConfiguration configuration);

		private static readonly Dictionary<string, ConfigRef<ShopListingSettings>> ShopConfigByCode = new Dictionary<string, ConfigRef<ShopListingSettings>>
		{
			["thrifty_threads"] = (ModShopsConfiguration c) => ref c.ThriftyThreads,
			["coke_shop"] = (ModShopsConfiguration c) => ref c.CokeSupplier,
			["meth_shop"] = (ModShopsConfiguration c) => ref c.MethSupplier,
			["weed_shop"] = (ModShopsConfiguration c) => ref c.WeedSupplier,
			["shrooms_shop"] = (ModShopsConfiguration c) => ref c.ShroomSupplier,
			["boutique"] = (ModShopsConfiguration c) => ref c.Boutique,
			["dark_market_shop"] = (ModShopsConfiguration c) => ref c.DarkMarket,
			["gas_mart_west"] = (ModShopsConfiguration c) => ref c.GasStation,
			["gas_mart_central"] = (ModShopsConfiguration c) => ref c.CentralGasStation,
			["dans_hardware"] = (ModShopsConfiguration c) => ref c.DansHardware,
			["handy_hanks"] = (ModShopsConfiguration c) => ref c.HandyHanks
		};

		private static readonly (Func<Supplier> Find, ConfigRef<SupplierListingOverride> Config)[] Suppliers = new(Func<Supplier>, ConfigRef<SupplierListingOverride>)[4]
		{
			(() => (Supplier)(object)Object.FindObjectOfType<Albert>(), (ModShopsConfiguration c) => ref c.Albert),
			(() => (Supplier)(object)Object.FindObjectOfType<Shirley>(), (ModShopsConfiguration c) => ref c.Shirley),
			(() => (Supplier)(object)Object.FindObjectOfType<Salvador>(), (ModShopsConfiguration c) => ref c.Salvador),
			(() => (Supplier)(object)Object.FindObjectOfType<Phil>(), (ModShopsConfiguration c) => ref c.Phil)
		};

		[HarmonyPrefix]
		public static void PatchPrices()
		{
			ModShopsConfiguration configuration = Core.Get<ModShops>().Configuration;
			if (configuration.Enabled)
			{
				ApplyItemRankOverrides(configuration);
			}
			ApplyShopOverrides();
			ApplySupplierOverrides();
			configuration.SaveConfiguration();
		}

		private static void ApplySupplierOverrides()
		{
			ModShopsConfiguration configuration = Core.Get<ModShops>().Configuration;
			(Func<Supplier>, ConfigRef<SupplierListingOverride>)[] suppliers = Suppliers;
			for (int i = 0; i < suppliers.Length; i++)
			{
				(Func<Supplier>, ConfigRef<SupplierListingOverride>) tuple = suppliers[i];
				Func<Supplier> item = tuple.Item1;
				ConfigRef<SupplierListingOverride> item2 = tuple.Item2;
				Supplier supplier = item();
				AssertSupplierConfigEntryExists(ref item2(configuration), supplier);
				if (configuration.Enabled)
				{
					ApplySupplierConfigValues(item2(configuration), supplier);
				}
			}
			static void ApplySupplierConfigValues(SupplierListingOverride supplierListingOverride, Supplier val)
			{
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				foreach (Listing item3 in (Il2CppArrayBase<Listing>)(object)val.OnlineShopItems)
				{
					if (supplierListingOverride.PriceOverrides.TryGetValue(((BaseItemDefinition)item3.Item).ID, out var value))
					{
						item3.Item.BasePurchasePrice = value;
					}
				}
			}
			static void AssertSupplierConfigEntryExists(ref SupplierListingOverride reference, Supplier val)
			{
				if (reference == null)
				{
					reference = new SupplierListingOverride();
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				foreach (Listing item4 in (Il2CppArrayBase<Listing>)(object)val.OnlineShopItems)
				{
					if (!reference.PriceOverrides.ContainsKey(((BaseItemDefinition)item4.Item).ID))
					{
						reference.PriceOverrides[((BaseItemDefinition)item4.Item).ID] = item4.Price;
					}
				}
			}
		}

		private static void ApplyShopOverrides()
		{
			List<ShopInterface> list = ((IEnumerable<ShopInterface>)Object.FindObjectsOfType<ShopInterface>()).ToList();
			ModShopsConfiguration configuration = Core.Get<ModShops>().Configuration;
			foreach (ShopInterface item in list)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				List<ShopListing> list2 = item.Listings.ToList<ShopListing>();
				if (list2 != null && ShopConfigByCode.TryGetValue(item.ShopCode, out var value))
				{
					AssertConfigurationEntries(ref value(configuration), item, list2);
					if (configuration.Enabled)
					{
						ApplyShopSettings(list2, item, value(configuration));
						ApplyAddedListings(item, value(configuration));
					}
				}
			}
		}

		private static void ApplyAddedListings(ShopInterface shopInterface, ShopListingSettings shopSettings)
		{
			//IL_00ef: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0127: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			if (!shopSettings.Override || shopSettings.AddedItems == null || shopSettings.AddedItems.Count == 0)
			{
				return;
			}
			bool flag = false;
			foreach (KeyValuePair<string, AddedListing> addedItem in shopSettings.AddedItems)
			{
				string key = addedItem.Key;
				AddedListing value = addedItem.Value;
				if (shopInterface.GetListing(key) != null)
				{
					continue;
				}
				StorableItemDefinition item = Registry.GetItem<StorableItemDefinition>(key);
				if ((Object)(object)item == (Object)null)
				{
					Log.Warning($"[Shops] Cannot add '{key}' to '{shopInterface.ShopCode}': " + "no such item in the registry. Check the item ID.");
					continue;
				}
				try
				{
					ShopListing val = new ShopListing
					{
						name = ((BaseItemDefinition)item).Name,
						Item = item,
						Shop = shopInterface,
						LimitedStock = (value.Stock >= 0),
						DefaultStock = ((value.Stock >= 0) ? value.Stock : shopSettings.DefaultStock),
						RestockRate = value.RestockRate
					};
					val.CurrentStock = val.DefaultStock;
					if (value.Price >= 0f)
					{
						val.OverridePrice = true;
						val.OverriddenPrice = value.Price;
					}
					shopInterface.Listings.Add(val);
					shopInterface.CreateListingUI(val);
					flag = true;
				}
				catch (Exception ex)
				{
					Log.Error($"[Shops] Failed to add '{key}' to '{shopInterface.ShopCode}': {ex.Message}");
				}
			}
			if (flag)
			{
				shopInterface.RefreshShownItems();
				shopInterface.RefreshUnlockStatus();
			}
		}

		private static void AssertConfigurationEntries(ref ShopListingSettings configSetting, ShopInterface shopInterface, List<ShopListing> listings)
		{
			//IL_0022: 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_0070: 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)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (configSetting == null)
			{
				configSetting = new ShopListingSettings();
			}
			if (configSetting.ItemOverrides.Count == 0)
			{
				configSetting.PaymentType = shopInterface.PaymentType;
			}
			foreach (ShopListing listing in listings)
			{
				if (!configSetting.ItemOverrides.ContainsKey(((BaseItemDefinition)listing.Item).ID))
				{
					FullRank requiredRank = listing.Item.RequiredRank;
					configSetting.ItemOverrides[((BaseItemDefinition)listing.Item).ID] = new ItemListingOverride
					{
						Price = listing.Price,
						Stock = (listing.LimitedStock ? listing.DefaultStock : (-1)),
						RestockRate = listing.RestockRate,
						RequiresRank = listing.Item.RequiresLevelToPurchase,
						RequiredRank = requiredRank.Rank,
						RequiredRankTier = requiredRank.Tier
					};
				}
			}
			shopInterface.RefreshShownItems();
			shopInterface.RefreshUnlockStatus();
		}

		private static void ApplyShopSettings(List<ShopListing> listings, ShopInterface shopInterface, ShopListingSettings shopSettings)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (!shopSettings.Override)
			{
				return;
			}
			shopInterface.PaymentType = shopSettings.PaymentType;
			foreach (ShopListing listing in listings)
			{
				if (shopSettings.ItemOverrides.TryGetValue(((BaseItemDefinition)listing.Item).ID, out var value))
				{
					listing.LimitedStock = value.Stock >= 0;
					listing.DefaultStock = ((value.Stock >= 0) ? value.Stock : shopSettings.DefaultStock);
					listing.CurrentStock = listing.DefaultStock;
					listing.RestockRate = value.RestockRate;
					if (value.Price >= 0f)
					{
						listing.OverridePrice = true;
						listing.OverriddenPrice = value.Price;
					}
				}
			}
		}

		private static void ApplyItemRankOverrides(ModShopsConfiguration configuration)
		{
			foreach (ConfigRef<ShopListingSettings> value in ShopConfigByCode.Values)
			{
				ShopListingSettings shopListingSettings = value(configuration);
				if (shopListingSettings == null || !shopListingSettings.Override)
				{
					continue;
				}
				if (shopListingSettings.ItemOverrides != null)
				{
					foreach (KeyValuePair<string, ItemListingOverride> itemOverride in shopListingSettings.ItemOverrides)
					{
						ApplyItemRank(itemOverride.Key, itemOverride.Value);
					}
				}
				if (shopListingSettings.AddedItems == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, AddedListing> addedItem in shopListingSettings.AddedItems)
				{
					ApplyItemRank(addedItem.Key, addedItem.Value);
				}
			}
		}

		private static void ApplyItemRank(string itemId, IRankRequirement spec)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0088: 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)
			if (spec == null || !spec.RequiresRank.HasValue)
			{
				return;
			}
			StorableItemDefinition item = Registry.GetItem<StorableItemDefinition>(itemId);
			if ((Object)(object)item == (Object)null)
			{
				Log.Warning("[Shops] Cannot set rank requirement for '" + itemId + "': not found in the registry.");
				return;
			}
			item.RequiresLevelToPurchase = spec.RequiresRank.Value;
			FullRank requiredRank = item.RequiredRank;
			requiredRank.Rank = spec.RequiredRank;
			requiredRank.Tier = spec.RequiredRankTier;
			item.RequiredRank = requiredRank;
			if (Log.DebugEnabled)
			{
				Log.Info($"[Shops] '{itemId}' rank requirement set: RequiresLevel={spec.RequiresRank.Value}, Rank={spec.RequiredRank} Tier={spec.RequiredRankTier}");
			}
		}
	}
}
namespace Lithium.Modules.LabOven
{
	public class ModLabOvenConfiguration : ModuleConfiguration
	{
		public float CookDurationMinutes = 60f;

		public override string Name => "LabOven";
	}
	public class ModLabOven : ModuleBase<ModLabOvenConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.LabOven.Patches
{
	[HarmonyPatch(typeof(LabOven), "OnTimePass")]
	public class LabOvenDurationPatch
	{
		private static readonly Dictionary<IntPtr, float> Carry = new Dictionary<IntPtr, float>();

		[HarmonyPrefix]
		public static void Prefix(LabOven __instance, ref int minutes, bool __runOriginal)
		{
			if (!__runOriginal)
			{
				return;
			}
			ModLabOvenConfiguration configuration = Core.Get<ModLabOven>().Configuration;
			if (!configuration.Enabled)
			{
				return;
			}
			OvenCookOperation currentOperation = __instance.CurrentOperation;
			if (currentOperation == null)
			{
				return;
			}
			float cookDurationMinutes = configuration.CookDurationMinutes;
			if (cookDurationMinutes <= 0f)
			{
				return;
			}
			float num = currentOperation.GetCookDuration();
			if (!(num <= 0f))
			{
				float num2 = num / cookDurationMinutes;
				if (!Mathf.Approximately(num2, 1f))
				{
					IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
					Carry.TryGetValue(pointer, out var value);
					float num3 = (float)minutes * num2 + value;
					int num4 = Mathf.FloorToInt(num3);
					Carry[pointer] = num3 - (float)num4;
					minutes = num4;
				}
			}
		}
	}
}
namespace Lithium.Modules.DryingRacks
{
	public class ModDryingRacksConfiguration : ModuleConfiguration
	{
		public Dictionary<string, int> PerQualityDryTimes = new Dictionary<string, int>
		{
			{ "Trash", 240 },
			{ "Poor", 360 },
			{ "Standard", 720 },
			{ "Premium", 800 },
			{ "Heavenly", 1200 }
		};

		public override string Name => "DryingRacks";

		public int Capacity { get; set; } = 20;

		public override void Validate()
		{
			Capacity = ConfigValidator.AtLeast(Name, "Capacity", Capacity, 1);
			foreach (string item in PerQualityDryTimes.Keys.ToList())
			{
				PerQualityDryTimes[item] = ConfigValidator.AtLeast(Name, "PerQualityDryTimes[" + item + "]", PerQualityDryTimes[item], 0);
			}
		}
	}
	public class ModDryingRacks : ModuleBase<ModDryingRacksConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.DryingRacks.Patches
{
	[HarmonyPatch(typeof(DryingRack), "OnMinPass")]
	public class DryingRackPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(DryingRack __instance)
		{
			//IL_0063: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			ModDryingRacksConfiguration configuration = Core.Get<ModDryingRacks>().Configuration;
			if (!configuration.Enabled)
			{
				return true;
			}
			Dictionary<string, int> perQualityDryTimes = configuration.PerQualityDryTimes;
			foreach (DryingOperation item in __instance.DryingOperations.ToArray())
			{
				float time = item.Time;
				item.Time = time + 1f;
				string key = ((object)item.GetQuality()/*cast due to .constrained prefix*/).ToString();
				int valueOrDefault = perQualityDryTimes.GetValueOrDefault(key, 720);
				if (!(item.Time >= (float)valueOrDefault))
				{
					continue;
				}
				if ((int)item.StartQuality >= 3)
				{
					if (InstanceFinder.IsServer && __instance.GetOutputCapacityForOperation(item, (EQuality)4) >= item.Quantity)
					{
						__instance.TryEndOperation(__instance.DryingOperations.IndexOf(item), false, (EQuality)4, Random.Range(int.MinValue, int.MaxValue));
					}
				}
				else
				{
					item.IncreaseQuality();
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DryingOperationUI), "UpdatePosition")]
	public class DryingOperationUIPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(DryingOperationUI __instance)
		{
			//IL_0030: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			ModDryingRacksConfiguration configuration = Core.Get<ModDryingRacks>().Configuration;
			if (!configuration.Enabled)
			{
				return true;
			}
			Dictionary<string, int> perQualityDryTimes = configuration.PerQualityDryTimes;
			string key = ((object)__instance.AssignedOperation.StartQuality/*cast due to .constrained prefix*/).ToString();
			int valueOrDefault = perQualityDryTimes.GetValueOrDefault(key, 720);
			DryingOperation assignedOperation = __instance.AssignedOperation;
			float num = Mathf.Clamp01(assignedOperation.Time / (float)valueOrDefault);
			int num2 = (int)Mathf.Clamp((float)valueOrDefault - assignedOperation.Time, 0f, (float)valueOrDefault);
			int value = num2 / 60;
			int value2 = num2 % 60;
			__instance.Tooltip.text = $"{value}h {value2}m until next tier";
			float num3 = -62.5f;
			float num4 = 0f - num3;
			__instance.Rect.anchoredPosition = new Vector2(Mathf.Lerp(num3, num4, num), 0f);
			return false;
		}
	}
	[HarmonyPatch(typeof(DryingOperation), "GetQuality")]
	public class DryingOperationPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(DryingOperation __instance, ref EQuality __result)
		{
			//IL_0026: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected I4, but got Unknown
			//IL_005c: 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)
			//IL_0064: Expected I4, but got Unknown
			ModDryingRacksConfiguration configuration = Core.Get<ModDryingRacks>().Configuration;
			if (!configuration.Enabled)
			{
				return true;
			}
			Dictionary<string, int> perQualityDryTimes = configuration.PerQualityDryTimes;
			string key = ((object)__instance.StartQuality/*cast due to .constrained prefix*/).ToString();
			if (__instance.Time >= (float)perQualityDryTimes.GetValueOrDefault(key, 720))
			{
				__result = (EQuality)(__instance.StartQuality + 1);
			}
			else
			{
				__result = (EQuality)(int)__instance.StartQuality;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DryingRackCanvas), "SetIsOpen")]
	public class DryingRackCapacityPatch
	{
		[HarmonyPostfix]
		public static void DryingRackCapacity(DryingRackCanvas __instance, DryingRack rack, bool open)
		{
			ModDryingRacksConfiguration configuration = Core.Get<ModDryingRacks>().Configuration;
			if (configuration.Enabled && rack != null)
			{
				rack.ItemCapacity = configuration.Capacity;
			}
		}
	}
}
namespace Lithium.Modules.WateringCans
{
	public class ModWateringCanConfiguration : ModuleConfiguration
	{
		public float DrainModifier = 1f;

		public override string Name => "WateringCan";
	}
	public class ModWateringCan : ModuleBase<ModWateringCanConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.WateringCans.Patches
{
	[HarmonyPatch(typeof(WaterContainerPourable), "PourAmount")]
	public static class FunctionalWateringCanPourAmountPatch
	{
		[HarmonyPrefix]
		public static void Prefix(ref float amount)
		{
			ModWateringCanConfiguration configuration = Core.Get<ModWateringCan>().Configuration;
			if (configuration.Enabled)
			{
				amount *= configuration.DrainModifier;
			}
		}
	}
}
namespace Lithium.Modules.Vehicles
{
	public class VehicleConfiguration
	{
		public bool OverrideSlotCount = false;

		public int SlotCount = 0;

		public bool OverridePrice = false;

		public int Price = 0;

		public bool OverrideDefaultColor = false;

		public EVehicleColor Color = (EVehicleColor)3;
	}
	public class ModVehiclesConfiguration : ModuleConfiguration
	{
		public Dictionary<string, VehicleConfiguration> Overrides = new Dictionary<string, VehicleConfiguration>
		{
			{
				"shitbox",
				new VehicleConfiguration()
			},
			{
				"bruiser",
				new VehicleConfiguration()
			},
			{
				"hounddog",
				new VehicleConfiguration()
			},
			{
				"dinkler",
				new VehicleConfiguration()
			},
			{
				"cheetah",
				new VehicleConfiguration()
			},
			{
				"veeper",
				new VehicleConfiguration()
			},
			{
				"hotbox",
				new VehicleConfiguration()
			}
		};

		public override string Name => "Vehicles";
	}
	public class ModVehicles : ModuleBase<ModVehiclesConfiguration>
	{
		public override void Apply()
		{
			if (!base.Configuration.Enabled)
			{
				return;
			}
			foreach (KeyValuePair<string, VehicleConfiguration> @override in base.Configuration.Overrides)
			{
				LandVehicle vehiclePrefab = NetworkSingleton<VehicleManager>.Instance.GetVehiclePrefab(@override.Key);
				if (@override.Value.OverridePrice)
				{
					vehiclePrefab.vehiclePrice = @override.Value.Price;
				}
				if (@override.Value.OverrideSlotCount)
				{
					vehiclePrefab.Storage.SlotCount = @override.Value.SlotCount;
				}
			}
		}
	}
}
namespace Lithium.Modules.PropertyPrices
{
	public class ModPropertyPricesConfiguration : ModuleConfiguration
	{
		public override string Name => "Property Prices";

		public Dictionary<string, int> PropertyPrices { get; set; } = new Dictionary<string, int>
		{
			{ "RV", 0 },
			{ "Sewer Office", 0 },
			{ "Motel Room", 75 },
			{ "Sweatshop", 800 },
			{ "Storage Unit", 5000 },
			{ "Bungalow", 6000 },
			{ "Barn", 25000 },
			{ "Docks Warehouse", 50000 },
			{ "Hyland Manor", 100000 },
			{ "Laundromat", 4000 },
			{ "Post Office", 10000 },
			{ "Car Wash", 20000 },
			{ "Taco Ticklers", 50000 }
		};
	}
	public class ModPropertyPrices : ModuleBase<ModPropertyPricesConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.PropertyPrices.Patches
{
	[HarmonyPatch(typeof(Player), "NetworkInitialize___Early")]
	public class ForcePropertyPrices
	{
		[HarmonyPrefix]
		public static void PatchPrices()
		{
			ModPropertyPricesConfiguration configuration = Core.Get<ModPropertyPrices>().Configuration;
			if (configuration.Enabled)
			{
				ChangePropertyPrices(configuration);
				UpdateMissMingDialog(configuration);
				configuration.SaveConfiguration();
			}
		}

		private static void ChangePropertyPrices(ModPropertyPricesConfiguration configuration)
		{
			Property[] array = Il2CppArrayBase<Property>.op_Implicit(Object.FindObjectsOfType<Property>());
			Property[] array2 = array;
			foreach (Property val in array2)
			{
				if (!configuration.PropertyPrices.TryGetValue(val.PropertyName, out var value))
				{
					value = (int)val.Price;
					configuration.PropertyPrices[val.PropertyName] = value;
					Log.Info($"Property {val.PropertyName} not in configuration; added at live price {value}.");
				}
				val.Price = value;
				if ((Object)(object)val.ForSaleSign != (Object)null)
				{
					((TMP_Text)((Component)val.ForSaleSign.transform.Find("Price")).GetComponent<TextMeshPro>()).text = MoneyManager.FormatAmount((float)value, false, false);
				}
				if ((Object)(object)val.ListingPoster != (Object)null)
				{
					((TMP_Text)((Component)val.ListingPoster.Find("Price")).GetComponent<TextMeshPro>()).text = MoneyManager.FormatAmount((float)value, false, false);
				}
			}
		}

		private static void UpdateMissMingDialog(ModPropertyPricesConfiguration configuration)
		{
			DialogueController_Ming[] array = Il2CppArrayBase<DialogueController_Ming>.op_Implicit(Object.FindObjectsOfType<DialogueController_Ming>());
			DialogueController_Ming[] array2 = array;
			foreach (DialogueController_Ming val in array2)
			{
				DialogueController_Ming val2 = val;
				Transform parent = ((Component)val).gameObject.transform.parent;
				string text = ((parent != null) ? ((Object)parent).name : null);
				if (1 == 0)
				{
				}
				float price = ((text == "Ming") ? ((float)configuration.PropertyPrices["Sweatshop"]) : ((!(text == "Donna")) ? val.Price : ((float)configuration.PropertyPrices["Motel Room"])));
				if (1 == 0)
				{
				}
				val2.Price = price;
			}
		}
	}
}
namespace Lithium.Modules.Employees
{
	public class BotanistConfiguration
	{
		public int MaxAssignedPots = 8;

		public float WalkSpeed = 1.2f;

		public int DailyWage = 200;

		public int InventorySlotCount = 5;

		public int InventoryRowCount = 1;
	}
	public class ChemistConfiguration
	{
		public int MaxStations = 6;

		public int DailyWage = 300;

		public float WalkSpeed = 1.2f;

		public int InventorySlotCount = 5;

		public int InventoryRowCount = 1;
	}
	public class PackagerConfiguration
	{
		public int MaxStations = 3;

		public int MaxRoutes = 10;

		public float PackagingSpeedMultiplier = 2f;

		public int DailyWage = 200;

		public float WalkSpeed = 1.2f;

		public int InventorySlotCount = 5;

		public int InventoryRowCount = 1;
	}
	public class CleanerConfiguration
	{
		public int MaxBins = 3;

		public int DailyWage = 100;

		public float WalkSpeed = 1.2f;

		public int InventorySlotCount = 5;

		public int InventoryRowCount = 1;
	}
	public class DealerConfiguration
	{
		public int InventorySlotCount = 5;

		public int InventoryRowCount = 1;
	}
	public class ChemistOrdersConfiguration
	{
		public bool Enabled = false;

		public bool AddDialogueOption = true;
	}
	public class NoCollisionConfiguration
	{
		public bool Enabled = true;
	}
	public class ModEmployeesConfiguration : ModuleConfiguration
	{
		public bool PreventWorkStoppage = false;

		public BotanistConfiguration Botanists = new BotanistConfiguration();

		public ChemistConfiguration Chemists = new ChemistConfiguration();

		public PackagerConfiguration Packagers = new PackagerConfiguration();

		public CleanerConfiguration Cleaners = new CleanerConfiguration();

		public DealerConfiguration Dealers = new DealerConfiguration();

		public ChemistOrdersConfiguration ChemistOrders = new ChemistOrdersConfiguration();

		public EmployeeUnstickConfiguration Unstick = new EmployeeUnstickConfiguration();

		public NoCollisionConfiguration NoCollision = new NoCollisionConfiguration();

		public override string Name => "Employees";
	}
	public class ModEmployees : ModuleBase<ModEmployeesConfiguration>
	{
		public static readonly HashSet<Employee> ConfiguredEmployees = new HashSet<Employee>();

		private readonly EmployeeStuckWatchdog _stuckWatchdog = new EmployeeStuckWatchdog();

		private const int AllLayers = -1;

		private int _collisionSweep;

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

		public static bool TryBeginConfigure(Employee employee, out ModEmployeesConfiguration config)
		{
			config = null;
			ModEmployees modEmployees = Core.Get<ModEmployees>();
			if (modEmployees == null || !modEmployees.Configuration.Enabled)
			{
				return false;
			}
			if (!ConfiguredEmployees.Add(employee))
			{
				return false;
			}
			config = modEmployees.Configuration;
			return true;
		}

		public override void Apply()
		{
			ChemistOrderService.Reset();
			_stuckWatchdog.Reset();
		}

		public void DriveUpdate()
		{
			_stuckWatchdog.Tick(base.Configuration.Unstick);
			TickNoCollision();
		}

		private void TickNoCollision()
		{
			//IL_00ee: 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_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_010b: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			if (++_collisionSweep < 60)
			{
				return;
			}
			_collisionSweep = 0;
			NoCollisionConfiguration noCollisionConfiguration = base.Configuration?.NoCollision;
			if (noCollisionConfiguration == null || !noCollisionConfiguration.Enabled)
			{
				RestoreCollision();
				return;
			}
			EmployeeManager instance = NetworkSingleton<EmployeeManager>.Instance;
			List<Employee> val = (((Object)(object)instance != (Object)null) ? instance.AllEmployees : null);
			if (val == null)
			{
				return;
			}
			for (int i = 0; i < val.Count; i++)
			{
				CapsuleCollider val2 = ResolveCapsule(val[i]);
				if (!((Object)(object)val2 == (Object)null))
				{
					LayerMask excludeLayers;
					if (!_origExcludeLayers.ContainsKey(((Object)val2).GetInstanceID()))
					{
						Dictionary<int, int> origExcludeLayers = _origExcludeLayers;
						int instanceID = ((Object)val2).GetInstanceID();
						excludeLayers = ((Collider)val2).excludeLayers;
						origExcludeLayers[instanceID] = ((LayerMask)(ref excludeLayers)).value;
					}
					excludeLayers = ((Collider)val2).excludeLayers;
					if (((LayerMask)(ref excludeLayers)).value != -1)
					{
						LayerMask excludeLayers2 = ((Collider)val2).excludeLayers;
						((LayerMask)(ref excludeLayers2)).value = -1;
						((Collider)val2).excludeLayers = excludeLayers2;
					}
				}
			}
		}

		private void RestoreCollision()
		{
			//IL_0078: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			if (_origExcludeLayers.Count == 0)
			{
				return;
			}
			EmployeeManager instance = NetworkSingleton<EmployeeManager>.Instance;
			List<Employee> val = (((Object)(object)instance != (Object)null) ? instance.AllEmployees : null);
			if (val != null)
			{
				for (int i = 0; i < val.Count; i++)
				{
					CapsuleCollider val2 = ResolveCapsule(val[i]);
					if ((Object)(object)val2 != (Object)null && _origExcludeLayers.TryGetValue(((Object)val2).GetInstanceID(), out var value))
					{
						LayerMask excludeLayers = ((Collider)val2).excludeLayers;
						((LayerMask)(ref excludeLayers)).value = value;
						((Collider)val2).excludeLayers = excludeLayers;
					}
				}
			}
			_origExcludeLayers.Clear();
		}

		private static CapsuleCollider ResolveCapsule(Employee employee)
		{
			try
			{
				return ((Object)(object)employee != (Object)null && (Object)(object)((NPC)employee).Movement != (Object)null) ? ((NPC)employee).Movement.CapsuleCollider : null;
			}
			catch
			{
				return null;
			}
		}
	}
	public class EmployeeUnstickConfiguration
	{
		public bool Enabled = true;

		public float ScanIntervalSeconds = 0.5f;

		public float ProgressEpsilon = 1f;

		public float StuckSeconds = 5f;

		public float WarpAfterSeconds = 4f;

		public float WarpSampleRadius = 5f;
	}
	public class EmployeeStuckWatchdog
	{
		private sealed class Tracker
		{
			public Vector3 Anchor;

			public float AnchorTime;

			public int BehaviourId;

			public bool Nudged;
		}

		private readonly Dictionary<int, Tracker> _trackers = new Dictionary<int, Tracker>();

		private readonly HashSet<int> _currentIds = new HashSet<int>();

		private readonly List<int> _pruneList = new List<int>();

		private float _nextScan;

		public void Reset()
		{
			_trackers.Clear();
			_nextScan = 0f;
		}

		public void Tick(EmployeeUnstickConfiguration settings)
		{
			if (settings == null || !settings.Enabled || !InstanceFinder.IsServer || !Core.IsInMainScene)
			{
				return;
			}
			float time = Time.time;
			if (time < _nextScan)
			{
				return;
			}
			_nextScan = time + Mathf.Max(0.1f, settings.ScanIntervalSeconds);
			if (!NetworkSingleton<EmployeeManager>.InstanceExists)
			{
				return;
			}
			EmployeeManager instance = NetworkSingleton<EmployeeManager>.Instance;
			List<Employee> val = ((instance != null) ? instance.AllEmployees : null);
			if (val == null)
			{
				return;
			}
			_currentIds.Clear();
			for (int i = 0; i < val.Count; i++)
			{
				Employee val2 = val[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val2).GetInstanceID();
				_currentIds.Add(instanceID);
				try
				{
					Evaluate(val2, instanceID, time, settings);
				}
				catch (Exception ex)
				{
					_trackers.Remove(instanceID);
					if (Log.DebugEnabled)
					{
						Log.Warning("[EmployeeUnstick] Evaluate failed for an employee: " + ex.Message);
					}
				}
			}
			PruneDespawned();
		}

		private void Evaluate(Employee e, int id, float now, EmployeeUnstickConfiguration settings)
		{
			//IL_0091: 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_00c5: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: 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)
			NPCMovement movement = ((NPC)e).Movement;
			NPCBehaviour behaviour = ((NPC)e).Behaviour;
			Behaviour val = (((Object)(object)behaviour != (Object)null) ? behaviour.activeBehaviour : null);
			if (!((NPC)e).IsConscious || ((NPC)e).IsInVehicle || e.Fired || e.IsWaitingOutside || !((Object)(object)movement != (Object)null) || !movement.HasDestination || movement.IsPaused || !((Object)(object)val != (Object)null) || !val.Active)
			{
				_trackers.Remove(id);
				return;
			}
			Vector3 position = ((Component)e).transform.position;
			int instanceID = ((Object)val).GetInstanceID();
			if (!_trackers.TryGetValue(id, out var value))
			{
				_trackers[id] = new Tracker
				{
					Anchor = position,
					AnchorTime = now,
					BehaviourId = instanceID
				};
				return;
			}
			if (instanceID != value.BehaviourId || HorizontalDistance(position, value.Anchor) >= settings.ProgressEpsilon)
			{
				value.Anchor = position;
				value.AnchorTime = now;
				value.BehaviourId = instanceID;
				value.Nudged = false;
				return;
			}
			float num = now - value.AnchorTime;
			if (!value.Nudged)
			{
				if (num >= settings.StuckSeconds)
				{
					Nudge(e, movement, val);
					value.Nudged = true;
					value.AnchorTime = now;
				}
			}
			else if (num >= settings.WarpAfterSeconds)
			{
				Warp(e, movement, val, settings);
				value.Anchor = ((Component)e).transform.position;
				value.AnchorTime = now;
				value.BehaviourId = ((Object)val).GetInstanceID();
				value.Nudged = false;
			}
		}

		private static void Nudge(Employee e, NPCMovement movement, Behaviour active)
		{
			if (Log.DebugEnabled)
			{
				Log.Info($"[EmployeeUnstick] {((NPC)e).fullName} appears stuck — re-pathing (pause/resume '{active.Name}').");
			}
			movement.Stop();
			active.Pause_Server();
			active.Resume_Server();
		}

		private void Warp(Employee e, NPCMovement movement, Behaviour active, EmployeeUnstickConfiguration settings)
		{
			//IL_0002: 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_0008: 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_000a: 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_002f: 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_006f: 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)
			Vector3 currentDestination = movement.CurrentDestination;
			Vector3 val = currentDestination;
			NavMeshHit val2 = default(NavMeshHit);
			if (NavMesh.SamplePosition(currentDestination, ref val2, Mathf.Max(1f, settings.WarpSampleRadius), -1))
			{
				val = ((NavMeshHit)(ref val2)).position;
			}
			if (Log.DebugEnabled)
			{
				Log.Info($"[EmployeeUnstick] {((NPC)e).fullName} still stuck after re-path — warping to {val} (near destination {currentDestination}).");
			}
			movement.Warp(val);
			active.Pause_Server();
			active.Resume_Server();
		}

		private void PruneDespawned()
		{
			if (_trackers.Count <= _currentIds.Count)
			{
				return;
			}
			_pruneList.Clear();
			foreach (KeyValuePair<int, Tracker> tracker in _trackers)
			{
				if (!_currentIds.Contains(tracker.Key))
				{
					_pruneList.Add(tracker.Key);
				}
			}
			foreach (int prune in _pruneList)
			{
				_trackers.Remove(prune);
			}
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			//IL_0001: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}
	}
}
namespace Lithium.Modules.Employees.ProductionOrders
{
	public sealed class OrderStep
	{
		[JsonProperty(Order = 1)]
		public string InputId = "";

		[JsonProperty(Order = 2)]
		public string MixerId = "";

		[JsonProperty(Order = 3)]
		public string OutputId = "";

		public OrderStep()
		{
		}

		public OrderStep(string input, string mixer, string output)
		{
			InputId = input;
			MixerId = mixer;
			OutputId = output;
		}
	}
	public sealed class ChemistOrderState
	{
		[JsonProperty(Order = 1)]
		public string TargetProductId = "";

		[JsonProperty(Order = 2)]
		public string TargetName = "";

		[JsonProperty(Order = 3)]
		public int Goal;

		[JsonProperty(Order = 4)]
		public int Started;

		[JsonProperty(Order = 5)]
		public List<string> ShelfGuids = new List<string>();

		[JsonProperty(Order = 6)]
		public List<OrderStep> Chain = new List<OrderStep>();

		[JsonProperty(Order = 7)]
		public bool Active = true;

		[JsonIgnore]
		public int Remaining => Goal - Started;

		[JsonIgnore]
		public bool IsComplete => !Active || Started >= Goal;
	}
	public sealed class OrderHistoryEntry
	{
		[JsonProperty(Order = 1)]
		public string TargetProductId = "";

		[JsonProperty(Order = 2)]
		public string TargetName = "";

		[JsonProperty(Order = 3)]
		public int Goal;

		[JsonProperty(Order = 4)]
		public List<string> ShelfGuids = new List<string>();

		public OrderHistoryEntry()
		{
		}

		public OrderHistoryEntry(ChemistOrderState order)
		{
			TargetProductId = order.TargetProductId;
			TargetName = order.TargetName;
			Goal = order.Goal;
			ShelfGuids = new List<string>(order.ShelfGuids);
		}

		public string Key()
		{
			List<string> list = new List<string>(ShelfGuids);
			list.Sort(StringComparer.Ordinal);
			return TargetProductId + "|" + Goal + "|" + string.Join(",", list);
		}
	}
	internal static class RecipeChainResolver
	{
		private readonly struct Edge
		{
			public readonly string BaseId;

			public readonly string MixerId;

			public readonly string OutputId;

			public Edge(string baseId, string mixerId, string outputId)
			{
				BaseId = baseId;
				MixerId = mixerId;
				OutputId = outputId;
			}
		}

		public static List<OrderStep> Resolve(string targetId, HashSet<string> availableIds)
		{
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance == (Object)null || instance.mixRecipes == null || string.IsNullOrEmpty(targetId))
			{
				return null;
			}
			HashSet<string> hashSet = new HashSet<string>();
			if (instance.ValidMixIngredients != null)
			{
				for (int i = 0; i < instance.ValidMixIngredients.Count; i++)
				{
					PropertyItemDefinition val = instance.ValidMixIngredients[i];
					if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)val).ID))
					{
						hashSet.Add(((BaseItemDefinition)val).ID);
					}
				}
			}
			Dictionary<string, List<Edge>> dictionary = new Dictionary<string, List<Edge>>();
			HashSet<string> hashSet2 = new HashSet<string>();
			List<StationRecipe> mixRecipes = instance.mixRecipes;
			for (int j = 0; j < mixRecipes.Count; j++)
			{
				StationRecipe val2 = mixRecipes[j];
				if ((Object)(object)val2 == (Object)null || val2.Ingredients == null || val2.Product == null || (Object)(object)val2.Product.Item == (Object)null || val2.Ingredients.Count < 2)
				{
					continue;
				}
				ItemDefinition val3 = null;
				ItemDefinition val4 = null;
				for (int k = 0; k < val2.Ingredients.Count; k++)
				{
					ItemDefinition item = val2.Ingredients[k].Item;
					if (!((Object)(object)item == (Object)null))
					{
						if ((Object)(object)val3 == (Object)null && hashSet.Contains(((BaseItemDefinition)item).ID))
						{
							val3 = item;
						}
						else
						{
							val4 = item;
						}
					}
				}
				if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					continue;
				}
				string iD = ((BaseItemDefinition)val2.Product.Item).ID;
				if (!string.IsNullOrEmpty(iD) && !(iD == ((BaseItemDefinition)val4).ID))
				{
					if (!dictionary.TryGetValue(iD, out var value))
					{
						value = (dictionary[iD] = new List<Edge>());
					}
					value.Add(new Edge(((BaseItemDefinition)val4).ID, ((BaseItemDefinition)val3).ID, iD));
					hashSet2.Add(iD);
				}
			}
			if (!dictionary.ContainsKey(targetId))
			{
				return null;
			}
			List<OrderStep> list2 = Search(targetId, dictionary, hashSet2, availableIds, requireAvailableMixers: true, requireAvailableBase: true);
			if (list2 != null)
			{
				return list2;
			}
			return Search(targetId, dictionary, hashSet2, availableIds, requireAvailableMixers: false, requireAvailableBase: false);
		}

		private static List<OrderStep> Search(string targetId, Dictionary<string, List<Edge>> producedBy, HashSet<string> hasRecipe, HashSet<string> availableIds, bool requireAvailableMixers, bool requireAvailableBase)
		{
			Queue<(string, List<OrderStep>)> queue = new Queue<(string, List<OrderStep>)>();
			HashSet<string> hashSet = new HashSet<string>();
			queue.Enqueue((targetId, new List<OrderStep>()));
			hashSet.Add(targetId);
			while (queue.Count > 0)
			{
				var (text, collection) = queue.Dequeue();
				if (!producedBy.TryGetValue(text, out var value))
				{
					continue;
				}
				foreach (Edge item in value)
				{
					if (!requireAvailableMixers || (availableIds != null && availableIds.Contains(item.MixerId)))
					{
						List<OrderStep> list = new List<OrderStep>
						{
							new OrderStep(item.BaseId, item.MixerId, text)
						};
						list.AddRange(collection);
						bool flag = !hasRecipe.Contains(item.BaseId);
						bool flag2 = availableIds?.Contains(item.BaseId) ?? false;
						if (requireAvailableBase ? flag2 : (flag2 || flag))
						{
							return list;
						}
						if (hashSet.Add(item.BaseId))
						{
							queue.Enqueue((item.BaseId, list));
						}
					}
				}
			}
			return null;
		}
	}
	internal static class OrderSlotLocks
	{
		public const string Reason = "Reserved for a Lithium production order";

		public static void Maintain(Chemist chemist, Dictionary<string, int> neededQuantities, List<ITransitEntity> shelves)
		{
			if (neededQuantities == null || neededQuantities.Count == 0 || shelves == null)
			{
				return;
			}
			NetworkObject val = OwnerOf(chemist);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ITransitEntity shelf in shelves)
			{
				StorageEntity val2 = Storage(shelf);
				if (((val2 != null) ? val2.ItemSlots : null) == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots = val2.ItemSlots;
				for (int i = 0; i < itemSlots.Count; i++)
				{
					ItemSlot val3 = itemSlots[i];
					if (val3 != null && IsOurLock(val3) && val3.ItemInstance != null && val3.Quantity > 0)
					{
						string text = (((Object)(object)val3.ItemInstance.Definition != (Object)null) ? ((BaseItemDefinition)val3.ItemInstance.Definition).ID : null);
						if (text != null && neededQuantities.ContainsKey(text))
						{
							dictionary[text] = (dictionary.TryGetValue(text, out var value) ? value : 0) + val3.Quantity;
						}
					}
				}
			}
			foreach (ITransitEntity shelf2 in shelves)
			{
				StorageEntity val4 = Storage(shelf2);
				if (((val4 != null) ? val4.ItemSlots : null) == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots2 = val4.ItemSlots;
				for (int j = 0; j < itemSlots2.Count; j++)
				{
					ItemSlot val5 = itemSlots2[j];
					if (val5 == null || val5.IsLocked || val5.ItemInstance == null || val5.Quantity <= 0)
					{
						continue;
					}
					string text2 = (((Object)(object)val5.ItemInstance.Definition != (Object)null) ? ((BaseItemDefinition)val5.ItemInstance.Definition).ID : null);
					if (text2 == null || !neededQuantities.TryGetValue(text2, out var value2) || value2 <= 0)
					{
						continue;
					}
					int value3;
					int num = (dictionary.TryGetValue(text2, out value3) ? value3 : 0);
					if (num < value2)
					{
						try
						{
							val5.ApplyLock(val, "Reserved for a Lithium production order", false);
							dictionary[text2] = num + val5.Quantity;
						}
						catch (Exception ex)
						{
							Log.Warning("[ChemistOrders] ApplyLock failed: " + ex.Message);
						}
					}
				}
			}
		}

		private static bool IsOurLock(ItemSlot slot)
		{
			try
			{
				return slot.IsLocked && slot.ActiveLock != null && slot.ActiveLock.LockReason == "Reserved for a Lithium production order";
			}
			catch
			{
				return false;
			}
		}

		public static void Release(Chemist chemist, List<ITransitEntity> shelves)
		{
			if (shelves == null)
			{
				return;
			}
			NetworkObject val = OwnerOf(chemist);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (ITransitEntity shelf in shelves)
			{
				if (shelf != null)
				{
					try
					{
						shelf.RemoveSlotLocks(val);
					}
					catch (Exception ex)
					{
						Log.Warning("[ChemistOrders] RemoveSlotLocks failed: " + ex.Message);
					}
				}
			}
		}

		private static NetworkObject OwnerOf(Chemist chemist)
		{
			if ((Object)(object)chemist == (Object)null)
			{
				return null;
			}
			try
			{
				return ((NetworkBehaviour)chemist).NetworkObject;
			}
			catch
			{
				return null;
			}
		}

		private static StorageEntity Storage(ITransitEntity shelf)
		{
			if (shelf == null)
			{
				return null;
			}
			PlaceableStorageEntity val = ((Il2CppObjectBase)shelf).TryCast<PlaceableStorageEntity>();
			return ((Object)(object)val != (Object)null) ? val.StorageEntity : null;
		}
	}
	internal static class ChemOrderNet
	{
		public const string Channel = "lithord_req";

		private const char Sep = '|';

		private const char ShelfSep = ',';

		public static bool IsHost => InstanceFinder.IsServer;

		public static void SendSet(Chemist chemist, string productId, int quantity, List<string> shelfGuids)
		{
			string value = ((shelfGuids != null) ? string.Join(','.ToString(), shelfGuids) : "");
			Send($"SET{124}{Guid(chemist)}{124}{productId}{124}{quantity}{124}{value}");
		}

		public static void SendCancel(Chemist chemist)
		{
			Send($"CANCEL{124}{Guid(chemist)}");
		}

		private static void Send(string payload)
		{
			try
			{
				VariableDatabase val = (NetworkSingleton<VariableDatabase>.InstanceExists ? NetworkSingleton<VariableDatabase>.Instance : null);
				if ((Object)(object)val == (Object)null)
				{
					Log.Warning("[ChemistOrders] No VariableDatabase; can't send order request to host.");
				}
				else
				{
					val.SendValue((NetworkConnection)null, "lithord_req", payload);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Failed to send order request: " + ex.Message);
			}
		}

		public static void Process(string payload)
		{
			if (!InstanceFinder.IsServer || string.IsNullOrEmpty(payload))
			{
				return;
			}
			try
			{
				string[] array = payload.Split('|');
				if (array.Length < 2)
				{
					return;
				}
				Chemist val = ResolveChemist(array[1]);
				if ((Object)(object)val == (Object)null)
				{
					Log.Warning("[ChemistOrders] Order request for unknown chemist GUID '" + array[1] + "'.");
					return;
				}
				string text = array[0];
				string text2 = text;
				if (!(text2 == "SET"))
				{
					if (text2 == "CANCEL")
					{
						ChemistOrderService.ClearOrder(val);
						Log.Info("[ChemistOrders] Applied client order cancel for " + Name(val) + ".");
					}
				}
				else if (array.Length >= 5)
				{
					int result;
					int num = (int.TryParse(array[3], out result) ? result : 0);
					List<string> shelfGuids = ((array[4].Length > 0) ? new List<string>(array[4].Split(',')) : new List<string>());
					if (ChemistOrderService.TrySetOrder(val, array[2], num, shelfGuids, out var error))
					{
						Log.Info($"[ChemistOrders] Applied client order for {Name(val)}: {num}x {array[2]}.");
					}
					else
					{
						Log.Warning("[ChemistOrders] Rejected client order for " + Name(val) + ": " + error);
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Failed to process order request: " + ex.Message);
			}
		}

		private static Chemist ResolveChemist(string guid)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			try
			{
				return GUIDManager.GetObject<Chemist>(new Guid(guid));
			}
			catch
			{
				return null;
			}
		}

		private static string Guid(Chemist chemist)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				return "";
			}
		}

		private static string Name(Chemist chemist)
		{
			try
			{
				return ((NPC)chemist).fullName;
			}
			catch
			{
				return "chemist";
			}
		}
	}
	internal sealed class ChemistOrderOrchestrator
	{
		private sealed class StationView
		{
			public MixingStation Station;

			public MixingStationConfiguration Cfg;

			public ITransitEntity Entity;

			public string Guid;

			public string ProdId;

			public int ProdQty;

			public string MixId;

			public int MixQty;

			public string OutId;

			public int OutQty;

			public MixOperation Op;

			public int MaxBatch;

			public static StationView Build(MixingStation station)
			{
				//IL_007c: 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)
				if ((Object)(object)station == (Object)null)
				{
					return null;
				}
				ITransitEntity val = ((Il2CppObjectBase)station).TryCast<ITransitEntity>();
				if (val == null)
				{
					return null;
				}
				StationView obj = new StationView
				{
					Station = station,
					Entity = val
				};
				EntityConfiguration configuration = station.Configuration;
				obj.Cfg = ((configuration != null) ? ((Il2CppObjectBase)configuration).TryCast<MixingStationConfiguration>() : null);
				obj.Op = station.CurrentMixOperation;
				obj.MaxBatch = Math.Max(1, station.MaxMixQuantity);
				StationView stationView = obj;
				try
				{
					stationView.Guid = ((object)((BuildableItem)station).GUID/*cast due to .constrained prefix*/).ToString();
				}
				catch
				{
					return null;
				}
				ItemSlot productSlot = station.ProductSlot;
				if (productSlot != null && productSlot.ItemInstance != null && productSlot.Quantity > 0)
				{
					stationView.ProdId = DefId(productSlot.ItemInstance);
					stationView.ProdQty = productSlot.Quantity;
				}
				ItemSlot mixerSlot = station.MixerSlot;
				if (mixerSlot != null && mixerSlot.ItemInstance != null && mixerSlot.Quantity > 0)
				{
					stationView.MixId = DefId(mixerSlot.ItemInstance);
					stationView.MixQty = mixerSlot.Quantity;
				}
				ItemSlot outputSlot = station.OutputSlot;
				if (outputSlot != null && outputSlot.ItemInstance != null && outputSlot.Quantity > 0)
				{
					stationView.OutId = DefId(outputSlot.ItemInstance);
					stationView.OutQty = outputSlot.Quantity;
				}
				return stationView;
			}
		}

		private readonly Dictionary<string, TransitRoute> _routes = new Dictionary<string, TransitRoute>();

		private readonly Dictionary<string, HashSet<string>> _countedFinal = new Dictionary<string, HashSet<string>>();

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

		private const float StationLoiterRadius = 2.75f;

		public void Reset()
		{
			foreach (TransitRoute value in _routes.Values)
			{
				try
				{
					if (value != null)
					{
						value.Destroy();
					}
				}
				catch
				{
				}
			}
			_routes.Clear();
			_countedFinal.Clear();
			_seeded.Clear();
		}

		public void Drain(Chemist chemist, ChemistOrderState order, List<ITransitEntity> shelves)
		{
			if ((Object)(object)chemist == (Object)null || order == null || !InstanceFinder.IsServer)
			{
				return;
			}
			try
			{
				DisableOrderBehaviours(chemist);
				ChemistConfiguration configuration = chemist.configuration;
				List<MixingStation> val = ((configuration != null) ? configuration.MixStations : null);
				List<ITransitEntity> list = new List<ITransitEntity>();
				if (val != null)
				{
					for (int i = 0; i < val.Count; i++)
					{
						ITransitEntity val2 = StationDestination(val[i]);
						if (val2 != null && !list.Contains(val2))
						{
							list.Add(val2);
						}
					}
				}
				if (shelves != null)
				{
					foreach (ITransitEntity shelf in shelves)
					{
						if (shelf != null && !list.Contains(shelf))
						{
							list.Add(shelf);
						}
					}
				}
				if (val != null)
				{
					for (int j = 0; j < val.Count; j++)
					{
						MixingStation val3 = val[j];
						if (!((Object)(object)val3 == (Object)null))
						{
							DepositSlot(chemist, val3.OutputSlot, list);
							DepositSlot(chemist, val3.ProductSlot, list);
							DepositSlot(chemist, val3.MixerSlot, list);
						}
					}
				}
				DrainInventory(chemist, order, list);
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Drain failed for " + SafeName(chemist) + ": " + ex.Message);
			}
		}

		private static void DisableOrderBehaviours(Chemist chemist)
		{
			try
			{
				MoveItemBehaviour moveItemBehaviour = ((Employee)chemist).MoveItemBehaviour;
				if ((Object)(object)moveItemBehaviour != (Object)null && (((Behaviour)moveItemBehaviour).Active || ((Behaviour)moveItemBehaviour).Enabled))
				{
					((Behaviour)moveItemBehaviour).Disable_Networked((NetworkConnection)null);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Disabling move behaviour failed: " + ex.Message);
			}
			try
			{
				StartMixingStationBehaviour startMixingStationBehaviour = chemist.StartMixingStationBehaviour;
				if ((Object)(object)startMixingStationBehaviour != (Object)null && (((Behaviour)startMixingStationBehaviour).Active || ((Behaviour)startMixingStationBehaviour).Enabled))
				{
					((Behaviour)startMixingStationBehaviour).Disable_Networked((NetworkConnection)null);
				}
			}
			catch (Exception ex2)
			{
				Log.Warning("[ChemistOrders] Disabling mix behaviour failed: " + ex2.Message);
			}
		}

		private static ITransitEntity StationDestination(MixingStation station)
		{
			if ((Object)(object)station == (Object)null)
			{
				return null;
			}
			try
			{
				EntityConfiguration configuration = station.Configuration;
				MixingStationConfiguration val = ((configuration != null) ? ((Il2CppObjectBase)configuration).TryCast<MixingStationConfiguration>() : null);
				TransitRoute val2 = ((val != null) ? val.DestinationRoute : null);
				if (val2 != null && val2.AreEntitiesNonNull())
				{
					return val2.Destination;
				}
			}
			catch
			{
			}
			return null;
		}

		private static void DrainInventory(Chemist chemist, ChemistOrderState order, List<ITransitEntity> outputs)
		{
			NPCInventory inventory;
			try
			{
				inventory = ((NPC)chemist).Inventory;
			}
			catch
			{
				return;
			}
			if ((Object)(object)inventory == (Object)null || inventory.ItemSlots == null)
			{
				return;
			}
			HashSet<string> hashSet = ChainItemIds(order);
			List<ItemSlot> itemSlots = inventory.ItemSlots;
			for (int i = 0; i < itemSlots.Count; i++)
			{
				ItemSlot val = itemSlots[i];
				if (val != null && val.ItemInstance != null && val.Quantity > 0)
				{
					string text = DefId(val.ItemInstance);
					if (text != null && hashSet.Contains(text))
					{
						DepositSlot(chemist, val, outputs);
					}
				}
			}
		}

		private static HashSet<string> ChainItemIds(ChemistOrderState order)
		{
			HashSet<string> hashSet = new HashSet<string>();
			if (order == null || order.Chain == null)
			{
				return hashSet;
			}
			if (!string.IsNullOrEmpty(order.TargetProductId))
			{
				hashSet.Add(order.TargetProductId);
			}
			for (int i = 0; i < order.Chain.Count; i++)
			{
				OrderStep orderStep = order.Chain[i];
				if (!string.IsNullOrEmpty(orderStep.InputId))
				{
					hashSet.Add(orderStep.InputId);
				}
				if (!string.IsNullOrEmpty(orderStep.MixerId))
				{
					hashSet.Add(orderStep.MixerId);
				}
				if (!string.IsNullOrEmpty(orderStep.OutputId))
				{
					hashSet.Add(orderStep.OutputId);
				}
			}
			return hashSet;
		}

		private static void DepositSlot(Chemist chemist, ItemSlot slot, List<ITransitEntity> outputs)
		{
			if (slot == null || outputs == null || outputs.Count == 0)
			{
				return;
			}
			int num = 0;
			while (slot.ItemInstance != null && slot.Quantity > 0 && num++ < 128)
			{
				int quantity = slot.Quantity;
				ItemInstance itemInstance = slot.ItemInstance;
				foreach (ITransitEntity output in outputs)
				{
					if (output == null)
					{
						continue;
					}
					int quantity2 = slot.Quantity;
					if (quantity2 <= 0)
					{
						break;
					}
					int val;
					try
					{
						val = output.GetInputCapacityForItem(itemInstance.GetCopy(quantity2), (NPC)null, true);
					}
					catch
					{
						val = 0;
					}
					int num2 = Math.Min(quantity2, val);
					if (num2 > 0)
					{
						try
						{
							output.InsertItemIntoInput(itemInstance.GetCopy(num2), (NPC)(object)chemist);
							slot.ChangeQuantity(-num2, false);
						}
						catch (Exception ex)
						{
							Log.Warning("[ChemistOrders] Deposit failed: " + ex.Message);
						}
					}
				}
				if (slot.Quantity >= quantity)
				{
					break;
				}
			}
		}

		public bool Run(Chemist chemist)
		{
			//IL_0024: 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)
			if ((Object)(object)chemist == (Object)null || !InstanceFinder.IsServer)
			{
				return false;
			}
			string text;
			try
			{
				text = ((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				return false;
			}
			if (!ChemistOrderService.Store.TryGet(text, out var value) || value == null || !value.Active)
			{
				return false;
			}
			bool flag;
			try
			{
				flag = ((Employee)chemist).Fired;
			}
			catch
			{
				flag = false;
			}
			if (flag)
			{
				ChemistOrderService.ReleaseAndClear(chemist, value, text);
				_seeded.Remove(text);
				_countedFinal.Remove(text);
				return false;
			}
			if (!((Employee)chemist).CanWork())
			{
				return false;
			}
			SuppressIdle(chemist);
			try
			{
				UpdateProgress(chemist, value, text);
				if (value.Goal <= 0 || value.Chain == null || value.Chain.Count == 0)
				{
					((Employee)chemist).SubmitNoWorkReason("My production order is invalid.", string.Empty, 0);
					return true;
				}
				List<ITransitEntity> shelves = ResolveShelves(value);
				OrderSlotLocks.Maintain(chemist, ChemistOrderService.NeededQuantities(value), shelves);
				if (DrainedAndComplete(chemist, value))
				{
					ChemistOrderService.CompleteOrder(chemist, value, text);
					return true;
				}
				if (IsBusy(chemist))
				{
					((Employee)chemist).MarkIsWorking();
					return true;
				}
				PlanOneAction(chemist, value, shelves);
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Orchestration failed for " + SafeName(chemist) + ": " + ex.Message);
			}
			return true;
		}

		private static bool IsBusy(Chemist chemist)
		{
			MoveItemBehaviour moveItemBehaviour = ((Employee)chemist).MoveItemBehaviour;
			StartMixingStationBehaviour startMixingStationBehaviour = chemist.StartMixingStationBehaviour;
			if ((Object)(object)moveItemBehaviour != (Object)null && (((Behaviour)moveItemBehaviour).Active || ((Behaviour)moveItemBehaviour).Enabled))
			{
				return true;
			}
			if ((Object)(object)startMixingStationBehaviour != (Object)null && (((Behaviour)startMixingStationBehaviour).Active || ((Behaviour)startMixingStationBehaviour).Enabled))
			{
				return true;
			}
			return false;
		}

		private void UpdateProgress(Chemist chemist, ChemistOrderState order, string key)
		{
			if (!_countedFinal.TryGetValue(key, out var value))
			{
				value = new HashSet<string>();
				_countedFinal[key] = value;
			}
			bool flag = _seeded.Add(key);
			bool flag2 = false;
			ChemistConfiguration configuration = chemist.configuration;
			List<MixingStation> val = ((configuration != null) ? configuration.MixStations : null);
			if (val == null)
			{
				return;
			}
			for (int i = 0; i < val.Count; i++)
			{
				MixingStation val2 = val[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text = SafeGuid(val2);
				if (text == null)
				{
					continue;
				}
				if (IsFinalOp(val2.CurrentMixOperation, order))
				{
					if (value.Add(text) && !flag)
					{
						order.Started += val2.CurrentMixOperation.Quantity;
						flag2 = true;
					}
				}
				else
				{
					value.Remove(text);
				}
			}
			if (flag2)
			{
				ChemistOrderService.Store.Set(key, order);
			}
		}

		private bool DrainedAndComplete(Chemist chemist, ChemistOrderState order)
		{
			if (order.Started < order.Goal)
			{
				return false;
			}
			ChemistConfiguration configuration = chemist.configuration;
			List<MixingStation> val = ((configuration != null) ? configuration.MixStations : null);
			if (val == null)
			{
				return true;
			}
			for (int i = 0; i < val.Count; i++)
			{
				MixingStation val2 = val[i];
				if (!((Object)(object)val2 == (Object)null))
				{
					if (val2.CurrentMixOperation != null)
					{
						return false;
					}
					if (val2.OutputSlot != null && val2.OutputSlot.Quantity > 0 && IsChainProduct(order, DefId(val2.OutputSlot.ItemInstance)))
					{
						return false;
					}
					if (val2.ProductSlot != null && val2.ProductSlot.Quantity > 0 && IsChainInput(order, DefId(val2.ProductSlot.ItemInstance)))
					{
						return false;
					}
				}
			}
			return true;
		}

		private static bool IsChainProduct(ChemistOrderState order, string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return false;
			}
			if (id == order.TargetProductId)
			{
				return true;
			}
			for (int i = 0; i < order.Chain.Count; i++)
			{
				if (order.Chain[i].OutputId == id || order.Chain[i].InputId == id)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsChainInput(ChemistOrderState order, string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return false;
			}
			for (int i = 0; i < order.Chain.Count; i++)
			{
				if (order.Chain[i].InputId == id)
				{
					return true;
				}
			}
			return false;
		}

		private void PlanOneAction(Chemist chemist, ChemistOrderState order, List<ITransitEntity> shelves)
		{
			ChemistConfiguration configuration = chemist.configuration;
			List<MixingStation> val = ((configuration != null) ? configuration.MixStations : null);
			if (val == null || val.Count == 0)
			{
				((Employee)chemist).SubmitNoWorkReason("I haven't been assigned a mixing station.", "Use your management clipboard to assign me a mixing station.", 0);
				return;
			}
			List<StationView> list = new List<StationView>();
			for (int i = 0; i < val.Count; i++)
			{
				StationView stationView = StationView.Build(val[i]);
				if (stationView != null)
				{
					list.Add(stationView);
				}
			}
			string targetProductId = order.TargetProductId;
			List<OrderStep> chain = order.Chain;
			int val2 = ChemistOrderService.BatchCapacity(chemist, chain);
			int num = 0;
			foreach (StationView item in list)
			{
				num += InFlightUnits(item, order);
			}
			int num2 = order.Goal - order.Started - num;
			foreach (StationView item2 in list)
			{
				if (item2.Op != null || item2.OutQty <= 0 || item2.OutId != targetProductId)
				{
					continue;
				}
				ItemInstance itemInstance = item2.Station.OutputSlot.ItemInstance;
				if (item2.Cfg != null && item2.Cfg.DestinationRoute != null && item2.Cfg.DestinationRoute.AreEntitiesNonNull())
				{
					if (Haul(chemist, item2.Cfg.DestinationRoute, itemInstance, -1))
					{
						return;
					}
				}
				else if (shelves.Count > 0)
				{
					ITransitEntity val3 = shelves[0];
					TransitRoute route = GetRoute(item2.Entity, val3, item2.Guid, ShelfGuid(val3));
					if (route != null && Haul(chemist, route, itemInstance, -1))
					{
						return;
					}
				}
			}
			foreach (StationView item3 in list)
			{
				if (item3.Op == null && item3.OutQty > 0 && item3.ProdQty <= 0 && !(item3.OutId == targetProductId))
				{
					int num3 = OutputStage(chain, item3.OutId);
					if (num3 >= 0 && num3 + 1 < chain.Count)
					{
						AdvanceIntermediate(item3);
						return;
					}
				}
			}
			foreach (StationView item4 in list)
			{
				if (item4.Op != null || item4.OutQty > 0 || item4.ProdQty <= 0)
				{
					continue;
				}
				int num4 = StageForInput(chain, item4.ProdId);
				if (num4 < 0)
				{
					continue;
				}
				string mixerId = chain[num4].MixerId;
				if (item4.MixId == null || !(item4.MixId != mixerId))
				{
					int num5 = Math.Min(Math.Min(val2, item4.MaxBatch), item4.ProdQty + Math.Max(0, num2));
					if (num4 == 0 && item4.MixQty == 0 && item4.ProdQty < num5 && FetchInto(chemist, shelves, item4, chain[0].InputId, num5 - item4.ProdQty))
					{
						return;
					}
					if (item4.MixQty >= item4.ProdQty)
					{
						StartMix(chemist, item4);
						return;
					}
					if (FetchInto(chemist, shelves, item4, mixerId, item4.ProdQty - item4.MixQty))
					{
						return;
					}
				}
			}
			if (num2 > 0)
			{
				Dictionary<string, int> dictionary = ShelfCounts(shelves);
				string inputId = chain[0].InputId;
				string mixerId2 = chain[0].MixerId;
				int value;
				bool flag = dictionary.TryGetValue(inputId, out value) && value > 0;
				int value2;
				bool flag2 = dictionary.TryGetValue(mixerId2, out value2) && value2 > 0;
				if (flag && flag2)
				{
					foreach (StationView item5 in list)
					{
						if (item5.Op == null && item5.OutQty <= 0 && item5.ProdQty <= 0 && item5.MixQty <= 0)
						{
							int num6 = Math.Min(Math.Min(val2, item5.MaxBatch), num2);
							if (num6 <= 0)
							{
								break;
							}
							if (FetchInto(chemist, shelves, item5, inputId, num6))
							{
								return;
							}
						}
					}
				}
			}
			LoiterAtStation(chemist, list);
			((Employee)chemist).SubmitNoWorkReason(MissingReason(order, shelves), "Stock the assigned shelves with the ingredients.", 0);
		}

		private static void SuppressIdle(Chemist chemist)
		{
			try
			{
				IdleBehaviour waitOutside = ((Employee)chemist).WaitOutside;
				if ((Object)(object)waitOutside != (Object)null && (((Behaviour)waitOutside).Enabled || ((Behaviour)waitOutside).Active))
				{
					((Behaviour)waitOutside).Disable_Networked((NetworkConnection)null);
					((Behaviour)waitOutside).Deactivate_Networked((NetworkConnection)null);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Suppress idle failed: " + ex.Message);
			}
		}

		private static void LoiterAtStation(Chemist chemist, List<StationView> views)
		{
			//IL_009e: 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_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)
			if (views == null || views.Count == 0)
			{
				return;
			}
			StationView stationView = null;
			foreach (StationView view in views)
			{
				if (view.Op != null)
				{
					stationView = view;
					break;
				}
			}
			if (stationView == null)
			{
				stationView = views[0];
			}
			try
			{
				NPCMovement movement = ((NPC)chemist).Movement;
				if (!((Object)(object)movement == (Object)null) && !movement.IsMoving)
				{
					Vector3 position = ((Component)stationView.Station).transform.position;
					if (!(Vector3.Distance(movement.FootPosition, position) <= 2.75f))
					{
						movement.SetDestination(stationView.Entity);
					}
				}
			}
			catch
			{
			}
		}

		private int InFlightUnits(StationView v, ChemistOrderState order)
		{
			if (v.Op != null)
			{
				return (!IsFinalOp(v.Op, order)) ? v.Op.Quantity : 0;
			}
			if (v.OutQty > 0)
			{
				return (!(v.OutId == order.TargetProductId)) ? v.OutQty : 0;
			}
			return v.ProdQty;
		}

		private void StartMix(Chemist chemist, StationView v)
		{
			float num = 1f;
			try
			{
				MixingStationConfiguration cfg = v.Cfg;
				if (((cfg != null) ? cfg.StartThrehold : null) != null)
				{
					num = v.Cfg.StartThrehold.Value;
				}
			}
			catch
			{
			}
			if ((float)v.ProdQty >= num)
			{
				chemist.StartMixingStationBehaviour.AssignStation(v.Station);
				((Behaviour)chemist.StartMixingStationBehaviour).Enable_Networked();
			}
			else
			{
				DirectStartMix(v);
			}
		}

		private static void DirectStartMix(StationView v)
		{
			//IL_0062: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//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)
			MixingStation station = v.Station;
			ItemInstance itemInstance = station.ProductSlot.ItemInstance;
			ItemInstance itemInstance2 = station.MixerSlot.ItemInstance;
			if (itemInstance == null || itemInstance2 == null)
			{
				return;
			}
			int num = Math.Min(Math.Min(v.ProdQty, v.MixQty), v.MaxBatch);
			if (num > 0)
			{
				EQuality val = (EQuality)2;
				QualityItemInstance val2 = ((Il2CppObjectBase)itemInstance).TryCast<QualityItemInstance>();
				if (val2 != null)
				{
					val = val2.Quality;
				}
				station.ProductSlot.ChangeQuantity(-num, false);
				station.MixerSlot.ChangeQuantity(-num, false);
				MixOperation val3 = new MixOperation(DefId(itemInstance), val, DefId(itemInstance2), num);
				station.SendMixingOperation(val3, 0);
			}
		}

		private static void AdvanceIntermediate(StationView v)
		{
			MixingStation station = v.Station;
			ItemInstance itemInstance = station.OutputSlot.ItemInstance;
			if (itemInstance != null)
			{
				int quantity = station.OutputSlot.Quantity;
				if (quantity > 0)
				{
					ItemInstance copy = itemInstance.GetCopy(quantity);
					station.ProductSlot.InsertItem(copy);
					station.OutputSlot.ChangeQuantity(-quantity, false);
				}
			}
		}

		private bool FetchInto(Chemist chemist, List<ITransitEntity> shelves, StationView v, string itemId, int amount)
		{
			if (amount <= 0 || string.IsNullOrEmpty(itemId))
			{
				return false;
			}
			ItemInstance template;
			ITransitEntity val = FindShelfWith(shelves, itemId, out template);
			if (val == null || template == null)
			{
				return false;
			}
			TransitRoute route = GetRoute(val, v.Entity, ShelfGuid(val), v.Guid);
			if (route == null)
			{
				return false;
			}
			return Haul(chemist, route, template.GetCopy(1), amount);
		}

		private static bool Haul(Chemist chemist, TransitRoute route, ItemInstance template, int maxAmount)
		{
			MoveItemBehaviour moveItemBehaviour = ((Employee)chemist).MoveItemBehaviour;
			if ((Object)(object)moveItemBehaviour == (Object)null || route == null || template == null)
			{
				return false;
			}
			string text = default(string);
			if (!moveItemBehaviour.IsTransitRouteValid(route, template, ref text))
			{
				return false;
			}
			moveItemBehaviour.Initialize(route, template, maxAmount, false);
			((Behaviour)moveItemBehaviour).Enable_Networked();
			return true;
		}

		private TransitRoute GetRoute(ITransitEntity src, ITransitEntity dst, string srcGuid, string dstGuid)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if (src == null || dst == null || srcGuid == null || dstGuid == null)
			{
				return null;
			}
			string key = srcGuid + "->" + dstGuid;
			if (_routes.TryGetValue(key, out var value))
			{
				if (value != null && value.Source != null && value.Destination != null)
				{
					return value;
				}
				try
				{
					if (value != null)
					{
						value.Destroy();
					}
				}
				catch
				{
				}
			}
			TransitRoute val = new TransitRoute(src, dst);
			_routes[key] = val;
			return val;
		}

		private static List<ITransitEntity> ResolveShelves(ChemistOrderState order)
		{
			List<ITransitEntity> list = new List<ITransitEntity>();
			if (order.ShelfGuids == null)
			{
				return list;
			}
			foreach (string shelfGuid in order.ShelfGuids)
			{
				PlaceableStorageEntity val = ChemistOrderService.ResolveShelf(shelfGuid);
				if (!((Object)(object)val == (Object)null))
				{
					ITransitEntity val2 = ((Il2CppObjectBase)val).TryCast<ITransitEntity>();
					if (val2 != null)
					{
						list.Add(val2);
					}
				}
			}
			return list;
		}

		private static ITransitEntity FindShelfWith(List<ITransitEntity> shelves, string itemId, out ItemInstance template)
		{
			template = null;
			foreach (ITransitEntity shelf in shelves)
			{
				StorageEntity val = ShelfStorage(shelf);
				if ((Object)(object)val == (Object)null || val.ItemSlots == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots = val.ItemSlots;
				for (int i = 0; i < itemSlots.Count; i++)
				{
					ItemSlot val2 = itemSlots[i];
					if (val2 != null && val2.ItemInstance != null && val2.Quantity > 0 && DefId(val2.ItemInstance) == itemId)
					{
						template = val2.ItemInstance;
						return shelf;
					}
				}
			}
			return null;
		}

		private static StorageEntity ShelfStorage(ITransitEntity shelf)
		{
			if (shelf == null)
			{
				return null;
			}
			PlaceableStorageEntity val = ((Il2CppObjectBase)shelf).TryCast<PlaceableStorageEntity>();
			return ((Object)(object)val != (Object)null) ? val.StorageEntity : null;
		}

		private static string ShelfGuid(ITransitEntity shelf)
		{
			//IL_0020: 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)
			PlaceableStorageEntity val = ((shelf != null) ? ((Il2CppObjectBase)shelf).TryCast<PlaceableStorageEntity>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				return ((object)((BuildableItem)val).GUID/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				return null;
			}
		}

		private static Dictionary<string, int> ShelfCounts(List<ITransitEntity> shelves)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ITransitEntity shelf in shelves)
			{
				StorageEntity val = ShelfStorage(shelf);
				if ((Object)(object)val == (Object)null || val.ItemSlots == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots = val.ItemSlots;
				for (int i = 0; i < itemSlots.Count; i++)
				{
					ItemSlot val2 = itemSlots[i];
					if (val2 != null && val2.ItemInstance != null && val2.Quantity > 0)
					{
						string text = DefId(val2.ItemInstance);
						if (text != null)
						{
							dictionary[text] = (dictionary.TryGetValue(text, out var value) ? (value + val2.Quantity) : val2.Quantity);
						}
					}
				}
			}
			return dictionary;
		}

		private bool IsFinalOp(MixOperation op, ChemistOrderState order)
		{
			if (op == null || order.Chain == null || order.Chain.Count == 0)
			{
				return false;
			}
			string productID = op.ProductID;
			string ingredientID = op.IngredientID;
			for (int i = 0; i < order.Chain.Count; i++)
			{
				OrderStep orderStep = order.Chain[i];
				if (orderStep.InputId == productID && orderStep.MixerId == ingredientID)
				{
					return i == order.Chain.Count - 1;
				}
			}
			return false;
		}

		private static int StageForInput(List<OrderStep> chain, string inputId)
		{
			for (int i = 0; i < chain.Count; i++)
			{
				if (chain[i].InputId == inputId)
				{
					return i;
				}
			}
			return -1;
		}

		private static int OutputStage(List<OrderStep> chain, string outputId)
		{
			for (int i = 0; i < chain.Count; i++)
			{
				if (chain[i].OutputId == outputId)
				{
					return i;
				}
			}
			return -1;
		}

		private string MissingReason(ChemistOrderState order, List<ITransitEntity> shelves)
		{
			Dictionary<string, int> required = new Dictionary<string, int>();
			Add(order.Chain[0].InputId);
			for (int i = 0; i < order.Chain.Count; i++)
			{
				Add(order.Chain[i].MixerId);
			}
			Dictionary<string, int> dictionary = ShelfCounts(shelves);
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> item in required)
			{
				int value;
				int num = (dictionary.TryGetValue(item.Key, out value) ? value : 0);
				if (num < item.Value)
				{
					list.Add((num <= 0) ? (ItemName(item.Key) + " (none on the shelves)") : $"{ItemName(item.Key)} (only {num})");
				}
			}
			if (list.Count > 0)
			{
				return $"I can't make {DisplayName(order)} — I need {string.Join(", ", list)}.";
			}
			return "I'm waiting on ingredients or running mixes for " + DisplayName(order) + ".";
			void Add(string id)
			{
				if (!string.IsNullOrEmpty(id))
				{
					required[id] = ((!required.TryGetValue(id, out var value2)) ? 1 : (value2 + 1));
				}
			}
		}

		private static string DisplayName(ChemistOrderState order)
		{
			return string.IsNullOrEmpty(order.TargetName) ? order.TargetProductId : order.TargetName;
		}

		private static string ItemName(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return id;
			}
			try
			{
				ItemDefinition item = Registry.GetItem(id);
				return ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)item).Name)) ? ((BaseItemDefinition)item).Name : id;
			}
			catch
			{
				return id;
			}
		}

		private static string DefId(ItemInstance inst)
		{
			if (inst == null)
			{
				return null;
			}
			ItemDefinition definition = inst.Definition;
			return ((Object)(object)definition != (Object)null) ? ((BaseItemDefinition)definition).ID : null;
		}

		private static string SafeGuid(MixingStation station)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((object)((BuildableItem)station).GUID/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				return null;
			}
		}

		private static string SafeName(Chemist chemist)
		{
			try
			{
				return ((NPC)chemist).fullName;
			}
			catch
			{
				return "chemist";
			}
		}
	}
	internal static class ChemistOrderService
	{
		public sealed class ProductOption
		{
			public string Id;

			public string Name;

			public EDrugType DrugType;

			public bool Listed;

			public Sprite Icon;

			public int Steps;
		}

		public sealed class ShelfOption
		{
			public string Guid;

			public string Name;

			public int ItemCount;
		}

		internal static readonly SaveSlotStore<ChemistOrderState> Store = new SaveSlotStore<ChemistOrderState>("ChemistOrders", "chemist orders", "orders");

		private static readonly SaveSlotStore<List<OrderHistoryEntry>> HistoryStore = new SaveSlotStore<List<OrderHistoryEntry>>("ChemistOrders", "chemist order history", "history");

		private const string HistoryKey = "__history__";

		private const int HistoryCap = 12;

		private static readonly ChemistOrderOrchestrator Orchestrator = new ChemistOrderOrchestrator();

		internal static ChemistOrdersConfiguration Config => Core.Get<ModEmployees>()?.Configuration?.ChemistOrders;

		internal static bool IsEnabled => Config != null && Config.Enabled;

		public static void Reset()
		{
			Orchestrator.Reset();
			Store.Unload();
			HistoryStore.Unload();
		}

		public static bool RunOrder(Chemist chemist)
		{
			if (!IsEnabled)
			{
				return false;
			}
			return Orchestrator.Run(chemist);
		}

		public static ChemistOrderState GetOrder(Chemist chemist)
		{
			//IL_0018: 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)
			if ((Object)(object)chemist == (Object)null)
			{
				return null;
			}
			try
			{
				ChemistOrderState value;
				return Store.TryGet(((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString(), out value) ? value : null;
			}
			catch
			{
				return null;
			}
		}

		public static bool TrySetOrder(Chemist chemist, string targetProductId, int quantity, List<string> shelfGuids, out string error)
		{
			//IL_0157: 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)
			error = "";
			if (!IsEnabled)
			{
				error = "Chemist production orders are disabled.";
				return false;
			}
			if (!InstanceFinder.IsServer)
			{
				error = "Only the host can set production orders.";
				return false;
			}
			if ((Object)(object)chemist == (Object)null)
			{
				error = "No chemist selected.";
				return false;
			}
			if (string.IsNullOrEmpty(targetProductId))
			{
				error = "Pick a product to produce.";
				return false;
			}
			if (quantity <= 0)
			{
				error = "Quantity must be at least 1.";
				return false;
			}
			if (shelfGuids == null || shelfGuids.Count == 0)
			{
				error = "Assign at least one shelf for ingredients.";
				return false;
			}
			HashSet<string> availableIds = AvailableIds(shelfGuids);
			List<OrderStep> list = RecipeChainResolver.Resolve(targetProductId, availableIds);
			if (list == null || list.Count == 0)
			{
				error = "That product can't be mixed from any recipe you've discovered.";
				return false;
			}
			int num = BatchCapacity(chemist, list);
			int num2 = (Math.Max(1, quantity) + num - 1) / num * num;
			ChemistOrderState chemistOrderState = new ChemistOrderState
			{
				TargetProductId = targetProductId,
				TargetName = NameOf(targetProductId),
				Goal = num2,
				Started = 0,
				ShelfGuids = new List<string>(shelfGuids),
				Chain = list,
				Active = true
			};
			string key;
			try
			{
				key = ((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				error = "Couldn't identify the chemist.";
				return false;
			}
			Store.Set(key, chemistOrderState);
			Orchestrator.Reset();
			RecordHistory(chemistOrderState);
			OrderSlotLocks.Maintain(chemist, NeededQuantities(chemistOrderState), ResolveShelfEntities(chemistOrderState.ShelfGuids));
			Log.Info($"[ChemistOrders] Order set for {SafeName(chemist)}: {num2}x {chemistOrderState.TargetName} ({list.Count}-step chain, batch {num}, {shelfGuids.Count} shelf/shelves).");
			return true;
		}

		public static void StopOrder(Chemist chemist)
		{
			//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)
			if (!((Object)(object)chemist == (Object)null) && InstanceFinder.IsServer)
			{
				string key;
				try
				{
					key = ((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString();
				}
				catch
				{
					return;
				}
				if (Store.TryGet(key, out var value) && value != null)
				{
					List<ITransitEntity> shelves = ResolveShelfEntities(value.ShelfGuids);
					OrderSlotLocks.Release(chemist, shelves);
					Orchestrator.Drain(chemist, value, shelves);
					Store.Remove(key);
					Orchestrator.Reset();
					Log.Info("[ChemistOrders] Order stopped for " + SafeName(chemist) + "; slots freed and items returned to output.");
				}
			}
		}

		public static void ClearOrder(Chemist chemist)
		{
			//IL_0011: 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)
			if ((Object)(object)chemist == (Object)null)
			{
				return;
			}
			try
			{
				string key = ((object)((NPC)chemist).GUID/*cast due to .constrained prefix*/).ToString();
				if (Store.TryGet(key, out var value) && value != null)
				{
					OrderSlotLocks.Release(chemist, ResolveShelfEntities(value.ShelfGuids));
				}
				Store.Remove(key);
				Orchestrator.Reset();
				Log.Info("[ChemistOrders] Order cleared for " + SafeName(chemist) + ".");
			}
			catch
			{
			}
		}

		internal static void CompleteOrder(Chemist chemist, ChemistOrderState order, string key)
		{
			order.Active = false;
			OrderSlotLocks.Release(chemist, ResolveShelfEntities(order.ShelfGuids));
			Store.Remove(key);
			Log.Info($"[ChemistOrders] {SafeName(chemist)} finished producing {order.Goal}x {(string.IsNullOrEmpty(order.TargetName) ? order.TargetProductId : order.TargetName)}.");
		}

		internal static void ReleaseAndClear(Chemist chemist, ChemistOrderState order, string key)
		{
			OrderSlotLocks.Release(chemist, ResolveShelfEntities(order.ShelfGuids));
			Store.Remove(key);
		}

		internal static Dictionary<string, int> NeededQuantities(ChemistOrderState order)
		{
			Dictionary<string, int> need = new Dictionary<string, int>();
			if (order?.Chain == null || order.Chain.Count == 0)
			{
				return need;
			}
			int remainingUnits = Math.Max(0, order.Goal - order.Started);
			if (remainingUnits <= 0)
			{
				return need;
			}
			Add(order.Chain[0].InputId);
			foreach (OrderStep item in order.Chain)
			{
				Add(item.MixerId);
			}
			return need;
			void Add(string id)
			{
				if (!string.IsNullOrEmpty(id))
				{
					need[id] = (need.TryGetValue(id, out var value) ? value : 0) + remainingUnits;
				}
			}
		}

		public static int GetBatchCapacity(Chemist chemist, string productId)
		{
			if ((Object)(object)chemist == (Object)null || string.IsNullOrEmpty(productId))
			{
				return 10;
			}
			return BatchCapacity(chemist, RecipeChainResolver.Resolve(productId, null));
		}

		internal static int BatchCapacity(Chemist chemist, List<OrderStep> chain)
		{
			int num = int.MaxValue;
			try
			{
				object obj;
				if (chemist == null)
				{
					obj = null;
				}
				else
				{
					ChemistConfiguration configuration = chemist.configuration;
					obj = ((configuration != null) ? configuration.MixStations : null);
				}
				List<MixingStation> val = (List<MixingStation>)obj;
				if (val != null)
				{
					for (int i = 0; i < val.Count; i++)
					{
						MixingStation val2 = val[i];
						if ((Object)(object)val2 != (Object)null)
						{
							num = Math.Min(num, Math.Max(1, val2.MaxMixQuantity));
						}
					}
				}
			}
			catch
			{
			}
			if (chain != null)
			{
				foreach (OrderStep item in chain)
				{
					num = Math.Min(num, StackLimitOf(item.InputId));
					num = Math.Min(num, StackLimitOf(item.MixerId));
				}
			}
			return (num == int.MaxValue || num < 1) ? 10 : num;
		}

		private static int StackLimitOf(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return int.MaxValue;
			}
			try
			{
				ItemDefinition item = Registry.GetItem(id);
				return ((Object)(object)item != (Object)null && ((BaseItemDefinition)item).StackLimit > 0) ? ((BaseItemDefinition)item).StackLimit : int.MaxValue;
			}
			catch
			{
				return int.MaxValue;
			}
		}

		internal static List<ITransitEntity> ResolveShelfEntities(IEnumerable<string> guids)
		{
			List<ITransitEntity> list = new List<ITransitEntity>();
			if (guids == null)
			{
				return list;
			}
			foreach (string guid in guids)
			{
				PlaceableStorageEntity val = ResolveShelf(guid);
				ITransitEntity val2 = (((Object)(object)val != (Object)null) ? ((Il2CppObjectBase)val).TryCast<ITransitEntity>() : null);
				if (val2 != null)
				{
					list.Add(val2);
				}
			}
			return list;
		}

		public static List<ShelfOption> GetNonEmptyShelves(Chemist chemist)
		{
			//IL_00be: 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)
			List<ShelfOption> list = new List<ShelfOption>();
			if ((Object)(object)chemist == (Object)null)
			{
				return list;
			}
			Property assignedProperty = ((Employee)chemist).AssignedProperty;
			if ((Object)(object)assignedProperty == (Object)null || assignedProperty.BuildableItems == null)
			{
				return list;
			}
			List<BuildableItem> buildableItems = assignedProperty.BuildableItems;
			for (int i = 0; i < buildableItems.Count; i++)
			{
				BuildableItem val = buildableItems[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PlaceableStorageEntity val2 = ((Il2CppObjectBase)val).TryCast<PlaceableStorageEntity>();
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.StorageEntity == (Object)null)
				{
					continue;
				}
				int num = ShelfItemCount(val2.StorageEntity);
				if (num > 0)
				{
					string guid;
					try
					{
						guid = ((object)((BuildableItem)val2).GUID/*cast due to .constrained prefix*/).ToString();
					}
					catch
					{
						continue;
					}
					list.Add(new ShelfOption
					{
						Guid = guid,
						Name = ShelfName(val2),
						ItemCount = num
					});
				}
			}
			list.Sort((ShelfOption a, ShelfOption b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public static List<ProductOption> GetOrderableProductInfos()
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_00f8: 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)
			List<ProductOption> list = new List<ProductOption>();
			List<ProductDefinition> discoveredProducts = ProductManager.DiscoveredProducts;
			if (discoveredProducts == null)
			{
				return list;
			}
			HashSet<string> hashSet = new HashSet<string>();
			List<ProductDefinition> listedProducts = ProductManager.ListedProducts;
			if (listedProducts != null)
			{
				for (int i = 0; i < listedProducts.Count; i++)
				{
					ProductDefinition val = listedProducts[i];
					if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)val).ID))
					{
						hashSet.Add(((BaseItemDefinition)val).ID);
					}
				}
			}
			Enumerator<ProductDefinition> enumerator = discoveredProducts.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ProductDefinition current = enumerator.Current;
				if ((Object)(object)current == (Object)null || string.IsNullOrEmpty(((BaseItemDefinition)current).ID))
				{
					continue;
				}
				List<OrderStep> list2 = RecipeChainResolver.Resolve(((BaseItemDefinition)current).ID, null);
				if (list2 != null && list2.Count != 0)
				{
					EDrugType drugType = (EDrugType)0;
					try
					{
						drugType = current.DrugType;
					}
					catch
					{
					}
					list.Add(new ProductOption
					{
						Id = ((BaseItemDefinition)current).ID,
						Name = ((BaseItemDefinition)current).Name,
						DrugType = drugType,
						Listed = hashSet.Contains(((BaseItemDefinition)current).ID),
						Icon = SafeIcon(current),
						Steps = list2.Count
					});
				}
			}
			list.Sort((ProductOption a, ProductOption b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public static List<OrderHistoryEntry> GetHistory(Chemist chemist)
		{
			List<OrderHistoryEntry> list = new List<OrderHistoryEntry>();
			if ((Object)(object)chemist == (Object)null)
			{
				return list;
			}
			if (!HistoryStore.TryGet("__history__", out var value) || value == null)
			{
				return list;
			}
			bool flag = false;
			try
			{
				flag = chemist.configuration != null && chemist.configuration.MixStations != null && chemist.configuration.MixStations.Count > 0;
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				return list;
			}
			foreach (OrderHistoryEntry item in value)
			{
				if (item == null || string.IsNullOrEmpty(item.TargetProductId) || item.ShelfGuids == null || item.ShelfGuids.Count == 0)
				{
					continue;
				}
				bool flag2 = true;
				foreach (string shelfGuid in item.ShelfGuids)
				{
					if ((Object)(object)ResolveShelf(shelfGuid) == (Object)null)
					{
						flag2 = false;
						break;
					}
				}
				if (flag2 && RecipeChainResolver.Resolve(item.TargetProductId, null) != null)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static void RecordHistory(ChemistOrderState order)
		{
			try
			{
				List<OrderHistoryEntry> value;
				List<OrderHistoryEntry> list = ((HistoryStore.TryGet("__history__", out value) && value != null) ? value : new List<OrderHistoryEntry>());
				OrderHistoryEntry orderHistoryEntry = new OrderHistoryEntry(order);
				string key = orderHistoryEntry.Key();
				list.RemoveAll((OrderHistoryEntry e) => e != null && e.Key() == key);
				list.Insert(0, orderHistoryEntry);
				while (list.Count > 12)
				{
					list.RemoveAt(list.Count - 1);
				}
				HistoryStore.Set("__history__", list);
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Failed to record order history: " + ex.Message);
			}
		}

		internal static PlaceableStorageEntity ResolveShelf(string guid)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			try
			{
				BuildableItem val = GUIDManager.GetObject<BuildableItem>(new Guid(guid));
				return ((Object)(object)val != (Object)null) ? ((Il2CppObjectBase)val).TryCast<PlaceableStorageEntity>() : null;
			}
			catch
			{
				return null;
			}
		}

		private static HashSet<string> AvailableIds(List<string> shelfGuids)
		{
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string shelfGuid in shelfGuids)
			{
				PlaceableStorageEntity val = ResolveShelf(shelfGuid);
				StorageEntity val2 = (((Object)(object)val != (Object)null) ? val.StorageEntity : null);
				if ((Object)(object)val2 == (Object)null || val2.ItemSlots == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots = val2.ItemSlots;
				for (int i = 0; i < itemSlots.Count; i++)
				{
					ItemSlot val3 = itemSlots[i];
					if (val3 != null && val3.ItemInstance != null && val3.Quantity > 0)
					{
						ItemDefinition definition = val3.ItemInstance.Definition;
						if ((Object)(object)definition != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)definition).ID))
						{
							hashSet.Add(((BaseItemDefinition)definition).ID);
						}
					}
				}
			}
			return hashSet;
		}

		private static int ShelfItemCount(StorageEntity storage)
		{
			if ((Object)(object)storage == (Object)null || storage.ItemSlots == null)
			{
				return 0;
			}
			int num = 0;
			List<ItemSlot> itemSlots = storage.ItemSlots;
			for (int i = 0; i < itemSlots.Count; i++)
			{
				ItemSlot val = itemSlots[i];
				if (val != null && val.ItemInstance != null && val.Quantity > 0)
				{
					num++;
				}
			}
			return num;
		}

		private static Sprite SafeIcon(ProductDefinition product)
		{
			try
			{
				return ((BaseItemDefinition)product).Icon;
			}
			catch
			{
				return null;
			}
		}

		private static string NameOf(string productId)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(productId);
				return ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)item).Name)) ? ((BaseItemDefinition)item).Name : productId;
			}
			catch
			{
				return productId;
			}
		}

		private static string ShelfName(PlaceableStorageEntity shelf)
		{
			try
			{
				if ((Object)(object)shelf.StorageEntity != (Object)null && !string.IsNullOrEmpty(shelf.StorageEntity.StorageEntityName))
				{
					return shelf.StorageEntity.StorageEntityName;
				}
			}
			catch
			{
			}
			return "Shelf";
		}

		private static string SafeName(Chemist chemist)
		{
			try
			{
				return ((NPC)chemist).fullName;
			}
			catch
			{
				return "chemist";
			}
		}
	}
	internal sealed class ChemistOrderScreen
	{
		private const string UiElementName = "LithiumChemistOrderScreen";

		private static readonly Color Bg = new Color(0.1f, 0.11f, 0.13f, 0.985f);

		private static readonly Color Header = new Color(0.85f, 0.95f, 1f);

		private static readonly Color RowColor = new Color(0.17f, 0.19f, 0.22f);

		private static readonly Color RowAlt = new Color(0.2f, 0.22f, 0.26f);

		private static readonly Color SelColor = new Color(0.2f, 0.45f, 0.3f);

		private static readonly Color Btn = new Color(0.22f, 0.25f, 0.3f);

		private static readonly Color BtnOn = new Color(0.2f, 0.42f, 0.55f);

		private static ChemistOrderScreen _instance;

		private GameObject _root;

		private Chemist _chemist;

		private Font _font;

		private List<ChemistOrderService.ProductOption> _products = new List<ChemistOrderService.ProductOption>();

		private List<ChemistOrderService.ShelfOption> _shelves = new List<ChemistOrderService.ShelfOption>();

		private List<OrderHistoryEntry> _history = new List<OrderHistoryEntry>();

		private string _selectedProductId = "";

		private int _quantity = 10;

		private int _batchSize = 10;

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

		private string _productSearch = "";

		private string _shelfSearch = "";

		private int _drugFilter;

		private bool _listedOnly;

		private RectTransform _productContent;

		private ScrollRect _productScroll;

		private RectTransform _shelfContent;

		private ScrollRect _shelfScroll;

		private readonly Dictionary<string, Image> _productRowBg = new Dictionary<string, Image>();

		private readonly Dictionary<string, Image> _shelfRowBg = new Dictionary<string, Image>();

		private readonly List<(Image bg, int index)> _drugButtons = new List<(Image, int)>();

		private Image _listedBtnBg;

		private Image _selIcon;

		private Text _selName;

		private Text _quantityLabel;

		private Text _chainLabel;

		private Text _statusLabel;

		private bool _progressMode;

		private object _progressLoop;

		private Text _progStarted;

		private Text _progRemaining;

		private RectTransform _progBarFillRt;

		private Text _progStatus;

		private GameObject _stopButtonGo;

		public static void Request(Chemist chemist)
		{
			if (!((Object)(object)chemist == (Object)null))
			{
				MelonCoroutines.Start(OpenDeferred(chemist));
			}
		}

		private static IEnumerator OpenDeferred(Chemist chemist)
		{
			yield return null;
			yield return null;
			try
			{
				(_instance ?? (_instance = new ChemistOrderScreen())).Open(chemist);
			}
			catch (Exception ex)
			{
				Exception e = ex;
				Log.Warning("[ChemistOrders] Failed to open order screen: " + e.Message);
			}
		}

		private void Open(Chemist chemist)
		{
			Teardown();
			_chemist = chemist;
			_font = ResolveFont();
			_progressMode = false;
			_products = ChemistOrderService.GetOrderableProductInfos();
			ChemistOrderState chemistOrderState = (ChemOrderNet.IsHost ? ChemistOrderService.GetOrder(chemist) : null);
			if (chemistOrderState != null && chemistOrderState.Active)
			{
				BuildProgress(chemistOrderState);
				LockInput();
				return;
			}
			_shelves = ChemistOrderService.GetNonEmptyShelves(chemist);
			_history = ChemistOrderService.GetHistory(chemist);
			_selected.Clear();
			_selectedProductId = "";
			_quantity = 10;
			_batchSize = 10;
			_productSearch = "";
			_shelfSearch = "";
			_drugFilter = 0;
			_listedOnly = false;
			BuildForm();
			LockInput();
			RebuildProducts();
			RebuildShelves();
			Refresh();
		}

		private void BuildForm()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_007b: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00e2: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0165: 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_01ae: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: 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_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: 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_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: 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_04e3: 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)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0705: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_0786: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			_root = new GameObject("LithiumChemistOrderScreen");
			Canvas val = _root.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 5000;
			_root.AddComponent<GraphicRaycaster>();
			GameObject val2 = Child(_root.transform, "Dim");
			RectTransform rt = val2.AddComponent<RectTransform>();
			Fill(rt);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.55f);
			GameObject val3 = Child(_root.transform, "Panel");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			Vector2 val5 = default(Vector2);
			((Vector2)(ref val5))..ctor(0.5f, 0.5f);
			val4.pivot = val5;
			Vector2 anchorMin = (val4.anchorMax = val5);
			val4.anchorMin = anchorMin;
			val4.sizeDelta = new Vector2(980f, 720f);
			val4.anchoredPosition = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = Bg;
			Transform transform = val3.transform;
			Label(transform, "Production Order — " + SafeName(_chemist), 24, new Vector2(20f, -14f), 760f, 34f, (TextAnchor)3, (FontStyle)1, Header);
			Button(transform, "✕  Close", new Vector2(820f, -14f), 140f, 34f, delegate
			{
				Close();
			}, new Color(0.45f, 0.25f, 0.22f));
			Label(transform, "PRODUCT", 15, new Vector2(20f, -58f), 460f, 20f, (TextAnchor)3, (FontStyle)1, Color.gray);
			MakeInput(transform, "Search products…", new Vector2(20f, -80f), new Vector2(460f, 32f), delegate(string s)
			{
				_productSearch = s;
				RebuildProducts();
			});
			string[] array = new string[6] { "All", "Weed", "Meth", "Coke", "Shroom", "Other" };
			_drugButtons.Clear();
			float num = 20f;
			float num2 = 73.333336f;
			for (int num3 = 0; num3 < array.Length; num3++)
			{
				int idx = num3;
				Button val7 = Button(transform, array[num3], new Vector2(num, -120f), num2, 28f, delegate
				{
					_drugFilter = idx;
					RebuildProducts();
					RestyleFilters();
				}, Btn);
				_drugButtons.Add((((Component)val7).GetComponent<Image>(), idx));
				num += num2 + 4f;
			}
			Button val8 = Button(transform, "Listed for sale only", new Vector2(20f, -154f), 460f, 28f, delegate
			{
				_listedOnly = !_listedOnly;
				RebuildProducts();
				RestyleFilters();
			}, Btn);
			_listedBtnBg = ((Component)val8).GetComponent<Image>();
			(_productScroll, _productContent) = MakeScroll(transform, new Vector2(20f, -190f), new Vector2(460f, 360f));
			Label(transform, "INGREDIENT SHELVES", 15, new Vector2(500f, -58f), 460f, 20f, (TextAnchor)3, (FontStyle)1, Color.gray);
			MakeInput(transform, "Search shelves…", new Vector2(500f, -80f), new Vector2(460f, 32f), delegate(string s)
			{
				_shelfSearch = s;
				RebuildShelves();
			});
			Label(transform, "Only shelves containing items are listed. Click to toggle.", 13, new Vector2(500f, -116f), 460f, 20f, (TextAnchor)3, (FontStyle)2, Color.gray);
			(ScrollRect, RectTransform) tuple2 = MakeScroll(transform, new Vector2(500f, -142f), new Vector2(460f, 408f));
			_shelfScroll = tuple2.Item1;
			_shelfContent = tuple2.Item2;
			float num4 = -566f;
			_selIcon = MakeIconImage(transform, new Vector2(20f, num4), 40f);
			_selName = Label(transform, "Select a product", 20, new Vector2(68f, num4), 520f, 40f, (TextAnchor)3, (FontStyle)1, Color.white);
			Label(transform, "Qty", 15, new Vector2(600f, num4), 40f, 40f, (TextAnchor)3, (FontStyle)0, Color.gray);
			Button(transform, "-5", new Vector2(640f, num4), 52f, 40f, delegate
			{
				AddBatches(-5);
			});
			Button(transform, "-1", new Vector2(696f, num4), 44f, 40f, delegate
			{
				AddBatches(-1);
			});
			_quantityLabel = Label(transform, "10", 22, new Vector2(744f, num4), 80f, 40f, (TextAnchor)4, (FontStyle)1, Color.white);
			Button(transform, "+1", new Vector2(828f, num4), 44f, 40f, delegate
			{
				AddBatches(1);
			});
			Button(transform, "+5", new Vector2(876f, num4), 52f, 40f, delegate
			{
				AddBatches(5);
			});
			_chainLabel = Label(transform, "", 14, new Vector2(20f, -612f), 940f, 48f, (TextAnchor)0, (FontStyle)0, new Color(0.8f, 0.85f, 0.9f));
			Label(transform, "Recent:", 14, new Vector2(20f, -662f), 70f, 26f, (TextAnchor)3, (FontStyle)0, Color.gray);
			float num5 = 92f;
			int num6 = Math.Min(_history.Count, 4);
			for (int num7 = 0; num7 < num6; num7++)
			{
				OrderHistoryEntry h = _history[num7];
				string label = Trim($"{h.Goal}x {DisplayName(h)}", 22);
				Button(transform, label, new Vector2(num5, -662f), 200f, 26f, delegate
				{
					LoadHistory(h);
				}, new Color(0.24f, 0.28f, 0.34f));
				num5 += 204f;
			}
			_statusLabel = Label(transform, "", 14, new Vector2(20f, -692f), 620f, 24f, (TextAnchor)3, (FontStyle)0, new Color(1f, 0.85f, 0.4f));
			Button(transform, "Assign Order", new Vector2(660f, -690f), 150f, 30f, AssignOrder, new Color(0.2f, 0.45f, 0.25f));
			Button(transform, "Cancel Order", new Vector2(818f, -690f), 142f, 30f, CancelOrder, new Color(0.45f, 0.25f, 0.22f));
		}

		private void BuildProgress(ChemistOrderState order)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0082: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00d5: 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_00f6: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: 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_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: 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_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			_progressMode = true;
			_root = new GameObject("LithiumChemistOrderScreen");
			Canvas val = _root.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 5000;
			_root.AddComponent<GraphicRaycaster>();
			GameObject val2 = Child(_root.transform, "Dim");
			RectTransform rt = val2.AddComponent<RectTransform>();
			Fill(rt);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.55f);
			GameObject val3 = Child(_root.transform, "Panel");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			Vector2 val5 = default(Vector2);
			((Vector2)(ref val5))..ctor(0.5f, 0.5f);
			val4.pivot = val5;
			Vector2 anchorMin = (val4.anchorMax = val5);
			val4.anchorMin = anchorMin;
			val4.sizeDelta = new Vector2(640f, 440f);
			val4.anchoredPosition = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = Bg;
			Transform transform = val3.transform;
			Label(transform, "Production Order — " + SafeName(_chemist), 22, new Vector2(20f, -14f), 470f, 32f, (TextAnchor)3, (FontStyle)1, Header);
			Button(transform, "✕  Close", new Vector2(480f, -14f), 140f, 32f, delegate
			{
				Close();
			}, new Color(0.45f, 0.25f, 0.22f));
			ChemistOrderService.ProductOption productOption = FindProduct(order.TargetProductId);
			Image val7 = MakeIconImage(transform, new Vector2(20f, -62f), 56f);
			if ((Object)(object)productOption?.Icon != (Object)null)
			{
				val7.sprite = productOption.Icon;
				((Behaviour)val7).enabled = true;
			}
			string text = ((productOption != null) ? productOption.Name : (string.IsNullOrEmpty(order.TargetName) ? order.TargetProductId : order.TargetName));
			Label(transform, text, 24, new Vector2(88f, -64f), 530f, 32f, (TextAnchor)3, (FontStyle)1, Color.white);
			_progStarted = Label(transform, "", 18, new Vector2(88f, -100f), 300f, 24f, (TextAnchor)3, (FontStyle)0, new Color(0.7f, 1f, 0.75f));
			_progRemaining = Label(transform, "", 16, new Vector2(360f, -100f), 258f, 24f, (TextAnchor)5, (FontStyle)0, Color.gray);
			GameObject val8 = Child(transform, "BarBg");
			RectTransform rt2 = val8.AddComponent<RectTransform>();
			TopLeft(rt2, new Vector2(20f, -136f), new Vector2(600f, 16f));
			((Graphic)val8.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.1f);
			GameObject val9 = Child(val8.transform, "Fill");
			_progBarFillRt = val9.AddComponent<RectTransform>();
			_progBarFillRt.anchorMin = new Vector2(0f, 0f);
			_progBarFillRt.anchorMax = new Vector2(0f, 1f);
			_progBarFillRt.pivot = new Vector2(0f, 0.5f);
			_progBarFillRt.offsetMin = Vector2.zero;
			_progBarFillRt.offsetMax = Vector2.zero;
			((Graphic)val9.AddComponent<Image>()).color = new Color(0.3f, 0.65f, 0.4f);
			Label(transform, BuildChainText(order), 14, new Vector2(20f, -166f), 600f, 24f, (TextAnchor)0, (FontStyle)0, new Color(0.8f, 0.85f, 0.9f));
			Label(transform, "Ingredient shelves:", 14, new Vector2(20f, -206f), 600f, 20f, (TextAnchor)3, (FontStyle)1, Color.gray);
			Label(transform, BuildShelvesText(order), 14, new Vector2(20f, -228f), 600f, 72f, (TextAnchor)0, (FontStyle)0, new Color(0.75f, 0.8f, 0.85f));
			_progStatus = Label(transform, "Stopping returns all carried items and station contents to the output, and frees the reserved shelf slots.", 13, new Vector2(20f, -312f), 600f, 40f, (TextAnchor)0, (FontStyle)2, new Color(0.7f, 0.72f, 0.78f));
			_stopButtonGo = ((Component)Button(transform, "Stop Order & Return Items", new Vector2(20f, -398f), 320f, 32f, StopOrder, new Color(0.5f, 0.28f, 0.24f))).gameObject;
			Button(transform, "Close", new Vector2(490f, -398f), 130f, 32f, delegate
			{
				Close();
			}, Btn);
			UpdateProgressView(order);
			_progressLoop = MelonCoroutines.Start(ProgressRoutine());
		}

		private void UpdateProgressView(ChemistOrderState order)
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (order != null)
			{
				int num = Math.Max(1, order.Goal);
				int value = Math.Max(0, Math.Min(order.Started, order.Goal));
				int num2 = Math.Max(0, order.Goal - order.Started);
				if ((Object)(object)_progStarted != (Object)null)
				{
					_progStarted.text = $"Produced {value} / {order.Goal}";
				}
				if ((Object)(object)_progRemaining != (Object)null)
				{
					_progRemaining.text = ((num2 > 0) ? $"{num2} to go" : "complete");
				}
				if ((Object)(object)_progBarFillRt != (Object)null)
				{
					_progBarFillRt.anchorMax = new Vector2(Mathf.Clamp01((float)order.Started / (float)num), 1f);
				}
			}
		}

		private IEnumerator ProgressRoutine()
		{
			while ((Object)(object)_root != (Object)null && _progressMode)
			{
				yield return (object)new WaitForSeconds(0.5f);
				if ((Object)(object)_root == (Object)null || !_progressMode)
				{
					break;
				}
				ChemistOrderState order = ChemistOrderService.GetOrder(_chemist);
				if (order == null || !order.Active)
				{
					OnOrderFinished();
					break;
				}
				UpdateProgressView(order);
			}
		}

		private void OnOrderFinished()
		{
			//IL_0021: 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)
			if ((Object)(object)_progBarFillRt != (Object)null)
			{
				_progBarFillRt.anchorMax = new Vector2(1f, 1f);
			}
			if ((Object)(object)_progStarted != (Object)null)
			{
				_progStarted.text = "Order complete";
			}
			if ((Object)(object)_progRemaining != (Object)null)
			{
				_progRemaining.text = "done";
			}
			if ((Object)(object)_progStatus != (Object)null)
			{
				_progStatus.text = "The chemist has finished this order.";
				((Graphic)_progStatus).color = new Color(0.6f, 1f, 0.65f);
			}
			if ((Object)(object)_stopButtonGo != (Object)null)
			{
				_stopButtonGo.SetActive(false);
			}
		}

		private void StopOrder()
		{
			if ((Object)(object)_chemist == (Object)null)
			{
				Close();
			}
			else if (!ChemOrderNet.IsHost)
			{
				ChemOrderNet.SendCancel(_chemist);
				Close();
			}
			else
			{
				ChemistOrderService.StopOrder(_chemist);
				Close();
			}
		}

		private string BuildChainText(ChemistOrderState order)
		{
			if (order?.Chain == null || order.Chain.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(ItemName(order.Chain[0].InputId));
			foreach (OrderStep item in order.Chain)
			{
				stringBuilder.Append(" +").Append(ItemName(item.MixerId));
			}
			stringBuilder.Append(" → ").Append(ItemName(order.Chain[order.Chain.Count - 1].OutputId));
			return $"{order.Chain.Count}-step mix:  {stringBuilder}";
		}

		private string BuildShelvesText(ChemistOrderState order)
		{
			if (order?.ShelfGuids == null || order.ShelfGuids.Count == 0)
			{
				return "—";
			}
			List<string> list = new List<string>();
			foreach (string shelfGuid in order.ShelfGuids)
			{
				PlaceableStorageEntity val = ChemistOrderService.ResolveShelf(shelfGuid);
				string item = "Shelf";
				try
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.StorageEntity != (Object)null && !string.IsNullOrEmpty(val.StorageEntity.StorageEntityName))
					{
						item = val.StorageEntity.StorageEntityName;
					}
				}
				catch
				{
				}
				list.Add(item);
			}
			return string.Join(", ", list);
		}

		private void RebuildProducts()
		{
			//IL_0134: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_productContent == (Object)null)
			{
				return;
			}
			Clear(_productContent);
			_productRowBg.Clear();
			float num = 34f;
			float num2 = 0f;
			int num3 = 0;
			string text = ((_productSearch != null) ? _productSearch.Trim().ToLowerInvariant() : "");
			foreach (ChemistOrderService.ProductOption product in _products)
			{
				if ((text.Length <= 0 || (product.Name != null && product.Name.ToLowerInvariant().Contains(text))) && MatchesDrug(product.DrugType) && (!_listedOnly || product.Listed))
				{
					AddProductRow(product, num2, num, num3);
					num2 -= num + 2f;
					num3++;
				}
			}
			_productContent.sizeDelta = new Vector2(0f, Math.Max(0f, 0f - num2));
			if ((Object)(object)_productScroll != (Object)null)
			{
				_productScroll.verticalNormalizedPosition = 1f;
			}
			if (num3 == 0)
			{
				Label((Transform)(object)_productContent, "No products match.", 14, new Vector2(8f, -8f), 400f, 22f, (TextAnchor)3, (FontStyle)2, Color.gray);
			}
		}

		private void AddProductRow(ChemistOrderService.ProductOption opt, float y, float rowH, int index)
		{
			//IL_005e: 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_0050: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Child((Transform)(object)_productContent, "P");
			RectTransform rt = val.AddComponent<RectTransform>();
			Row(rt, y, rowH);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = ((opt.Id == _selectedProductId) ? SelColor : ((index % 2 == 0) ? RowColor : RowAlt));
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			string id = opt.Id;
			((UnityEvent)val3.onClick).AddListener(UA(delegate
			{
				SelectProduct(id);
			}));
			_productRowBg[id] = val2;
			if ((Object)(object)opt.Icon != (Object)null)
			{
				Image val4 = MakeIconImage(val.transform, new Vector2(4f, -3f), 28f);
				val4.sprite = opt.Icon;
				((Behaviour)val4).enabled = true;
			}
			string text = ((opt.Steps > 1) ? $"  <color=#88aacc>· {opt.Steps} steps</color>" : "");
			if (opt.Listed)
			{
				text += "  <color=#88cc88>· listed</color>";
			}
			Label(val.transform, opt.Name + text, 15, new Vector2(38f, 0f), 412f, rowH, (TextAnchor)3, (FontStyle)0, Color.white);
		}

		private void RebuildShelves()
		{
			//IL_00f9: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_shelfContent == (Object)null)
			{
				return;
			}
			Clear(_shelfContent);
			_shelfRowBg.Clear();
			float num = 34f;
			float num2 = 0f;
			int num3 = 0;
			string text = ((_shelfSearch != null) ? _shelfSearch.Trim().ToLowerInvariant() : "");
			foreach (ChemistOrderService.ShelfOption shelf in _shelves)
			{
				if (text.Length <= 0 || (shelf.Name != null && shelf.Name.ToLowerInvariant().Contains(text)))
				{
					AddShelfRow(shelf, num2, num, num3);
					num2 -= num + 2f;
					num3++;
				}
			}
			_shelfContent.sizeDelta = new Vector2(0f, Math.Max(0f, 0f - num2));
			if ((Object)(object)_shelfScroll != (Object)null)
			{
				_shelfScroll.verticalNormalizedPosition = 1f;
			}
			if (num3 == 0)
			{
				Label((Transform)(object)_shelfContent, (_shelves.Count == 0) ? "No non-empty shelves on this property." : "No shelves match.", 14, new Vector2(8f, -8f), 420f, 22f, (TextAnchor)3, (FontStyle)2, new Color(1f, 0.7f, 0.6f));
			}
		}

		private void AddShelfRow(ChemistOrderService.ShelfOption opt, float y, float rowH, int index)
		{
			//IL_005e: 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_011e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Child((Transform)(object)_shelfContent, "S");
			RectTransform rt = val.AddComponent<RectTransform>();
			Row(rt, y, rowH);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = (_selected.Contains(opt.Guid) ? SelColor : ((index % 2 == 0) ? RowColor : RowAlt));
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			string g = opt.Guid;
			((UnityEvent)val3.onClick).AddListener(UA(delegate
			{
				ToggleShelf(g);
			}));
			_shelfRowBg[g] = val2;
			Label(val.transform, $"{opt.Name}  <color=#888888>· {opt.ItemCount} item(s)</color>", 15, new Vector2(10f, 0f), 430f, rowH, (TextAnchor)3, (FontStyle)0, Color.white);
		}

		private void SelectProduct(string id)
		{
			//IL_004d: 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)
			_selectedProductId = id;
			foreach (KeyValuePair<string, Image> item in _productRowBg)
			{
				if ((Object)(object)item.Value != (Object)null)
				{
					((Graphic)item.Value).color = ((item.Key == id) ? SelColor : RowColor);
				}
			}
			RecomputeBatch();
			Refresh();
		}

		private void ToggleShelf(string guid)
		{
			//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)
			if (!_selected.Remove(guid))
			{
				_selected.Add(guid);
			}
			if (_shelfRowBg.TryGetValue(guid, out var value) && (Object)(object)value != (Object)null)
			{
				((Graphic)value).color = (_selected.Contains(guid) ? SelColor : RowColor);
			}
			Refresh();
		}

		private void AddBatches(int n)
		{
			int num = Math.Max(1, _batchSize);
			int val = Math.Max(1, _quantity / num) + n;
			val = Math.Max(1, Math.Min(999, val));
			_quantity = val * num;
			Refresh();
		}

		private void RecomputeBatch()
		{
			_batchSize = Math.Max(1, ChemistOrderService.GetBatchCapacity(_chemist, _selectedProductId));
			int num = Math.Max(1, (int)Math.Round((double)_quantity / (double)_batchSize));
			_quantity = num * _batchSize;
		}

		private void LoadHistory(OrderHistoryEntry h)
		{
			if (h == null)
			{
				return;
			}
			_selectedProductId = h.TargetProductId;
			_quantity = Math.Max(1, h.Goal);
			RecomputeBatch();
			_selected.Clear();
			if (h.ShelfGuids != null)
			{
				foreach (string shelfGuid in h.ShelfGuids)
				{
					_selected.Add(shelfGuid);
				}
			}
			_productSearch = "";
			_shelfSearch = "";
			_drugFilter = 0;
			_listedOnly = false;
			RestyleFilters();
			RebuildProducts();
			RebuildShelves();
			Refresh();
			SetStatus($"Loaded recent order: {h.Goal}x {DisplayName(h)}.", isError: false);
		}

		private void AssignOrder()
		{
			if (string.IsNullOrEmpty(_selectedProductId))
			{
				SetStatus("Pick a product first.", isError: true);
				return;
			}
			List<string> list = new List<string>(_selected);
			string error;
			if (!ChemOrderNet.IsHost)
			{
				if (list.Count == 0)
				{
					SetStatus("Assign at least one shelf for ingredients.", isError: true);
					return;
				}
				ChemOrderNet.SendSet(_chemist, _selectedProductId, _quantity, list);
				Close();
			}
			else if (ChemistOrderService.TrySetOrder(_chemist, _selectedProductId, _quantity, list, out error))
			{
				Close();
			}
			else
			{
				SetStatus(error, isError: true);
			}
		}

		private void CancelOrder()
		{
			if (!ChemOrderNet.IsHost)
			{
				ChemOrderNet.SendCancel(_chemist);
				SetStatus("Cancel request sent to the host.", isError: false);
			}
			else
			{
				ChemistOrderService.ClearOrder(_chemist);
				SetStatus("Order cancelled; reserved slots freed.", isError: false);
			}
		}

		private void Close()
		{
			Teardown();
			UnlockInput();
		}

		private void Refresh()
		{
			if ((Object)(object)_quantityLabel != (Object)null)
			{
				_quantityLabel.text = _quantity.ToString();
			}
			ChemistOrderService.ProductOption productOption = FindProduct(_selectedProductId);
			if ((Object)(object)_selName != (Object)null)
			{
				_selName.text = ((productOption != null) ? productOption.Name : "Select a product");
			}
			if ((Object)(object)_selIcon != (Object)null)
			{
				_selIcon.sprite = productOption?.Icon;
				((Behaviour)_selIcon).enabled = (Object)(object)productOption?.Icon != (Object)null;
			}
			if ((Object)(object)_chainLabel != (Object)null)
			{
				_chainLabel.text = BuildPreview();
			}
			RestyleFilters();
		}

		private void RestyleFilters()
		{
			//IL_0040: 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_008c: 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)
			foreach (var (val, num) in _drugButtons)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Graphic)val).color = ((num == _drugFilter) ? BtnOn : Btn);
				}
			}
			if ((Object)(object)_listedBtnBg != (Object)null)
			{
				((Graphic)_listedBtnBg).color = (_listedOnly ? BtnOn : Btn);
			}
		}

		private string BuildPreview()
		{
			if (string.IsNullOrEmpty(_selectedProductId))
			{
				return "";
			}
			HashSet<string> hashSet = AvailableFromSelected();
			List<OrderStep> list = RecipeChainResolver.Resolve(_selectedProductId, null);
			if (list == null || list.Count == 0)
			{
				return "<color=#ff8866>No known recipe chain for this product.</color>";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(ItemName(list[0].InputId));
			foreach (OrderStep item in list)
			{
				stringBuilder.Append(" +").Append(ItemName(item.MixerId));
			}
			stringBuilder.Append(" → ").Append(ItemName(list[list.Count - 1].OutputId));
			HashSet<string> hashSet2 = new HashSet<string> { list[0].InputId };
			foreach (OrderStep item2 in list)
			{
				hashSet2.Add(item2.MixerId);
			}
			StringBuilder stringBuilder2 = new StringBuilder("Needs on shelves: ");
			bool flag = true;
			foreach (string item3 in hashSet2)
			{
				if (!flag)
				{
					stringBuilder2.Append(", ");
				}
				flag = false;
				bool flag2 = hashSet.Contains(item3);
				stringBuilder2.Append(flag2 ? "" : "<color=#ff8866>").Append(ItemName(item3)).Append(flag2 ? "" : "</color>");
			}
			int num = Math.Max(1, _batchSize);
			string value = $"<color=#88aacc>Batch size {num} (mixing-machine limit) · {_quantity / num} batch(es) = {_quantity}</color>";
			return $"{list.Count}-step mix:  {stringBuilder}\n{stringBuilder2}\n{value}";
		}

		private HashSet<string> AvailableFromSelected()
		{
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in _selected)
			{
				PlaceableStorageEntity val = ChemistOrderService.ResolveShelf(item);
				StorageEntity val2 = (((Object)(object)val != (Object)null) ? val.StorageEntity : null);
				if ((Object)(object)val2 == (Object)null || val2.ItemSlots == null)
				{
					continue;
				}
				List<ItemSlot> itemSlots = val2.ItemSlots;
				for (int i = 0; i < itemSlots.Count; i++)
				{
					ItemSlot val3 = itemSlots[i];
					if (val3 != null && val3.ItemInstance != null && val3.Quantity > 0)
					{
						ItemDefinition definition = val3.ItemInstance.Definition;
						if ((Object)(object)definition != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)definition).ID))
						{
							hashSet.Add(((BaseItemDefinition)definition).ID);
						}
					}
				}
			}
			return hashSet;
		}

		private bool MatchesDrug(EDrugType d)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0044: 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_0049: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			return _drugFilter switch
			{
				1 => (int)d == 0, 
				2 => (int)d == 1, 
				3 => (int)d == 2, 
				4 => (int)d == 4, 
				5 => (int)d != 0 && (int)d != 1 && (int)d != 2 && (int)d != 4, 
				_ => true, 
			};
		}

		private ChemistOrderService.ProductOption FindProduct(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return null;
			}
			foreach (ChemistOrderService.ProductOption product in _products)
			{
				if (product.Id == id)
				{
					return product;
				}
			}
			return null;
		}

		private void SetStatus(string text, bool isError)
		{
			//IL_004e: 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)
			if (!((Object)(object)_statusLabel == (Object)null))
			{
				_statusLabel.text = text;
				((Graphic)_statusLabel).color = (isError ? new Color(1f, 0.55f, 0.5f) : new Color(0.6f, 1f, 0.65f));
			}
		}

		private static GameObject Child(Transform parent, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.transform.localScale = Vector3.one;
			return val;
		}

		private static void Fill(RectTransform rt)
		{
			//IL_0002: 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)
			//IL_001a: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		private static void TopLeft(RectTransform rt, Vector2 pos, Vector2 size)
		{
			//IL_0015: 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_001d: 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)
			//IL_002d: 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)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			rt.pivot = val;
			Vector2 anchorMin = (rt.anchorMax = val);
			rt.anchorMin = anchorMin;
			rt.sizeDelta = size;
			rt.anchoredPosition = pos;
		}

		private static void Row(RectTransform rt, float y, float h)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_004a: 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)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(1f, 1f);
			rt.pivot = new Vector2(0.5f, 1f);
			rt.sizeDelta = new Vector2(0f, h);
			rt.anchoredPosition = new Vector2(0f, y);
		}

		private Text Label(Transform parent, string text, int size, Vector2 pos, float w, float h, TextAnchor anchor, FontStyle style, Color color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Text val = PhoneAppBuilder.MakeText(parent, _font, "L", size, color, anchor, wrap: true);
			val.fontStyle = style;
			val.text = text;
			TopLeft(((Graphic)val).rectTransform, pos, new Vector2(w, h));
			return val;
		}

		private Button Button(Transform parent, string label, Vector2 pos, float w, float h, Action onClick)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Button(parent, label, pos, w, h, onClick, Btn);
		}

		private Button Button(Transform parent, string label, Vector2 pos, float w, float h, Action onClick, Color color)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			Image bg;
			Text labelText;
			Button val = PhoneAppBuilder.MakeButton(parent, _font, "B", label, 15, color, Color.white, onClick, out bg, out labelText);
			TopLeft(((Component)val).GetComponent<RectTransform>(), pos, new Vector2(w, h));
			return val;
		}

		private Image MakeIconImage(Transform parent, Vector2 pos, float size)
		{
			//IL_0015: 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)
			GameObject val = Child(parent, "Icon");
			RectTransform rt = val.AddComponent<RectTransform>();
			TopLeft(rt, pos, new Vector2(size, size));
			Image val2 = val.AddComponent<Image>();
			val2.preserveAspect = true;
			((Behaviour)val2).enabled = false;
			return val2;
		}

		private InputField MakeInput(Transform parent, string placeholder, Vector2 pos, Vector2 size, Action<string> onChanged)
		{
			//IL_0015: 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_003a: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Child(parent, "Input");
			RectTransform rt = val.AddComponent<RectTransform>();
			TopLeft(rt, pos, size);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(1f, 1f, 1f, 0.12f);
			InputField val3 = val.AddComponent<InputField>();
			Text val4 = PhoneAppBuilder.MakeText(val.transform, _font, "Text", 16, Color.white, (TextAnchor)3, wrap: false);
			FillPad(((Graphic)val4).rectTransform, 8f, 4f);
			val4.supportRichText = false;
			Text val5 = PhoneAppBuilder.MakeText(val.transform, _font, "Placeholder", 16, new Color(1f, 1f, 1f, 0.4f), (TextAnchor)3, wrap: false);
			FillPad(((Graphic)val5).rectTransform, 8f, 4f);
			val5.fontStyle = (FontStyle)2;
			val5.text = placeholder;
			val3.textComponent = val4;
			val3.placeholder = (Graphic)(object)val5;
			val3.text = "";
			val3.lineType = (LineType)0;
			val3.caretWidth = 2;
			if (onChanged != null)
			{
				((UnityEvent<string>)(object)val3.onValueChanged).AddListener(UnityAction<string>.op_Implicit(onChanged));
			}
			return val3;
		}

		private static void FillPad(RectTransform rt, float padX, float padY)
		{
			//IL_0002: 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)
			//IL_001c: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(padX, padY);
			rt.offsetMax = new Vector2(0f - padX, 0f - padY);
		}

		private (ScrollRect, RectTransform) MakeScroll(Transform parent, Vector2 pos, Vector2 size)
		{
			//IL_0015: 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_0037: 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_00bf: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Child(parent, "Scroll");
			RectTransform rt = val.AddComponent<RectTransform>();
			TopLeft(rt, pos, size);
			((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.25f);
			ScrollRect val2 = val.AddComponent<ScrollRect>();
			val2.horizontal = false;
			val2.vertical = true;
			val2.movementType = (MovementType)2;
			val2.scrollSensitivity = 24f;
			GameObject val3 = Child(val.transform, "Viewport");
			RectTransform val4 = val3.AddComponent<RectTransform>();
			Fill(val4);
			val4.pivot = new Vector2(0f, 1f);
			((Graphic)val3.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.012f);
			Mask val5 = val3.AddComponent<Mask>();
			val5.showMaskGraphic = false;
			GameObject val6 = Child(val3.transform, "Content");
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.sizeDelta = Vector2.zero;
			val7.anchoredPosition = Vector2.zero;
			val2.viewport = val4;
			val2.content = val7;
			return (val2, val7);
		}

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

		private static UnityAction UA(Action a)
		{
			return UnityAction.op_Implicit(a);
		}

		private void Teardown()
		{
			if (_progressLoop != null)
			{
				try
				{
					MelonCoroutines.Stop(_progressLoop);
				}
				catch
				{
				}
				_progressLoop = null;
			}
			_progressMode = false;
			_progStarted = (_progRemaining = (_progStatus = null));
			_progBarFillRt = null;
			_stopButtonGo = null;
			_productRowBg.Clear();
			_shelfRowBg.Clear();
			_drugButtons.Clear();
			_productContent = (_shelfContent = null);
			_productScroll = (_shelfScroll = null);
			_selIcon = null;
			_selName = (_quantityLabel = (_chainLabel = (_statusLabel = null)));
			_listedBtnBg = null;
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
		}

		private static void LockInput()
		{
			try
			{
				PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.AddActiveUIElement("LithiumChemistOrderScreen");
					instance.SetCanLook(false);
					instance.FreeMouse();
				}
				PlayerMovement instance2 = PlayerSingleton<PlayerMovement>.Instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					instance2.CanMove = false;
				}
				PlayerInventory instance3 = PlayerSingleton<PlayerInventory>.Instance;
				if ((Object)(object)instance3 != (Object)null)
				{
					instance3.SetInventoryEnabled(false);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] LockInput failed: " + ex.Message);
			}
		}

		private static void UnlockInput()
		{
			try
			{
				PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.RemoveActiveUIElement("LithiumChemistOrderScreen");
					if (instance.activeUIElementCount == 0)
					{
						instance.SetCanLook(true);
						instance.LockMouse();
					}
				}
				PlayerMovement instance2 = PlayerSingleton<PlayerMovement>.Instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					instance2.CanMove = true;
				}
				PlayerInventory instance3 = PlayerSingleton<PlayerInventory>.Instance;
				if ((Object)(object)instance3 != (Object)null)
				{
					instance3.SetInventoryEnabled(true);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] UnlockInput failed: " + ex.Message);
			}
		}

		private static Font ResolveFont()
		{
			Font val = PhoneAppFont.Resolve();
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			try
			{
				Il2CppArrayBase<Font> val2 = Resources.FindObjectsOfTypeAll<Font>();
				if (val2 != null && val2.Count > 0)
				{
					return val2[0];
				}
			}
			catch
			{
			}
			return null;
		}

		private static string ItemName(string id)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(id);
				return ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)item).Name)) ? ((BaseItemDefinition)item).Name : id;
			}
			catch
			{
				return id;
			}
		}

		private static string DisplayName(OrderHistoryEntry h)
		{
			return string.IsNullOrEmpty(h.TargetName) ? h.TargetProductId : h.TargetName;
		}

		private static string Trim(string s, int max)
		{
			return (s != null && s.Length > max) ? (s.Substring(0, max - 1) + "…") : s;
		}

		private static string SafeName(Chemist chemist)
		{
			try
			{
				return ((NPC)chemist).fullName;
			}
			catch
			{
				return "Chemist";
			}
		}
	}
}
namespace Lithium.Modules.Employees.Patches
{
	[HarmonyPatch(typeof(Cleaner), "NetworkInitialize___Early")]
	public class CleanerPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Cleaner __instance)
		{
			if (ModEmployees.TryBeginConfigure((Employee)(object)__instance, out var config))
			{
				__instance.configuration.Bins.MaxItems = config.Cleaners.MaxBins;
				((NPC)__instance).Movement.WalkSpeed = config.Cleaners.WalkSpeed;
				((Employee)__instance).DailyWage = config.Cleaners.DailyWage;
			}
		}
	}
	[HarmonyPatch(typeof(StorageMenu), "Open", new Type[]
	{
		typeof(IItemSlotOwner),
		typeof(string),
		typeof(string)
	})]
	public class StorageMenuRowPatch
	{
		[HarmonyPostfix]
		private static void Postfix(StorageMenu __instance, IItemSlotOwner __0)
		{
			ModEmployees modEmployees = Core.Get<ModEmployees>();
			if (modEmployees == null || !modEmployees.Configuration.Enabled)
			{
				return;
			}
			NPCInventory val = ((Il2CppObjectBase)__0).TryCast<NPCInventory>();
			if (!((Object)(object)val == (Object)null))
			{
				ModEmployeesConfiguration configuration = modEmployees.Configuration;
				int? num = null;
				if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<Botanist>()))
				{
					num = configuration.Botanists.InventoryRowCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<Chemist>()))
				{
					num = configuration.Chemists.InventoryRowCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<Cleaner>()))
				{
					num = configuration.Cleaners.InventoryRowCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<Dealer>()))
				{
					num = configuration.Dealers.InventoryRowCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<Packager>()))
				{
					num = configuration.Packagers.InventoryRowCount;
				}
				if (num.HasValue)
				{
					__instance.SlotGridLayout.constraintCount = num.Value;
				}
			}
		}
	}
	[HarmonyPatch(typeof(NPCInventory), "Awake")]
	public class NPCInventoryAwakePatch
	{
		[HarmonyPrefix]
		private static void NPCSlotPatch(NPCInventory __instance)
		{
			ModEmployees modEmployees = Core.Get<ModEmployees>();
			if (modEmployees != null && modEmployees.Configuration.Enabled)
			{
				ModEmployeesConfiguration configuration = modEmployees.Configuration;
				if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<Botanist>()))
				{
					__instance.SlotCount = configuration.Botanists.InventorySlotCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<Chemist>()))
				{
					__instance.SlotCount = configuration.Chemists.InventorySlotCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<Cleaner>()))
				{
					__instance.SlotCount = configuration.Cleaners.InventorySlotCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<Dealer>()))
				{
					__instance.SlotCount = configuration.Dealers.InventorySlotCount;
				}
				else if (Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<Packager>()))
				{
					__instance.SlotCount = configuration.Packagers.InventorySlotCount;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Packager), "NetworkInitialize__Late")]
	public class PackagerPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Packager __instance)
		{
			if (!ModEmployees.TryBeginConfigure((Employee)(object)__instance, out var config))
			{
				return;
			}
			PackagerConfiguration configuration = __instance.configuration;
			if (configuration != null)
			{
				if (configuration.Stations != null)
				{
					configuration.Stations.MaxItems = config.Packagers.MaxStations;
				}
				if (configuration.Routes != null)
				{
					configuration.Routes.MaxRoutes = config.Packagers.MaxRoutes;
				}
			}
			else
			{
				Log.Warning("Packager configuration was null in NetworkInitialize__Late; skipped station/route caps for " + ((NPC)__instance).fullName + ".");
			}
			if ((Object)(object)((NPC)__instance).Movement != (Object)null)
			{
				((NPC)__instance).Movement.WalkSpeed = config.Packagers.WalkSpeed;
			}
			((Employee)__instance).DailyWage = config.Packagers.DailyWage;
			__instance.PackagingSpeedMultiplier = config.Packagers.PackagingSpeedMultiplier;
		}
	}
	[HarmonyPatch(typeof(Chemist), "NetworkInitialize__Late")]
	public class ChemistPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Chemist __instance)
		{
			if (ModEmployees.TryBeginConfigure((Employee)(object)__instance, out var config))
			{
				ChemistConfiguration configuration = __instance.configuration;
				if (configuration != null && configuration.Stations != null)
				{
					configuration.Stations.MaxItems = config.Chemists.MaxStations;
				}
				else
				{
					Log.Warning("Chemist configuration was null in NetworkInitialize__Late; skipped station caps for " + ((NPC)__instance).fullName + ".");
				}
				if ((Object)(object)((NPC)__instance).Movement != (Object)null)
				{
					((NPC)__instance).Movement.WalkSpeed = config.Chemists.WalkSpeed;
				}
				((Employee)__instance).DailyWage = config.Chemists.DailyWage;
			}
		}
	}
	[HarmonyPatch(typeof(Botanist), "NetworkInitialize__Late")]
	public class BotanistPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Botanist __instance)
		{
			if (ModEmployees.TryBeginConfigure((Employee)(object)__instance, out var config))
			{
				__instance.MaxAssignedPots = config.Botanists.MaxAssignedPots;
				((NPC)__instance).Movement.WalkSpeed = config.Botanists.WalkSpeed;
				((Employee)__instance).DailyWage = config.Botanists.DailyWage;
			}
		}
	}
	[HarmonyPatch(typeof(Employee), "WalkCallback")]
	public class EmployeeStuckPatch
	{
		[HarmonyPrefix]
		private static void Prefix(Employee __instance)
		{
			ModEmployees modEmployees = Core.Get<ModEmployees>();
			if (modEmployees != null && modEmployees.Configuration.Enabled && modEmployees.Configuration.PreventWorkStoppage)
			{
				__instance.consecutivePathingFailures = 0;
			}
		}
	}
	[HarmonyPatch(typeof(Chemist), "UpdateBehaviour")]
	internal static class ChemistOrderUpdateBehaviourPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Chemist __instance)
		{
			try
			{
				return !ChemistOrderService.RunOrder(__instance);
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] UpdateBehaviour prefix failed: " + ex.Message);
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(Employee), "Start")]
	internal static class ChemistOrderDialoguePatch
	{
		private const string ChoiceLabel = "I have a production order for you.";

		[HarmonyPostfix]
		private static void Postfix(Employee __instance)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			try
			{
				Chemist val = (((Object)(object)__instance != (Object)null) ? ((Il2CppObjectBase)__instance).TryCast<Chemist>() : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ChemistOrdersConfiguration config = ChemistOrderService.Config;
				if (config == null || !config.Enabled || !config.AddDialogueOption)
				{
					return;
				}
				DialogueHandler dialogueHandler = ((NPC)val).DialogueHandler;
				if ((Object)(object)dialogueHandler == (Object)null)
				{
					Log.Warning("[ChemistOrders] Chemist has no DialogueHandler; can't add the order choice.");
					return;
				}
				DialogueController component = ((Component)dialogueHandler).GetComponent<DialogueController>();
				if ((Object)(object)component == (Object)null)
				{
					Log.Warning("[ChemistOrders] Chemist has no DialogueController; can't add the order choice.");
					return;
				}
				List<DialogueChoice> choices = component.Choices;
				if (choices != null)
				{
					for (int i = 0; i < choices.Count; i++)
					{
						if (choices[i] != null && choices[i].ChoiceText == "I have a production order for you.")
						{
							return;
						}
					}
				}
				Chemist captured = val;
				DialogueChoice val2 = new DialogueChoice();
				val2.ChoiceText = "I have a production order for you.";
				val2.Enabled = true;
				val2.onChoosen.AddListener(UnityAction.op_Implicit((Action)delegate
				{
					ChemistOrderScreen.Request(captured);
				}));
				component.AddDialogueChoice(val2, 2);
				Log.Info("[ChemistOrders] Added production-order dialogue choice to " + SafeName(val) + ".");
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Failed to add dialogue choice: " + ex.Message);
			}
		}

		private static string SafeName(Chemist chemist)
		{
			try
			{
				return ((NPC)chemist).fullName;
			}
			catch
			{
				return "chemist";
			}
		}
	}
	[HarmonyPatch(typeof(VariableDatabase), "ReceiveValue")]
	internal static class ChemOrderRequestPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(string variableName, string value)
		{
			try
			{
				if (variableName != null && variableName.Equals("lithord_req", StringComparison.OrdinalIgnoreCase))
				{
					if (InstanceFinder.IsServer)
					{
						ChemOrderNet.Process(value);
					}
					return false;
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Order request intercept failed: " + ex.Message);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ItemSlot), "ChangeQuantity")]
	internal static class OrderSlotRestockReleasePatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemSlot __instance, int change)
		{
			try
			{
				if (__instance != null && change < 0)
				{
					ItemSlotLock activeLock = __instance.ActiveLock;
					if (activeLock != null && !(activeLock.LockReason != "Reserved for a Lithium production order") && InstanceFinder.IsServer && (__instance.ItemInstance == null || __instance.Quantity <= 0))
					{
						__instance.RemoveLock(false);
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[ChemistOrders] Failed to release emptied order lock for restock: " + ex.Message);
			}
		}
	}
}
namespace Lithium.Modules.EffectCombos
{
	public class EffectCombo
	{
		public string Name { get; set; }

		public int FixedBonus { get; set; } = 0;

		public float PercentageBonus { get; set; } = 0f;

		public string[] Effects { get; set; } = Array.Empty<string>();
	}
	public class ComboGenerationRanges
	{
		public float ThreeEffectChance { get; set; } = 0.5f;

		public int TwoEffectFixedBonusMin { get; set; } = 5;

		public int TwoEffectFixedBonusMax { get; set; } = 15;

		public int ThreeEffectFixedBonusMin { get; set; } = 15;

		public int ThreeEffectFixedBonusMax { get; set; } = 30;

		public float TwoEffectPercentageBonusMin { get; set; } = 3f;

		public float TwoEffectPercentageBonusMax { get; set; } = 8f;

		public float ThreeEffectPercentageBonusMin { get; set; } = 8f;

		public float ThreeEffectPercentageBonusMax { get; set; } = 15f;
	}
	public class ModEffectCombosConfiguration : ModuleConfiguration
	{
		public override string Name => "EffectCombos";

		public bool AffectsDealers { get; set; } = true;

		public int AutoGenerateCount { get; set; } = 20;

		public ComboGenerationRanges GenerationRanges { get; set; } = new ComboGenerationRanges();

		public EffectCombo[] Combos { get; set; } = Array.Empty<EffectCombo>();

		public override void Validate()
		{
			AutoGenerateCount = ConfigValidator.AtLeast(Name, "AutoGenerateCount", AutoGenerateCount, 0);
			ComboGenerationRanges generationRanges = GenerationRanges;
			generationRanges.ThreeEffectChance = ConfigValidator.InRange(Name, "GenerationRanges.ThreeEffectChance", generationRanges.ThreeEffectChance, 0f, 1f);
			int min = ConfigValidator.AtLeast(Name, "GenerationRanges.TwoEffectFixedBonusMin", generationRanges.TwoEffectFixedBonusMin, 0);
			int max = ConfigValidator.AtLeast(Name, "GenerationRanges.TwoEffectFixedBonusMax", generationRanges.TwoEffectFixedBonusMax, 0);
			ConfigValidator.EnsureOrdered(Name, "GenerationRanges.TwoEffectFixedBonusMin", "GenerationRanges.TwoEffectFixedBonusMax", ref min, ref max);
			generationRanges.TwoEffectFixedBonusMin = min;
			generationRanges.TwoEffectFixedBonusMax = max;
			int min2 = ConfigValidator.AtLeast(Name, "GenerationRanges.ThreeEffectFixedBonusMin", generationRanges.ThreeEffectFixedBonusMin, 0);
			int max2 = ConfigValidator.AtLeast(Name, "GenerationRanges.ThreeEffectFixedBonusMax", generationRanges.ThreeEffectFixedBonusMax, 0);
			ConfigValidator.EnsureOrdered(Name, "GenerationRanges.ThreeEffectFixedBonusMin", "GenerationRanges.ThreeEffectFixedBonusMax", ref min2, ref max2);
			generationRanges.ThreeEffectFixedBonusMin = min2;
			generationRanges.ThreeEffectFixedBonusMax = max2;
			float min3 = ConfigValidator.AtLeast(Name, "GenerationRanges.TwoEffectPercentageBonusMin", generationRanges.TwoEffectPercentageBonusMin, 0f);
			float max3 = ConfigValidator.AtLeast(Name, "GenerationRanges.TwoEffectPercentageBonusMax", generationRanges.TwoEffectPercentageBonusMax, 0f);
			ConfigValidator.EnsureOrdered(Name, "GenerationRanges.TwoEffectPercentageBonusMin", "GenerationRanges.TwoEffectPercentageBonusMax", ref min3, ref max3);
			generationRanges.TwoEffectPercentageBonusMin = min3;
			generationRanges.TwoEffectPercentageBonusMax = max3;
			float min4 = ConfigValidator.AtLeast(Name, "GenerationRanges.ThreeEffectPercentageBonusMin", generationRanges.ThreeEffectPercentageBonusMin, 0f);
			float max4 = ConfigValidator.AtLeast(Name, "GenerationRanges.ThreeEffectPercentageBonusMax", generationRanges.ThreeEffectPercentageBonusMax, 0f);
			ConfigValidator.EnsureOrdered(Name, "GenerationRanges.ThreeEffectPercentageBonusMin", "GenerationRanges.ThreeEffectPercentageBonusMax", ref min4, ref max4);
			generationRanges.ThreeEffectPercentageBonusMin = min4;
			generationRanges.ThreeEffectPercentageBonusMax = max4;
		}
	}
	public class ModEffectCombos : ModuleBase<ModEffectCombosConfiguration>
	{
		private static readonly string[] NameAdjectives = new string[24]
		{
			"Golden", "Cosmic", "Velvet", "Midnight", "Electric", "Crimson", "Royal", "Frosted", "Blazing", "Mystic",
			"Silver", "Lunar", "Savage", "Hazy", "Diamond", "Wicked", "Turbo", "Phantom", "Emerald", "Neon",
			"Sacred", "Feral", "Glacial", "Solar"
		};

		private static readonly string[] NameNouns = new string[24]
		{
			"Tiger", "Haze", "Dream", "Storm", "Punch", "Rush", "Bliss", "Nova", "Mirage", "Comet",
			"Dragon", "Voyage", "Frenzy", "Cyclone", "Reverie", "Jackpot", "Tornado", "Serpent", "Phoenix", "Avalanche",
			"Tsunami", "Eclipse", "Whirlwind", "Surge"
		};

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

		protected override void OnBeforeConfigurationLoaded()
		{
			base.OnBeforeConfigurationLoaded();
			base.Configuration.Enabled = true;
		}

		public override void Apply()
		{
			if (base.Configuration.AutoGenerateCount > 0 && (base.Configuration.Combos == null || base.Configuration.Combos.Length == 0))
			{
				GenerateCombos(base.Configuration.AutoGenerateCount);
			}
			if (base.Configuration.Enabled)
			{
				Core.Get<ModCustomers>().RegisterBonusPaymentHandler(new EffectComboBonus());
			}
		}

		private void GenerateCombos(int count)
		{
			List<string> availableEffectNames = GetAvailableEffectNames();
			if (availableEffectNames.Count < 2)
			{
				Log.Warning("[Lithium] EffectCombos: not enough effects available to generate combos yet.");
				return;
			}
			Random random = new Random();
			ComboGenerationRanges generationRanges = base.Configuration.GenerationRanges;
			List<EffectCombo> list = new List<EffectCombo>();
			HashSet<string> used = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet = new HashSet<string>();
			int num = 0;
			int num2 = count * 100;
			while (list.Count < count && num < num2)
			{
				num++;
				bool flag = availableEffectNames.Count >= 3 && random.NextDouble() < (double)generationRanges.ThreeEffectChance;
				int count2 = (flag ? 3 : 2);
				List<string> list2 = PickDistinct(availableEffectNames, count2, random);
				string item = string.Join("+", list2.OrderBy<string, string>((string e) => e, StringComparer.OrdinalIgnoreCase));
				if (hashSet.Add(item))
				{
					string text = GenerateName(random, used);
					if (text == null)
					{
						break;
					}
					list.Add(new EffectCombo
					{
						Name = text,
						Effects = list2.ToArray(),
						FixedBonus = (flag ? random.Next(generationRanges.ThreeEffectFixedBonusMin, generationRanges.ThreeEffectFixedBonusMax + 1) : random.Next(generationRanges.TwoEffectFixedBonusMin, generationRanges.TwoEffectFixedBonusMax + 1)),
						PercentageBonus = (flag ? RollFloat(random, generationRanges.ThreeEffectPercentageBonusMin, generationRanges.ThreeEffectPercentageBonusMax) : RollFloat(random, generationRanges.TwoEffectPercentageBonusMin, generationRanges.TwoEffectPercentageBonusMax))
					});
				}
			}
			base.Configuration.Combos = list.ToArray();
			base.Configuration.SaveConfiguration();
			Log.Info($"[Lithium] EffectCombos: generated {list.Count} effect combos.");
		}

		private static List<string> GetAvailableEffectNames()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				foreach (Effect item in Resources.FindObjectsOfTypeAll<Effect>())
				{
					if ((Object)(object)item != (Object)null && !string.IsNullOrWhiteSpace(item.Name))
					{
						hashSet.Add(item.Name);
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] EffectCombos: failed to read effects from game (" + ex.Message + "); using fallback list.");
			}
			if (hashSet.Count < 2)
			{
				return FallbackEffects.ToList();
			}
			return hashSet.ToList();
		}

		private static float RollFloat(Random rng, float min, float max)
		{
			return (float)((double)min + rng.NextDouble() * (double)(max - min));
		}

		private static List<string> PickDistinct(List<string> source, int count, Random rng)
		{
			List<string> list = source.ToList();
			List<string> list2 = new List<string>(count);
			for (int i = 0; i < count; i++)
			{
				if (list.Count <= 0)
				{
					break;
				}
				int index = rng.Next(list.Count);
				list2.Add(list[index]);
				list.RemoveAt(index);
			}
			return list2;
		}

		private static string GenerateName(Random rng, HashSet<string> used)
		{
			for (int i = 0; i < 100; i++)
			{
				string text = NameAdjectives[rng.Next(NameAdjectives.Length)] + " " + NameNouns[rng.Next(NameNouns.Length)];
				if (used.Add(text))
				{
					return text;
				}
			}
			return null;
		}
	}
}
namespace Lithium.Modules.EffectCombos.BonusPayments
{
	public class EffectComboBonus : IBonusPaymentHandler
	{
		public bool TryCalculateBonus(Customer customer, Contract contract, List<ItemInstance> items, out List<BonusPayment> boni)
		{
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			boni = new List<BonusPayment>();
			ModEffectCombosConfiguration configuration = Core.Get<ModEffectCombos>().Configuration;
			if (!configuration.Enabled)
			{
				return false;
			}
			if (!configuration.AffectsDealers && (Object)(object)contract.Dealer != (Object)null)
			{
				return false;
			}
			int num = items.ToList().Sum((ItemInstance i) => (i != null) ? ((BaseItemInstance)i).Quantity : 0);
			foreach (ItemInstance item in items)
			{
				if (item == null)
				{
					continue;
				}
				ProductDefinition val = ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToList<ProductDefinition>()).SingleOrDefault((Func<ProductDefinition, bool>)((ProductDefinition p) => ((BaseItemDefinition)p).ID.Equals(((BaseItemInstance)item).ID)));
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string[] second = (from p in ((PropertyItemDefinition)val).Properties.ToList<Effect>()
					select p.Name.ToLowerInvariant()).ToArray();
				float num2 = ((num > 0) ? ((float)((BaseItemInstance)item).Quantity / (float)num) : 0f);
				EffectCombo effectCombo = null;
				float num3 = 0f;
				EffectCombo[] combos = configuration.Combos;
				foreach (EffectCombo effectCombo2 in combos)
				{
					if (effectCombo2.Effects != null && effectCombo2.Effects.Length != 0 && effectCombo2.Effects.Select((string s) => s.ToLowerInvariant()).Intersect(second).Count() == effectCombo2.Effects.Length)
					{
						float num5 = effectCombo2.FixedBonus * ((BaseItemInstance)item).Quantity;
						float num6 = contract.Payment * (effectCombo2.PercentageBonus / 100f) * num2;
						float num7 = num5 + num6;
						if (effectCombo == null || num7 > num3)
						{
							effectCombo = effectCombo2;
							num3 = num7;
						}
					}
				}
				if (effectCombo != null && num3 > 0f)
				{
					boni.Add(new BonusPayment("\"" + effectCombo.Name + "\" Combo Bonus", num3));
				}
			}
			return boni.Any();
		}
	}
}
namespace Lithium.Modules.Customers
{
	public sealed class ReducedDealDetails
	{
		public string ProductName { get; }

		public int Quantity { get; }

		public float PriceEach { get; }

		public float Total { get; }

		public ReducedDealDetails(string productName, int quantity, float priceEach, float total)
		{
			ProductName = productName;
			Quantity = quantity;
			PriceEach = priceEach;
			Total = total;
		}
	}
	public static class CustomerNotifier
	{
		public static void NotifyPlayerProductsNotSuitable(Customer customer)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			Notify(customer, configuration, configuration.Contracts.SendNotification, configuration.Contracts.MessageTemplates, isDealer: false);
		}

		public static void NotifyDealerNotSuitable(Customer customer)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			Notify(customer, configuration, configuration.Contracts.SendNotificationForDealers, configuration.Contracts.DealerTemplates, isDealer: true);
		}

		public static void NotifyPlayerReducedDeal(Customer customer, string productName, int quantity, float priceEach, float total)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			Notify(customer, configuration, configuration.Contracts.SendNotification, configuration.Contracts.ReducedSaleTemplates, isDealer: false, new ReducedDealDetails(productName, quantity, priceEach, total));
		}

		public static void NotifyDealerReducedDeal(Customer customer, string productName, int quantity, float priceEach, float total)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			Notify(customer, configuration, configuration.Contracts.SendNotificationForDealers, configuration.Contracts.ReducedDealerTemplates, isDealer: true, new ReducedDealDetails(productName, quantity, priceEach, total));
		}

		private static void Notify(Customer customer, ModCustomersConfiguration config, bool gateFlag, string[] templates, bool isDealer, ReducedDealDetails details = null)
		{
			if (gateFlag && ReadyToNotify(customer, config))
			{
				string text = templates.PickRandom().Replace("##DESIRES##", ProductHelper.FormatDesires(customer.CustomerData));
				if (isDealer)
				{
					text = text.Replace("##DEALER##", ((NPC)customer.AssignedDealer).FirstName);
				}
				if (details != null)
				{
					text = text.Replace("##QTY##", details.Quantity.ToString()).Replace("##PRODUCT##", details.ProductName).Replace("##PRICE_EACH##", $"${details.PriceEach:N2}")
						.Replace("##TOTAL##", $"${details.Total:N0}");
				}
				Send(customer, text);
			}
		}

		private static bool ReadyToNotify(Customer customer, ModCustomersConfiguration config)
		{
			CustomerNotificationState customerNotificationState = default(CustomerNotificationState);
			if (((Component)customer).TryGetComponent<CustomerNotificationState>(ref customerNotificationState))
			{
				if (NetworkSingleton<TimeManager>.Instance.Playtime - customerNotificationState.LastNotification < (float)(60 * config.Contracts.NotificationCooldownInMinutes))
				{
					return false;
				}
			}
			else
			{
				customerNotificationState = ((Component)customer).gameObject.AddComponent<CustomerNotificationState>();
			}
			customerNotificationState.LastNotification = NetworkSingleton<TimeManager>.Instance.Playtime;
			return true;
		}

		private static void Send(Customer customer, string msg)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			NetworkSingleton<MessagingManager>.Instance.ReceiveMessage(new Message(msg, (ESenderType)1, false, -1), true, customer.NPC.ID);
		}
	}
	public static class DealerCoverageNotifier
	{
		private static HashSet<string> _knownNoDealerCovered;

		public static void ReportForDealer(Dealer dealer)
		{
			if ((Object)(object)dealer == (Object)null)
			{
				return;
			}
			List<Customer> list = (from c in dealer.AssignedCustomers.ToList<Customer>()
				where c.IsServeable()
				select c).ToList();
			if (list.Count == 0)
			{
				return;
			}
			List<string> dealerStockedEffects = dealer.GetDealerStockedEffects();
			int num = 0;
			List<string> list2 = new List<string>();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (Customer item in list)
			{
				List<string> desireNames = ProductHelper.GetDesireNames(item.CustomerData);
				List<string> list3 = desireNames.Except(dealerStockedEffects).ToList();
				if (desireNames.Count == 0 || list3.Count < desireNames.Count)
				{
					num++;
				}
				else
				{
					list2.Add(item.NPC.fullName);
				}
				foreach (string item2 in list3)
				{
					hashSet.Add(item2);
				}
			}
			int count = list.Count;
			int value = (int)Math.Round((double)num * 100.0 / (double)count);
			string value2 = (string.IsNullOrEmpty(((NPC)dealer).FirstName) ? ((NPC)dealer).fullName : ((NPC)dealer).FirstName);
			string text = $"{value2} — {num}/{count} customers covered ({value}%).";
			if (list2.Count == 0)
			{
				LithiumContact.Send(text + " Stock covers everyone — nice work.");
				return;
			}
			LithiumContact.Send($"{text} Uncovered: {list2.OrderBy((string n) => n).SmartJoin(", ", " and ")}. Missing effects: {hashSet.OrderBy((string e) => e).SmartJoin(", ", " and ")}.");
		}

		public static void ResetNoDealer()
		{
			_knownNoDealerCovered = null;
		}

		public static void ReportNoDealerCustomers()
		{
			(HashSet<string> coveredIds, int total, List<string> uncovered) tuple = ComputeNoDealer();
			HashSet<string> item = tuple.coveredIds;
			int item2 = tuple.total;
			List<string> item3 = tuple.uncovered;
			_knownNoDealerCovered = item;
			SendNoDealer(item.Count, item2, item3);
		}

		public static void ReportNoDealerChange()
		{
			var (hashSet, total, uncovered) = ComputeNoDealer();
			if (_knownNoDealerCovered == null || !_knownNoDealerCovered.SetEquals(hashSet))
			{
				_knownNoDealerCovered = hashSet;
				SendNoDealer(hashSet.Count, total, uncovered);
			}
		}

		private static (HashSet<string> coveredIds, int total, List<string> uncovered) ComputeNoDealer()
		{
			List<ProductDefinition> source = ProductManager.ListedProducts.ToList<ProductDefinition>();
			List<Customer> list = (from c in Customer.UnlockedCustomers.ToList<Customer>()
				where c.IsServeable() && (Object)(object)c.AssignedDealer == (Object)null
				select c).ToList();
			HashSet<string> hashSet = new HashSet<string>();
			List<string> list2 = new List<string>();
			foreach (Customer item in list)
			{
				List<string> desires = ProductHelper.GetDesireNames(item.CustomerData);
				if (desires.Count == 0 || source.Any((ProductDefinition p) => ProductHelper.ProductMatchesDesires(p, desires)))
				{
					hashSet.Add(item.NPC.ID);
				}
				else
				{
					list2.Add(item.NPC.fullName);
				}
			}
			return (coveredIds: hashSet, total: list.Count, uncovered: list2);
		}

		private static void SendNoDealer(int covered, int total, List<string> uncovered)
		{
			if (total == 0)
			{
				return;
			}
			int value = (int)Math.Round((double)covered * 100.0 / (double)total);
			string text = $"No-dealer customers — {covered}/{total} covered ({value}%).";
			if (uncovered.Count == 0)
			{
				LithiumContact.Send(text + " You've got them all.");
				return;
			}
			LithiumContact.Send(text + " Uncovered: " + uncovered.OrderBy((string n) => n).SmartJoin(", ", " and ") + ".");
		}
	}
	public static class LithiumContact
	{
		public static void Send(string message)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			NPC val = Resolve(configuration.Coverage.ContactNpcName);
			if ((Object)(object)val == (Object)null)
			{
				Log.Warning("[Lithium] Coverage contact NPC '" + configuration.Coverage.ContactNpcName + "' not found; message dropped.");
				return;
			}
			MSGConversation mSGConversation = val.MSGConversation;
			if (mSGConversation != null)
			{
				if (mSGConversation.contactName != configuration.Coverage.ContactDisplayName)
				{
					mSGConversation.contactName = configuration.Coverage.ContactDisplayName;
				}
				mSGConversation.SetIsKnown(true);
			}
			NetworkSingleton<MessagingManager>.Instance.ReceiveMessage(new Message(message, (ESenderType)1, false, -1), true, val.ID);
		}

		private static NPC Resolve(string fullName)
		{
			foreach (NPC item in NPCManager.NPCRegistry.ToList<NPC>())
			{
				if ((Object)(object)item != (Object)null && string.Equals(item.fullName, fullName, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	public static class LithiumStartupReport
	{
		public static bool WorldReady()
		{
			return (Object)(object)NetworkSingleton<MessagingManager>.Instance != (Object)null && Customer.UnlockedCustomers != null && Customer.UnlockedCustomers.Count > 0;
		}

		public static void Send()
		{
			if (InstanceFinder.IsServer)
			{
				List<Customer> list = (from c in Customer.UnlockedCustomers.ToList<Customer>()
					where (Object)(object)c != (Object)null && (Object)(object)c.CustomerData != (Object)null && (Object)(object)c.NPC != (Object)null
					select c).ToList();
				List<Customer> list2 = list.Where((Customer c) => c.CustomerData.PreferredProperties.ToList<Effect>().Count > 0).ToList();
				HashSet<string> covered = ProductCoverageNotifier.ComputeCoveredIds();
				int num = list2.Count((Customer c) => covered.Contains(c.NPC.ID));
				int value = ((list2.Count > 0) ? ((int)Math.Round((double)num * 100.0 / (double)list2.Count)) : 0);
				int num2 = list2.Count - num;
				int num3 = Dealer.AllPlayerDealers.ToList<Dealer>().Count((Dealer d) => (Object)(object)d != (Object)null && d.IsRecruited);
				int count = ProductManager.ListedProducts.ToList<ProductDefinition>().Count;
				string message = $"Welcome back. {num3} {((num3 == 1) ? "dealer" : "dealers")} on payroll, {list.Count} {((list.Count == 1) ? "customer" : "customers")} unlocked, {count} {((count == 1) ? "product" : "products")} listed. Effect coverage: {value}%" + ((num2 > 0) ? $" — {num2} {((num2 == 1) ? "customer is" : "customers are")} still uncovered." : " — everyone's covered.");
				LithiumContact.Send(message);
			}
		}
	}
	public class EffectMatchBonus
	{
		public float PercentageBonusMin { get; set; } = 0f;

		public float PercentageBonusMax { get; set; } = 0f;

		public int FixedBonusMin { get; set; } = 0;

		public int FixedBonusMax { get; set; } = 0;
	}
	public class EffectBonus
	{
		public bool Enabled { get; set; }

		public bool AffectsDealers { get; set; } = true;

		public EffectMatchBonus OneCoveredEffect { get; set; } = new EffectMatchBonus
		{
			FixedBonusMin = 2,
			FixedBonusMax = 5,
			PercentageBonusMin = 1f,
			PercentageBonusMax = 3f
		};

		public EffectMatchBonus TwoCoveredEffects { get; set; } = new EffectMatchBonus
		{
			FixedBonusMin = 5,
			FixedBonusMax = 10,
			PercentageBonusMin = 3f,
			PercentageBonusMax = 7f
		};

		public EffectMatchBonus ThreeCoveredEffects { get; set; } = new EffectMatchBonus
		{
			FixedBonusMin = 10,
			FixedBonusMax = 20,
			PercentageBonusMin = 7f,
			PercentageBonusMax = 15f
		};
	}
	public class SampleOffering
	{
		public bool Enabled { get; set; }

		public float QualityLevelModifier { get; set; } = 0.2f;

		public bool IncludeDrugPreference { get; set; } = true;

		public float BaseAcceptance { get; set; } = 0f;

		public bool RequireEffectMatch { get; set; } = true;

		[JsonConverter(typeof(StringEnumConverter))]
		public ERank MinRank { get; set; } = (ERank)0;

		public int MinRankTier { get; set; } = 1;

		public int MaxQualityOverDeliveryLevels { get; set; } = 1;

		public float DrugAffinitySharpness { get; set; } = 0.5f;

		public bool RankMet()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return RankHelper.PlayerRankAtLeast(MinRank, MinRankTier);
		}
	}
	public class DirectSales
	{
		public bool RequireEffectMatch { get; set; } = true;

		public float MinIntervalFractionBeforeOffer { get; set; } = 0.5f;

		public float PriceToleranceMultiplier { get; set; } = 1f;

		public float PriceToleranceJitter { get; set; } = 0f;
	}
	public class Contracts
	{
		public bool Enabled { get; set; }

		public int XPRequired { get; set; } = 1400;

		public bool SendNotification { get; set; } = true;

		public bool SendNotificationForDealers { get; set; } = true;

		public int NotificationCooldownInMinutes { get; set; } = 5;

		public int NotificationWindowStartHour { get; set; } = 8;

		public int NotificationWindowEndHour { get; set; } = 22;

		public string[] MessageTemplates { get; set; } = new string[4] { "Hey, I wanted to get fresh stuff, but you don't offer good stuff. I prefer ##DESIRES##", "I was looking for something ##DESIRES##, but you don't have any. Please improve your offering.", "Yo you still haven't got anything ##DESIRES##? Dang!", "##DESIRES## ... come on, can't be that hard to find, right?" };

		public string[] DealerTemplates { get; set; } = new string[4] { "Hey, I wanted to get fresh stuff, but ##DEALER## doesn't offer good stuff. I prefer ##DESIRES##", "I was looking for something ##DESIRES##, but ##DEALER## doesn't have any. Could you help him out?", "Yo ##DEALER## still hasn't got anything ##DESIRES##? Dang!", "##DESIRES## ... come on, can't be that hard for ##DEALER## to find, right?" };

		public bool RequireEffectMatch { get; set; } = true;

		public bool DealerRequireEffectMatch { get; set; } = true;

		public float ReducedDealPriceMultiplier { get; set; } = 0.75f;

		public bool DealerSellAtListedPrice { get; set; } = true;

		public bool SellAtListedPrice { get; set; } = true;

		public bool RetryNextDayOnRefusal { get; set; } = true;

		public AcceptanceWindow AcceptanceWindow { get; set; } = new AcceptanceWindow();

		public ProductSelection ProductSelection { get; set; } = new ProductSelection();

		public BulkRewards BulkRewards { get; set; } = new BulkRewards();

		public string[] ReducedSaleTemplates { get; set; } = new string[4] { "Couldn't find anything ##DESIRES##, so I grabbed ##QTY##x ##PRODUCT## instead at a lower ##PRICE_EACH## each — ##TOTAL## total.", "You had nothing ##DESIRES##, so I settled for ##QTY##x ##PRODUCT## at ##PRICE_EACH## each (##TOTAL## in total).", "No ##DESIRES##? I took ##QTY##x ##PRODUCT## instead, but only paid ##PRICE_EACH## each — ##TOTAL## total.", "Bought ##QTY##x ##PRODUCT## off you, but since it wasn't ##DESIRES## I knocked it down to ##PRICE_EACH## each (##TOTAL## total)." };

		public string[] ReducedDealerTemplates { get; set; } = new string[4] { "##DEALER## had nothing ##DESIRES##, so I took ##QTY##x ##PRODUCT## at a lower ##PRICE_EACH## each — ##TOTAL## total.", "Since ##DEALER## didn't have ##DESIRES##, I settled for ##QTY##x ##PRODUCT## at ##PRICE_EACH## each (##TOTAL## in total).", "No ##DESIRES## from ##DEALER## — grabbed ##QTY##x ##PRODUCT## instead at ##PRICE_EACH## each, ##TOTAL## total.", "Got ##QTY##x ##PRODUCT## from ##DEALER##, but it wasn't ##DESIRES## so I only paid ##PRICE_EACH## each — ##TOTAL## total." };
	}
	public class ProductSelection
	{
		public float CoverageBiasExponent { get; set; } = 3f;

		public float DrugTypeBiasExponent { get; set; } = 1f;

		public bool EnableSecondProduct { get; set; } = true;

		public float SecondProductChance { get; set; } = 0.5f;

		public float SecondProductQuantityShare { get; set; } = 0.25f;
	}
	public class BulkRewards
	{
		public bool Enabled { get; set; } = true;

		public bool ScaleRelationship { get; set; } = true;

		public bool ScaleXP { get; set; } = true;

		public float MaxRewardMultiplier { get; set; } = 7f;
	}
	public class OrderPatternWeights
	{
		public float Weekly { get; set; } = 55f;

		public float TwiceWeekly { get; set; } = 30f;

		public float EveryThreeDays { get; set; } = 15f;
	}
	public class OrderPatterns
	{
		public bool Enabled { get; set; }

		public float BulkOrderSizeFactor { get; set; } = 1f;

		public bool CatchUpMissedOrders { get; set; } = true;

		public OrderPatternWeights ArchetypeWeights { get; set; } = new OrderPatternWeights();

		public bool AnnounceNextOrder { get; set; } = true;

		public bool ShowPatternInContactPanel { get; set; } = true;

		[JsonConverter(typeof(StringEnumConverter))]
		public ERank MinRank { get; set; } = (ERank)0;

		public int MinRankTier { get; set; } = 3;

		public string[] NextOrderTemplates { get; set; } = new string[4] { "Thanks, good doing business! I'll hit you up again ##DAY##.", "Appreciate it — I'll call you back ##DAY##.", "Solid as always. Expect to hear from me ##DAY##.", "Nice doing business. I'll be in touch again ##DAY##." };

		public bool RankMet()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return RankHelper.PlayerRankAtLeast(MinRank, MinRankTier);
		}
	}
	public class AcceptanceWindow
	{
		public bool Enabled { get; set; } = true;

		public float DurationMultiplier { get; set; } = 1.5f;

		public int BaseQuantity { get; set; } = 10;

		public float MinutesPerExtraUnit { get; set; } = 60f;

		public int MaxWindowMinutes { get; set; } = 8640;

		public bool SendDeadlineMessage { get; set; } = true;

		public string[] OfferDeadlineTemplates { get; set; } = new string[4] { "You've got until ##DEADLINE## to let me know.", "Let me know by ##DEADLINE##.", "I'll need your answer by ##DEADLINE##.", "Hit me back by ##DEADLINE## or I'll assume you're not interested." };
	}
	public class CoverageNotifications
	{
		public bool Enabled { get; set; }

		public string ContactNpcName { get; set; } = "Manny Oakfield";

		public string ContactDisplayName { get; set; } = "Lithium";

		public bool ListUncovered { get; set; }

		public bool NotifyDealerInventoryOnClose { get; set; }

		public bool SendStartupOverview { get; set; } = true;

		public bool NotifyNoDealerCustomers { get; set; } = true;
	}
	public class ModCustomersConfiguration : ModuleConfiguration
	{
		public override string Name => "Customers";

		public int HandoverSlotCount { get; set; } = 4;

		public SampleOffering SampleOffering { get; set; } = new SampleOffering();

		public DirectSales DirectSales { get; set; } = new DirectSales();

		public Contracts Contracts { get; set; } = new Contracts();

		public EffectBonus EffectBonus { get; set; } = new EffectBonus();

		public OrderPatterns OrderPatterns { get; set; } = new OrderPatterns();

		public CoverageNotifications Coverage { get; set; } = new CoverageNotifications();

		public override void Validate()
		{
			HandoverSlotCount = ConfigValidator.InRange(Name, "HandoverSlotCount", HandoverSlotCount, 4, 12);
			SampleOffering.MinRankTier = ConfigValidator.InRange(Name, "SampleOffering.MinRankTier", SampleOffering.MinRankTier, 1, 5);
			OrderPatterns.MinRankTier = ConfigValidator.InRange(Name, "OrderPatterns.MinRankTier", OrderPatterns.MinRankTier, 1, 5);
			Contracts.ProductSelection.CoverageBiasExponent = ConfigValidator.AtLeast(Name, "Contracts.ProductSelection.CoverageBiasExponent", Contracts.ProductSelection.CoverageBiasExponent, 0f);
			Contracts.ProductSelection.DrugTypeBiasExponent = ConfigValidator.AtLeast(Name, "Contracts.ProductSelection.DrugTypeBiasExponent", Contracts.ProductSelection.DrugTypeBiasExponent, 0f);
			Contracts.NotificationWindowStartHour = ConfigValidator.InRange(Name, "Contracts.NotificationWindowStartHour", Contracts.NotificationWindowStartHour, 0, 23);
			Contracts.NotificationWindowEndHour = ConfigValidator.InRange(Name, "Contracts.NotificationWindowEndHour", Contracts.NotificationWindowEndHour, 1, 24);
			if (Contracts.NotificationWindowStartHour >= Contracts.NotificationWindowEndHour)
			{
				Log.Warning($"[Lithium] {Name}: 'Contracts.NotificationWindowStartHour' ({Contracts.NotificationWindowStartHour}) must be before 'Contracts.NotificationWindowEndHour' ({Contracts.NotificationWindowEndHour}); " + "reverting to 8–22.");
				Contracts.NotificationWindowStartHour = 8;
				Contracts.NotificationWindowEndHour = 22;
			}
		}
	}
	public class ModCustomers : ModuleBase<ModCustomersConfiguration>
	{
		internal readonly List<IBonusPaymentHandler> BonusPaymentHandlers = new List<IBonusPaymentHandler>();

		public ModCustomers()
		{
			ClassInjector.RegisterTypeInIl2Cpp<CustomerNotificationState>();
			RegisterBonusPaymentHandler(new EffectCoverageBonus());
		}

		public override void Apply()
		{
			ProductCoverageNotifier.Reset();
			DealerCoverageNotifier.ResetNoDealer();
			ContractRetryTracker.Unload();
			OfferDeadlineTracker.Unload();
			DailyOrderTracker.Unload();
			OrderPatternProfile.ClearCache();
			CustomerContractGenerationPatch.ResetState();
			if (base.Configuration.Enabled && base.Configuration.Coverage.Enabled && (base.Configuration.Coverage.SendStartupOverview || base.Configuration.Coverage.NotifyNoDealerCustomers))
			{
				MelonCoroutines.Start(StartupOverviewRoutine());
			}
		}

		private static IEnumerator StartupOverviewRoutine()
		{
			for (float waited = 0f; waited < 30f; waited += 1f)
			{
				if (LithiumStartupReport.WorldReady())
				{
					break;
				}
				yield return (object)new WaitForSeconds(1f);
			}
			if (LithiumStartupReport.WorldReady())
			{
				yield return (object)new WaitForSeconds(2f);
				CoverageNotifications coverage = Core.Get<ModCustomers>().Configuration.Coverage;
				if (coverage.SendStartupOverview)
				{
					LithiumStartupReport.Send();
				}
				if (coverage.NotifyNoDealerCustomers)
				{
					DealerCoverageNotifier.ReportNoDealerCustomers();
				}
			}
		}

		public void RegisterBonusPaymentHandler(IBonusPaymentHandler handler)
		{
			if (BonusPaymentHandlers.All((IBonusPaymentHandler h) => h.GetType() != handler.GetType()))
			{
				BonusPaymentHandlers.Add(handler);
			}
		}
	}
	public static class NpcRosterDebug
	{
		public static void Dump()
		{
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
				{
					if ((Object)(object)item != (Object)null && (Object)(object)item.NPC != (Object)null)
					{
						hashSet.Add(item.NPC.ID);
					}
				}
				foreach (Customer item2 in Customer.LockedCustomers.ToList<Customer>())
				{
					if ((Object)(object)item2 != (Object)null && (Object)(object)item2.NPC != (Object)null)
					{
						hashSet.Add(item2.NPC.ID);
					}
				}
				List<NPC> list = NPCManager.NPCRegistry.ToList<NPC>();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== Lithium NPC Roster ===");
				stringBuilder.AppendLine("** = hijack candidate (not a customer, has a conversation, 0 messages).");
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(12, 1, stringBuilder2);
				handler.AppendLiteral("Total NPCs: ");
				handler.AppendFormatted(list.Count);
				stringBuilder3.AppendLine(ref handler);
				stringBuilder.AppendLine();
				foreach (NPC item3 in list)
				{
					if (!((Object)(object)item3 == (Object)null))
					{
						bool flag = hashSet.Contains(item3.ID);
						MSGConversation mSGConversation = item3.MSGConversation;
						int num = ((mSGConversation != null) ? mSGConversation.messageHistory.Count : (-1));
						string name = ((MemberInfo)((Object)item3).GetIl2CppType()).Name;
						bool flag2 = !flag && mSGConversation != null && num == 0;
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder4 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(51, 9, stringBuilder2);
						handler.AppendFormatted(flag2 ? "** " : "   ");
						handler.AppendFormatted<string>(item3.fullName, -22);
						handler.AppendLiteral(" type=");
						handler.AppendFormatted<string>(name, -14);
						handler.AppendLiteral(" id=");
						handler.AppendFormatted<string>(item3.ID, -22);
						handler.AppendLiteral(" ");
						handler.AppendLiteral("customer=");
						handler.AppendFormatted(flag, -5);
						handler.AppendLiteral(" conv=");
						handler.AppendFormatted(mSGConversation != null, -5);
						handler.AppendLiteral(" msgs=");
						handler.AppendFormatted(num, -3);
						handler.AppendLiteral(" important=");
						handler.AppendFormatted(item3.IsImportant, -5);
						handler.AppendLiteral(" region=");
						handler.AppendFormatted<EMapRegion>(item3.Region);
						stringBuilder4.AppendLine(ref handler);
					}
				}
				string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "NpcRoster.txt");
				File.WriteAllText(text2, stringBuilder.ToString());
				Log.Info($"[NpcRoster] Wrote {list.Count} NPCs to {text2}");
			}
			catch (Exception value)
			{
				Log.Error($"[NpcRoster] Dump failed: {value}");
			}
		}
	}
	public static class OrderPatternDebug
	{
		public static void Dump()
		{
			//IL_00f9: 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_0114: 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_0130: 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_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== Lithium Order Pattern Dump ===");
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(28, 1, stringBuilder2);
				handler.AppendLiteral("Module.Enabled            : ");
				handler.AppendFormatted(configuration.Enabled);
				stringBuilder3.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(28, 1, stringBuilder2);
				handler.AppendLiteral("Contracts.Enabled         : ");
				handler.AppendFormatted(configuration.Contracts.Enabled);
				stringBuilder4.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder5 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(28, 1, stringBuilder2);
				handler.AppendLiteral("OrderPatterns.Enabled     : ");
				handler.AppendFormatted(configuration.OrderPatterns.Enabled);
				stringBuilder5.AppendLine(ref handler);
				int value = (((Object)(object)NetworkSingleton<LevelManager>.Instance != (Object)null) ? NetworkSingleton<LevelManager>.Instance.TotalXP : (-1));
				string value2 = (((Object)(object)NetworkSingleton<LevelManager>.Instance != (Object)null) ? ((object)NetworkSingleton<LevelManager>.Instance.GetFullRank()/*cast due to .constrained prefix*/).ToString() : "<none>");
				string value3 = ((object)new FullRank(configuration.OrderPatterns.MinRank, Math.Clamp(configuration.OrderPatterns.MinRankTier, 1, 5))/*cast due to .constrained prefix*/).ToString();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder6 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(28, 1, stringBuilder2);
				handler.AppendLiteral("Total XP (current)        : ");
				handler.AppendFormatted(value);
				stringBuilder6.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder7 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(31, 2, stringBuilder2);
				handler.AppendLiteral("Rank (current / required) : ");
				handler.AppendFormatted(value2);
				handler.AppendLiteral(" / ");
				handler.AppendFormatted(value3);
				stringBuilder7.AppendLine(ref handler);
				bool flag = configuration.Enabled && configuration.Contracts.Enabled && configuration.OrderPatterns.Enabled && configuration.OrderPatterns.RankMet();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder8 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(28, 2, stringBuilder2);
				handler.AppendLiteral("Patterns ACTIVE in-game   : ");
				handler.AppendFormatted(flag);
				handler.AppendFormatted(flag ? "" : "  (profiles below are still shown for inspection)");
				stringBuilder8.AppendLine(ref handler);
				EDay val = (EDay)(((Object)(object)NetworkSingleton<TimeManager>.Instance != (Object)null) ? ((int)NetworkSingleton<TimeManager>.Instance.CurrentDay) : 0);
				int value4 = (((Object)(object)NetworkSingleton<TimeManager>.Instance != (Object)null) ? NetworkSingleton<TimeManager>.Instance.ElapsedDays : (-1));
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder9 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(31, 2, stringBuilder2);
				handler.AppendLiteral("Current day / elapsed     : ");
				handler.AppendFormatted<EDay>(val);
				handler.AppendLiteral(" / ");
				handler.AppendFormatted(value4);
				stringBuilder9.AppendLine(ref handler);
				stringBuilder.AppendLine();
				List<Customer> list = new List<Customer>();
				list.AddRange(Customer.UnlockedCustomers.ToList<Customer>());
				list.AddRange(Customer.LockedCustomers.ToList<Customer>());
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder10 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(40, 3, stringBuilder2);
				handler.AppendLiteral("Total customers: ");
				handler.AppendFormatted(list.Count);
				handler.AppendLiteral(" (Unlocked: ");
				handler.AppendFormatted(Customer.UnlockedCustomers.Count);
				handler.AppendLiteral(", Locked: ");
				handler.AppendFormatted(Customer.LockedCustomers.Count);
				handler.AppendLiteral(")");
				stringBuilder10.AppendLine(ref handler);
				stringBuilder.AppendLine();
				foreach (Customer item in list)
				{
					DumpCustomer(stringBuilder, item, val);
				}
				string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "OrderPatternsDump.txt");
				File.WriteAllText(text2, stringBuilder.ToString());
				Log.Info($"[OrderPatternDebug] Wrote {list.Count} customers to {text2}");
			}
			catch (Exception value5)
			{
				Log.Error($"[OrderPatternDebug] Dump failed: {value5}");
			}
		}

		private static void DumpCustomer(StringBuilder sb, Customer customer, EDay currentDay)
		{
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: 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)
			try
			{
				CustomerData customerData = customer.CustomerData;
				string value = (((Object)(object)customer.NPC != (Object)null) ? customer.NPC.fullName : "<no npc>");
				bool flag = Customer.UnlockedCustomers.Contains(customer);
				StringBuilder stringBuilder = sb;
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(6, 2, stringBuilder);
				handler.AppendLiteral("- ");
				handler.AppendFormatted(value);
				handler.AppendLiteral("  [");
				handler.AppendFormatted(flag ? "Unlocked" : "Locked");
				handler.AppendLiteral("]");
				stringBuilder2.AppendLine(ref handler);
				if ((Object)(object)customerData == (Object)null)
				{
					sb.AppendLine("    <no CustomerData>");
					sb.AppendLine();
					return;
				}
				string name = ((Object)customerData).name;
				int value2 = StableHash.Compute(name);
				int value3 = Math.Clamp((int)Math.Round((double)(customerData.MinOrdersPerWeek + customerData.MaxOrdersPerWeek) / 2.0), 1, 7);
				OrderPatternProfile orderPatternProfile = OrderPatternProfile.Create(name, customerData.MinOrdersPerWeek, customerData.MaxOrdersPerWeek);
				OrderPatternProfile orderPatternProfile2 = OrderPatternProfile.Create(name, customerData.MinOrdersPerWeek, customerData.MaxOrdersPerWeek);
				bool flag2 = orderPatternProfile.Archetype == orderPatternProfile2.Archetype && string.Join(",", orderPatternProfile.OrderDays) == string.Join(",", orderPatternProfile2.OrderDays);
				string value4 = (((Object)(object)customer.AssignedDealer != (Object)null) ? ((NPC)customer.AssignedDealer).FirstName : "<none>");
				List<string> list = ((customerData.PreferredProperties != null) ? ProductHelper.GetDesireNames(customerData) : new List<string>());
				int count = list.Count;
				string value5 = ((count > 0) ? string.Join(", ", list) : "<none>");
				string value6 = ((customerData.DefaultAffinityData != null) ? string.Join(", ", from a in customerData.DefaultAffinityData.ProductAffinities.ToList<ProductTypeAffinity>()
					select $"{a.DrugType}={a.Affinity:0.##}") : "<none>");
				string value7;
				if (count == 0)
				{
					value7 = "no desires -> effect gate N/A (accepts on quality/drug)";
				}
				else
				{
					int num = 0;
					string value8 = "<none>";
					foreach (ProductDefinition item in ProductManager.ListedProducts.ToList<ProductDefinition>())
					{
						int num2 = (from p in ((PropertyItemDefinition)item).Properties.ToList<Effect>()
							select p.Name).Intersect(list).Count();
						if (num2 > num)
						{
							num = num2;
							value8 = ((BaseItemDefinition)item).Name;
						}
					}
					value7 = $"{num}/{count} covered (best listed: '{value8}', {num * 100 / count}% -> sample base before quality/drug)";
				}
				bool value9 = orderPatternProfile.OrderDays.Contains(currentDay);
				stringBuilder = sb;
				StringBuilder stringBuilder3 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(39, 2, stringBuilder);
				handler.AppendLiteral("    CustomerData.name (seed): ");
				handler.AppendFormatted(name);
				handler.AppendLiteral("  (hash ");
				handler.AppendFormatted(value2);
				handler.AppendLiteral(")");
				stringBuilder3.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder4 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(45, 3, stringBuilder);
				handler.AppendLiteral("    OrdersPerWeek min/max   : ");
				handler.AppendFormatted(customerData.MinOrdersPerWeek);
				handler.AppendLiteral("/");
				handler.AppendFormatted(customerData.MaxOrdersPerWeek);
				handler.AppendLiteral("  (reference ");
				handler.AppendFormatted(value3);
				handler.AppendLiteral(")");
				stringBuilder4.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder5 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(31, 2, stringBuilder);
				handler.AppendLiteral("    WeeklySpend min/max     : ");
				handler.AppendFormatted(customerData.MinWeeklySpend, "0.##");
				handler.AppendLiteral("/");
				handler.AppendFormatted(customerData.MaxWeeklySpend, "0.##");
				stringBuilder5.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder6 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    Standards               : ");
				handler.AppendFormatted<ECustomerStandard>(customerData.Standards);
				stringBuilder6.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder7 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 2, stringBuilder);
				handler.AppendLiteral("    Desired effects (");
				handler.AppendFormatted(count);
				handler.AppendLiteral(")      : ");
				handler.AppendFormatted(value5);
				stringBuilder7.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder8 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    Drug affinities         : ");
				handler.AppendFormatted(value6);
				stringBuilder8.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder9 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    Effect coverage (listed): ");
				handler.AppendFormatted(value7);
				stringBuilder9.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder10 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    Assigned dealer         : ");
				handler.AppendFormatted(value4);
				stringBuilder10.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder11 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    >> Archetype            : ");
				handler.AppendFormatted(orderPatternProfile.Archetype);
				stringBuilder11.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder12 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(29, 2, stringBuilder);
				handler.AppendLiteral("    >> Order days (");
				handler.AppendFormatted(orderPatternProfile.OrderDays.Count);
				handler.AppendLiteral(")       : ");
				handler.AppendFormatted(string.Join(", ", orderPatternProfile.OrderDays));
				stringBuilder12.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder13 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(82, 1, stringBuilder);
				handler.AppendLiteral("    >> Quantity multiplier  : ");
				handler.AppendFormatted(orderPatternProfile.QuantityMultiplier, "0.###");
				handler.AppendLiteral("  (per-order = base x mult; weekly volume conserved)");
				stringBuilder13.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder14 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(26, 2, stringBuilder);
				handler.AppendLiteral("    >> Orders today (");
				handler.AppendFormatted<EDay>(currentDay);
				handler.AppendLiteral(")? : ");
				handler.AppendFormatted(value9);
				stringBuilder14.AppendLine(ref handler);
				stringBuilder = sb;
				StringBuilder stringBuilder15 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    >> Deterministic        : ");
				handler.AppendFormatted(flag2 ? "OK" : "MISMATCH!");
				stringBuilder15.AppendLine(ref handler);
				sb.AppendLine();
			}
			catch (Exception ex)
			{
				StringBuilder stringBuilder = sb;
				StringBuilder stringBuilder16 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(30, 1, stringBuilder);
				handler.AppendLiteral("    <error dumping customer: ");
				handler.AppendFormatted(ex.Message);
				handler.AppendLiteral(">");
				stringBuilder16.AppendLine(ref handler);
				sb.AppendLine();
			}
		}
	}
	public static class ProductCoverageNotifier
	{
		private static HashSet<string> _knownCovered;

		public static void Reset()
		{
			_knownCovered = null;
		}

		public static void EnsureBaseline()
		{
			if (_knownCovered == null)
			{
				_knownCovered = ComputeCoveredIds();
			}
		}

		public static HashSet<string> ComputeCoveredIds()
		{
			HashSet<string> hashSet = new HashSet<string>();
			List<ProductDefinition> source = ProductManager.ListedProducts.ToList<ProductDefinition>();
			foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
			{
				if (item.IsServeable())
				{
					List<string> desires = ProductHelper.GetDesireNames(item.CustomerData);
					if (desires.Count != 0 && source.Any((ProductDefinition p) => ProductHelper.ProductMatchesDesires(p, desires)))
					{
						hashSet.Add(item.NPC.ID);
					}
				}
			}
			return hashSet;
		}

		public static void ReportChange()
		{
			HashSet<string> hashSet = ComputeCoveredIds();
			if (_knownCovered == null)
			{
				_knownCovered = hashSet;
				return;
			}
			Dictionary<string, string> idToName = new Dictionary<string, string>();
			List<string> list = new List<string>();
			foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
			{
				if (item.IsServeable() && item.CustomerData.PreferredProperties.ToList<Effect>().Count != 0)
				{
					list.Add(item.NPC.ID);
					idToName[item.NPC.ID] = item.NPC.fullName;
				}
			}
			List<string> list2 = (from n in hashSet.Except(_knownCovered).Select(Name)
				orderby n
				select n).ToList();
			List<string> list3 = (from n in _knownCovered.Except(hashSet).Select(Name)
				orderby n
				select n).ToList();
			_knownCovered = hashSet;
			if (list2.Count != 0 || list3.Count != 0)
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				int count = list.Count;
				int value = ((count > 0) ? ((int)Math.Round((double)hashSet.Count * 100.0 / (double)count)) : 0);
				string value2 = BuildUncoveredSuffix(configuration, list, hashSet, idToName);
				if (list2.Count > 0)
				{
					LithiumContact.Send($"You now cover {list2.SmartJoin(", ", " and ")} with your products. Overall: {value}%{value2}");
				}
				if (list3.Count > 0)
				{
					LithiumContact.Send($"{list3.SmartJoin(", ", " and ")} {((list3.Count == 1) ? "is" : "are")} no longer covered. Overall: {value}%{value2}");
				}
			}
			string Name(string id)
			{
				string value3;
				return idToName.TryGetValue(id, out value3) ? value3 : id;
			}
		}

		private static string BuildUncoveredSuffix(ModCustomersConfiguration config, List<string> coverableIds, HashSet<string> covered, Dictionary<string, string> idToName)
		{
			if (!config.Coverage.ListUncovered)
			{
				return string.Empty;
			}
			List<string> list = (from id in coverableIds
				where !covered.Contains(id)
				select idToName[id] into n
				orderby n
				select n).ToList();
			if (list.Count == 0)
			{
				return " Everyone is covered!";
			}
			return " Still uncovered: " + list.SmartJoin(", ", " and ");
		}
	}
}
namespace Lithium.Modules.Customers.Patches
{
	[HarmonyPatch(typeof(Customer), "ProcessHandover")]
	public static class CustomerBulkRewardPatch
	{
		private const int PlayerHandoverXP = 20;

		private const int PlayerDealerHandoverXP = 10;

		private static bool _armed;

		private static float _effectiveMultiplier;

		private static int _baseXp;

		private static float _relationshipBefore;

		[HarmonyPrefix]
		public static void Prefix(Customer __instance, EHandoverOutcome outcome, Contract contract, bool handoverByPlayer, bool giveBonuses)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			_armed = false;
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			BulkRewards bulkRewards = configuration.Contracts.BulkRewards;
			if (bulkRewards != null && bulkRewards.Enabled && (int)outcome == 1 && giveBonuses && configuration.OrderPatterns.Enabled && !((Object)(object)NetworkSingleton<LevelManager>.Instance == (Object)null) && configuration.OrderPatterns.RankMet() && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.CustomerData == (Object)null) && !((Object)(object)__instance.NPC == (Object)null) && __instance.NPC.RelationData != null)
			{
				float quantityMultiplier = OrderPatternProfile.Create(((Object)__instance.CustomerData).name, __instance.CustomerData.MinOrdersPerWeek, __instance.CustomerData.MaxOrdersPerWeek).QuantityMultiplier;
				if (!(quantityMultiplier <= 1f))
				{
					_effectiveMultiplier = Mathf.Min(quantityMultiplier, Mathf.Max(1f, bulkRewards.MaxRewardMultiplier));
					_baseXp = ResolveBaseXp(handoverByPlayer, contract);
					_relationshipBefore = __instance.NPC.RelationData.RelationDelta;
					_armed = true;
				}
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			if (!_armed)
			{
				return;
			}
			_armed = false;
			BulkRewards bulkRewards = Core.Get<ModCustomers>().Configuration.Contracts.BulkRewards;
			float num = _effectiveMultiplier - 1f;
			if (num <= 0f)
			{
				return;
			}
			if (bulkRewards.ScaleRelationship && (Object)(object)__instance != (Object)null && (Object)(object)__instance.NPC != (Object)null && __instance.NPC.RelationData != null)
			{
				float num2 = __instance.NPC.RelationData.RelationDelta - _relationshipBefore;
				if (num2 > 0f)
				{
					float num3 = num2 * num;
					__instance.NPC.RelationData.ChangeRelationship(num3, true);
					if (Log.DebugEnabled)
					{
						Log.Info($"[Lithium] Bulk affection x{_effectiveMultiplier:F2} for {((Object)__instance.CustomerData).name}: +{num3:F2} (base {num2:F2}).");
					}
				}
			}
			if (!bulkRewards.ScaleXP || _baseXp <= 0 || !((Object)(object)NetworkSingleton<LevelManager>.Instance != (Object)null))
			{
				return;
			}
			int num4 = Mathf.RoundToInt((float)_baseXp * num);
			if (num4 > 0)
			{
				NetworkSingleton<LevelManager>.Instance.AddXP(num4);
				if (Log.DebugEnabled)
				{
					Log.Info($"[Lithium] Bulk XP x{_effectiveMultiplier:F2}: +{num4} (base {_baseXp}).");
				}
			}
		}

		private static int ResolveBaseXp(bool handoverByPlayer, Contract contract)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			if (handoverByPlayer)
			{
				return 20;
			}
			if ((Object)(object)contract != (Object)null && (Object)(object)contract.Dealer != (Object)null && (int)contract.Dealer.DealerType == 0)
			{
				return 10;
			}
			return 0;
		}
	}
	[HarmonyPatch(typeof(Customer), "TryGenerateContract")]
	public class CustomerContractGenerationPatch
	{
		private readonly struct ReducedDeal
		{
			public string ProductName { get; }

			public int Quantity { get; }

			public float UnitPrice { get; }

			public float Total { get; }

			public ReducedDeal(string productName, int quantity, float unitPrice, float total)
			{
				ProductName = productName;
				Quantity = quantity;
				UnitPrice = unitPrice;
				Total = total;
			}
		}

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

		private static readonly Dictionary<string, int> _lastOrderDay = new Dictionary<string, int>();

		private const int MaxOrderQuantity = 9999;

		public static void ResetState()
		{
			_lastWritten.Clear();
			_lastOrderDay.Clear();
		}

		[HarmonyPostfix]
		public static void Postfix(ref ContractInfo __result, Customer __instance, Dealer dealer)
		{
			try
			{
				Generate(ref __result, __instance, dealer);
			}
			catch (Exception value)
			{
				string value2 = (((Object)(object)__instance != (Object)null && (Object)(object)__instance.CustomerData != (Object)null) ? ((Object)__instance.CustomerData).name : "<unknown>");
				Log.Warning($"[Customers] Contract generation failed for {value2}; leaving the game's contract untouched. {value}");
			}
		}

		private static void Generate(ref ContractInfo __result, Customer __instance, Dealer dealer)
		{
			//IL_0147: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: 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_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled || __result == null)
			{
				return;
			}
			if ((Object)(object)dealer == (Object)null && (Object)(object)__instance.AssignedDealer != (Object)null)
			{
				__result = null;
			}
			else
			{
				if (NetworkSingleton<LevelManager>.Instance.TotalXP < configuration.Contracts.XPRequired)
				{
					return;
				}
				bool flag = configuration.Contracts.RetryNextDayOnRefusal && ContractRetryTracker.IsRetryDay(((Object)__instance.CustomerData).name);
				OrderPatternProfile orderPatternProfile = null;
				if (configuration.OrderPatterns.Enabled)
				{
					orderPatternProfile = OrderPatternProfile.Create(((Object)__instance.CustomerData).name, __instance.CustomerData.MinOrdersPerWeek, __instance.CustomerData.MaxOrdersPerWeek);
					if (!flag && !orderPatternProfile.OrderDays.Contains(NetworkSingleton<TimeManager>.Instance.CurrentDay))
					{
						__result = null;
						return;
					}
				}
				List<string> desires = ProductHelper.GetDesireNames(__instance.CustomerData);
				Entry val = __result.Products.entries.ToList<Entry>()[0];
				EQuality quality = val.Quality;
				if (desires.Count == 0)
				{
					ContractRetryTracker.Clear(((Object)__instance.CustomerData).name);
					return;
				}
				float num = ((orderPatternProfile != null) ? ComputeOrderBudget(__instance, orderPatternProfile.OrderDays.Count) : (-1f));
				string text = ((Object)__instance.CustomerData).name ?? string.Empty;
				string text2 = Fingerprint(__result);
				if (_lastWritten.TryGetValue(text, out var value) && value == text2)
				{
					Log.Info("[Lithium] Skipped reprocessed contract for " + ((Object)__instance.CustomerData).name + ".");
					return;
				}
				if (orderPatternProfile != null && _lastOrderDay.TryGetValue(text, out var value2) && value2 == NetworkSingleton<TimeManager>.Instance.ElapsedDays)
				{
					__result = null;
					return;
				}
				if (orderPatternProfile != null && Log.DebugEnabled)
				{
					Log.Info($"[Lithium] OrderGen {((Object)__instance.CustomerData).name}: gameBase={ProductHelper.GetTotalQuantity(__result.Products)}, ordersPerWeek={__instance.CustomerData.MinOrdersPerWeek}-{__instance.CustomerData.MaxOrdersPerWeek}, archetype={orderPatternProfile.Archetype}, days={orderPatternProfile.OrderDays.Count}, perOrderBudget=${num:F0}");
				}
				if ((Object)(object)__instance.AssignedDealer != (Object)null)
				{
					__instance.DealerHasSuitableProduct(out var dealerItems);
					if (dealerItems.Count == 0)
					{
						__result = null;
						return;
					}
					List<ProductDefinition> list = (from i in dealerItems
						select ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToList<ProductDefinition>()).FirstOrDefault((Func<ProductDefinition, bool>)((ProductDefinition p) => ((BaseItemDefinition)p).ID.Equals(((BaseItemInstance)i).ID))) into p
						where (Object)(object)p != (Object)null
						select p).Distinct().ToList();
					Func<ProductDefinition, int> func = (ProductDefinition p) => dealerItems.Where((ItemInstance i) => ((BaseItemInstance)i).ID == ((BaseItemDefinition)p).ID).Sum((ItemInstance i) => ((BaseItemInstance)i).Quantity);
					if (!configuration.Contracts.DealerRequireEffectMatch)
					{
						ComposeMatchingOrder(__result, list, desires, __instance.CustomerData, quality, num, func, configuration.Contracts.DealerSellAtListedPrice);
					}
					else
					{
						List<ProductDefinition> list2 = list.Where((ProductDefinition p) => ProductHelper.ProductMatchesDesires(p, desires)).ToList();
						if (list2.Count == 0)
						{
							ProductDefinition val2 = list.OrderBy((ProductDefinition x) => Random.value).First();
							ReducedDeal reducedDeal = ApplyReducedDeal(__result, val2, quality, Mathf.Max(1, func(val2)), num, configuration.Contracts.DealerSellAtListedPrice);
							CustomerNotifier.NotifyDealerReducedDeal(__instance, reducedDeal.ProductName, reducedDeal.Quantity, reducedDeal.UnitPrice, reducedDeal.Total);
						}
						else
						{
							ComposeMatchingOrder(__result, list2, desires, __instance.CustomerData, quality, num, func, configuration.Contracts.DealerSellAtListedPrice);
						}
					}
				}
				else
				{
					List<ProductDefinition> list3 = ProductManager.ListedProducts.ToList<ProductDefinition>();
					if (list3.Count == 0)
					{
						__result = null;
						return;
					}
					if (!configuration.Contracts.RequireEffectMatch)
					{
						ComposeMatchingOrder(__result, list3, desires, __instance.CustomerData, quality, num, (ProductDefinition _) => int.MaxValue, configuration.Contracts.SellAtListedPrice);
					}
					else
					{
						List<ProductDefinition> list4 = list3.Where((ProductDefinition p) => ProductHelper.ProductMatchesDesires(p, desires)).ToList();
						if (list4.Count == 0)
						{
							ProductDefinition product = list3.OrderBy((ProductDefinition x) => Random.value).First();
							ReducedDeal reducedDeal2 = ApplyReducedDeal(__result, product, quality, int.MaxValue, num, configuration.Contracts.SellAtListedPrice);
							CustomerNotifier.NotifyPlayerReducedDeal(__instance, reducedDeal2.ProductName, reducedDeal2.Quantity, reducedDeal2.UnitPrice, reducedDeal2.Total);
						}
						else
						{
							ComposeMatchingOrder(__result, list4, desires, __instance.CustomerData, quality, num, (ProductDefinition _) => int.MaxValue, configuration.Contracts.SellAtListedPrice);
						}
					}
				}
				if (__result != null && Log.DebugEnabled)
				{
					Log.Info("[Lithium] Contract for " + ((Object)__instance.CustomerData).name + ": " + string.Join(", ", from e in __result.Products.entries.ToList<Entry>()
						select $"{e.Quantity}x {e.ProductID}") + $" = ${__result.Payment:F0}");
				}
				RememberWritten(text, __result);
				if (orderPatternProfile != null && __result != null)
				{
					_lastOrderDay[text] = NetworkSingleton<TimeManager>.Instance.ElapsedDays;
				}
				ContractRetryTracker.Clear(((Object)__instance.CustomerData).name);
			}
		}

		private static string Fingerprint(ContractInfo info)
		{
			if (info == null || info.Products == null)
			{
				return string.Empty;
			}
			return string.Join(",", from e in info.Products.entries.ToList<Entry>()
				select $"{e.ProductID}:{e.Quantity}:{(int)e.Quality}");
		}

		private static void RememberWritten(string customerKey, ContractInfo info)
		{
			if (info == null)
			{
				_lastWritten.Remove(customerKey);
				return;
			}
			if (_lastWritten.Count > 4096)
			{
				_lastWritten.Clear();
			}
			_lastWritten[customerKey] = Fingerprint(info);
		}

		private static float ComputeOrderBudget(Customer customer, int orderDayCount)
		{
			if ((Object)(object)customer == (Object)null || (Object)(object)customer.CustomerData == (Object)null)
			{
				return -1f;
			}
			float num = 0f;
			if ((Object)(object)customer.NPC != (Object)null && customer.NPC.RelationData != null)
			{
				num = customer.NPC.RelationData.NormalizedRelationDelta;
			}
			float adjustedWeeklySpend = customer.CustomerData.GetAdjustedWeeklySpend(num);
			if (adjustedWeeklySpend <= 0f)
			{
				return -1f;
			}
			float num2 = Mathf.Max(0f, Core.Get<ModCustomers>().Configuration.OrderPatterns.BulkOrderSizeFactor);
			int num3 = Mathf.Max(1, orderDayCount);
			return adjustedWeeklySpend * num2 / (float)num3;
		}

		private static float UnitPrice(ProductDefinition product, bool useListedPrice, float gameUnitPrice)
		{
			if (useListedPrice)
			{
				ProductManager instance = NetworkSingleton<ProductManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					return Mathf.Max(0.01f, instance.GetPrice(product));
				}
			}
			return Mathf.Max(0.01f, gameUnitPrice);
		}

		private static int QuantityFromBudget(float budget, float unitPrice, int cap)
		{
			int num = Mathf.RoundToInt(budget / Mathf.Max(0.01f, unitPrice));
			int num2 = Mathf.Max(1, Mathf.Min(cap, 9999));
			return Mathf.Clamp(num, 1, num2);
		}

		private static ReducedDeal ApplyReducedDeal(ContractInfo __result, ProductDefinition product, EQuality quality, int maxAvailableQuantity, float perOrderBudget, bool useListedPrice)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			float num = UnitPrice(product, useListedPrice, product.MarketValue);
			int totalQuantity = ProductHelper.GetTotalQuantity(__result.Products);
			int num2 = ((perOrderBudget > 0f) ? QuantityFromBudget(perOrderBudget, num, maxAvailableQuantity) : Mathf.Max(1, Mathf.Min(maxAvailableQuantity, totalQuantity)));
			ProductList val = new ProductList();
			val.entries.Add(new Entry
			{
				ProductID = ((BaseItemDefinition)product).ID,
				Quality = quality,
				Quantity = num2
			});
			__result.Products = val;
			float num3 = num * configuration.Contracts.ReducedDealPriceMultiplier;
			__result.Payment = num3 * (float)num2;
			return new ReducedDeal(((BaseItemDefinition)product).Name, num2, num3, __result.Payment);
		}

		private static void ComposeMatchingOrder(ContractInfo __result, List<ProductDefinition> matching, List<string> desires, CustomerData customerData, EQuality quality, float perOrderBudget, Func<ProductDefinition, int> availableOf, bool useListedPrice)
		{
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: 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_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			ProductSelection productSelection = Core.Get<ModCustomers>().Configuration.Contracts.ProductSelection;
			int totalQuantity = ProductHelper.GetTotalQuantity(__result.Products);
			float payment = __result.Payment;
			float gameUnitPrice = ((totalQuantity > 0) ? (payment / (float)totalQuantity) : 0f);
			bool flag = perOrderBudget > 0f;
			ProductDefinition val = PickWeightedByCoverage(matching, desires, customerData, productSelection);
			ProductDefinition val2 = PickSecondaryProduct(matching, val, desires, customerData, productSelection);
			float num = UnitPrice(val, useListedPrice, gameUnitPrice);
			int num2 = Mathf.Max(1, availableOf(val));
			int num3 = 0;
			int num5;
			if ((Object)(object)val2 != (Object)null)
			{
				float unitPrice = UnitPrice(val2, useListedPrice, gameUnitPrice);
				int num4 = Mathf.Max(0, availableOf(val2));
				if (flag)
				{
					num3 = QuantityFromBudget(perOrderBudget * productSelection.SecondProductQuantityShare, unitPrice, num4);
					num5 = QuantityFromBudget(perOrderBudget * (1f - productSelection.SecondProductQuantityShare), num, num2);
				}
				else
				{
					num3 = Mathf.Clamp(Mathf.RoundToInt((float)totalQuantity * productSelection.SecondProductQuantityShare), 0, num4);
					num5 = Mathf.Min(Mathf.Max(1, totalQuantity - num3), num2);
				}
				if (num3 <= 0 || num5 <= 0)
				{
					val2 = null;
					num3 = 0;
					num5 = (flag ? QuantityFromBudget(perOrderBudget, num, num2) : Mathf.Max(1, Mathf.Min(totalQuantity, num2)));
				}
			}
			else
			{
				num5 = (flag ? QuantityFromBudget(perOrderBudget, num, num2) : Mathf.Max(1, Mathf.Min(totalQuantity, num2)));
			}
			ProductList val3 = new ProductList();
			val3.entries.Add(new Entry
			{
				ProductID = ((BaseItemDefinition)val).ID,
				Quality = quality,
				Quantity = num5
			});
			if ((Object)(object)val2 != (Object)null && num3 > 0)
			{
				val3.entries.Add(new Entry
				{
					ProductID = ((BaseItemDefinition)val2).ID,
					Quality = quality,
					Quantity = num3
				});
			}
			__result.Products = val3;
			float num6 = num * (float)num5;
			if ((Object)(object)val2 != (Object)null && num3 > 0)
			{
				num6 += UnitPrice(val2, useListedPrice, gameUnitPrice) * (float)num3;
			}
			__result.Payment = num6;
		}

		private static ProductDefinition PickSecondaryProduct(List<ProductDefinition> matching, ProductDefinition primary, List<string> desires, CustomerData customerData, ProductSelection selection)
		{
			if (!selection.EnableSecondProduct || matching.Count <= 1 || Random.value >= selection.SecondProductChance)
			{
				return null;
			}
			List<ProductDefinition> list = matching.Where((ProductDefinition p) => ((BaseItemDefinition)p).ID != ((BaseItemDefinition)primary).ID).ToList();
			return (list.Count > 0) ? PickWeightedByCoverage(list, desires, customerData, selection) : null;
		}

		private static ProductDefinition PickWeightedByCoverage(List<ProductDefinition> candidates, List<string> desires, CustomerData customerData, ProductSelection selection)
		{
			if (candidates.Count == 1)
			{
				return candidates[0];
			}
			float[] array = new float[candidates.Count];
			float num = 0f;
			for (int i = 0; i < candidates.Count; i++)
			{
				int num2 = ProductHelper.CoveredEffectCount(candidates[i], desires);
				float num3 = Mathf.Pow((float)(num2 + 1), selection.CoverageBiasExponent);
				float num4 = DrugTypeWeight(candidates[i], customerData, selection.DrugTypeBiasExponent);
				array[i] = num3 * num4;
				num += array[i];
			}
			if (num <= 0f)
			{
				return candidates[Random.Range(0, candidates.Count)];
			}
			float num5 = Random.value * num;
			for (int j = 0; j < candidates.Count; j++)
			{
				num5 -= array[j];
				if (num5 <= 0f)
				{
					return candidates[j];
				}
			}
			return candidates[candidates.Count - 1];
		}

		private static float DrugTypeWeight(ProductDefinition product, CustomerData customerData, float exponent)
		{
			if (exponent <= 0f)
			{
				return 1f;
			}
			float num = ProductHelper.DrugTypeAffinity(product, customerData);
			float num2 = Mathf.Clamp01((num + 1f) / 2f);
			return Mathf.Pow(Mathf.Max(0.0001f, num2), exponent);
		}
	}
	[HarmonyPatch(typeof(Customer), "ContractAccepted")]
	public class CustomerContractAcceptedPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (configuration.Enabled && configuration.Contracts.Enabled && InstanceFinder.IsServer)
			{
				CustomerData customerData = __instance.CustomerData;
				string text = ((customerData != null) ? ((Object)customerData).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					OfferDeadlineTracker.Clear(text);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "ContractRejected")]
	public class CustomerContractRejectedPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled || !InstanceFinder.IsServer)
			{
				return;
			}
			CustomerData customerData = __instance.CustomerData;
			string text = ((customerData != null) ? ((Object)customerData).name : null);
			if (!string.IsNullOrEmpty(text))
			{
				OfferDeadlineTracker.Clear(text);
				if (configuration.Contracts.RetryNextDayOnRefusal)
				{
					ContractRetryTracker.FlagForRetry(text);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "ExpireOffer")]
	public class CustomerExpireOfferPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			if (!CustomerExpireOfferGuardPatch.LastCallBlocked)
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				if (configuration.Enabled && configuration.Contracts.Enabled && configuration.Contracts.RetryNextDayOnRefusal && InstanceFinder.IsServer)
				{
					ContractRetryTracker.FlagForRetry(((Object)__instance.CustomerData).name);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "ExpireOffer")]
	public class CustomerExpireOfferGuardPatch
	{
		internal static bool LastCallBlocked;

		[HarmonyPrefix]
		public static bool Prefix(Customer __instance)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			LastCallBlocked = false;
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return true;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null)
			{
				return true;
			}
			if (!InstanceFinder.IsServer)
			{
				return true;
			}
			ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
			if (offeredContractInfo == null || !offeredContractInfo.Expires)
			{
				return true;
			}
			CustomerData customerData = __instance.CustomerData;
			string customerName = ((customerData != null) ? ((Object)customerData).name : null);
			if (!OfferDeadlineTracker.TryGet(customerName, out var deadlineMinSum))
			{
				return true;
			}
			GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
			int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
			if (minSum < deadlineMinSum)
			{
				LastCallBlocked = true;
				return false;
			}
			OfferDeadlineTracker.Clear(customerName);
			return true;
		}
	}
	[HarmonyPatch(typeof(Customer), "UpdateOfferExpiry")]
	public class CustomerUpdateOfferExpiryPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Customer __instance)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return true;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null || !acceptanceWindow.Enabled)
			{
				return true;
			}
			if (!InstanceFinder.IsServer)
			{
				return true;
			}
			ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
			if (offeredContractInfo == null || !offeredContractInfo.Expires)
			{
				return true;
			}
			CustomerData customerData = __instance.CustomerData;
			string customerName = ((customerData != null) ? ((Object)customerData).name : null);
			if (!OfferDeadlineTracker.TryGet(customerName, out var deadlineMinSum))
			{
				return true;
			}
			GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
			int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
			if (minSum >= deadlineMinSum)
			{
				return true;
			}
			UpdateSlider(__instance, deadlineMinSum, minSum);
			return false;
		}

		private static void UpdateSlider(Customer customer, int deadlineMinSum, int now)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NPC nPC = customer.NPC;
				if (!((Object)(object)nPC == (Object)null) && nPC.MSGConversation != null)
				{
					GameDateTime offeredContractTime = customer.OfferedContractTime;
					int minSum = ((GameDateTime)(ref offeredContractTime)).GetMinSum();
					int num = deadlineMinSum - minSum;
					if (num > 0)
					{
						float num2 = 1f - Mathf.Clamp01((float)(now - minSum) / (float)num);
						HUD instance = Singleton<HUD>.Instance;
						Color val = (((Object)(object)instance != (Object)null) ? instance.RedGreenGradient.Evaluate(num2) : Color.white);
						nPC.MSGConversation.SetSliderValue(num2, val);
					}
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] Offer-expiry slider update failed: {value}");
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "OnMinPass")]
	public class CustomerMinPassOfferExpiryPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Customer __instance)
		{
			//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_0232: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				if (!configuration.Enabled || !configuration.Contracts.Enabled)
				{
					return;
				}
				AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
				if (acceptanceWindow == null || !acceptanceWindow.Enabled || !InstanceFinder.IsServer)
				{
					return;
				}
				CustomerData customerData = __instance.CustomerData;
				string text = ((customerData != null) ? ((Object)customerData).name : null);
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
				ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
				if (offeredContractInfo == null || !offeredContractInfo.Expires)
				{
					if (OfferDeadlineTracker.TryGet(text, out var deadlineMinSum) && minSum >= deadlineMinSum)
					{
						OfferDeadlineTracker.Clear(text);
						Log.Info($"[Customers] Swept stale offer deadline for {text} (no pending offer, deadline lapsed {minSum - deadlineMinSum} min ago).");
					}
					return;
				}
				if (!OfferDeadlineTracker.TryGet(text, out var deadlineMinSum2))
				{
					if (offeredContractInfo.Products == null)
					{
						return;
					}
					int totalQuantity = ProductHelper.GetTotalQuantity(offeredContractInfo.Products);
					if (totalQuantity <= 0)
					{
						return;
					}
					int num = OfferAcceptanceWindow.Extend(Customer.OFFER_EXPIRY_TIME_MINS, totalQuantity, acceptanceWindow);
					deadlineMinSum2 = minSum + num;
					OfferDeadlineTracker.Set(text, deadlineMinSum2);
					Log.Info($"[Customers] Self-healed offer deadline for {text}: +{num} min (qty {totalQuantity}).");
				}
				if (minSum < deadlineMinSum2)
				{
					__instance.OfferedContractTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
					UpdateSlider(__instance, deadlineMinSum2, minSum);
					return;
				}
				Log.Info($"[Customers] Expiring {text}'s offer: now {minSum} >= deadline {deadlineMinSum2} (overshoot {minSum - deadlineMinSum2} min).");
				__instance.ExpireOffer();
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] OnMinPass offer-expiry enforcement failed: {value}");
			}
		}

		private static void UpdateSlider(Customer customer, int deadlineMinSum, int now)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NPC nPC = customer.NPC;
				if (!((Object)(object)nPC == (Object)null) && nPC.MSGConversation != null)
				{
					GameDateTime offeredContractTime = customer.OfferedContractTime;
					int minSum = ((GameDateTime)(ref offeredContractTime)).GetMinSum();
					int num = deadlineMinSum - minSum;
					if (num > 0)
					{
						float num2 = 1f - Mathf.Clamp01((float)(now - minSum) / (float)num);
						HUD instance = Singleton<HUD>.Instance;
						Color val = (((Object)(object)instance != (Object)null) ? instance.RedGreenGradient.Evaluate(num2) : Color.white);
						nPC.MSGConversation.SetSliderValue(num2, val);
					}
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] Offer-expiry slider update failed: {value}");
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "OnSleepStart")]
	public class CustomerSleepOfferGuardPatch
	{
		private static ContractInfo _savedContract;

		private static GameDateTime _savedTime;

		private static bool _shouldRestore;

		[HarmonyPrefix]
		public static void Prefix(Customer __instance)
		{
			//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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			_shouldRestore = false;
			_savedContract = null;
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null || !InstanceFinder.IsServer)
			{
				return;
			}
			ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
			if (offeredContractInfo == null || !offeredContractInfo.Expires)
			{
				return;
			}
			CustomerData customerData = __instance.CustomerData;
			string customerName = ((customerData != null) ? ((Object)customerData).name : null);
			if (OfferDeadlineTracker.TryGet(customerName, out var deadlineMinSum))
			{
				GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
				if (minSum < deadlineMinSum)
				{
					_savedContract = offeredContractInfo;
					_savedTime = __instance.OfferedContractTime;
					_shouldRestore = true;
				}
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (_shouldRestore)
			{
				_shouldRestore = false;
				ContractInfo savedContract = _savedContract;
				_savedContract = null;
				if (savedContract != null && __instance.OfferedContractInfo == null)
				{
					__instance.OfferedContractInfo = savedContract;
					__instance.OfferedContractTime = _savedTime;
				}
			}
		}
	}
	[HarmonyPatch(typeof(TimeManager), "OnTimeSkip_Client")]
	public class OfferDeadlineTimeSkipPatch
	{
		[HarmonyPrefix]
		public static void Prefix(int oldTime, int newTime)
		{
			//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)
			try
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				if (!configuration.Enabled || !configuration.Contracts.Enabled)
				{
					return;
				}
				AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
				if (acceptanceWindow == null || !acceptanceWindow.Enabled || !InstanceFinder.IsServer)
				{
					return;
				}
				int num = ((TimeManager.GetMinSumFrom24HourTime(newTime) - TimeManager.GetMinSumFrom24HourTime(oldTime)) % 1440 + 1440) % 1440;
				if (num <= 0)
				{
					return;
				}
				GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
				foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
				{
					ContractInfo val = ((item != null) ? item.OfferedContractInfo : null);
					if (val != null && val.Expires)
					{
						CustomerData customerData = item.CustomerData;
						string text = ((customerData != null) ? ((Object)customerData).name : null);
						if (!string.IsNullOrEmpty(text) && OfferDeadlineTracker.TryGet(text, out var deadlineMinSum) && deadlineMinSum > minSum)
						{
							OfferDeadlineTracker.Set(text, deadlineMinSum + num);
							Log.Info($"[Customers] Shifted {text}'s offer deadline by {num} skipped min ({oldTime} -> {newTime}).");
						}
					}
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] Offer-deadline time-skip shift failed: {value}");
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "Load", new Type[] { typeof(CustomerData) })]
	public class CustomerLoadOfferDeadlinePatch
	{
		private const int GraceMinutes = 180;

		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			//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_01a7: Unknown result type (might be due to invalid IL or missing references)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null || !InstanceFinder.IsServer)
			{
				return;
			}
			ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
			if (offeredContractInfo == null || !offeredContractInfo.Expires || offeredContractInfo.Products == null)
			{
				return;
			}
			CustomerData customerData = __instance.CustomerData;
			string text = ((customerData != null) ? ((Object)customerData).name : null);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
			int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
			int totalQuantity = ProductHelper.GetTotalQuantity(offeredContractInfo.Products);
			int oFFER_EXPIRY_TIME_MINS = Customer.OFFER_EXPIRY_TIME_MINS;
			int num = (acceptanceWindow.Enabled ? OfferAcceptanceWindow.Extend(oFFER_EXPIRY_TIME_MINS, totalQuantity, acceptanceWindow) : oFFER_EXPIRY_TIME_MINS);
			if (OfferDeadlineTracker.TryGet(text, out var deadlineMinSum))
			{
				if (deadlineMinSum > minSum)
				{
					int num2 = deadlineMinSum;
				}
				else
				{
					int num2 = minSum + Mathf.Min(num, 180);
					OfferDeadlineTracker.Set(text, num2);
					Log.Info($"[Customers] Granted {text} a {num2 - minSum} min grace window for a " + "save-restored offer whose deadline had lapsed.");
				}
			}
			else
			{
				int num2 = minSum + num;
				OfferDeadlineTracker.Set(text, num2);
			}
			__instance.OfferedContractTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
		}
	}
	[HarmonyPatch(typeof(ContactsDetailPanel), "Open")]
	public class ContactsPanelOrderPatternPatch
	{
		private static readonly string[] DayAbbr = new string[7] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };

		private const int MaxPreferencesShown = 3;

		private const float MinAffinityShown = 0.05f;

		[HarmonyPostfix]
		public static void Postfix(ContactsDetailPanel __instance)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled || !configuration.OrderPatterns.Enabled || !configuration.OrderPatterns.ShowPatternInContactPanel || !configuration.OrderPatterns.RankMet() || (Object)(object)__instance.PropertiesLabel == (Object)null || (Object)(object)__instance.PropertiesContainer == (Object)null || !((Component)__instance.PropertiesContainer).gameObject.activeInHierarchy)
			{
				return;
			}
			NPC selectedNPC = __instance.SelectedNPC;
			if ((Object)(object)selectedNPC == (Object)null)
			{
				return;
			}
			Customer component = ((Component)selectedNPC).GetComponent<Customer>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.CustomerData == (Object)null || __instance.PropertiesLabel.text.Contains("\nOrders: "))
			{
				return;
			}
			OrderPatternProfile profile = OrderPatternProfile.Create(((Object)component.CustomerData).name, component.CustomerData.MinOrdersPerWeek, component.CustomerData.MaxOrdersPerWeek);
			Text propertiesLabel = __instance.PropertiesLabel;
			propertiesLabel.text = propertiesLabel.text + "\nOrders: " + Describe(profile);
			if (!selectedNPC.RelationData.Unlocked)
			{
				string text = DescribePreferences(component.CustomerData);
				if (text != null)
				{
					Text propertiesLabel2 = __instance.PropertiesLabel;
					propertiesLabel2.text = propertiesLabel2.text + "\nPrefers: " + text;
				}
			}
		}

		private static string DescribePreferences(CustomerData data)
		{
			if (data.DefaultAffinityData == null || data.DefaultAffinityData.ProductAffinities == null)
			{
				return null;
			}
			List<string> list = (from a in (from a in data.DefaultAffinityData.ProductAffinities.ToList<ProductTypeAffinity>()
					where Mathf.Abs(a.Affinity) >= 0.05f
					orderby Mathf.Abs(a.Affinity) descending
					select a).Take(3)
				select $"{a.DrugType} {Mathf.RoundToInt(a.Affinity * 100f).ToString("+0;-0;0")}%").ToList();
			return (list.Count > 0) ? string.Join(", ", list) : null;
		}

		private static string Describe(OrderPatternProfile profile)
		{
			string text = string.Join(", ", profile.OrderDays.Select((EDay d) => DayAbbr[d]));
			OrderPatternArchetype archetype = profile.Archetype;
			if (1 == 0)
			{
			}
			string text2 = archetype switch
			{
				OrderPatternArchetype.EveryThreeDays => "every few days", 
				OrderPatternArchetype.TwiceWeekly => "twice weekly", 
				OrderPatternArchetype.Weekly => "weekly bulk", 
				_ => "varies", 
			};
			if (1 == 0)
			{
			}
			string text3 = text2;
			return text + " (" + text3 + ")";
		}
	}
	[HarmonyPatch(typeof(Customer), "CurrentContractEnded")]
	public class CustomerNextOrderMessagePatch
	{
		private static readonly string[] DayNames = new string[7] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };

		private static readonly Dictionary<string, int> _lastAnnouncedMinSum = new Dictionary<string, int>();

		[HarmonyPostfix]
		public static void Postfix(Customer __instance, EQuestState outcome)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_0158: 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_0168: Expected I4, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled || !configuration.OrderPatterns.AnnounceNextOrder || (int)outcome != 2 || !InstanceFinder.IsServer || (Object)(object)__instance == (Object)null || (Object)(object)__instance.CustomerData == (Object)null || (Object)(object)__instance.NPC == (Object)null || (Object)(object)__instance.AssignedDealer != (Object)null)
			{
				return;
			}
			string name = ((Object)__instance.CustomerData).name;
			GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
			int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
			if (_lastAnnouncedMinSum.TryGetValue(name, out var value) && value == minSum)
			{
				return;
			}
			_lastAnnouncedMinSum[name] = minSum;
			if (configuration.OrderPatterns.Enabled && !((Object)(object)NetworkSingleton<LevelManager>.Instance == (Object)null) && configuration.OrderPatterns.RankMet())
			{
				OrderPatternProfile orderPatternProfile = OrderPatternProfile.Create(name, __instance.CustomerData.MinOrdersPerWeek, __instance.CustomerData.MaxOrdersPerWeek);
				EDay currentDay = NetworkSingleton<TimeManager>.Instance.CurrentDay;
				string newValue = DayPhrase((int)currentDay, orderPatternProfile.DaysUntilNextOrder(currentDay));
				string text = configuration.OrderPatterns.NextOrderTemplates.PickRandom();
				if (!string.IsNullOrEmpty(text))
				{
					string text2 = text.Replace("##DAY##", newValue);
					NetworkSingleton<MessagingManager>.Instance.ReceiveMessage(new Message(text2, (ESenderType)1, false, -1), true, __instance.NPC.ID);
					Log.Info($"[Lithium] Next-order text sent to {name}: \"{text2}\"");
				}
			}
		}

		private static string DayPhrase(int today, int delta)
		{
			if (delta == 1)
			{
				return "tomorrow";
			}
			string text = DayNames[(today + delta) % 7];
			return (today + delta >= 7) ? ("next " + text) : ("on " + text);
		}
	}
	[HarmonyPatch(typeof(Customer), "SetOfferedContract")]
	public class CustomerOfferDeadlinePatch
	{
		[HarmonyPostfix]
		public static void Postfix(Customer __instance)
		{
			//IL_0089: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null || !InstanceFinder.IsServer)
			{
				return;
			}
			ContractInfo offeredContractInfo = __instance.OfferedContractInfo;
			if (offeredContractInfo != null && offeredContractInfo.Expires && offeredContractInfo.Products != null)
			{
				GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
				int totalQuantity = ProductHelper.GetTotalQuantity(offeredContractInfo.Products);
				if (totalQuantity > 0)
				{
					int oFFER_EXPIRY_TIME_MINS = Customer.OFFER_EXPIRY_TIME_MINS;
					int num = (acceptanceWindow.Enabled ? OfferAcceptanceWindow.Extend(oFFER_EXPIRY_TIME_MINS, totalQuantity, acceptanceWindow) : oFFER_EXPIRY_TIME_MINS);
					OfferDeadlineTracker.Set(((Object)__instance.CustomerData).name, minSum + num);
					__instance.OfferedContractTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				}
			}
		}
	}
	[HarmonyPatch(typeof(MessagesApp), "SetCurrentConversation")]
	public class GhostOfferRegenerationPatch
	{
		private static string _lastName = string.Empty;

		private static int _lastMin = int.MinValue;

		[HarmonyPostfix]
		public static void Postfix(MSGConversation conversation)
		{
			//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)
			try
			{
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				if (!configuration.Enabled || !configuration.Contracts.Enabled || !InstanceFinder.IsServer || conversation == null || (Object)(object)conversation.sender == (Object)null)
				{
					return;
				}
				Customer val = FindCustomerByNpc(conversation.sender);
				if ((Object)(object)val == (Object)null || (Object)(object)val.CustomerData == (Object)null || val.OfferedContractInfo != null || (Object)(object)val.CurrentContract != (Object)null)
				{
					return;
				}
				string name = ((Object)val.CustomerData).name;
				if (!string.IsNullOrEmpty(name) && OfferDeadlineTracker.TryGet(name, out var deadlineMinSum))
				{
					GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
					int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
					if (minSum >= deadlineMinSum)
					{
						OfferDeadlineTracker.Clear(name);
					}
					else if (!(_lastName == name) || _lastMin != minSum)
					{
						_lastName = name;
						_lastMin = minSum;
						OfferDeadlineTracker.Clear(name);
						Log.Info($"[Customers] Regenerating ghost offer for {name} (offer lost, {deadlineMinSum - minSum} min still left on its window).");
						val.ForceDealOffer();
					}
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] Ghost-offer regeneration failed: {value}");
			}
		}

		private static Customer FindCustomerByNpc(NPC npc)
		{
			List<Customer> unlockedCustomers = Customer.UnlockedCustomers;
			if (unlockedCustomers == null)
			{
				return null;
			}
			IntPtr pointer = ((Il2CppObjectBase)npc).Pointer;
			for (int i = 0; i < unlockedCustomers.Count; i++)
			{
				Customer val = unlockedCustomers[i];
				if ((Object)(object)val != (Object)null && (Object)(object)val.NPC != (Object)null && ((Il2CppObjectBase)val.NPC).Pointer == pointer)
				{
					return val;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(Customer), "NotifyPlayerOfContract")]
	public class CustomerOfferDeadlineMessagePatch
	{
		private static readonly string[] DayNames = new string[7] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };

		[HarmonyPrefix]
		public static void Prefix(Customer __instance, ContractInfo contract, MessageChain offerMessage)
		{
			//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_00e7: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			AcceptanceWindow acceptanceWindow = configuration.Contracts.AcceptanceWindow;
			if (acceptanceWindow == null || contract == null || !contract.Expires)
			{
				return;
			}
			int totalQuantity = ProductHelper.GetTotalQuantity(contract.Products);
			int num = Customer.OFFER_EXPIRY_TIME_MINS;
			if (acceptanceWindow.Enabled)
			{
				num = OfferAcceptanceWindow.Extend(num, totalQuantity, acceptanceWindow);
			}
			RepairTrackedDeadline(__instance, acceptanceWindow, num, totalQuantity);
			if (!acceptanceWindow.SendDeadlineMessage || offerMessage == null || offerMessage.Messages == null)
			{
				return;
			}
			string[] offerDeadlineTemplates = acceptanceWindow.OfferDeadlineTemplates;
			if (offerDeadlineTemplates == null || offerDeadlineTemplates.Length == 0)
			{
				return;
			}
			GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
			GameDateTime deadline = ((GameDateTime)(ref dateTime)).AddMins(num);
			int num2 = (((GameDateTime)(ref deadline)).GetMinSum() % offerDeadlineTemplates.Length + offerDeadlineTemplates.Length) % offerDeadlineTemplates.Length;
			string text = offerDeadlineTemplates[num2].Replace("##QUANTITY##", totalQuantity.ToString()).Replace("##DEADLINE##", FormatDeadline(deadline));
			Enumerator<string> enumerator = offerMessage.Messages.GetEnumerator();
			while (enumerator.MoveNext())
			{
				string current = enumerator.Current;
				if (current == text)
				{
					return;
				}
			}
			Log.Info($"[Lithium] Offer deadline: {num} min window (base {Customer.OFFER_EXPIRY_TIME_MINS}, qty {totalQuantity}) -> {FormatDeadline(deadline)}");
			offerMessage.Messages.Add(text);
		}

		private static void RepairTrackedDeadline(Customer customer, AcceptanceWindow window, int windowMins, int quantity)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!window.Enabled || quantity <= 0 || !InstanceFinder.IsServer)
			{
				return;
			}
			object obj;
			if (customer == null)
			{
				obj = null;
			}
			else
			{
				CustomerData customerData = customer.CustomerData;
				obj = ((customerData != null) ? ((Object)customerData).name : null);
			}
			string text = (string)obj;
			if (!string.IsNullOrEmpty(text))
			{
				GameDateTime dateTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
				int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
				if (!OfferDeadlineTracker.TryGet(text, out var deadlineMinSum) || deadlineMinSum <= minSum)
				{
					OfferDeadlineTracker.Set(text, minSum + windowMins);
					Log.Info($"[Customers] Repaired offer deadline for {text} at announce: +{windowMins} min (qty {quantity}).");
				}
			}
		}

		private static string FormatDeadline(GameDateTime deadline)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0062: 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_0066: 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_006a: Expected I4, but got Unknown
			int num = deadline.elapsedDays - NetworkSingleton<TimeManager>.Instance.ElapsedDays;
			string text = Format12Hour(deadline.time);
			if (num <= 0)
			{
				return "today, " + text;
			}
			if (num == 1)
			{
				return "tomorrow, " + text;
			}
			int num2 = ((NetworkSingleton<TimeManager>.Instance.CurrentDay + num) % 7 + 7) % 7;
			string text2 = DayNames[num2];
			return (num < 7) ? (text2 + ", " + text) : $"{text2} ({num} days), {text}";
		}

		private static string Format12Hour(int hhmm)
		{
			int num = hhmm / 100;
			int value = hhmm % 100;
			string value2 = ((num >= 12) ? "PM" : "AM");
			int num2 = num % 12;
			if (num2 == 0)
			{
				num2 = 12;
			}
			return $"{num2}:{value:D2} {value2}";
		}
	}
	[HarmonyPatch(typeof(TimeManager), "PassMinute")]
	public class CustomerDailyNotificationPatch
	{
		[HarmonyPostfix]
		public static void Postfix(TimeManager __instance)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled || (!configuration.Contracts.SendNotification && !configuration.Contracts.SendNotificationForDealers))
			{
				return;
			}
			int num = configuration.Contracts.NotificationWindowStartHour * 60;
			int num2 = configuration.Contracts.NotificationWindowEndHour * 60;
			if (!InstanceFinder.IsServer || (Object)(object)NetworkSingleton<LevelManager>.Instance == (Object)null || NetworkSingleton<LevelManager>.Instance.TotalXP < configuration.Contracts.XPRequired)
			{
				return;
			}
			int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(__instance.CurrentTime);
			uint num3 = (uint)(num2 - num);
			foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item.CustomerData == (Object)null)
				{
					continue;
				}
				int num4 = num + (int)((uint)StableHash.Compute(((Object)item.CustomerData).name) % num3);
				if (minSumFrom24HourTime != num4)
				{
					continue;
				}
				List<string> list = (from p in item.CustomerData.PreferredProperties.ToList<Effect>()
					select p.Name).ToList();
				if (list.Count == 0)
				{
					continue;
				}
				if ((Object)(object)item.AssignedDealer != (Object)null)
				{
					item.DealerHasSuitableProduct(out var dealerItems);
					if (dealerItems.Count == 0)
					{
						CustomerNotifier.NotifyDealerNotSuitable(item);
					}
				}
				else if (ProductManager.ListedProducts.ToList<ProductDefinition>().Count == 0)
				{
					CustomerNotifier.NotifyPlayerProductsNotSuitable(item);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CustomerData), "GetOrderDays")]
	public class CustomerGetOrderDaysPatch
	{
		[HarmonyPostfix]
		public static void Postfix(CustomerData __instance, ref List<EDay> __result)
		{
			//IL_00d1: 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)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.Contracts.Enabled)
			{
				return;
			}
			if (configuration.OrderPatterns.Enabled && configuration.OrderPatterns.RankMet())
			{
				OrderPatternProfile orderPatternProfile = OrderPatternProfile.Create(((Object)__instance).name, __instance.MinOrdersPerWeek, __instance.MaxOrdersPerWeek);
				if (orderPatternProfile.OrderDays != null && orderPatternProfile.OrderDays.Count > 0)
				{
					__result = orderPatternProfile.OrderDays.ToIL2CPPList();
				}
			}
			if (configuration.Contracts.RetryNextDayOnRefusal && ContractRetryTracker.HasPendingRetry(((Object)__instance).name, out var retryDay))
			{
				List<EDay> list = ((__result != null) ? __result.ToList<EDay>() : new List<EDay>());
				if (!list.Contains(retryDay))
				{
					list.Add(retryDay);
					__result = list.ToIL2CPPList();
				}
			}
		}
	}
	[HarmonyPatch(typeof(TimeManager), "OnTimeSkip_Client")]
	public class CustomerMissedOrderCatchupPatch
	{
		private const int RecentDealCooldownMinutes = 780;

		[HarmonyPostfix]
		public static void Postfix(int oldTime, int newTime)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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)
			try
			{
				if (!InstanceFinder.IsServer)
				{
					return;
				}
				ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
				if (!configuration.Enabled || !configuration.Contracts.Enabled || !configuration.OrderPatterns.Enabled || !configuration.OrderPatterns.CatchUpMissedOrders || !configuration.OrderPatterns.RankMet())
				{
					return;
				}
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(oldTime);
				int minSumFrom24HourTime2 = TimeManager.GetMinSumFrom24HourTime(newTime);
				if (minSumFrom24HourTime == minSumFrom24HourTime2)
				{
					return;
				}
				bool flag = minSumFrom24HourTime2 < minSumFrom24HourTime;
				EDay currentDay = instance.CurrentDay;
				EDay val = (EDay)(flag ? ((currentDay - 1 + 7) % 7) : currentDay);
				foreach (Customer item in Customer.UnlockedCustomers.ToList<Customer>())
				{
					try
					{
						if (MissedOrderWindow(item, val, currentDay, minSumFrom24HourTime, minSumFrom24HourTime2, flag))
						{
							item.ForceDealOffer();
							if (item.OfferedContractInfo != null)
							{
								DailyOrderTracker.RecordCatchUp(((Object)item.CustomerData).name);
							}
							if (Log.DebugEnabled)
							{
								Log.Info($"[Customers] Sleep catch-up: re-offered {item.NPC.fullName}'s missed {val} order in the morning ({oldTime} -> {newTime}).");
							}
						}
					}
					catch (Exception ex)
					{
						Log.Warning("[Customers] Missed-order catch-up failed for a customer: " + ex.Message);
					}
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Customers] Missed-order catch-up failed: {value}");
			}
		}

		private static bool MissedOrderWindow(Customer customer, EDay oldDay, EDay newDay, int oldMin, int newMin, bool dayRolled)
		{
			//IL_0116: 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)
			if ((Object)(object)customer == (Object)null || (Object)(object)customer.CustomerData == (Object)null || (Object)(object)customer.NPC == (Object)null)
			{
				return false;
			}
			if (customer.NPC.RelationData == null || !customer.NPC.RelationData.Unlocked)
			{
				return false;
			}
			if (customer.OfferedContractInfo != null || (Object)(object)customer.CurrentContract != (Object)null)
			{
				return false;
			}
			if (!customer.NPC.IsConscious)
			{
				return false;
			}
			if (customer.TimeSinceLastDealOffered < 780 || customer.TimeSinceLastDealCompleted < 780)
			{
				return false;
			}
			CustomerData customerData = customer.CustomerData;
			float num = customer.NPC.RelationData.RelationDelta / 5f;
			List<EDay> list = customerData.GetOrderDays(customer.CurrentAddiction, num).ToList<EDay>();
			int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(customerData.OrderTime);
			int num2 = minSumFrom24HourTime + 120;
			if (list.Contains(oldDay))
			{
				if (dayRolled)
				{
					if (num2 > oldMin)
					{
						return true;
					}
				}
				else if (oldMin < num2 && num2 <= newMin)
				{
					return true;
				}
			}
			if (dayRolled && list.Contains(newDay) && num2 <= newMin)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Customer), "GetOfferSuccessChance")]
	public class CustomerOfferSuccessPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Customer __instance, List<ItemInstance> items, ref float askingPrice, ref float __result)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled)
			{
				return true;
			}
			if (!OfferTimingGate.AcceptsOfferNow(__instance, configuration))
			{
				__result = 0f;
				return false;
			}
			ApplyPriceTolerance(__instance, configuration, ref askingPrice);
			if (!configuration.DirectSales.RequireEffectMatch)
			{
				return true;
			}
			List<string> list = (from p in __instance.CustomerData.PreferredProperties.ToList<Effect>()
				select p.Name).ToList();
			if (list.Count == 0)
			{
				return true;
			}
			bool flag = false;
			Enumerator<ItemInstance> enumerator = items.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemInstance current = enumerator.Current;
				ProductDefinition val = ((Il2CppObjectBase)current.Definition).TryCast<ProductDefinition>();
				if ((Object)(object)val != (Object)null && ProductHelper.ProductMatchesDesires(val, list))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				__result = 0f;
				return false;
			}
			return true;
		}

		private static void ApplyPriceTolerance(Customer customer, ModCustomersConfiguration config, ref float askingPrice)
		{
			float priceToleranceMultiplier = config.DirectSales.PriceToleranceMultiplier;
			if (priceToleranceMultiplier <= 0f)
			{
				return;
			}
			float num = priceToleranceMultiplier;
			float priceToleranceJitter = config.DirectSales.PriceToleranceJitter;
			if (priceToleranceJitter > 0f)
			{
				num = priceToleranceMultiplier * (1f + DeterministicJitter(customer, priceToleranceJitter));
			}
			if (!(num <= 0f) && !Mathf.Approximately(num, 1f))
			{
				askingPrice /= num;
				if (Log.DebugEnabled)
				{
					Log.Info($"DirectSales: price tolerance {num:0.###}x -> perceived asking price {askingPrice:0.##}");
				}
			}
		}

		private static float DeterministicJitter(Customer customer, float range)
		{
			int num = (((Object)(object)NetworkSingleton<TimeManager>.Instance != (Object)null) ? NetworkSingleton<TimeManager>.Instance.ElapsedDays : 0);
			string text = (((Object)(object)customer != (Object)null && (Object)(object)customer.NPC != (Object)null) ? customer.NPC.ID : string.Empty);
			uint num2 = 2166136261u;
			string text2 = text;
			foreach (char c in text2)
			{
				num2 ^= c;
				num2 *= 16777619;
			}
			num2 ^= (uint)num;
			num2 *= 16777619;
			float num3 = (float)(num2 & 0xFFFFFF) / 16777216f;
			return (num3 * 2f - 1f) * range;
		}
	}
	[HarmonyPatch(typeof(Customer), "ProcessHandoverServerSide")]
	public static class CustomerCompletionTrackPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Customer __instance, EHandoverOutcome outcome)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			try
			{
				if (InstanceFinder.IsServer && (int)outcome == 1 && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.CustomerData == (Object)null))
				{
					DailyOrderTracker.RecordCompletion(((Object)__instance.CustomerData).name);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Customers] Daily completion tracking failed: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "ProcessHandoverServerSide")]
	public static class CustomerProcessHandoverPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Customer __instance, List<ItemInstance> items, bool handoverByPlayer, ref float totalPayment)
		{
			ModCustomers modCustomers = Core.Get<ModCustomers>();
			if (modCustomers == null)
			{
				return;
			}
			ModCustomersConfiguration configuration = modCustomers.Configuration;
			if (!configuration.Enabled || !configuration.EffectBonus.Enabled || (!handoverByPlayer && !configuration.EffectBonus.AffectsDealers))
			{
				return;
			}
			Contract currentContract = __instance.CurrentContract;
			if ((Object)(object)currentContract == (Object)null || items == null)
			{
				return;
			}
			List<ItemInstance> items2 = items.ToList<ItemInstance>();
			float num = 0f;
			foreach (IBonusPaymentHandler bonusPaymentHandler in modCustomers.BonusPaymentHandlers)
			{
				if (bonusPaymentHandler.TryCalculateBonus(__instance, currentContract, items2, out var boni))
				{
					float num2 = boni.Sum((BonusPayment b) => b.Amount);
					if (num2 > 0f)
					{
						num += num2;
					}
				}
			}
			if (!(num <= 0f))
			{
				totalPayment = Mathf.Clamp(totalPayment + num, 0f, float.MaxValue);
				Log.Info($"[Lithium] Effect match bonus applied: +{num} (new payout {totalPayment})");
			}
		}
	}
	[HarmonyPatch(typeof(HandoverScreen), "Start")]
	public static class HandoverSlotCountPatch
	{
		private const int VanillaSlotCount = 4;

		private const int MaxSlotCount = 12;

		private static readonly MethodInfo CustomerItemsChanged = AccessTools.Method(typeof(HandoverScreen), "CustomerItemsChanged", (Type[])null, (Type[])null);

		private static readonly List<Action> RootedHandlers = new List<Action>();

		[HarmonyPostfix]
		public static void Postfix(HandoverScreen __instance)
		{
			//IL_0130: 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_0170: Expected O, but got Unknown
			try
			{
				ModCustomers modCustomers = Core.Get<ModCustomers>();
				if (modCustomers == null)
				{
					return;
				}
				int num = Mathf.Clamp(modCustomers.Configuration.HandoverSlotCount, 4, 12);
				Il2CppReferenceArray<ItemSlot> customerSlots = __instance.CustomerSlots;
				Il2CppReferenceArray<ItemSlotUI> customerSlotUIs = __instance.CustomerSlotUIs;
				if (customerSlots == null || customerSlotUIs == null)
				{
					return;
				}
				int length = ((Il2CppArrayBase<ItemSlot>)(object)customerSlots).Length;
				if (num <= length || ((Il2CppArrayBase<ItemSlotUI>)(object)customerSlotUIs).Length < length)
				{
					return;
				}
				ItemSlotUI val = ((Il2CppArrayBase<ItemSlotUI>)(object)customerSlotUIs)[length - 1];
				Transform customerSlotContainer = (Transform)(object)__instance.CustomerSlotContainer;
				if ((Object)(object)val == (Object)null || (Object)(object)customerSlotContainer == (Object)null)
				{
					return;
				}
				Il2CppReferenceArray<ItemSlot> val2 = new Il2CppReferenceArray<ItemSlot>((long)num);
				Il2CppReferenceArray<ItemSlotUI> val3 = new Il2CppReferenceArray<ItemSlotUI>((long)num);
				for (int i = 0; i < length; i++)
				{
					((Il2CppArrayBase<ItemSlot>)(object)val2)[i] = ((Il2CppArrayBase<ItemSlot>)(object)customerSlots)[i];
					((Il2CppArrayBase<ItemSlotUI>)(object)val3)[i] = ((Il2CppArrayBase<ItemSlotUI>)(object)customerSlotUIs)[i];
				}
				for (int j = length; j < num; j++)
				{
					GameObject val4 = Object.Instantiate<GameObject>(((Component)val).gameObject, customerSlotContainer);
					((Object)val4).name = "CustomerSlot_Lithium_" + j;
					val4.transform.localScale = Vector3.one;
					val4.SetActive(true);
					ItemSlotUI component = val4.GetComponent<ItemSlotUI>();
					if ((Object)(object)component == (Object)null)
					{
						Object.Destroy((Object)(object)val4);
						return;
					}
					ItemSlot val5 = new ItemSlot();
					val5.onItemDataChanged = MakeScreenHandler(__instance);
					component.AssignSlot(val5);
					((Il2CppArrayBase<ItemSlot>)(object)val2)[j] = val5;
					((Il2CppArrayBase<ItemSlotUI>)(object)val3)[j] = component;
				}
				__instance.CustomerSlots = val2;
				__instance.CustomerSlotUIs = val3;
				Log.Info($"[Lithium] Handover screen expanded from {length} to {num} customer slots.");
			}
			catch (Exception value)
			{
				Log.Error($"[Lithium] HandoverSlotCountPatch failed: {value}");
			}
		}

		private static Action MakeScreenHandler(HandoverScreen screen)
		{
			if (CustomerItemsChanged == null)
			{
				return null;
			}
			Action action = delegate
			{
				try
				{
					CustomerItemsChanged.Invoke(screen, null);
				}
				catch (Exception value)
				{
					Log.Error($"[Lithium] handover CustomerItemsChanged failed: {value}");
				}
			};
			RootedHandlers.Add(action);
			return DelegateSupport.ConvertDelegate<Action>((Delegate)action);
		}
	}
	[HarmonyPatch(typeof(Customer), "GetSampleSuccess")]
	public class CustomerSampleSuccessPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Customer __instance, List<ItemInstance> items, float price, ref float __result)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.Enabled || !configuration.SampleOffering.Enabled)
			{
				return true;
			}
			if (!configuration.SampleOffering.RankMet())
			{
				Log.Info("Sample offering: below configured rank - using vanilla acceptance calculation.");
				return true;
			}
			float num = 0f;
			Enumerator<ItemInstance> enumerator = items.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemInstance current = enumerator.Current;
				ProductDefinition val = ((Il2CppObjectBase)current.Definition).TryCast<ProductDefinition>();
				ProductItemInstance val2 = ((Il2CppObjectBase)current).TryCast<ProductItemInstance>();
				string[] desires = ProductHelper.GetDesireNames(__instance.CustomerData).ToArray();
				string[] effects = (from p in ((PropertyItemDefinition)val).Properties.ToList<Effect>()
					select p.Name).ToArray();
				num += SuccessChanceCalculator.CalculateSuccess(val.DrugType, ((QualityItemInstance)val2).Quality, configuration.SampleOffering.QualityLevelModifier, __instance.CustomerData.Standards, desires, effects, __instance.CustomerData.DefaultAffinityData, configuration.SampleOffering.IncludeDrugPreference, configuration.SampleOffering.BaseAcceptance, configuration.SampleOffering.RequireEffectMatch, configuration.SampleOffering.MaxQualityOverDeliveryLevels, configuration.SampleOffering.DrugAffinitySharpness);
			}
			__result = num / (float)items.Count;
			return false;
		}
	}
	[HarmonyPatch(typeof(ProductManager), "SetProductListed", new Type[]
	{
		typeof(string),
		typeof(bool)
	})]
	public class ProductListingPatch
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			if (ShouldRun())
			{
				ProductCoverageNotifier.EnsureBaseline();
			}
		}

		[HarmonyPostfix]
		public static void Postfix()
		{
			if (ShouldRun())
			{
				ProductCoverageNotifier.ReportChange();
				if (Core.Get<ModCustomers>().Configuration.Coverage.NotifyNoDealerCustomers)
				{
					DealerCoverageNotifier.ReportNoDealerChange();
				}
			}
		}

		private static bool ShouldRun()
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			return configuration.Enabled && configuration.Coverage.Enabled && InstanceFinder.IsServer;
		}
	}
	[HarmonyPatch(typeof(DeliveryApp), "SetOpen")]
	public class DeliveryAppPatch
	{
		[HarmonyPrefix]
		public static void Prefix(ref bool open, DeliveryApp __instance)
		{
			ModShops modShops = Core.Get<ModShops>();
			if (modShops == null || !modShops.Configuration.Enabled)
			{
				return;
			}
			ModShopsConfiguration configuration = Core.Get<ModShops>().Configuration;
			ModShopsConfiguration modShopsConfiguration = configuration;
			if (modShopsConfiguration.Deliveries == null)
			{
				Dictionary<string, DeliverySettings> dictionary = (modShopsConfiguration.Deliveries = new Dictionary<string, DeliverySettings>());
			}
			bool flag = false;
			foreach (DeliveryShop item in PlayerSingleton<DeliveryApp>.Instance.deliveryShops.ToList<DeliveryShop>())
			{
				if (!((Object)(object)((item != null) ? item.MatchingShop : null) == (Object)null) && !configuration.Deliveries.ContainsKey(item.MatchingShop.ShopName))
				{
					configuration.Deliveries[item.MatchingShop.ShopName] = new DeliverySettings
					{
						Availability = DeliveryAvailabilitySettings.Unchanged,
						DeliveryFee = item.GetDeliveryFee(),
						XPRequirement = 0
					};
					flag = true;
				}
			}
			if (flag)
			{
				configuration.SaveConfiguration();
			}
			DeliveryUtils.ApplyDeliveryOverrides();
		}
	}
	[HarmonyPatch(typeof(Dealer), "TradeItemsDone")]
	public class DealerInventoryClosePatch
	{
		[HarmonyPostfix]
		public static void Postfix(Dealer __instance)
		{
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (configuration.Enabled && configuration.Coverage.Enabled && configuration.Coverage.NotifyDealerInventoryOnClose && InstanceFinder.IsServer)
			{
				DealerCoverageNotifier.ReportForDealer(__instance);
			}
		}
	}
}
namespace Lithium.Modules.Customers.BonusPayments
{
	public class EffectCoverageBonus : IBonusPaymentHandler
	{
		public bool TryCalculateBonus(Customer customer, Contract contract, List<ItemInstance> items, out List<BonusPayment> boni)
		{
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Expected O, but got Unknown
			boni = new List<BonusPayment>();
			ModCustomersConfiguration configuration = Core.Get<ModCustomers>().Configuration;
			if (!configuration.EffectBonus.Enabled)
			{
				return false;
			}
			if (!configuration.EffectBonus.AffectsDealers && (Object)(object)contract.Dealer != (Object)null)
			{
				return false;
			}
			List<string> desireNames = ProductHelper.GetDesireNames(customer.CustomerData, toLower: true);
			if (desireNames.Count == 0 || items == null || items.Count == 0)
			{
				return false;
			}
			int num = items.ToList().Sum((ItemInstance i) => (i != null) ? ((BaseItemInstance)i).Quantity : 0);
			float num2 = 0f;
			foreach (ItemInstance item in items)
			{
				if (item == null)
				{
					continue;
				}
				ProductDefinition val = ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToList<ProductDefinition>()).SingleOrDefault((Func<ProductDefinition, bool>)((ProductDefinition p) => ((BaseItemDefinition)p).ID.Equals(((BaseItemInstance)item).ID)));
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				int num3 = (from p in ((PropertyItemDefinition)val).Properties.ToList<Effect>()
					select p.Name.ToLowerInvariant()).Intersect(desireNames).Count();
				if (num3 > 0)
				{
					if (1 == 0)
					{
					}
					EffectMatchBonus effectMatchBonus = num3 switch
					{
						1 => configuration.EffectBonus.OneCoveredEffect, 
						2 => configuration.EffectBonus.TwoCoveredEffects, 
						_ => configuration.EffectBonus.ThreeCoveredEffects, 
					};
					if (1 == 0)
					{
					}
					EffectMatchBonus effectMatchBonus2 = effectMatchBonus;
					int num4 = Mathf.Max(1, ((BaseItemInstance)item).Quantity);
					int num5 = Mathf.Min(effectMatchBonus2.FixedBonusMin, effectMatchBonus2.FixedBonusMax);
					int num6 = Mathf.Max(effectMatchBonus2.FixedBonusMin, effectMatchBonus2.FixedBonusMax);
					float num7 = Mathf.Min(effectMatchBonus2.PercentageBonusMin, effectMatchBonus2.PercentageBonusMax);
					float num8 = Mathf.Max(effectMatchBonus2.PercentageBonusMin, effectMatchBonus2.PercentageBonusMax);
					int num9 = ((num6 > num5) ? Random.Range(num5, num6 + 1) : num5);
					float num10 = ((num8 > num7) ? Random.Range(num7, num8) : num7);
					float num11 = num9 * num4;
					float num12 = (float)num4 / (float)num;
					float num13 = contract.Payment * (num10 / 100f) * num12;
					float num14 = num11 + num13;
					num2 += num14;
					Log.Info($"Effect match boni for item {((BaseItemDefinition)val).Name}: x{num4} (matches: {num3}) Fixed: {num11} Percent: {num13} Total: {num14}");
				}
			}
			if (num2 <= 0f)
			{
				return false;
			}
			boni.Add(new BonusPayment("Effect Match Bonus", num2));
			return true;
		}
	}
}
namespace Lithium.Modules.Customers.Behaviours
{
	public class CustomerNotificationState : MonoBehaviour
	{
		public float LastNotification;
	}
}
namespace Lithium.Modules.Customers.Architecture
{
	public interface IBonusPaymentHandler
	{
		bool TryCalculateBonus(Customer customer, Contract contract, List<ItemInstance> items, out List<BonusPayment> boni);
	}
	public static class ContractRetryTracker
	{
		private static readonly SaveSlotStore<EDay> Store = new SaveSlotStore<EDay>("ContractRetries", "contract retries");

		public static void FlagForRetry(string customerName)
		{
			//IL_0012: 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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected I4, but got Unknown
			if (!string.IsNullOrEmpty(customerName))
			{
				int num = (NetworkSingleton<TimeManager>.Instance.CurrentDay + 1) % 7;
				Store.Set(customerName, (EDay)num);
			}
		}

		public static bool IsRetryDay(string customerName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			EDay value;
			return Store.TryGet(customerName, out value) && value == NetworkSingleton<TimeManager>.Instance.CurrentDay;
		}

		public static bool HasPendingRetry(string customerName, out EDay retryDay)
		{
			return Store.TryGet(customerName, out retryDay);
		}

		public static void Clear(string customerName)
		{
			Store.Remove(customerName);
		}

		public static void Unload()
		{
			Store.Unload();
		}
	}
	public static class DailyOrderTracker
	{
		private static readonly SaveSlotStore<int> CompletedDay = new SaveSlotStore<int>("DailyOrderCompleted", "daily order completions");

		private static readonly SaveSlotStore<int> CaughtUpDay = new SaveSlotStore<int>("DailyOrderCatchups", "daily order catch-ups");

		private static int Today => GameDay.CurrentIndex;

		public static void RecordCompletion(string customerName)
		{
			if (!string.IsNullOrEmpty(customerName))
			{
				CompletedDay.Set(customerName, Today);
			}
		}

		public static void RecordCatchUp(string customerName)
		{
			if (!string.IsNullOrEmpty(customerName))
			{
				CaughtUpDay.Set(customerName, Today);
			}
		}

		public static bool CompletedToday(string customerName)
		{
			int value;
			return !string.IsNullOrEmpty(customerName) && CompletedDay.TryGet(customerName, out value) && value == Today;
		}

		public static bool CaughtUpToday(string customerName)
		{
			int value;
			return !string.IsNullOrEmpty(customerName) && CaughtUpDay.TryGet(customerName, out value) && value == Today;
		}

		public static void Unload()
		{
			CompletedDay.Unload();
			CaughtUpDay.Unload();
		}
	}
	public enum OrderPatternArchetype
	{
		EveryThreeDays,
		TwiceWeekly,
		Weekly
	}
	public class OrderPatternProfile
	{
		private static readonly Dictionary<string, OrderPatternProfile> _cache = new Dictionary<string, OrderPatternProfile>();

		public OrderPatternArchetype Archetype { get; private set; }

		public List<EDay> OrderDays { get; private set; }

		public float QuantityMultiplier { get; private set; }

		public int DaysUntilNextOrder(EDay today)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Expected I4, but got Unknown
			//IL_0016: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0023: 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_0028: Expected I4, but got Unknown
			int num = (int)today;
			int num2 = 7;
			foreach (EDay orderDay in OrderDays)
			{
				int num3 = ((orderDay - num) % 7 + 7) % 7;
				if (num3 == 0)
				{
					num3 = 7;
				}
				if (num3 < num2)
				{
					num2 = num3;
				}
			}
			return num2;
		}

		public float IntervalFractionElapsed(float weekPosition)
		{
			//IL_001f: 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_0030: 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_0035: Expected I4, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected I4, but got Unknown
			//IL_003c: 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_0041: Expected I4, but got Unknown
			float num = float.NegativeInfinity;
			float num2 = float.PositiveInfinity;
			foreach (EDay orderDay in OrderDays)
			{
				int[] array = new int[3]
				{
					orderDay - 7,
					(int)orderDay,
					orderDay + 7
				};
				foreach (float num3 in array)
				{
					if (num3 <= weekPosition && num3 > num)
					{
						num = num3;
					}
					if (num3 > weekPosition && num3 < num2)
					{
						num2 = num3;
					}
				}
			}
			float num4 = num2 - num;
			if (num4 <= 0f || float.IsInfinity(num4))
			{
				return 1f;
			}
			float num5 = (weekPosition - num) / num4;
			return (num5 < 0f) ? 0f : ((num5 > 1f) ? 1f : num5);
		}

		public static void ClearCache()
		{
			_cache.Clear();
		}

		public static OrderPatternProfile Create(string customerName, int minOrdersPerWeek, int maxOrdersPerWeek)
		{
			string key = customerName ?? string.Empty;
			if (_cache.TryGetValue(key, out var value))
			{
				return value;
			}
			int num = StableHash.Compute(customerName);
			Random rng = new Random(num);
			int num2 = Math.Clamp((int)Math.Round((double)(minOrdersPerWeek + maxOrdersPerWeek) / 2.0), 1, 7);
			OrderPatternArchetype archetype = PickArchetype(rng);
			List<EDay> list = BuildDays(archetype, rng);
			if (list.Count == 0)
			{
				list.Add((EDay)((num % 7 + 7) % 7));
			}
			float num3 = Math.Max(0f, Core.Get<ModCustomers>().Configuration.OrderPatterns.BulkOrderSizeFactor);
			OrderPatternProfile orderPatternProfile = new OrderPatternProfile
			{
				Archetype = archetype,
				OrderDays = list,
				QuantityMultiplier = (float)num2 / (float)list.Count * num3
			};
			_cache[key] = orderPatternProfile;
			return orderPatternProfile;
		}

		private static OrderPatternArchetype PickArchetype(Random rng)
		{
			OrderPatternWeights archetypeWeights = Core.Get<ModCustomers>().Configuration.OrderPatterns.ArchetypeWeights;
			WeightedPicker<OrderPatternArchetype> weightedPicker = new WeightedPicker<OrderPatternArchetype>(rng);
			weightedPicker.Add(OrderPatternArchetype.Weekly, Math.Max(0f, archetypeWeights.Weekly));
			weightedPicker.Add(OrderPatternArchetype.TwiceWeekly, Math.Max(0f, archetypeWeights.TwiceWeekly));
			weightedPicker.Add(OrderPatternArchetype.EveryThreeDays, Math.Max(0f, archetypeWeights.EveryThreeDays));
			return weightedPicker.Pick();
		}

		private static List<EDay> BuildDays(OrderPatternArchetype archetype, Random rng)
		{
			switch (archetype)
			{
			case OrderPatternArchetype.Weekly:
				return new List<EDay>(1) { (EDay)rng.Next(0, 7) };
			case OrderPatternArchetype.TwiceWeekly:
			{
				int num2 = rng.Next(0, 7);
				int b = (num2 + 3 + rng.Next(0, 2)) % 7;
				return Distinct(num2, b);
			}
			default:
			{
				int num = rng.Next(0, 3);
				List<EDay> list = new List<EDay>();
				for (int i = num; i < 7; i += 3)
				{
					list.Add((EDay)i);
				}
				return list;
			}
			}
		}

		private static List<EDay> Distinct(int a, int b)
		{
			List<int> list = ((a == b) ? new List<int>(1) { a } : new List<int>(2) { a, b });
			list.Sort();
			return list.Select((int d) => (EDay)d).ToList();
		}
	}
	internal static class OfferAcceptanceWindow
	{
		public const int AbsoluteMaxWindowMinutes = 8640;

		public static int Extend(int currentWindowMinutes, int quantity, AcceptanceWindow config)
		{
			int num = ((quantity > config.BaseQuantity) ? Mathf.Max(0, Mathf.RoundToInt((float)(quantity - config.BaseQuantity) * config.MinutesPerExtraUnit)) : 0);
			float num2 = Mathf.Max(0f, config.DurationMultiplier);
			int num3 = Mathf.RoundToInt((float)(currentWindowMinutes + num) * num2);
			int num4 = Mathf.Min(config.MaxWindowMinutes, 8640);
			num3 = Mathf.Max(num3, currentWindowMinutes);
			return Mathf.Min(num3, Mathf.Max(num4, currentWindowMinutes));
		}
	}
	internal static class OfferTimingGate
	{
		public static bool AcceptsOfferNow(Customer customer, ModCustomersConfiguration config)
		{
			float minIntervalFractionBeforeOffer = config.DirectSales.MinIntervalFractionBeforeOffer;
			if (minIntervalFractionBeforeOffer <= 0f)
			{
				return true;
			}
			if (!config.Contracts.Enabled || !config.OrderPatterns.Enabled || (Object)(object)NetworkSingleton<LevelManager>.Instance == (Object)null || NetworkSingleton<LevelManager>.Instance.TotalXP < config.Contracts.XPRequired)
			{
				return true;
			}
			if ((Object)(object)customer == (Object)null || (Object)(object)customer.CustomerData == (Object)null || (Object)(object)NetworkSingleton<TimeManager>.Instance == (Object)null)
			{
				return true;
			}
			OrderPatternProfile orderPatternProfile = OrderPatternProfile.Create(((Object)customer.CustomerData).name, customer.CustomerData.MinOrdersPerWeek, customer.CustomerData.MaxOrdersPerWeek);
			float num = orderPatternProfile.IntervalFractionElapsed(WeekPosition());
			return num >= minIntervalFractionBeforeOffer;
		}

		private static float WeekPosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected I4, but got Unknown
			int num = (int)NetworkSingleton<TimeManager>.Instance.CurrentDay;
			int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(NetworkSingleton<TimeManager>.Instance.CurrentTime);
			float num2 = (float)minSumFrom24HourTime / 1440f;
			if (num2 < 0f)
			{
				num2 = 0f;
			}
			else if (num2 > 0.999f)
			{
				num2 = 0.999f;
			}
			return (float)num + num2;
		}
	}
	internal static class OfferDeadlineTracker
	{
		private static readonly SaveSlotStore<int> Store = new SaveSlotStore<int>("OfferDeadlines", "offer deadlines");

		public static void Set(string customerName, int deadlineMinSum)
		{
			if (!string.IsNullOrEmpty(customerName))
			{
				Store.Set(customerName, deadlineMinSum);
			}
		}

		public static bool TryGet(string customerName, out int deadlineMinSum)
		{
			deadlineMinSum = 0;
			return !string.IsNullOrEmpty(customerName) && Store.TryGet(customerName, out deadlineMinSum);
		}

		public static bool Clear(string customerName)
		{
			if (string.IsNullOrEmpty(customerName))
			{
				return false;
			}
			return Store.Remove(customerName);
		}

		public static void Unload()
		{
			Store.Unload();
		}
	}
	internal static class SaveSlotKey
	{
		public static string Resolve()
		{
			try
			{
				LoadManager instance = Singleton<LoadManager>.Instance;
				string text = ((instance != null) ? instance.LoadedGameFolderPath : null);
				if (string.IsNullOrEmpty(text))
				{
					return null;
				}
				string name = new DirectoryInfo(text).Name;
				if (string.IsNullOrEmpty(name))
				{
					return null;
				}
				SaveInfo activeSaveInfo = instance.ActiveSaveInfo;
				string text2 = ((activeSaveInfo != null) ? activeSaveInfo.OrganisationName : null);
				if (string.IsNullOrWhiteSpace(text2))
				{
					return null;
				}
				return Sanitize(name + " - " + text2);
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] Failed to resolve save slot key: " + ex.Message);
				return null;
			}
		}

		private static string Sanitize(string raw)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				raw = raw.Replace(oldChar, '_');
			}
			return raw;
		}
	}
	internal interface IFlushableStore
	{
		void Flush();
	}
	internal static class SaveSlotStores
	{
		private static readonly List<IFlushableStore> Stores = new List<IFlushableStore>();

		public static void Register(IFlushableStore store)
		{
			if (store != null && !Stores.Contains(store))
			{
				Stores.Add(store);
			}
		}

		public static void FlushAll()
		{
			foreach (IFlushableStore store in Stores)
			{
				try
				{
					store.Flush();
				}
				catch (Exception ex)
				{
					Log.Warning("[Lithium] Store flush failed: " + ex.Message);
				}
			}
		}
	}
	internal sealed class SaveSlotStore<TValue> : IFlushableStore
	{
		private readonly string _storageFolder;

		private readonly string _label;

		private readonly string _fileDiscriminator;

		private Dictionary<string, TValue> _entries = new Dictionary<string, TValue>();

		private string _currentSaveKey;

		private bool _loaded;

		private bool _dirty;

		public SaveSlotStore(string folderName, string label, string fileDiscriminator = null)
		{
			_storageFolder = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium", folderName);
			_label = label;
			_fileDiscriminator = fileDiscriminator;
			SaveSlotStores.Register(this);
		}

		public bool TryGet(string key, out TValue value)
		{
			EnsureLoaded();
			return _entries.TryGetValue(key, out value);
		}

		public void Set(string key, TValue value)
		{
			EnsureLoaded();
			_entries[key] = value;
			_dirty = true;
		}

		public bool Remove(string key)
		{
			EnsureLoaded();
			if (!_entries.Remove(key))
			{
				return false;
			}
			_dirty = true;
			return true;
		}

		public void Unload()
		{
			_entries = new Dictionary<string, TValue>();
			_currentSaveKey = null;
			_loaded = false;
			_dirty = false;
		}

		public void Flush()
		{
			if (_dirty && _loaded)
			{
				Persist();
				_dirty = false;
			}
		}

		private void EnsureLoaded()
		{
			if (!_loaded)
			{
				string text = SaveSlotKey.Resolve();
				if (text != null)
				{
					_currentSaveKey = text;
					_entries = ReadFromDisk(text) ?? new Dictionary<string, TValue>();
					_loaded = true;
				}
			}
		}

		private void Persist()
		{
			if (_currentSaveKey == null)
			{
				_currentSaveKey = SaveSlotKey.Resolve();
			}
			if (_currentSaveKey == null)
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(_storageFolder);
				File.WriteAllText(FilePath(_currentSaveKey), JsonConvert.SerializeObject((object)_entries, (Formatting)1));
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] Failed to save " + _label + ": " + ex.Message);
			}
		}

		private Dictionary<string, TValue> ReadFromDisk(string key)
		{
			string path = FilePath(key);
			if (!File.Exists(path))
			{
				return null;
			}
			try
			{
				return JsonConvert.DeserializeObject<Dictionary<string, TValue>>(File.ReadAllText(path));
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] Failed to load " + _label + ": " + ex.Message);
				return null;
			}
		}

		private string FilePath(string key)
		{
			return Path.Combine(_storageFolder, string.IsNullOrEmpty(_fileDiscriminator) ? (key + ".json") : (key + " - " + _fileDiscriminator + ".json"));
		}
	}
}
namespace Lithium.Modules.Warehouse
{
	public class ModWarehouseConfiguration : ModuleConfiguration
	{
		[JsonConverter(typeof(StringEnumConverter))]
		public ERank RequiredRank = (ERank)1;

		public int RequiredRankTier = 1;

		public bool CloseDuringPursuit = true;

		public bool PreventInteriorGlitch = true;

		public override string Name => "Warehouse";

		public override void Validate()
		{
			if (RequiredRankTier < 1)
			{
				RequiredRankTier = 1;
			}
			if (RequiredRankTier > 5)
			{
				RequiredRankTier = 5;
			}
		}
	}
	public class ModWarehouse : ModuleBase<ModWarehouseConfiguration>
	{
		private Dictionary<int, List<DoorSensor>> _interiorSensorsByDoor;

		private bool _darkMarketResolved;

		public override void Apply()
		{
			_interiorSensorsByDoor = null;
			_darkMarketResolved = false;
		}

		public bool ShouldBlockInteriorOpen(DoorController door)
		{
			if ((Object)(object)door == (Object)null || !base.Configuration.PreventInteriorGlitch)
			{
				return false;
			}
			ResolveDarkMarketDoors();
			if (_interiorSensorsByDoor == null || !_interiorSensorsByDoor.TryGetValue(((Object)door).GetInstanceID(), out var value))
			{
				return false;
			}
			return !LocalPlayerInsideAny(value);
		}

		private static bool LocalPlayerInsideAny(List<DoorSensor> sensors)
		{
			Player local = Player.Local;
			if ((Object)(object)local == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)local).GetInstanceID();
			foreach (DoorSensor sensor in sensors)
			{
				if ((Object)(object)sensor == (Object)null)
				{
					continue;
				}
				List<Player> playersInContact = sensor.playersInContact;
				if (playersInContact == null)
				{
					continue;
				}
				for (int i = 0; i < playersInContact.Count; i++)
				{
					Player val = playersInContact[i];
					if ((Object)(object)val != (Object)null && ((Object)val).GetInstanceID() == instanceID)
					{
						return true;
					}
				}
			}
			return false;
		}

		private void ResolveDarkMarketDoors()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			if (_darkMarketResolved)
			{
				return;
			}
			DarkMarketAccessZone val = Object.FindObjectOfType<DarkMarketAccessZone>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			HashSet<int> hashSet = new HashSet<int>();
			Il2CppReferenceArray<DoorController> doors = ((AccessZone)val).Doors;
			if (doors != null)
			{
				for (int i = 0; i < ((Il2CppArrayBase<DoorController>)(object)doors).Count; i++)
				{
					DoorController val2 = ((Il2CppArrayBase<DoorController>)(object)doors)[i];
					if ((Object)(object)val2 != (Object)null)
					{
						hashSet.Add(((Object)val2).GetInstanceID());
					}
				}
			}
			Dictionary<int, List<DoorSensor>> dictionary = new Dictionary<int, List<DoorSensor>>();
			foreach (DoorSensor item in Object.FindObjectsOfType<DoorSensor>(true))
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item.Door == (Object)null || (int)item.DetectorSide > 0)
				{
					continue;
				}
				int instanceID = ((Object)item.Door).GetInstanceID();
				if (hashSet.Contains(instanceID))
				{
					if (!dictionary.TryGetValue(instanceID, out var value))
					{
						value = (dictionary[instanceID] = new List<DoorSensor>());
					}
					value.Add(item);
				}
			}
			_interiorSensorsByDoor = dictionary;
			_darkMarketResolved = true;
			Log.Info($"[Warehouse] Resolved {dictionary.Count} Dark Market door(s) with interior sensors for glitch guard.");
		}

		public bool RequirementMet()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return RankHelper.PlayerRankAtLeast(base.Configuration.RequiredRank, base.Configuration.RequiredRankTier, defaultWhenUnavailable: false);
		}

		public static bool AnyPlayerPursued()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			for (int i = 0; i < Player.PlayerList.Count; i++)
			{
				Player val = Player.PlayerList[i];
				if ((Object)(object)val != (Object)null && (Object)(object)val.CrimeData != (Object)null && (int)val.CrimeData.CurrentPursuitLevel > 0)
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace Lithium.Modules.Warehouse.Patches
{
	[HarmonyPatch(typeof(DarkMarket), "Update")]
	public class DarkMarketShouldBeOpenPatch
	{
		[HarmonyPostfix]
		public static void Postfix(DarkMarket __instance)
		{
			ModWarehouse modWarehouse = Core.Get<ModWarehouse>();
			if (modWarehouse != null && modWarehouse.Configuration.Enabled && modWarehouse.RequirementMet())
			{
				if (modWarehouse.Configuration.CloseDuringPursuit && ModWarehouse.AnyPlayerPursued())
				{
					__instance.IsOpen = false;
				}
				else
				{
					__instance.IsOpen = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(DarkMarketAccessZone), "GetIsOpen")]
	public class DarkMarketAccessZoneGetIsOpenPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ref bool __result)
		{
			ModWarehouse modWarehouse = Core.Get<ModWarehouse>();
			if (modWarehouse == null || !modWarehouse.Configuration.Enabled)
			{
				return true;
			}
			if (!modWarehouse.RequirementMet())
			{
				return true;
			}
			DarkMarket instance = NetworkSingleton<DarkMarket>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			__result = instance.IsOpen && instance.Unlocked;
			return false;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class DarkMarketInteriorAccessPatch
	{
		[HarmonyPostfix]
		public static void Postfix(DoorController __instance, EDoorSide side, ref bool __result)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			if (__result && (int)side <= 0)
			{
				ModWarehouse modWarehouse = Core.Get<ModWarehouse>();
				if (modWarehouse != null && modWarehouse.Configuration.Enabled && (int)__instance.PlayerAccess == 2 && modWarehouse.ShouldBlockInteriorOpen(__instance))
				{
					__result = false;
				}
			}
		}
	}
}
namespace Lithium.Modules.Weapons
{
	public class ModWeaponsConfiguration : ModuleConfiguration
	{
		public override string Name => "Weapons";

		public bool BlockPoliceLooting { get; set; } = true;

		public bool ZeroPawnValue { get; set; } = false;

		public bool MatchCombatItems { get; set; } = true;

		public List<string> ExtraWeaponIds { get; set; } = new List<string>();

		public List<string> IgnoredItemIds { get; set; } = new List<string>();
	}
	public class ModWeapons : ModuleBase<ModWeaponsConfiguration>
	{
		public override void Apply()
		{
			WeaponPawnValue.ReapplyAll();
		}
	}
	public static class WeaponMatcher
	{
		public static bool IsWeapon(ItemDefinition definition)
		{
			if ((Object)(object)definition == (Object)null)
			{
				return false;
			}
			ModWeapons modWeapons = Core.Get<ModWeapons>();
			if (modWeapons == null)
			{
				return false;
			}
			ModWeaponsConfiguration configuration = modWeapons.Configuration;
			string iD = ((BaseItemDefinition)definition).ID;
			if (configuration.IgnoredItemIds.Contains(iD))
			{
				return false;
			}
			if (configuration.ExtraWeaponIds.Contains(iD))
			{
				return true;
			}
			if (configuration.MatchCombatItems)
			{
				StorableItemDefinition val = ((Il2CppObjectBase)definition).TryCast<StorableItemDefinition>();
				if ((Object)(object)val != (Object)null && val.CombatUtility > 0f)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class WeaponPawnValue
	{
		private static readonly Dictionary<string, float> OriginalResell = new Dictionary<string, float>();

		public static Registry RegistryInstance;

		public static void ReapplyAll()
		{
			if ((Object)(object)RegistryInstance == (Object)null)
			{
				return;
			}
			ModWeapons modWeapons = Core.Get<ModWeapons>();
			if (modWeapons == null)
			{
				return;
			}
			ModWeaponsConfiguration configuration = modWeapons.Configuration;
			bool flag = configuration.Enabled && configuration.ZeroPawnValue;
			int num = 0;
			Enumerator<ItemRegister> enumerator = RegistryInstance.ItemRegistry.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemRegister current = enumerator.Current;
				StorableItemDefinition val = ((Il2CppObjectBase)current.Definition).TryCast<StorableItemDefinition>();
				if (!((Object)(object)val == (Object)null))
				{
					string iD = ((BaseItemDefinition)val).ID;
					if (!OriginalResell.ContainsKey(iD))
					{
						OriginalResell[iD] = val.ResellMultiplier;
					}
					bool flag2 = flag && WeaponMatcher.IsWeapon((ItemDefinition)(object)val);
					float num2 = (flag2 ? 0f : OriginalResell[iD]);
					if (val.ResellMultiplier != num2)
					{
						val.ResellMultiplier = num2;
					}
					if (flag2)
					{
						num++;
					}
				}
			}
			if (flag)
			{
				Log.Info($"[Weapons] Zeroed pawn value on {num} weapon definition(s).");
			}
		}
	}
}
namespace Lithium.Modules.Weapons.Patches
{
	[HarmonyPatch(typeof(Registry), "Start")]
	public class RegistryStartPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Registry __instance)
		{
			WeaponPawnValue.RegistryInstance = __instance;
			WeaponPawnValue.ReapplyAll();
		}
	}
	[HarmonyPatch(typeof(PickpocketScreen), "Open")]
	public class PickpocketBlockWeaponsPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PickpocketScreen __instance, NPC _npc)
		{
			ModWeapons modWeapons = Core.Get<ModWeapons>();
			if (modWeapons == null || !modWeapons.Configuration.Enabled || !modWeapons.Configuration.BlockPoliceLooting || (Object)(object)_npc == (Object)null || (Object)(object)((Il2CppObjectBase)_npc).TryCast<PoliceOfficer>() == (Object)null)
			{
				return;
			}
			Il2CppReferenceArray<ItemSlotUI> slots = __instance.Slots;
			if (slots == null)
			{
				return;
			}
			for (int i = 0; i < ((Il2CppArrayBase<ItemSlotUI>)(object)slots).Length; i++)
			{
				ItemSlotUI val = ((Il2CppArrayBase<ItemSlotUI>)(object)slots)[i];
				ItemSlot val2 = ((val != null) ? val.assignedSlot : null);
				ItemInstance val3 = ((val2 != null) ? val2.ItemInstance : null);
				if (val3 != null && WeaponMatcher.IsWeapon(val3.Definition))
				{
					__instance.SetSlotLocked(i, true);
					if (i < ((Il2CppArrayBase<RectTransform>)(object)__instance.GreenAreas).Length && (Object)(object)((Il2CppArrayBase<RectTransform>)(object)__instance.GreenAreas)[i] != (Object)null)
					{
						((Component)((Il2CppArrayBase<RectTransform>)(object)__instance.GreenAreas)[i]).gameObject.SetActive(false);
					}
				}
			}
		}
	}
}
namespace Lithium.Modules.Police
{
	public class ModPoliceConfiguration : ModuleConfiguration
	{
		public override string Name => "Police";

		public ContrabandSettings Contraband { get; set; } = new ContrabandSettings();

		public PropertyContrabandSettings PropertyContraband { get; set; } = new PropertyContrabandSettings();

		public PoliceEntrySettings PoliceEntry { get; set; } = new PoliceEntrySettings();

		public float PostPursuitGraceSeconds { get; set; } = 20f;
	}
	public class PropertyContrabandSettings
	{
		public bool Enabled { get; set; } = true;

		public bool DetectPlants { get; set; } = true;

		public bool DetectStations { get; set; } = true;

		public bool DetectStoredDrugs { get; set; } = true;

		public bool RequireOpenDoorsOrBlinds { get; set; } = true;

		public float MaxDistance { get; set; } = 25f;

		public float OpeningViewAngleDegrees { get; set; } = 60f;

		public bool RequireFacing { get; set; } = true;

		public float MaxViewAngleDegrees { get; set; } = 90f;

		public float ScanIntervalSeconds { get; set; } = 1f;

		public float GraceSeconds { get; set; } = 8f;

		public bool ShowWarning { get; set; } = true;
	}
	public class PoliceEntrySettings
	{
		public bool Enabled { get; set; } = true;
	}
	public class ContrabandSettings
	{
		public bool Enabled { get; set; } = true;

		public bool MarkAllSeeds { get; set; } = true;

		public bool MarkAllProducts { get; set; } = true;

		[JsonConverter(typeof(StringEnumConverter))]
		public ELegalStatus SeedSeverity { get; set; } = (ELegalStatus)3;

		[JsonConverter(typeof(StringEnumConverter))]
		public ELegalStatus ProductSeverity { get; set; } = (ELegalStatus)4;

		[JsonProperty(ItemConverterType = typeof(StringEnumConverter))]
		public Dictionary<string, ELegalStatus> IllegalItems { get; set; } = new Dictionary<string, ELegalStatus> { 
		{
			"cocaleaf",
			(ELegalStatus)4
		} };

		public List<string> IgnoredItemIds { get; set; } = new List<string>();

		[JsonConverter(typeof(StringEnumConverter))]
		public EVisualState PursuitTrigger { get; set; } = (EVisualState)5;
	}
	public class ModPolice : ModuleBase<ModPoliceConfiguration>
	{
		private const string ContrabandStateLabel = "lithium_contraband";

		private bool _flagged;

		private float _nextScanTime;

		private bool _pursuitWasActive;

		private float _graceUntil;

		private bool _watchSignalReady;

		private float _watchSignalBaseline;

		private float _watchPollAllowedAt;

		private bool _bustSignalReady;

		private float _bustSignalBaseline;

		private bool InPostPursuitGrace => Time.time < _graceUntil;

		public override void Apply()
		{
			ContrabandMarker.ReapplyAll();
			PropertyDoorAccess.Apply(base.Configuration.PoliceEntry);
			PropertyContrabandScanner.RefreshDoorsCache();
			PropertyContrabandScanner.ResetNoticeState();
			_flagged = false;
			_nextScanTime = 0f;
			_pursuitWasActive = false;
			_graceUntil = 0f;
			_watchSignalReady = false;
			_watchSignalBaseline = 0f;
			_bustSignalReady = false;
			_bustSignalBaseline = 0f;
			_watchPollAllowedAt = Time.time + 2f;
		}

		public void DriveUpdate()
		{
			if (!base.Configuration.Enabled)
			{
				ClearFlag();
				return;
			}
			UpdatePursuitGrace();
			DriveHeldContraband(base.Configuration.Contraband);
			DrivePropertyScan(base.Configuration.PropertyContraband);
			DriveClientWarning(base.Configuration.PropertyContraband);
			DriveClientBust(base.Configuration.PropertyContraband);
		}

		private void UpdatePursuitGrace()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			Player local = Player.Local;
			PlayerCrimeData val = ((local != null) ? local.CrimeData : null);
			bool flag = (Object)(object)val != (Object)null && (int)val.CurrentPursuitLevel > 0;
			if (_pursuitWasActive && !flag)
			{
				_graceUntil = Time.time + Mathf.Max(0f, base.Configuration.PostPursuitGraceSeconds);
			}
			_pursuitWasActive = flag;
		}

		private void DriveHeldContraband(ContrabandSettings contraband)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!contraband.Enabled || InPostPursuitGrace)
			{
				ClearFlag();
				return;
			}
			Player local = Player.Local;
			if ((Object)(object)local == (Object)null)
			{
				_flagged = false;
				return;
			}
			bool flag = ShouldFlag(local, contraband);
			if (flag == _flagged)
			{
				return;
			}
			EntityVisibility visibility = local.Visibility;
			if (!((Object)(object)visibility == (Object)null))
			{
				if (flag)
				{
					visibility.ApplyState("lithium_contraband", contraband.PursuitTrigger, 0f);
				}
				else
				{
					visibility.RemoveState("lithium_contraband", 0f);
				}
				_flagged = flag;
			}
		}

		private void DrivePropertyScan(PropertyContrabandSettings settings)
		{
			if (!settings.Enabled)
			{
				return;
			}
			float time = Time.time;
			if (!(time < _nextScanTime))
			{
				_nextScanTime = time + Mathf.Max(0.1f, settings.ScanIntervalSeconds);
				if (!InPostPursuitGrace)
				{
					PropertyContrabandScanner.Scan(settings);
				}
			}
		}

		private void DriveClientWarning(PropertyContrabandSettings settings)
		{
			if (!InstanceFinder.IsServer && settings.Enabled && settings.ShowWarning && !(Time.time < _watchPollAllowedAt))
			{
				float number = HostStateSync.GetNumber("police_propwatch");
				if (!_watchSignalReady)
				{
					_watchSignalBaseline = number;
					_watchSignalReady = true;
				}
				else if (!(number <= _watchSignalBaseline))
				{
					_watchSignalBaseline = number;
					ShowClientWarning();
				}
			}
		}

		private static void ShowClientWarning()
		{
			try
			{
				NotificationsManager val = (Singleton<NotificationsManager>.InstanceExists ? Singleton<NotificationsManager>.Instance : null);
				if (val != null)
				{
					val.SendNotification("Police", "An officer is eyeing one of your properties — get out of sight!", (Sprite)null, 5f, true);
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Police] Failed to show client property-watch warning: {value}");
			}
		}

		private void DriveClientBust(PropertyContrabandSettings settings)
		{
			if (!InstanceFinder.IsServer && settings.Enabled && !(Time.time < _watchPollAllowedAt))
			{
				float number = HostStateSync.GetNumber("police_propbust");
				if (!_bustSignalReady)
				{
					_bustSignalBaseline = number;
					_bustSignalReady = true;
				}
				else if (!(number <= _bustSignalBaseline))
				{
					_bustSignalBaseline = number;
					ApplyClientBust();
				}
			}
		}

		private static void ApplyClientBust()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			try
			{
				Player local = Player.Local;
				if (!((Object)(object)local == (Object)null) && !((Object)(object)local.CrimeData == (Object)null))
				{
					local.CrimeData.AddCrime((Crime)new DrugTrafficking(), 1);
					local.CrimeData.SetPursuitLevel((EPursuitLevel)2);
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Police] Failed to apply client property bust: {value}");
			}
		}

		private static bool ShouldFlag(Player local, ContrabandSettings contraband)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_0041: 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_00a7: Invalid comparison between Unknown and I4
			if (local.IsInVehicle)
			{
				return false;
			}
			if ((Object)(object)local.CrimeData != (Object)null && (int)local.CrimeData.CurrentPursuitLevel > 0)
			{
				return false;
			}
			if (PropertyContrabandScanner.IsPlayerInSealedOwnedProperty(((Component)local).transform.position))
			{
				return false;
			}
			PlayerInventory instance = PlayerSingleton<PlayerInventory>.Instance;
			ItemInstance val = ((instance != null) ? instance.EquippedItem : null);
			ItemDefinition val2 = ((val != null) ? val.Definition : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (contraband.IgnoredItemIds.Contains(((BaseItemDefinition)val2).ID))
			{
				return false;
			}
			return (int)((BaseItemDefinition)val2).legalStatus > 0;
		}

		private void ClearFlag()
		{
			if (_flagged)
			{
				Player local = Player.Local;
				EntityVisibility val = ((local != null) ? local.Visibility : null);
				if (val != null)
				{
					val.RemoveState("lithium_contraband", 0f);
				}
				_flagged = false;
			}
		}
	}
}
namespace Lithium.Modules.Police.PoliceEntry
{
	public static class PropertyDoorAccess
	{
		private static readonly Dictionary<int, bool> OriginalOpenableByNpcs = new Dictionary<int, bool>();

		public static void Apply(PoliceEntrySettings settings)
		{
			Il2CppArrayBase<PropertyDoorController> val = Object.FindObjectsOfType<PropertyDoorController>(true);
			if (val == null)
			{
				return;
			}
			bool flag = settings?.Enabled ?? false;
			int num = 0;
			for (int i = 0; i < val.Length; i++)
			{
				PropertyDoorController val2 = val[i];
				if (!((Object)(object)val2 == (Object)null))
				{
					int instanceID = ((Object)val2).GetInstanceID();
					if (!OriginalOpenableByNpcs.ContainsKey(instanceID))
					{
						OriginalOpenableByNpcs[instanceID] = ((DoorController)val2).OpenableByNPCs;
					}
					bool flag2 = flag || OriginalOpenableByNpcs[instanceID];
					if (((DoorController)val2).OpenableByNPCs != flag2)
					{
						((DoorController)val2).OpenableByNPCs = flag2;
						num++;
					}
				}
			}
			if (flag)
			{
				Log.Info($"[Police] NPC entry enabled on property doors ({val.Length} found, {num} changed).");
			}
		}
	}
}
namespace Lithium.Modules.Police.PropertyContraband
{
	public static class PropertyContrabandScanner
	{
		internal struct ContrabandPoint
		{
			public Property Property;

			public Vector3 Position;
		}

		internal struct PropertyGroup
		{
			public Property Property;

			public Vector3 Centroid;
		}

		private static Il2CppArrayBase<PropertyDoorController> _doorsCache;

		private static readonly Dictionary<int, float> _noticeByProperty = new Dictionary<int, float>();

		private static float _lastNoticeTime;

		internal const string WatchSignalKey = "police_propwatch";

		private static int _watchSignalSeq;

		internal const string BustSignalKey = "police_propbust";

		private static int _bustSignalSeq;

		internal static void RefreshDoorsCache()
		{
			_doorsCache = Object.FindObjectsOfType<PropertyDoorController>(true);
		}

		internal static void ResetNoticeState()
		{
			_noticeByProperty.Clear();
			_lastNoticeTime = 0f;
			_watchSignalSeq = 0;
			_bustSignalSeq = 0;
			HostStateSync.SetNumber("police_propwatch", 0f);
			HostStateSync.SetNumber("police_propbust", 0f);
		}

		public static void Scan(PropertyContrabandSettings settings)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			Player local = Player.Local;
			if ((Object)(object)local == (Object)null || (Object)(object)local.CrimeData == (Object)null || (int)local.CrimeData.CurrentPursuitLevel > 0)
			{
				return;
			}
			List<PoliceOfficer> officers = PoliceOfficer.Officers;
			if (officers == null || officers.Count == 0)
			{
				return;
			}
			List<ContrabandPoint> list = CollectContraband(settings);
			if (list.Count == 0)
			{
				_noticeByProperty.Clear();
				return;
			}
			if (_doorsCache == null)
			{
				RefreshDoorsCache();
			}
			float time = Time.time;
			float num = Mathf.Max(0.2f, settings.ScanIntervalSeconds * 2f);
			float num2 = Mathf.Clamp(time - _lastNoticeTime, 0f, num);
			_lastNoticeTime = time;
			float num3 = Mathf.Max(0f, settings.GraceSeconds);
			HashSet<int> hashSet = new HashSet<int>();
			PoliceOfficer val = null;
			foreach (PropertyGroup item in GroupByProperty(list))
			{
				int instanceID = ((Object)item.Property).GetInstanceID();
				hashSet.Add(instanceID);
				PoliceOfficer val2 = FindWitnessForProperty(item.Property, item.Centroid, officers, _doorsCache, settings);
				float value2;
				if ((Object)(object)val2 != (Object)null)
				{
					float value;
					float num4 = (_noticeByProperty.TryGetValue(instanceID, out value) ? value : 0f);
					float num5 = num4 + num2;
					_noticeByProperty[instanceID] = num5;
					if (num3 > 0f && num4 <= 0f && settings.ShowWarning)
					{
						ShowWatchedWarning(item.Property);
					}
					if (num5 >= num3)
					{
						val = val2;
						break;
					}
				}
				else if (_noticeByProperty.TryGetValue(instanceID, out value2))
				{
					float num6 = value2 - num2;
					if (num6 <= 0f)
					{
						_noticeByProperty.Remove(instanceID);
					}
					else
					{
						_noticeByProperty[instanceID] = num6;
					}
				}
			}
			PruneNotice(hashSet);
			if ((Object)(object)val != (Object)null)
			{
				_noticeByProperty.Clear();
				TriggerPursuit(officers, val);
			}
			else if (Log.DebugEnabled)
			{
				Log.Info($"[Police] Property scan: {list.Count} contraband point(s); {_noticeByProperty.Count} property(ies) being watched (grace {num3:0.#}s).");
			}
		}

		private static void PruneNotice(HashSet<int> present)
		{
			if (_noticeByProperty.Count == 0)
			{
				return;
			}
			List<int> list = null;
			foreach (int key in _noticeByProperty.Keys)
			{
				if (!present.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				_noticeByProperty.Remove(item);
			}
		}

		private static void ShowWatchedWarning(Property property)
		{
			_watchSignalSeq++;
			HostStateSync.SetNumber("police_propwatch", _watchSignalSeq);
			try
			{
				NotificationsManager val = (Singleton<NotificationsManager>.InstanceExists ? Singleton<NotificationsManager>.Instance : null);
				if (!((Object)(object)val == (Object)null))
				{
					string text = (((Object)(object)property != (Object)null && !string.IsNullOrEmpty(property.PropertyName)) ? property.PropertyName : "your property");
					val.SendNotification("Police", "An officer is eyeing " + text + " — get out of sight!", (Sprite)null, 5f, true);
				}
			}
			catch (Exception value)
			{
				Log.Warning($"[Police] Failed to show property-watch warning: {value}");
			}
		}

		internal static List<PropertyGroup> GroupByProperty(List<ContrabandPoint> points)
		{
			//IL_0064: 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_0068: 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_00fd: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<int, Vector3> dictionary = new Dictionary<int, Vector3>();
			Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
			Dictionary<int, Property> dictionary3 = new Dictionary<int, Property>();
			foreach (ContrabandPoint point in points)
			{
				if (!((Object)(object)point.Property == (Object)null))
				{
					int instanceID = ((Object)point.Property).GetInstanceID();
					dictionary[instanceID] = (dictionary.TryGetValue(instanceID, out var value) ? value : Vector3.zero) + point.Position;
					dictionary2[instanceID] = (dictionary2.TryGetValue(instanceID, out var value2) ? value2 : 0) + 1;
					dictionary3[instanceID] = point.Property;
				}
			}
			List<PropertyGroup> list = new List<PropertyGroup>();
			foreach (KeyValuePair<int, Property> item in dictionary3)
			{
				list.Add(new PropertyGroup
				{
					Property = item.Value,
					Centroid = dictionary[item.Key] / (float)dictionary2[item.Key]
				});
			}
			return list;
		}

		private static PoliceOfficer FindWitnessForProperty(Property property, Vector3 interior, List<PoliceOfficer> officers, Il2CppArrayBase<PropertyDoorController> doors, PropertyContrabandSettings settings)
		{
			//IL_0010: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			if (!settings.RequireOpenDoorsOrBlinds)
			{
				return NearestSeeingOfficer(officers, interior, settings);
			}
			foreach (Vector3 item in EnumerateOpenOpenings(property, doors))
			{
				PoliceOfficer val = OfficerSeeingThroughOpening(officers, item, interior, settings);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		internal static IEnumerable<Vector3> EnumerateOpenOpenings(Property property, Il2CppArrayBase<PropertyDoorController> doors)
		{
			int propertyId = ((Object)property).GetInstanceID();
			if (doors != null)
			{
				for (int i = 0; i < doors.Length; i++)
				{
					PropertyDoorController door = doors[i];
					if (IsDeliberatelyOpenDoor(door))
					{
						Property doorProperty = door.Property;
						if ((Object)(object)doorProperty != (Object)null && ((Object)doorProperty).GetInstanceID() == propertyId)
						{
							yield return ((Component)door).transform.position;
						}
					}
				}
			}
			List<InteractableToggleable> toggleables = property.Toggleables;
			if (toggleables == null)
			{
				yield break;
			}
			for (int j = 0; j < toggleables.Count; j++)
			{
				InteractableToggleable toggleable = toggleables[j];
				if (IsOpenBlind(toggleable))
				{
					yield return ((Component)toggleable).transform.position;
				}
			}
		}

		internal static bool IsDeliberatelyOpenDoor(PropertyDoorController door)
		{
			return (Object)(object)door != (Object)null && ((DoorController)door).IsOpen && !((DoorController)door).openedByNPC && !((DoorController)door).autoOpenedForPlayer;
		}

		internal static PoliceOfficer OfficerSeeingThroughOpening(List<PoliceOfficer> officers, Vector3 openingPos, Vector3 interior, PropertyContrabandSettings settings)
		{
			//IL_0037: 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_003d: 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_0054: 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_0056: 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)
			for (int i = 0; i < officers.Count; i++)
			{
				PoliceOfficer val = officers[i];
				if (!((Object)(object)val == (Object)null) && ((NPC)val).IsConscious && !val.IgnorePlayers)
				{
					Vector3 position = ((Component)val).transform.position;
					if (!(Vector3.Distance(position, openingPos) > settings.MaxDistance) && CanSeeThroughOpening(position, openingPos, interior, settings.OpeningViewAngleDegrees) && (!settings.RequireFacing || IsFacing(val, openingPos, settings.MaxViewAngleDegrees)))
					{
						return val;
					}
				}
			}
			return null;
		}

		internal static bool CanSeeThroughOpening(Vector3 officerPos, Vector3 openingPos, Vector3 interior, float maxAngleDegrees)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0017: 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_0050: 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)
			Vector3 val = openingPos - officerPos;
			val.y = 0f;
			Vector3 val2 = interior - openingPos;
			val2.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f || ((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				return true;
			}
			return Vector3.Angle(val, val2) <= maxAngleDegrees;
		}

		internal static PoliceOfficer NearestSeeingOfficer(List<PoliceOfficer> officers, Vector3 position, PropertyContrabandSettings settings)
		{
			//IL_0034: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < officers.Count; i++)
			{
				PoliceOfficer val = officers[i];
				if (!((Object)(object)val == (Object)null) && ((NPC)val).IsConscious && !val.IgnorePlayers && !(Vector3.Distance(((Component)val).transform.position, position) > settings.MaxDistance) && (!settings.RequireFacing || IsFacing(val, position, settings.MaxViewAngleDegrees)))
				{
					return val;
				}
			}
			return null;
		}

		internal static bool IsFacing(PoliceOfficer officer, Vector3 point, float maxAngleDegrees)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0045: 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_004f: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			NPCAwareness awareness = ((NPC)officer).Awareness;
			object obj;
			if (awareness == null)
			{
				obj = null;
			}
			else
			{
				VisionCone visionCone = awareness.VisionCone;
				obj = ((visionCone != null) ? visionCone.VisionOrigin : null);
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			Vector3 forward = val.forward;
			forward.y = 0f;
			Vector3 val2 = point - val.position;
			val2.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f || ((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				return true;
			}
			return Vector3.Angle(forward, val2) <= maxAngleDegrees;
		}

		internal static bool IsPlayerInSealedOwnedProperty(Vector3 position)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (_doorsCache == null)
			{
				RefreshDoorsCache();
			}
			foreach (Property ownedProperty in GetOwnedProperties())
			{
				if (ownedProperty.DoBoundsContainPoint(position))
				{
					return !IsExposed(ownedProperty, _doorsCache);
				}
			}
			return false;
		}

		internal static bool IsExposed(Property property, Il2CppArrayBase<PropertyDoorController> doors)
		{
			if (doors != null)
			{
				int instanceID = ((Object)property).GetInstanceID();
				for (int i = 0; i < doors.Length; i++)
				{
					PropertyDoorController val = doors[i];
					if (IsDeliberatelyOpenDoor(val))
					{
						Property property2 = val.Property;
						if ((Object)(object)property2 != (Object)null && ((Object)property2).GetInstanceID() == instanceID)
						{
							return true;
						}
					}
				}
			}
			List<InteractableToggleable> toggleables = property.Toggleables;
			if (toggleables != null)
			{
				for (int j = 0; j < toggleables.Count; j++)
				{
					if (IsOpenBlind(toggleables[j]))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool IsOpenBlind(InteractableToggleable toggleable)
		{
			if ((Object)(object)toggleable == (Object)null)
			{
				return false;
			}
			string text = toggleable.ActivateMessage ?? string.Empty;
			string text2 = toggleable.DeactivateMessage ?? string.Empty;
			string text3 = (text + " " + text2).ToLowerInvariant();
			if (!text3.Contains("blind") && !text3.Contains("curtain") && !text3.Contains("shutter"))
			{
				return false;
			}
			string text4 = (toggleable.IsActivated ? text2 : text).ToLowerInvariant();
			if (text4.Contains("open") || text4.Contains("raise"))
			{
				return false;
			}
			if (text4.Contains("close") || text4.Contains("shut") || text4.Contains("lower"))
			{
				return true;
			}
			return false;
		}

		private static List<ContrabandPoint> CollectContraband(PropertyContrabandSettings settings)
		{
			//IL_008c: 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)
			List<ContrabandPoint> list = new List<ContrabandPoint>();
			foreach (Property ownedProperty in GetOwnedProperties())
			{
				List<BuildableItem> buildableItems = ownedProperty.BuildableItems;
				if (buildableItems == null)
				{
					continue;
				}
				for (int i = 0; i < buildableItems.Count; i++)
				{
					BuildableItem val = buildableItems[i];
					if (!((Object)(object)val == (Object)null) && !val.isGhost && !val.IsDestroyed && TryClassifyContraband(val, settings, out var point))
					{
						list.Add(new ContrabandPoint
						{
							Property = ownedProperty,
							Position = point
						});
					}
				}
			}
			return list;
		}

		private static List<Property> GetOwnedProperties()
		{
			List<Property> list = new List<Property>();
			HashSet<int> hashSet = new HashSet<int>();
			List<Property> ownedProperties = Property.OwnedProperties;
			if (ownedProperties != null)
			{
				for (int i = 0; i < ownedProperties.Count; i++)
				{
					Property val = ownedProperties[i];
					if ((Object)(object)val != (Object)null && hashSet.Add(((Object)val).GetInstanceID()))
					{
						list.Add(val);
					}
				}
			}
			List<Business> ownedBusinesses = Business.OwnedBusinesses;
			if (ownedBusinesses != null)
			{
				for (int j = 0; j < ownedBusinesses.Count; j++)
				{
					Business val2 = ownedBusinesses[j];
					if ((Object)(object)val2 != (Object)null && hashSet.Add(((Object)val2).GetInstanceID()))
					{
						list.Add((Property)(object)val2);
					}
				}
			}
			return list;
		}

		internal static bool TryClassifyContraband(BuildableItem item, PropertyContrabandSettings settings, out Vector3 point)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0064: 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_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)
			//IL_010c: 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)
			point = default(Vector3);
			if (settings.DetectStations && IsDrugStation(item))
			{
				point = SightPoint((Component)(object)item);
				return true;
			}
			if (settings.DetectPlants)
			{
				Pot val = ((Il2CppObjectBase)item).TryCast<Pot>();
				if ((Object)(object)val != (Object)null && (Object)(object)val.Plant != (Object)null)
				{
					point = SightPoint((Component)(object)val);
					return true;
				}
			}
			if (settings.DetectStoredDrugs)
			{
				FloorRack val2 = ((Il2CppObjectBase)item).TryCast<FloorRack>();
				if ((Object)(object)val2 != (Object)null && RackHasIllegalItem(val2))
				{
					point = SightPoint((Component)(object)val2);
					return true;
				}
				PlaceableStorageEntity obj = ((Il2CppObjectBase)item).TryCast<PlaceableStorageEntity>();
				object obj2 = ((obj != null) ? obj.StorageEntity : null);
				if (obj2 == null)
				{
					SurfaceStorageEntity obj3 = ((Il2CppObjectBase)item).TryCast<SurfaceStorageEntity>();
					obj2 = ((obj3 != null) ? obj3.StorageEntity : null);
				}
				StorageEntity val3 = (StorageEntity)obj2;
				if ((Object)(object)val3 != (Object)null && val3.ItemCount > 0 && ContainsIllegalItem(val3))
				{
					point = SightPoint((Component)(object)val3);
					return true;
				}
			}
			return false;
		}

		internal static bool IsDrugStation(BuildableItem item)
		{
			return (Object)(object)((Il2CppObjectBase)item).TryCast<ChemistryStation>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<LabOven>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<MixingStation>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<DryingRack>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<BrickPress>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<Cauldron>() != (Object)null || (Object)(object)((Il2CppObjectBase)item).TryCast<PackagingStation>() != (Object)null;
		}

		internal static bool RackHasIllegalItem(FloorRack rack)
		{
			List<ProceduralTile> proceduralTiles = rack.ProceduralTiles;
			if (proceduralTiles == null)
			{
				return false;
			}
			for (int i = 0; i < proceduralTiles.Count; i++)
			{
				ProceduralTile obj = proceduralTiles[i];
				List<ProceduralGridItem> val = ((obj != null) ? obj.Occupants : null);
				if (val == null)
				{
					continue;
				}
				for (int j = 0; j < val.Count; j++)
				{
					ProceduralGridItem obj2 = val[j];
					object definition;
					if (obj2 == null)
					{
						definition = null;
					}
					else
					{
						ItemInstance itemInstance = ((BuildableItem)obj2).ItemInstance;
						definition = ((itemInstance != null) ? itemInstance.Definition : null);
					}
					if (IsContraband((ItemDefinition)definition))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool ContainsIllegalItem(StorageEntity storage)
		{
			List<ItemInstance> allItems = storage.GetAllItems();
			if (allItems == null)
			{
				return false;
			}
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemInstance obj = allItems[i];
				if (IsContraband((obj != null) ? obj.Definition : null))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsContraband(ItemDefinition definition)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)definition == (Object)null)
			{
				return false;
			}
			return (int)((BaseItemDefinition)definition).legalStatus != 0 || ContrabandMatcher.GetSeverity(definition).HasValue;
		}

		internal static Vector3 SightPoint(Component component)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_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_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_001c: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			Renderer componentInChildren = component.GetComponentInChildren<Renderer>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Bounds bounds = componentInChildren.bounds;
				return ((Bounds)(ref bounds)).center;
			}
			return component.transform.position + Vector3.up * 0.5f;
		}

		private static void TriggerPursuit(List<PoliceOfficer> officers, PoliceOfficer witness)
		{
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			List<PoliceOfficer> list = new List<PoliceOfficer>();
			HashSet<int> hashSet = new HashSet<int>();
			if ((Object)(object)witness != (Object)null && ((NPC)witness).IsConscious && !witness.IgnorePlayers && hashSet.Add(((Object)witness).GetInstanceID()))
			{
				list.Add(witness);
			}
			if (officers != null)
			{
				for (int i = 0; i < officers.Count; i++)
				{
					PoliceOfficer val = officers[i];
					if ((Object)(object)val != (Object)null && ((NPC)val).IsConscious && !val.IgnorePlayers && hashSet.Add(((Object)val).GetInstanceID()))
					{
						list.Add(val);
					}
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			Player local = Player.Local;
			List<Player> playerList = Player.PlayerList;
			int num = 0;
			if (playerList != null)
			{
				for (int j = 0; j < playerList.Count; j++)
				{
					Player val2 = playerList[j];
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.CrimeData == (Object)null)
					{
						continue;
					}
					try
					{
						val2.CrimeData.SetPursuitLevel((EPursuitLevel)2);
						if ((Object)(object)val2 == (Object)(object)local)
						{
							val2.CrimeData.AddCrime((Crime)new DrugTrafficking(), 1);
						}
						PoliceOfficer val3 = list[num % list.Count];
						val3.BeginFootPursuit_Networked(val2.PlayerCode, true);
						num++;
					}
					catch (Exception ex)
					{
						Log.Warning("[Police] Failed to start property pursuit for a player: " + ex.Message);
					}
				}
			}
			_bustSignalSeq++;
			HostStateSync.SetNumber("police_propbust", _bustSignalSeq);
			Log.Warning($"[Police] An officer spotted contraband inside one of your properties — pursuit started for {num} player(s).");
		}
	}
	public static class PoliceContrabandDebug
	{
		public static void Dump()
		{
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: 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_0253: 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_0290: 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_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0786: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0827: Unknown result type (might be due to invalid IL or missing references)
			//IL_086a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Unknown result type (might be due to invalid IL or missing references)
			//IL_0878: Unknown result type (might be due to invalid IL or missing references)
			//IL_087d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0889: Unknown result type (might be due to invalid IL or missing references)
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0890: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08da: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== Lithium Police Contraband Scan Debug ===");
				ModPolice modPolice = Core.Get<ModPolice>();
				if (modPolice == null)
				{
					stringBuilder.AppendLine("ModPolice not registered.");
					Write(stringBuilder);
					return;
				}
				PropertyContrabandSettings propertyContraband = modPolice.Configuration.PropertyContraband;
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(10, 1, stringBuilder2);
				handler.AppendLiteral("IsServer: ");
				handler.AppendFormatted(InstanceFinder.IsServer);
				stringBuilder3.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(71, 3, stringBuilder2);
				handler.AppendLiteral("Module.Enabled: ");
				handler.AppendFormatted(modPolice.Configuration.Enabled);
				handler.AppendLiteral("   PropertyContraband.Enabled: ");
				handler.AppendFormatted(propertyContraband.Enabled);
				handler.AppendLiteral("   PoliceEntry.Enabled: ");
				handler.AppendFormatted(modPolice.Configuration.PoliceEntry.Enabled);
				stringBuilder4.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder5 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(122, 8, stringBuilder2);
				handler.AppendLiteral("Settings: Plants=");
				handler.AppendFormatted(propertyContraband.DetectPlants);
				handler.AppendLiteral(" Stations=");
				handler.AppendFormatted(propertyContraband.DetectStations);
				handler.AppendLiteral(" StoredDrugs=");
				handler.AppendFormatted(propertyContraband.DetectStoredDrugs);
				handler.AppendLiteral(" RequireOpenDoorsOrBlinds=");
				handler.AppendFormatted(propertyContraband.RequireOpenDoorsOrBlinds);
				handler.AppendLiteral(" MaxDistance=");
				handler.AppendFormatted(propertyContraband.MaxDistance);
				handler.AppendLiteral(" RequireFacing=");
				handler.AppendFormatted(propertyContraband.RequireFacing);
				handler.AppendLiteral(" MaxViewAngle=");
				handler.AppendFormatted(propertyContraband.MaxViewAngleDegrees);
				handler.AppendLiteral(" ScanInterval=");
				handler.AppendFormatted(propertyContraband.ScanIntervalSeconds);
				stringBuilder5.AppendLine(ref handler);
				Player local = Player.Local;
				Vector3 val = (((Object)(object)local != (Object)null) ? ((Component)local).transform.position : Vector3.zero);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder6 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(35, 3, stringBuilder2);
				handler.AppendLiteral("Player.Local: ");
				handler.AppendFormatted(((Object)(object)local != (Object)null) ? "ok" : "NULL");
				handler.AppendLiteral("  pos=");
				handler.AppendFormatted<Vector3>(val);
				handler.AppendLiteral("  pursuitLevel=");
				handler.AppendFormatted(((Object)(object)((local != null) ? local.CrimeData : null) != (Object)null) ? ((object)local.CrimeData.CurrentPursuitLevel/*cast due to .constrained prefix*/).ToString() : "?");
				stringBuilder6.AppendLine(ref handler);
				PlayerInventory instance = PlayerSingleton<PlayerInventory>.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					ItemInstance equippedItem = instance.EquippedItem;
					obj = ((equippedItem != null) ? equippedItem.Definition : null);
				}
				ItemDefinition val2 = (ItemDefinition)obj;
				bool flag = (Object)(object)val2 != (Object)null && ((int)((BaseItemDefinition)val2).legalStatus != 0 || ContrabandMatcher.GetSeverity(val2).HasValue);
				bool flag2 = (Object)(object)local != (Object)null && PropertyContrabandScanner.IsPlayerInSealedOwnedProperty(val);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder7 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(60, 3, stringBuilder2);
				handler.AppendLiteral("Held item: ");
				handler.AppendFormatted(((Object)(object)val2 != (Object)null) ? $"{((BaseItemDefinition)val2).ID}:{((BaseItemDefinition)val2).legalStatus} contraband={flag}" : "(none)");
				handler.AppendLiteral("  playerInSealedOwnedProperty=");
				handler.AppendFormatted(flag2);
				handler.AppendLiteral("  -> heldWouldFlag=");
				handler.AppendFormatted(flag && !flag2 && ((Object)(object)local == (Object)null || !local.IsInVehicle));
				stringBuilder7.AppendLine(ref handler);
				stringBuilder.AppendLine();
				List<PoliceOfficer> officers = PoliceOfficer.Officers;
				int num = officers?.Count ?? 0;
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder8 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(10, 1, stringBuilder2);
				handler.AppendLiteral("Officers: ");
				handler.AppendFormatted(num);
				stringBuilder8.AppendLine(ref handler);
				for (int i = 0; i < num; i++)
				{
					PoliceOfficer val3 = officers[i];
					if ((Object)(object)val3 == (Object)null)
					{
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder9 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(8, 1, stringBuilder2);
						handler.AppendLiteral("  #");
						handler.AppendFormatted(i);
						handler.AppendLiteral(" NULL");
						stringBuilder9.AppendLine(ref handler);
					}
					else
					{
						float value = (((Object)(object)local != (Object)null) ? Vector3.Distance(((Component)val3).transform.position, val) : (-1f));
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder10 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(44, 4, stringBuilder2);
						handler.AppendLiteral("  #");
						handler.AppendFormatted(i);
						handler.AppendLiteral(" distToPlayer=");
						handler.AppendFormatted(value, "0.0");
						handler.AppendLiteral("m conscious=");
						handler.AppendFormatted(((NPC)val3).IsConscious);
						handler.AppendLiteral(" ignorePlayers=");
						handler.AppendFormatted(val3.IgnorePlayers);
						stringBuilder10.AppendLine(ref handler);
					}
				}
				stringBuilder.AppendLine();
				Il2CppArrayBase<PropertyDoorController> val4 = Object.FindObjectsOfType<PropertyDoorController>(true);
				Il2CppArrayBase<BuildableItem> val5 = Object.FindObjectsOfType<BuildableItem>(true);
				int num2 = val5?.Length ?? 0;
				List<PropertyContrabandScanner.ContrabandPoint> list = new List<PropertyContrabandScanner.ContrabandPoint>();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder11 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(25, 1, stringBuilder2);
				handler.AppendLiteral("BuildableItems in scene: ");
				handler.AppendFormatted(num2);
				stringBuilder11.AppendLine(ref handler);
				stringBuilder.AppendLine("Contraband in owned properties:");
				for (int j = 0; j < num2; j++)
				{
					BuildableItem val6 = val5[j];
					if ((Object)(object)val6 == (Object)null || val6.isGhost || val6.IsDestroyed)
					{
						continue;
					}
					Property parentProperty = val6.ParentProperty;
					if (!((Object)(object)parentProperty == (Object)null) && parentProperty.IsOwned)
					{
						bool illegal;
						Vector3 point;
						string value2 = DescribeContraband(val6, propertyContraband, out illegal, out point);
						if (illegal)
						{
							list.Add(new PropertyContrabandScanner.ContrabandPoint
							{
								Property = parentProperty,
								Position = point
							});
							stringBuilder2 = stringBuilder;
							StringBuilder stringBuilder12 = stringBuilder2;
							handler = new StringBuilder.AppendInterpolatedStringHandler(5, 2, stringBuilder2);
							handler.AppendLiteral("  \"");
							handler.AppendFormatted(parentProperty.PropertyName);
							handler.AppendLiteral("\" ");
							handler.AppendFormatted(value2);
							stringBuilder12.AppendLine(ref handler);
						}
					}
				}
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder13 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(25, 1, stringBuilder2);
				handler.AppendLiteral("  (");
				handler.AppendFormatted(list.Count);
				handler.AppendLiteral(" contraband object(s))");
				stringBuilder13.AppendLine(ref handler);
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("Sightline check (per property, through each open door/window):");
				foreach (PropertyContrabandScanner.PropertyGroup item in PropertyContrabandScanner.GroupByProperty(list))
				{
					Property property = item.Property;
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder14 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(23, 3, stringBuilder2);
					handler.AppendLiteral("  \"");
					handler.AppendFormatted(property.PropertyName);
					handler.AppendLiteral("\" interior=");
					handler.AppendFormatted<Vector3>(item.Centroid);
					handler.AppendLiteral(" exposed=");
					handler.AppendFormatted(PropertyContrabandScanner.IsExposed(property, val4));
					stringBuilder14.AppendLine(ref handler);
					bool flag3 = false;
					foreach (Vector3 item2 in PropertyContrabandScanner.EnumerateOpenOpenings(property, val4))
					{
						flag3 = true;
						PoliceOfficer val7 = PropertyContrabandScanner.OfficerSeeingThroughOpening(officers, item2, item.Centroid, propertyContraband);
						PoliceOfficer val8 = null;
						float num3 = float.MaxValue;
						for (int k = 0; k < num; k++)
						{
							PoliceOfficer val9 = officers[k];
							if (!((Object)(object)val9 == (Object)null))
							{
								float num4 = Vector3.Distance(((Component)val9).transform.position, item2);
								if (num4 < num3)
								{
									num3 = num4;
									val8 = val9;
								}
							}
						}
						float value3 = (((Object)(object)val8 != (Object)null) ? Vector3.Angle(Flat(item2 - ((Component)val8).transform.position), Flat(item.Centroid - item2)) : (-1f));
						bool value4 = (Object)(object)val8 != (Object)null && PropertyContrabandScanner.IsFacing(val8, item2, propertyContraband.MaxViewAngleDegrees);
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder15 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(91, 6, stringBuilder2);
						handler.AppendLiteral("      opening=");
						handler.AppendFormatted<Vector3>(item2);
						handler.AppendLiteral(": nearestOfficer=");
						handler.AppendFormatted(num3, "0.0");
						handler.AppendLiteral("m seeThroughAngle=");
						handler.AppendFormatted(value3, "0");
						handler.AppendLiteral("°(<= ");
						handler.AppendFormatted(propertyContraband.OpeningViewAngleDegrees);
						handler.AppendLiteral(") facingOpening=");
						handler.AppendFormatted(value4);
						handler.AppendLiteral("  => seenThroughThis=");
						handler.AppendFormatted((Object)(object)val7 != (Object)null);
						stringBuilder15.AppendLine(ref handler);
					}
					if (!flag3)
					{
						stringBuilder.AppendLine("      (no open doors/windows — sealed)");
					}
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("Owned properties — doors & blinds:");
				List<Property> properties = Property.Properties;
				int num5 = properties?.Count ?? 0;
				for (int l = 0; l < num5; l++)
				{
					Property val10 = properties[l];
					if ((Object)(object)val10 == (Object)null || !val10.IsOwned)
					{
						continue;
					}
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder16 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(13, 2, stringBuilder2);
					handler.AppendLiteral("  \"");
					handler.AppendFormatted(val10.PropertyName);
					handler.AppendLiteral("\" exposed=");
					handler.AppendFormatted(PropertyContrabandScanner.IsExposed(val10, val4));
					stringBuilder16.AppendLine(ref handler);
					if (val4 != null)
					{
						for (int m = 0; m < val4.Length; m++)
						{
							PropertyDoorController val11 = val4[m];
							if (!((Object)(object)val11 == (Object)null) && !((Object)(object)val11.Property == (Object)null) && ((Object)val11.Property).GetInstanceID() == ((Object)val10).GetInstanceID())
							{
								stringBuilder2 = stringBuilder;
								StringBuilder stringBuilder17 = stringBuilder2;
								handler = new StringBuilder.AppendInterpolatedStringHandler(70, 4, stringBuilder2);
								handler.AppendLiteral("      door: IsOpen=");
								handler.AppendFormatted(((DoorController)val11).IsOpen);
								handler.AppendLiteral(" openedByNPC=");
								handler.AppendFormatted(((DoorController)val11).openedByNPC);
								handler.AppendLiteral(" autoOpenedForPlayer=");
								handler.AppendFormatted(((DoorController)val11).autoOpenedForPlayer);
								handler.AppendLiteral(" countsAsOpening=");
								handler.AppendFormatted(PropertyContrabandScanner.IsDeliberatelyOpenDoor(val11));
								stringBuilder17.AppendLine(ref handler);
							}
						}
					}
					List<InteractableToggleable> toggleables = val10.Toggleables;
					if (toggleables == null)
					{
						continue;
					}
					for (int n = 0; n < toggleables.Count; n++)
					{
						InteractableToggleable val12 = toggleables[n];
						if (!((Object)(object)val12 == (Object)null))
						{
							stringBuilder2 = stringBuilder;
							StringBuilder stringBuilder18 = stringBuilder2;
							handler = new StringBuilder.AppendInterpolatedStringHandler(70, 4, stringBuilder2);
							handler.AppendLiteral("      toggleable: activate=\"");
							handler.AppendFormatted(val12.ActivateMessage);
							handler.AppendLiteral("\" deactivate=\"");
							handler.AppendFormatted(val12.DeactivateMessage);
							handler.AppendLiteral("\" IsActivated=");
							handler.AppendFormatted(val12.IsActivated);
							handler.AppendLiteral(" -> openBlind=");
							handler.AppendFormatted(PropertyContrabandScanner.IsOpenBlind(val12));
							stringBuilder18.AppendLine(ref handler);
						}
					}
				}
				Write(stringBuilder);
			}
			catch (Exception value5)
			{
				Log.Error($"[Police] Contraband scan dump failed: {value5}");
			}
		}

		private static Vector3 Flat(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			return new Vector3(v.x, 0f, v.z);
		}

		private static string DescribeContraband(BuildableItem item, PropertyContrabandSettings settings, out bool illegal, out Vector3 point)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			illegal = false;
			point = PropertyContrabandScanner.SightPoint((Component)(object)item);
			if (PropertyContrabandScanner.IsDrugStation(item))
			{
				illegal = settings.DetectStations;
				return $"drug station (counts={settings.DetectStations})";
			}
			Pot val = ((Il2CppObjectBase)item).TryCast<Pot>();
			if ((Object)(object)val != (Object)null && (Object)(object)val.Plant != (Object)null)
			{
				illegal = settings.DetectPlants;
				point = PropertyContrabandScanner.SightPoint((Component)(object)val);
				return $"pot with plant (counts={settings.DetectPlants})";
			}
			FloorRack val2 = ((Il2CppObjectBase)item).TryCast<FloorRack>();
			if ((Object)(object)val2 != (Object)null)
			{
				bool flag = PropertyContrabandScanner.RackHasIllegalItem(val2);
				illegal = settings.DetectStoredDrugs && flag;
				point = PropertyContrabandScanner.SightPoint((Component)(object)val2);
				return $"display rack (illegalItems={flag})";
			}
			PlaceableStorageEntity obj = ((Il2CppObjectBase)item).TryCast<PlaceableStorageEntity>();
			object obj2 = ((obj != null) ? obj.StorageEntity : null);
			if (obj2 == null)
			{
				SurfaceStorageEntity obj3 = ((Il2CppObjectBase)item).TryCast<SurfaceStorageEntity>();
				obj2 = ((obj3 != null) ? obj3.StorageEntity : null);
			}
			StorageEntity val3 = (StorageEntity)obj2;
			if ((Object)(object)val3 != (Object)null)
			{
				point = PropertyContrabandScanner.SightPoint((Component)(object)val3);
				bool flag2 = val3.ItemCount > 0 && PropertyContrabandScanner.ContainsIllegalItem(val3);
				illegal = settings.DetectStoredDrugs && flag2;
				return "storage [" + DescribeStorage(val3) + "]";
			}
			return "(not contraband)";
		}

		private static string DescribeStorage(StorageEntity storage)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			List<ItemInstance> allItems = storage.GetAllItems();
			if (allItems == null || allItems.Count == 0)
			{
				return "empty";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < allItems.Count && i < 8; i++)
			{
				ItemInstance obj = allItems[i];
				ItemDefinition val = ((obj != null) ? obj.Definition : null);
				if (!((Object)(object)val == (Object)null))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(", ");
					}
					StringBuilder stringBuilder2 = stringBuilder;
					StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(1, 3, stringBuilder2);
					handler.AppendFormatted(((BaseItemDefinition)val).ID);
					handler.AppendLiteral(":");
					handler.AppendFormatted<ELegalStatus>(((BaseItemDefinition)val).legalStatus);
					handler.AppendFormatted(PropertyContrabandScanner.IsContraband(val) ? "!" : "");
					stringBuilder2.Append(ref handler);
				}
			}
			return stringBuilder.ToString();
		}

		private static void Write(StringBuilder sb)
		{
			string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
			Directory.CreateDirectory(text);
			string text2 = Path.Combine(text, "PoliceScan.txt");
			File.WriteAllText(text2, sb.ToString());
			Log.Warning("[Police] Wrote contraband scan debug to " + text2);
		}
	}
}
namespace Lithium.Modules.Police.Contraband
{
	public static class ContrabandMatcher
	{
		public static ELegalStatus? GetSeverity(ItemDefinition definition)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)definition == (Object)null)
			{
				return null;
			}
			ModPolice modPolice = Core.Get<ModPolice>();
			if (modPolice == null)
			{
				return null;
			}
			ContrabandSettings contraband = modPolice.Configuration.Contraband;
			string iD = ((BaseItemDefinition)definition).ID;
			if (contraband.IgnoredItemIds.Contains(iD))
			{
				return null;
			}
			if (contraband.IllegalItems.TryGetValue(iD, out var value))
			{
				return value;
			}
			if (contraband.MarkAllSeeds && (Object)(object)((Il2CppObjectBase)definition).TryCast<SeedDefinition>() != (Object)null)
			{
				return contraband.SeedSeverity;
			}
			if (contraband.MarkAllProducts && (Object)(object)((Il2CppObjectBase)definition).TryCast<ProductDefinition>() != (Object)null)
			{
				return contraband.ProductSeverity;
			}
			return null;
		}
	}
	public static class ContrabandMarker
	{
		private static readonly Dictionary<string, ELegalStatus> OriginalStatus = new Dictionary<string, ELegalStatus>();

		public static void ReapplyAll()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_00fa: 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_0103: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Invalid comparison between Unknown and I4
			Registry instance = Singleton<Registry>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			ModPolice modPolice = Core.Get<ModPolice>();
			if (modPolice == null)
			{
				return;
			}
			bool flag = modPolice.Configuration.Enabled && modPolice.Configuration.Contraband.Enabled;
			List<ItemDefinition> allItems = instance.GetAllItems();
			if (allItems == null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemDefinition val = allItems[i];
				if (!((Object)(object)val == (Object)null))
				{
					string iD = ((BaseItemDefinition)val).ID;
					if (!OriginalStatus.ContainsKey(iD))
					{
						OriginalStatus[iD] = ((BaseItemDefinition)val).legalStatus;
					}
					ELegalStatus? val2 = (flag ? ContrabandMatcher.GetSeverity(val) : ((ELegalStatus?)null));
					ELegalStatus val3 = (ELegalStatus)(((??)val2) ?? OriginalStatus[iD]);
					if (((BaseItemDefinition)val).legalStatus != val3)
					{
						((BaseItemDefinition)val).legalStatus = val3;
					}
					if (val2.HasValue && (int)val2.Value > 0)
					{
						num++;
					}
				}
			}
			if (flag)
			{
				Log.Info($"[Police] Marked {num} item definition(s) as contraband.");
			}
		}
	}
}
namespace Lithium.Modules.Repairs
{
	public class ModRepairsConfiguration : ModuleConfiguration
	{
		public int RepairDays = 1;

		public override string Name => "Repairs";

		public override void Validate()
		{
			if (RepairDays < 1)
			{
				RepairDays = 1;
			}
		}
	}
	public class ModRepairs : ModuleBase<ModRepairsConfiguration>
	{
		public override void Apply()
		{
		}
	}
}
namespace Lithium.Modules.Repairs.Patches
{
	[HarmonyPatch(typeof(ATM), "DayPass")]
	public class AtmDayPassPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ATM __instance)
		{
			ModRepairs modRepairs = Core.Get<ModRepairs>();
			if (modRepairs == null || !modRepairs.Configuration.Enabled)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || !InstanceFinder.IsServer || !__instance.IsBroken)
			{
				return true;
			}
			int num = __instance.DaysUntilRepair + 1;
			if (num >= modRepairs.Configuration.RepairDays)
			{
				__instance.Repair();
			}
			else
			{
				__instance.DaysUntilRepair = num;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(VendingMachine), "DayPass")]
	public class VendingMachineDayPassPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(VendingMachine __instance)
		{
			ModRepairs modRepairs = Core.Get<ModRepairs>();
			if (modRepairs == null || !modRepairs.Configuration.Enabled)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || !__instance.IsBroken)
			{
				return true;
			}
			int num = __instance.DaysUntilRepair + 1;
			if (num >= modRepairs.Configuration.RepairDays)
			{
				__instance.Repair();
			}
			else
			{
				__instance.DaysUntilRepair = num;
			}
			return false;
		}
	}
}
namespace Lithium.Modules.Dealers
{
	public class RobberyConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool PreventWhenArmed = true;

		[JsonProperty(Order = 2)]
		public float OutdatedWeaponImmunityChance = 0.5f;
	}
	public class WeaponAlertConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = true;
	}
	public class WeaponLossConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = true;

		[JsonProperty(Order = 2)]
		public float ChancePerDay = 1f / 14f;
	}
	public class ShortageConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = true;

		[JsonProperty(Order = 2)]
		public int LeadHours = 8;
	}
	public class WeeklyReportConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = true;
	}
	public class ModDealersConfiguration : ModuleConfiguration
	{
		[JsonProperty(Order = 1)]
		public RobberyConfiguration Robbery = new RobberyConfiguration();

		[JsonProperty(Order = 2)]
		public WeaponAlertConfiguration WeaponAlerts = new WeaponAlertConfiguration();

		[JsonProperty(Order = 3)]
		public WeaponLossConfiguration WeaponLoss = new WeaponLossConfiguration();

		[JsonProperty(Order = 4)]
		public ShortageConfiguration Shortage = new ShortageConfiguration();

		[JsonProperty(Order = 5)]
		public WeeklyReportConfiguration WeeklyReport = new WeeklyReportConfiguration();

		public override string Name => "Dealers";

		public override void Validate()
		{
			if (Robbery.OutdatedWeaponImmunityChance < 0f)
			{
				Robbery.OutdatedWeaponImmunityChance = 0f;
			}
			if (Robbery.OutdatedWeaponImmunityChance > 1f)
			{
				Robbery.OutdatedWeaponImmunityChance = 1f;
			}
			if (WeaponLoss.ChancePerDay < 0f)
			{
				WeaponLoss.ChancePerDay = 0f;
			}
			if (WeaponLoss.ChancePerDay > 1f)
			{
				WeaponLoss.ChancePerDay = 1f;
			}
			if (Shortage.LeadHours < 1)
			{
				Shortage.LeadHours = 1;
			}
		}
	}
	public class ModDealers : ModuleBase<ModDealersConfiguration>
	{
		private int _lastDay = -1;

		private int _lastHour = -1;

		private bool _initialised;

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

		public override void Apply()
		{
			DealerStatsStore.Unload();
			_alertedShortages.Clear();
			_lastDay = -1;
			_lastHour = -1;
			_initialised = false;
		}

		public void Tick()
		{
			if (!base.Configuration.Enabled)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			int elapsedDays = instance.ElapsedDays;
			int num = instance.CurrentTime / 100;
			if (!_initialised)
			{
				_lastDay = elapsedDays;
				_lastHour = num;
				_initialised = true;
				return;
			}
			if (num != _lastHour || elapsedDays != _lastDay)
			{
				_lastHour = num;
				OnHourPass();
			}
			if (elapsedDays != _lastDay)
			{
				int lastDay = _lastDay;
				_lastDay = elapsedDays;
				OnDayPass();
				if (elapsedDays / 7 != lastDay / 7)
				{
					OnWeekPass(elapsedDays / 7);
				}
			}
		}

		private void OnHourPass()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!base.Configuration.Shortage.Enabled)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			GameDateTime dateTime = instance.GetDateTime();
			int nowAbs = ((GameDateTime)(ref dateTime)).GetMinSum();
			int num = base.Configuration.Shortage.LeadHours * 60;
			_alertedShortages.RemoveWhere(delegate(string text)
			{
				int num3 = text.LastIndexOf('@');
				int result;
				return num3 >= 0 && int.TryParse(text.Substring(num3 + 1), out result) && result < nowAbs;
			});
			foreach (Dealer item2 in RecruitedDealers())
			{
				List<Shortfall> list = DealerShortageCalculator.Compute(item2);
				if (list.Count == 0)
				{
					continue;
				}
				foreach (IGrouping<int, Shortfall> item3 in from s in list
					group s by s.DealAbsMinute into g
					orderby g.Key
					select g)
				{
					int key = item3.Key;
					int num2 = key - nowAbs;
					if (num2 <= 0 || num2 > num)
					{
						continue;
					}
					string item = $"{((NPC)item2).ID}@{key}";
					if (_alertedShortages.Add(item))
					{
						string value = string.Join(", ", item3.Select((Shortfall s) => $"{s.Deficit}x {s.ProductName}"));
						int value2 = Math.Max(1, num2 / 60);
						DealerMessenger.Send(item2, $"Heads up - I'm going to come up short for a deal in about {value2}h. I still need {value} or I can't deliver. Restock me.");
					}
					break;
				}
			}
		}

		private void OnDayPass()
		{
			bool flag = base.Configuration.WeaponLoss.Enabled && base.Configuration.WeaponLoss.ChancePerDay > 0f;
			bool enabled = base.Configuration.WeaponAlerts.Enabled;
			if (!flag && !enabled)
			{
				return;
			}
			foreach (Dealer item in RecruitedDealers())
			{
				if ((!flag || !TryWeaponLoss(item)) && enabled)
				{
					SendWeaponAlert(item);
				}
			}
		}

		private bool TryWeaponLoss(Dealer dealer)
		{
			if (Random.value >= base.Configuration.WeaponLoss.ChancePerDay)
			{
				return false;
			}
			string text = DealerWeaponInspector.RemoveBestWeapon(dealer);
			if (text == null)
			{
				return false;
			}
			string message = ((Random.value < 0.5f) ? ("Bad news - I lost my " + text + " during a run and couldn't find it. I need a replacement weapon or I'm a sitting duck.") : ("My " + text + " jammed and broke on me - it's useless now. Get me a new weapon before I get jumped."));
			DealerMessenger.Send(dealer, message);
			Log.Info($"[Dealers] {((NPC)dealer).fullName} lost their {text}.");
			return true;
		}

		private static void SendWeaponAlert(Dealer dealer)
		{
			switch (DealerWeaponInspector.Classify(dealer))
			{
			case WeaponStatus.None:
				DealerMessenger.Send(dealer, "I've got nothing to defend myself with - if the cartel hits me they'll clean me out. Put a weapon in my inventory.");
				break;
			case WeaponStatus.Outdated:
				DealerMessenger.Send(dealer, "My weapon's getting old - there's better available at your rank now. Swap it out or I'm only half-safe if I get jumped.");
				break;
			}
		}

		private void OnWeekPass(int weekIndex)
		{
			if (!base.Configuration.WeeklyReport.Enabled)
			{
				return;
			}
			foreach (Dealer item in RecruitedDealers())
			{
				Dictionary<string, int> dictionary = DealerStatsStore.RollWeek(((NPC)item).ID, weekIndex);
				if (dictionary.Count != 0)
				{
					int value = dictionary.Values.Sum();
					string value2 = string.Join(", ", from kv in dictionary
						orderby kv.Value descending
						select $"{kv.Value}x {kv.Key}");
					DealerMessenger.Send(item, $"Weekly numbers: I moved about {value} units - {value2}.");
				}
			}
		}

		private static IEnumerable<Dealer> RecruitedDealers()
		{
			List<Dealer> all = Dealer.AllPlayerDealers;
			if (all == null)
			{
				yield break;
			}
			Enumerator<Dealer> enumerator = all.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Dealer dealer = enumerator.Current;
				if ((Object)(object)dealer != (Object)null && dealer.IsRecruited)
				{
					yield return dealer;
				}
			}
		}
	}
}
namespace Lithium.Modules.Dealers.Patches
{
	[HarmonyPatch(typeof(TimeManager), "PassMinute")]
	public class DealerTickPatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			try
			{
				Core.Get<ModDealers>()?.Tick();
			}
			catch (Exception ex)
			{
				Log.Warning("[Dealers] Tick failed: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(Dealer), "TryRobDealer")]
	public class DealerRobberyPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Dealer __instance)
		{
			ModDealers modDealers = Core.Get<ModDealers>();
			if (modDealers == null || !modDealers.Configuration.Enabled || !modDealers.Configuration.Robbery.PreventWhenArmed)
			{
				return true;
			}
			switch (DealerWeaponInspector.Classify(__instance))
			{
			case WeaponStatus.Adequate:
				Log.Info("[Dealers] Robbery prevented: " + ((NPC)__instance).fullName + " is adequately armed.");
				return false;
			case WeaponStatus.Outdated:
				if (Random.value < modDealers.Configuration.Robbery.OutdatedWeaponImmunityChance)
				{
					Log.Info("[Dealers] Robbery prevented (" + ((NPC)__instance).fullName + "'s outdated weapon held them off).");
					return false;
				}
				return true;
			default:
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(Dealer), "RemoveContractItems")]
	public class DealerSaleTrackingPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Dealer __instance, Contract contract)
		{
			ModDealers modDealers = Core.Get<ModDealers>();
			if (modDealers == null || !modDealers.Configuration.Enabled || !modDealers.Configuration.WeeklyReport.Enabled || (Object)(object)__instance == (Object)null || (Object)(object)contract == (Object)null || contract.ProductList == null)
			{
				return;
			}
			try
			{
				Enumerator<Entry> enumerator = contract.ProductList.entries.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Entry current = enumerator.Current;
					if (current != null && !string.IsNullOrEmpty(current.ProductID))
					{
						DealerStatsStore.Record(((NPC)__instance).ID, DealerShortageCalculator.ResolveName(current.ProductID), current.Quantity);
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Dealers] Sale tracking failed: " + ex.Message);
			}
		}
	}
}
namespace Lithium.Modules.Dealers.Architecture
{
	internal static class DealerMessenger
	{
		public static void Send(Dealer dealer, string message)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			if ((Object)(object)dealer == (Object)null)
			{
				return;
			}
			MessagingManager instance = NetworkSingleton<MessagingManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				MSGConversation mSGConversation = ((NPC)dealer).MSGConversation;
				if (mSGConversation != null)
				{
					mSGConversation.SetIsKnown(true);
				}
				instance.ReceiveMessage(new Message(message, (ESenderType)1, false, -1), true, ((NPC)dealer).ID);
			}
			catch (Exception ex)
			{
				Log.Warning("[Dealers] Failed to text from " + ((NPC)dealer).fullName + ": " + ex.Message);
			}
		}
	}
	internal enum WeaponStatus
	{
		None,
		Outdated,
		Adequate
	}
	internal static class DealerWeaponInspector
	{
		private static List<float> _weaponRankLadder;

		public static WeaponStatus Classify(Dealer dealer)
		{
			if ((Object)(object)dealer == (Object)null)
			{
				return WeaponStatus.None;
			}
			float? num = BestHeldWeaponRank(dealer);
			if (!num.HasValue)
			{
				return WeaponStatus.None;
			}
			float num2 = BestBuyableWeaponRank();
			return (!(num.Value + 0.0001f >= num2)) ? WeaponStatus.Outdated : WeaponStatus.Adequate;
		}

		public static bool NeedsAttention(Dealer dealer)
		{
			return Classify(dealer) != WeaponStatus.Adequate;
		}

		public static string RemoveBestWeapon(Dealer dealer)
		{
			if ((Object)(object)dealer == (Object)null)
			{
				return null;
			}
			List<ItemSlot> allSlots = dealer.GetAllSlots();
			if (allSlots == null)
			{
				return null;
			}
			ItemSlot val = null;
			StorableItemDefinition val2 = null;
			float num = 0f;
			Enumerator<ItemSlot> enumerator = allSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				object def;
				if (current == null)
				{
					def = null;
				}
				else
				{
					ItemInstance itemInstance = current.ItemInstance;
					def = ((itemInstance != null) ? itemInstance.Definition : null);
				}
				StorableItemDefinition val3 = AsWeapon((ItemDefinition)def);
				if (!((Object)(object)val3 == (Object)null))
				{
					float num2 = RankFloat(val3);
					if (val == null || num2 > num)
					{
						val = current;
						val2 = val3;
						num = num2;
					}
				}
			}
			if (val == null)
			{
				return null;
			}
			string name = ((BaseItemDefinition)val2).Name;
			val.ClearStoredInstance(false);
			return name;
		}

		private static float? BestHeldWeaponRank(Dealer dealer)
		{
			List<ItemSlot> allSlots = dealer.GetAllSlots();
			if (allSlots == null)
			{
				return null;
			}
			float? result = null;
			Enumerator<ItemSlot> enumerator = allSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				object def;
				if (current == null)
				{
					def = null;
				}
				else
				{
					ItemInstance itemInstance = current.ItemInstance;
					def = ((itemInstance != null) ? itemInstance.Definition : null);
				}
				StorableItemDefinition val = AsWeapon((ItemDefinition)def);
				if (!((Object)(object)val == (Object)null))
				{
					float num = RankFloat(val);
					if (!result.HasValue || num > result.Value)
					{
						result = num;
					}
				}
			}
			return result;
		}

		private static float BestBuyableWeaponRank()
		{
			EnsureLadder();
			if (_weaponRankLadder == null || _weaponRankLadder.Count == 0)
			{
				return 0f;
			}
			float num = RankHelper.PlayerRankFloat(0f);
			float num2 = 0f;
			foreach (float item in _weaponRankLadder)
			{
				if (item <= num && item > num2)
				{
					num2 = item;
				}
			}
			return num2;
		}

		private static void EnsureLadder()
		{
			if (_weaponRankLadder != null)
			{
				return;
			}
			Registry instance = Singleton<Registry>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			List<float> list = new List<float>();
			List<ItemDefinition> allItems = instance.GetAllItems();
			if (allItems != null)
			{
				Enumerator<ItemDefinition> enumerator = allItems.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ItemDefinition current = enumerator.Current;
					StorableItemDefinition val = AsWeapon(current);
					if ((Object)(object)val != (Object)null)
					{
						list.Add(RankFloat(val));
					}
				}
			}
			_weaponRankLadder = list;
			Log.Info($"[Dealers] Weapon rank ladder built: {list.Count} weapon definition(s).");
		}

		private static StorableItemDefinition AsWeapon(ItemDefinition def)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if ((Object)(object)def == (Object)null)
			{
				return null;
			}
			StorableItemDefinition val = ((Il2CppObjectBase)def).TryCast<StorableItemDefinition>();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((int)((BaseItemDefinition)val).Category != 8)
			{
				return null;
			}
			if (val.CombatUtility <= 0f)
			{
				return null;
			}
			return val;
		}

		private static float RankFloat(StorableItemDefinition weapon)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			float result;
			if (!weapon.RequiresLevelToPurchase)
			{
				result = 0f;
			}
			else
			{
				FullRank requiredRank = weapon.RequiredRank;
				result = ((FullRank)(ref requiredRank)).ToFloat();
			}
			return result;
		}
	}
	internal sealed class Shortfall
	{
		public string ProductName;

		public int Deficit;

		public int DealAbsMinute;
	}
	internal static class DealerShortageCalculator
	{
		public static List<Shortfall> Compute(Dealer dealer)
		{
			//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)
			List<Shortfall> list = new List<Shortfall>();
			if ((Object)(object)dealer == (Object)null)
			{
				return list;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return list;
			}
			GameDateTime dateTime = instance.GetDateTime();
			int minSum = ((GameDateTime)(ref dateTime)).GetMinSum();
			int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(instance.CurrentTime);
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			List<ItemSlot> allSlots = dealer.GetAllSlots();
			if (allSlots != null)
			{
				Enumerator<ItemSlot> enumerator = allSlots.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ItemSlot current = enumerator.Current;
					ItemInstance val = ((current != null) ? current.ItemInstance : null);
					ItemDefinition val2 = ((val != null) ? val.Definition : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						string iD = ((BaseItemDefinition)val2).ID;
						if (!string.IsNullOrEmpty(iD))
						{
							dictionary[iD] = (dictionary.TryGetValue(iD, out var value) ? value : 0) + current.Quantity;
						}
					}
				}
			}
			List<(Contract, int)> list2 = new List<(Contract, int)>();
			List<Contract> activeContracts = dealer.ActiveContracts;
			if (activeContracts != null)
			{
				Enumerator<Contract> enumerator2 = activeContracts.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					Contract current2 = enumerator2.Current;
					if (!((Object)(object)current2 == (Object)null) && current2.ProductList != null)
					{
						list2.Add((current2, DueAbsMinute(current2, minSum, minSumFrom24HourTime)));
					}
				}
			}
			list2.Sort(((Contract contract, int dealAbs) a, (Contract contract, int dealAbs) b) => a.dealAbs.CompareTo(b.dealAbs));
			HashSet<string> hashSet = new HashSet<string>();
			foreach (var item3 in list2)
			{
				Contract item = item3.Item1;
				int item2 = item3.Item2;
				Enumerator<Entry> enumerator4 = item.ProductList.entries.GetEnumerator();
				while (enumerator4.MoveNext())
				{
					Entry current4 = enumerator4.Current;
					if (current4 == null)
					{
						continue;
					}
					string productID = current4.ProductID;
					if (!string.IsNullOrEmpty(productID))
					{
						int value2;
						int num = (dictionary[productID] = (dictionary.TryGetValue(productID, out value2) ? value2 : 0) - current4.Quantity);
						if (num < 0 && hashSet.Add(productID))
						{
							list.Add(new Shortfall
							{
								ProductName = ResolveName(productID),
								Deficit = -num,
								DealAbsMinute = item2
							});
						}
					}
				}
			}
			list.Sort((Shortfall a, Shortfall b) => a.DealAbsMinute.CompareTo(b.DealAbsMinute));
			return list;
		}

		private static int DueAbsMinute(Contract contract, int nowAbs, int nowMinOfDay)
		{
			QuestWindowConfig deliveryWindow = contract.DeliveryWindow;
			int num = ((deliveryWindow != null && deliveryWindow.IsEnabled) ? TimeManager.GetMinSumFrom24HourTime(deliveryWindow.WindowStartTime) : 0);
			int num2 = num - nowMinOfDay;
			if (num2 < 0)
			{
				num2 += 1440;
			}
			return nowAbs + num2;
		}

		public static string ResolveName(string productId)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(productId);
				string text = ((item != null) ? ((BaseItemDefinition)item).Name : null);
				return string.IsNullOrEmpty(text) ? productId : text;
			}
			catch
			{
				return productId;
			}
		}
	}
	internal sealed class DealerWeeklyStats
	{
		public int WeekIndex;

		public Dictionary<string, int> CurrentWeek = new Dictionary<string, int>();

		public Dictionary<string, int> LastWeek = new Dictionary<string, int>();
	}
	internal static class DealerStatsStore
	{
		private static readonly SaveSlotStore<DealerWeeklyStats> Store = new SaveSlotStore<DealerWeeklyStats>("DealerStats", "dealer sales stats");

		public static void Unload()
		{
			Store.Unload();
		}

		public static void Record(string dealerId, string productName, int quantity)
		{
			if (!string.IsNullOrEmpty(dealerId) && !string.IsNullOrEmpty(productName) && quantity > 0)
			{
				DealerWeeklyStats dealerWeeklyStats = Get(dealerId);
				dealerWeeklyStats.CurrentWeek[productName] = (dealerWeeklyStats.CurrentWeek.TryGetValue(productName, out var value) ? value : 0) + quantity;
				Store.Set(dealerId, dealerWeeklyStats);
			}
		}

		public static Dictionary<string, int> RollWeek(string dealerId, int newWeekIndex)
		{
			DealerWeeklyStats dealerWeeklyStats = Get(dealerId);
			Dictionary<string, int> result = (dealerWeeklyStats.LastWeek = new Dictionary<string, int>(dealerWeeklyStats.CurrentWeek));
			dealerWeeklyStats.CurrentWeek = new Dictionary<string, int>();
			dealerWeeklyStats.WeekIndex = newWeekIndex;
			Store.Set(dealerId, dealerWeeklyStats);
			return result;
		}

		private static DealerWeeklyStats Get(string dealerId)
		{
			DealerWeeklyStats value;
			return Store.TryGet(dealerId, out value) ? value : new DealerWeeklyStats();
		}
	}
}
namespace Lithium.Modules.Rent
{
	public class RentLocationConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = false;

		[JsonProperty(Order = 2)]
		public float WeeklyRent = 0f;

		[JsonProperty(Order = 3)]
		public string DeadDropName = "";

		[JsonProperty(Order = 4)]
		public string DeadDropGUID = "";

		[JsonProperty(Order = 5)]
		public string ContactNpcName = "Fixer";
	}
	public class ModRentConfiguration : ModuleConfiguration
	{
		[JsonProperty(Order = 1)]
		public int RentIntervalDays = 7;

		[JsonProperty(Order = 2)]
		public int DaysUntilLockout = 2;

		[JsonProperty(Order = 3)]
		public bool SendFinalWarning = true;

		[JsonProperty(Order = 4)]
		public Dictionary<string, RentLocationConfiguration> Locations = new Dictionary<string, RentLocationConfiguration>
		{
			["RV"] = new RentLocationConfiguration(),
			["Sweatshop"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 200f,
				DeadDropName = "North arcade wall",
				DeadDropGUID = "dd3d22f1-da56-4673-9203-640eeaf915fc",
				ContactNpcName = "Mrs. Ming"
			},
			["Hyland Manor"] = new RentLocationConfiguration(),
			["Motel Room"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 75f,
				DeadDropName = "Behind motel office",
				DeadDropGUID = "d66b3fd6-7b7f-4e98-b000-6d5a197f7437",
				ContactNpcName = "Donna Martin"
			},
			["Sewer Office"] = new RentLocationConfiguration(),
			["Laundromat"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 250f,
				DeadDropName = "Alleyway behind the laundromat",
				DeadDropGUID = "555e565d-2f65-4882-9edb-7167168b2e00",
				ContactNpcName = "Doris Lubbin"
			},
			["Storage Unit"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 500f,
				DeadDropName = "Behind Casino",
				DeadDropGUID = "f5614c42-2c74-42d5-bee2-025e84718792",
				ContactNpcName = "Geraldine Poon"
			},
			["Taco Ticklers"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 1000f,
				DeadDropName = "Taco Ticklers exterior wall",
				DeadDropGUID = "79200bb6-7d39-44d9-ab22-c63f136d8cdf",
				ContactNpcName = "Dean Webster"
			},
			["Bungalow"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 300f,
				DeadDropName = "Brown apartment block",
				DeadDropGUID = "b77ed1a0-c729-41d5-b8a2-81b480ca971f",
				ContactNpcName = "Hank Stevenson"
			},
			["Barn"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 750f,
				DeadDropName = "Behind fire station",
				DeadDropGUID = "86835825-f5f8-454d-9c74-c31e257f9cc2",
				ContactNpcName = "Harold Colt"
			},
			["Post Office"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 850f,
				DeadDropName = "Central canal",
				DeadDropGUID = "4ac50ff1-ad3c-415b-aa77-c80249dfa473",
				ContactNpcName = "Bruce Norton"
			},
			["Car Wash"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 1000f,
				DeadDropName = "Behind auto shop",
				DeadDropGUID = "aaea12a7-ee38-47ba-aeb8-fb0d45a03957",
				ContactNpcName = "Kelly Reynolds"
			},
			["Docks Warehouse"] = new RentLocationConfiguration
			{
				Enabled = true,
				WeeklyRent = 2500f,
				DeadDropName = "Behind Randy's bait & tackle",
				DeadDropGUID = "baf08ceb-a0e7-4e4a-baa8-6b4cc992cb15",
				ContactNpcName = "Carl Bundy"
			}
		};

		public override string Name => "Rent";

		public override void Validate()
		{
			RentIntervalDays = ConfigValidator.AtLeast(Name, "RentIntervalDays", RentIntervalDays, 1);
			DaysUntilLockout = ConfigValidator.AtLeast(Name, "DaysUntilLockout", DaysUntilLockout, 0);
			foreach (string item in Locations.Keys.ToList())
			{
				RentLocationConfiguration rentLocationConfiguration = Locations[item];
				rentLocationConfiguration.WeeklyRent = ConfigValidator.AtLeast(Name, "Locations[" + item + "].WeeklyRent", rentLocationConfiguration.WeeklyRent, 0f);
			}
		}
	}
	public class ModRent : ModuleBase<ModRentConfiguration>
	{
		public sealed class RentAppView
		{
			public string PropertyName;

			public string PropertyCode;

			public float WeeklyRent;

			public float Owed;

			public bool Paid;

			public bool FirstWeek;

			public bool LockedOut;

			public bool HasNextDue;

			public int DaysUntilDue;

			public EDay NextDueWeekday;

			public bool HasOwedDue;

			public int DaysOverdue;

			public EDay OwedDueWeekday;

			public string DeadDropName;

			public string ContactName;
		}

		private static readonly SaveSlotStore<RentLocationState> Store = new SaveSlotStore<RentLocationState>("Rent", "rent state");

		private static readonly HashSet<string> LockedCodes = new HashSet<string>();

		private const string BaselineKey = "__lithium_rent_baseline_v2__";

		private const string LegacyBaselineKey = "__lithium_rent_baseline__";

		private bool _baselineReady;

		private int _lastElapsedDay = -1;

		private bool _initialised;

		private float _nextDriveTime;

		public override void Apply()
		{
			DiscoverLocations();
			if (base.Configuration.Enabled)
			{
				Store.Unload();
				LockedCodes.Clear();
				_baselineReady = false;
				_lastElapsedDay = -1;
				_initialised = false;
				_nextDriveTime = 0f;
				MelonCoroutines.Start(LoadReminderRoutine());
			}
		}

		private static IEnumerator LoadReminderRoutine()
		{
			for (float waited = 0f; waited < 30f; waited += 1f)
			{
				if (WorldReady())
				{
					break;
				}
				yield return (object)new WaitForSeconds(1f);
			}
			if (!WorldReady())
			{
				Log.Warning("[Rent] World not ready after 30s; skipped load rent reminders.");
				yield break;
			}
			yield return (object)new WaitForSeconds(2f);
			Core.Get<ModRent>()?.SendLoadReminders();
		}

		private static bool WorldReady()
		{
			return (Object)(object)NetworkSingleton<MessagingManager>.Instance != (Object)null && NPCManager.NPCRegistry != null && NPCManager.NPCRegistry.Count > 0;
		}

		public void DriveUpdate()
		{
			if (!base.Configuration.Enabled || !InstanceFinder.IsServer)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextDriveTime)
			{
				return;
			}
			_nextDriveTime = realtimeSinceStartup + 1f;
			try
			{
				Tick();
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Drive update failed: " + ex.Message);
			}
		}

		public void Tick()
		{
			if (!base.Configuration.Enabled)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if (!((Object)(object)instance == (Object)null) && EnsureBaseline())
			{
				int elapsedDays = instance.ElapsedDays;
				if (!_initialised)
				{
					DiscoverLocations();
					RebuildLockedFromState();
					ReconcileLockoutsOnLoad(elapsedDays);
					PublishAll();
					_lastElapsedDay = elapsedDays;
					_initialised = true;
				}
				AnchorNewLocations(elapsedDays);
				ScanDeadDropPayments();
				if (elapsedDays != _lastElapsedDay)
				{
					_lastElapsedDay = elapsedDays;
					ProcessDay(elapsedDays);
				}
			}
		}

		private bool EnsureBaseline()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			if (_baselineReady)
			{
				return true;
			}
			LoadManager instance = Singleton<LoadManager>.Instance;
			if ((Object)(object)instance == (Object)null || !instance.IsGameLoaded || instance.IsLoading || (int)instance.LoadStatus > 0)
			{
				return false;
			}
			if (!Store.TryGet("__lithium_rent_baseline_v2__", out var value))
			{
				TimeManager instance2 = NetworkSingleton<TimeManager>.Instance;
				int today = ((instance2 != null) ? instance2.ElapsedDays : 0);
				if (Store.TryGet("__lithium_rent_baseline__", out value))
				{
					int num = 0;
					foreach (var item5 in EnabledOwnedLocations())
					{
						Property item = item5.Item1;
						RentLocationConfiguration item2 = item5.Item2;
						string propertyCode = item.PropertyCode;
						if (!string.IsNullOrEmpty(propertyCode) && Store.TryGet(propertyCode, out var value2) && !value2.LockedOut)
						{
							RentLocationState rentLocationState = new RentLocationState();
							ApplyDueCharges(rentLocationState, item2, today);
							Store.Set(propertyCode, rentLocationState);
							num++;
						}
					}
					Store.Remove("__lithium_rent_baseline__");
					Store.Set("__lithium_rent_baseline_v2__", new RentLocationState());
					Log.Info($"[Rent] Migrated rent baseline to first-week-free ({num} location(s) re-anchored).");
					_baselineReady = true;
					return true;
				}
				int num2 = 0;
				foreach (var item6 in EnabledOwnedLocations())
				{
					Property item3 = item6.Item1;
					RentLocationConfiguration item4 = item6.Item2;
					string propertyCode2 = item3.PropertyCode;
					if (!string.IsNullOrEmpty(propertyCode2) && !Store.TryGet(propertyCode2, out value))
					{
						RentLocationState rentLocationState2 = new RentLocationState();
						ApplyDueCharges(rentLocationState2, item4, today);
						Store.Set(propertyCode2, rentLocationState2);
						num2++;
					}
				}
				Store.Set("__lithium_rent_baseline_v2__", new RentLocationState());
				Log.Info($"[Rent] Rent baseline established ({num2} pre-existing location(s) anchored, first week free).");
			}
			_baselineReady = true;
			return true;
		}

		private void AnchorNewLocations(int today)
		{
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				string propertyCode = item.PropertyCode;
				if (!string.IsNullOrEmpty(propertyCode) && !Store.TryGet(propertyCode, out var _))
				{
					RentLocationState rentLocationState = new RentLocationState();
					ApplyDueCharges(rentLocationState, item2, today);
					Store.Set(propertyCode, rentLocationState);
					PublishState(propertyCode, rentLocationState);
					Log.Info($"[Rent] Anchored freshly acquired '{item.PropertyName}' at day {today}; first period free.");
				}
			}
		}

		public void DebugToggleLockout()
		{
			if (!base.Configuration.Enabled)
			{
				Log.Warning("[Rent] Lockout test ignored: the Rent module is disabled.");
				return;
			}
			if (!InstanceFinder.IsServer)
			{
				Log.Warning("[Rent] Lockout test ignored: only the host can change rent state.");
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			int dueSinceDay = ((instance != null) ? instance.ElapsedDays : 0);
			int num = 0;
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				string propertyCode = item.PropertyCode;
				if (string.IsNullOrEmpty(propertyCode))
				{
					continue;
				}
				RentLocationState value;
				RentLocationState rentLocationState = (Store.TryGet(propertyCode, out value) ? value : new RentLocationState());
				if (rentLocationState.LockedOut)
				{
					rentLocationState.LockedOut = false;
					rentLocationState.Owed = 0f;
					rentLocationState.DueSinceDay = -1;
					rentLocationState.WarningSent = false;
					LockedCodes.Remove(propertyCode);
					RentMessenger.Send(item2, "[TEST] Lockout cleared for " + item.PropertyName + ". Your access is restored.");
				}
				else
				{
					if (rentLocationState.Owed <= 0f)
					{
						rentLocationState.Owed = ((item2.WeeklyRent > 0f) ? item2.WeeklyRent : 1f);
					}
					if (rentLocationState.DueSinceDay < 0)
					{
						rentLocationState.DueSinceDay = dueSinceDay;
					}
					rentLocationState.LockedOut = true;
					LockedCodes.Add(propertyCode);
					RentMessenger.Send(item2, $"[TEST] You're locked out of {item.PropertyName}. Pay the ${rentLocationState.Owed:N0} you owe at {item2.DeadDropName} to get back in.");
				}
				Store.Set(propertyCode, rentLocationState);
				PublishState(propertyCode, rentLocationState);
				num++;
			}
			Log.Warning((num > 0) ? $"[Rent] Lockout test toggled {num} owned, rent-enabled location(s)." : "[Rent] Lockout test: no owned, rent-enabled locations found (own the property and enable its rent first).");
		}

		private void ProcessDay(int today)
		{
			DiscoverLocations();
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				string propertyCode = item.PropertyCode;
				RentLocationState value;
				RentLocationState rentLocationState = (Store.TryGet(propertyCode, out value) ? value : new RentLocationState());
				if (rentLocationState.LockedOut)
				{
					rentLocationState.LastChargedDay = today;
					RentMessenger.Send(item2, StillLockedMessage(item, item2, rentLocationState.Owed));
					Store.Set(propertyCode, rentLocationState);
					PublishState(propertyCode, rentLocationState);
					continue;
				}
				bool flag = ApplyDueCharges(rentLocationState, item2, today);
				bool flag2 = false;
				if (flag)
				{
					float num = Core.Get<ModElectricBill>()?.BillNowWithRent(item) ?? 0f;
					string text = $"Rent of ${item2.WeeklyRent:N0} for {item.PropertyName} is due";
					if (num > 0.01f)
					{
						text += $", plus ${num:N0} electricity";
					}
					text += $". Drop it at {item2.DeadDropName}. You have {base.Configuration.DaysUntilLockout} day(s) before I change the locks.";
					RentMessenger.Send(item2, text);
					flag2 = true;
				}
				string text2 = ReconcileOverdue(item, item2, propertyCode, rentLocationState, today);
				if (text2 != null)
				{
					RentMessenger.Send(item2, text2);
					flag2 = true;
				}
				if (rentLocationState.Owed > 0f && rentLocationState.DueSinceDay >= 0 && !rentLocationState.LockedOut && !flag2)
				{
					RentMessenger.Send(item2, ReminderMessage(item, item2, rentLocationState.Owed));
				}
				Store.Set(propertyCode, rentLocationState);
				PublishState(propertyCode, rentLocationState);
			}
		}

		private bool ApplyDueCharges(RentLocationState state, RentLocationConfiguration loc, int today)
		{
			if (state.LastChargedDay < 0)
			{
				state.LastChargedDay = today;
			}
			bool result = false;
			while (today - state.LastChargedDay >= base.Configuration.RentIntervalDays)
			{
				state.LastChargedDay += base.Configuration.RentIntervalDays;
				state.Owed += loc.WeeklyRent;
				if (state.DueSinceDay < 0)
				{
					state.DueSinceDay = state.LastChargedDay;
				}
				result = true;
			}
			return result;
		}

		private string ReconcileOverdue(Property prop, RentLocationConfiguration loc, string code, RentLocationState state, int today)
		{
			if (state.LockedOut || state.Owed <= 0f || state.DueSinceDay < 0)
			{
				return null;
			}
			int num = today - state.DueSinceDay;
			if (num >= base.Configuration.DaysUntilLockout)
			{
				state.LockedOut = true;
				LockedCodes.Add(code);
				return $"You're locked out of {prop.PropertyName}. Pay the ${state.Owed:N0} you owe at {loc.DeadDropName} to get back in{ElectricClause(prop)}.";
			}
			if (base.Configuration.SendFinalWarning && !state.WarningSent && base.Configuration.DaysUntilLockout >= 1 && num == base.Configuration.DaysUntilLockout - 1)
			{
				state.WarningSent = true;
				return $"Final warning: ${state.Owed:N0} rent still owed for {prop.PropertyName}{ElectricClause(prop)}. Pay at {loc.DeadDropName} by tomorrow or you're locked out.";
			}
			return null;
		}

		private void ReconcileLockoutsOnLoad(int today)
		{
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				string propertyCode = item.PropertyCode;
				if (!string.IsNullOrEmpty(propertyCode) && Store.TryGet(propertyCode, out var value) && !value.LockedOut)
				{
					ApplyDueCharges(value, item2, today);
					ReconcileOverdue(item, item2, propertyCode, value, today);
					Store.Set(propertyCode, value);
					PublishState(propertyCode, value);
				}
			}
		}

		private void SendLoadReminders()
		{
			if (!base.Configuration.Enabled)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if ((Object)(object)instance == (Object)null || !EnsureBaseline())
			{
				return;
			}
			int elapsedDays = instance.ElapsedDays;
			int num = 0;
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				string propertyCode = item.PropertyCode;
				RentLocationState value;
				RentLocationState rentLocationState = (Store.TryGet(propertyCode, out value) ? value : new RentLocationState());
				if (!rentLocationState.LockedOut)
				{
					ApplyDueCharges(rentLocationState, item2, elapsedDays);
					ReconcileOverdue(item, item2, propertyCode, rentLocationState, elapsedDays);
				}
				Store.Set(propertyCode, rentLocationState);
				PublishState(propertyCode, rentLocationState);
				if (!(rentLocationState.Owed <= 0f))
				{
					RentMessenger.Send(item2, rentLocationState.LockedOut ? StillLockedMessage(item, item2, rentLocationState.Owed) : ReminderMessage(item, item2, rentLocationState.Owed));
					num++;
				}
			}
			Log.Info($"[Rent] Load reminders sent for {num} location(s) with outstanding rent.");
		}

		private static string StillLockedMessage(Property prop, RentLocationConfiguration loc, float owed)
		{
			return $"You're still locked out of {prop.PropertyName}. Pay the ${owed:N0} you owe at {loc.DeadDropName} to get back in{ElectricClause(prop)}.";
		}

		private static string ReminderMessage(Property prop, RentLocationConfiguration loc, float owed)
		{
			return $"Reminder: ${owed:N0} rent still owed for {prop.PropertyName}{ElectricClause(prop)}. Drop it at {loc.DeadDropName}.";
		}

		private static float ElectricOutstanding(Property prop)
		{
			ModElectricBill modElectricBill = Core.Get<ModElectricBill>();
			return (modElectricBill != null && (Object)(object)prop != (Object)null) ? modElectricBill.GetOutstandingBill(prop.PropertyCode) : 0f;
		}

		private static string ElectricClause(Property prop)
		{
			float num = ElectricOutstanding(prop);
			return (num > 0.01f) ? $" (plus ${num:N0} electricity)" : "";
		}

		public void ProcessPayment(StorageEntity closed)
		{
			if (!base.Configuration.Enabled || (Object)(object)closed == (Object)null || !InstanceFinder.IsServer)
			{
				return;
			}
			try
			{
				int instanceID = ((Object)closed).GetInstanceID();
				Enumerator<DeadDrop> enumerator = DeadDrop.DeadDrops.GetEnumerator();
				while (enumerator.MoveNext())
				{
					DeadDrop current = enumerator.Current;
					if ((Object)(object)current != (Object)null && (Object)(object)current.Storage != (Object)null && ((Object)current.Storage).GetInstanceID() == instanceID)
					{
						CreditFromDrop(current);
						break;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Payment processing failed: " + ex.Message);
			}
		}

		public void ScanDeadDropPayments()
		{
			if (!base.Configuration.Enabled || !InstanceFinder.IsServer)
			{
				return;
			}
			List<DeadDrop> deadDrops = DeadDrop.DeadDrops;
			if (deadDrops == null)
			{
				return;
			}
			Enumerator<DeadDrop> enumerator = deadDrops.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeadDrop current = enumerator.Current;
				if (!((Object)(object)current == (Object)null) && !((Object)(object)current.Storage == (Object)null))
				{
					try
					{
						CreditFromDrop(current);
					}
					catch (Exception ex)
					{
						Log.Warning("[Rent] Dead drop payment scan failed: " + ex.Message);
					}
				}
			}
		}

		private void CreditFromDrop(DeadDrop drop)
		{
			//IL_002c: 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)
			if ((Object)(object)drop == (Object)null || (Object)(object)drop.Storage == (Object)null)
			{
				return;
			}
			string deadDropName = drop.DeadDropName;
			string b = ((object)drop.GUID/*cast due to .constrained prefix*/).ToString();
			string propertyName = null;
			RentLocationConfiguration rentLocationConfiguration = null;
			foreach (KeyValuePair<string, RentLocationConfiguration> location in base.Configuration.Locations)
			{
				RentLocationConfiguration value = location.Value;
				if (!value.Enabled || ((string.IsNullOrEmpty(value.DeadDropGUID) || !string.Equals(value.DeadDropGUID, b, StringComparison.OrdinalIgnoreCase)) && (!string.IsNullOrEmpty(value.DeadDropGUID) || string.IsNullOrEmpty(value.DeadDropName) || !(value.DeadDropName == deadDropName))))
				{
					continue;
				}
				propertyName = location.Key;
				rentLocationConfiguration = value;
				break;
			}
			if (rentLocationConfiguration == null)
			{
				return;
			}
			Property val = FindOwned(propertyName);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string propertyCode = val.PropertyCode;
			float num = 0f;
			float rentOwed = 0f;
			bool rentCleared = false;
			bool accessRestored = false;
			if (Store.TryGet(propertyCode, out var value2) && value2.Owed > 0f)
			{
				num = TakeCash((StorageEntity)(object)drop.Storage, value2.Owed);
				if (num > 0f)
				{
					value2.Owed -= num;
					if (value2.Owed < 0.01f)
					{
						value2.Owed = 0f;
						value2.DueSinceDay = -1;
						value2.WarningSent = false;
						accessRestored = value2.LockedOut;
						value2.LockedOut = false;
						LockedCodes.Remove(propertyCode);
						rentCleared = true;
					}
					rentOwed = value2.Owed;
					Store.Set(propertyCode, value2);
					PublishState(propertyCode, value2);
				}
			}
			float num2 = 0f;
			float electricOwed = 0f;
			bool electricCleared = false;
			bool powerRestored = false;
			ModElectricBill modElectricBill = Core.Get<ModElectricBill>();
			if (modElectricBill != null)
			{
				float outstandingBill = modElectricBill.GetOutstandingBill(propertyCode);
				if (outstandingBill > 0f)
				{
					float num3 = TakeCash((StorageEntity)(object)drop.Storage, outstandingBill);
					if (num3 > 0f)
					{
						ModElectricBill.CashPaymentResult cashPaymentResult = modElectricBill.ApplyCashPayment(val, num3, announce: false);
						num2 = cashPaymentResult.Paid;
						electricOwed = cashPaymentResult.Remaining;
						electricCleared = cashPaymentResult.Cleared;
						powerRestored = cashPaymentResult.PowerRestored;
					}
				}
			}
			if (num > 0f || num2 > 0f)
			{
				RentMessenger.Send(rentLocationConfiguration, ComposeDropMessage(val, rentLocationConfiguration, num, rentOwed, rentCleared, accessRestored, num2, electricOwed, electricCleared, powerRestored));
			}
		}

		private static string ComposeDropMessage(Property prop, RentLocationConfiguration loc, float rentPaid, float rentOwed, bool rentCleared, bool accessRestored, float electricPaid, float electricOwed, bool electricCleared, bool powerRestored)
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder stringBuilder3 = stringBuilder2;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(15, 2, stringBuilder2);
			handler.AppendLiteral("Received $");
			handler.AppendFormatted(rentPaid + electricPaid, "N0");
			handler.AppendLiteral(" for ");
			handler.AppendFormatted(prop.PropertyName);
			stringBuilder3.Append(ref handler);
			List<string> list = new List<string>();
			if (rentPaid > 0f)
			{
				list.Add(rentCleared ? $"${rentPaid:N0} rent (paid up)" : $"${rentPaid:N0} rent (${rentOwed:N0} still owed)");
			}
			if (electricPaid > 0f)
			{
				list.Add(electricCleared ? $"${electricPaid:N0} electricity (paid up)" : $"${electricPaid:N0} electricity (${electricOwed:N0} still owed)");
			}
			if (list.Count > 0)
			{
				stringBuilder.Append(": ").Append(string.Join(", ", list));
			}
			stringBuilder.Append('.');
			if (accessRestored)
			{
				stringBuilder.Append(" Your access is restored.");
			}
			if (powerRestored)
			{
				stringBuilder.Append(" Power is back on.");
			}
			if ((rentPaid > 0f && !rentCleared) || (electricPaid > 0f && !electricCleared))
			{
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(19, 1, stringBuilder2);
				handler.AppendLiteral(" Drop the rest at ");
				handler.AppendFormatted(loc.DeadDropName);
				handler.AppendLiteral(".");
				stringBuilder4.Append(ref handler);
			}
			return stringBuilder.ToString();
		}

		private static float TakeCash(StorageEntity storage, float max)
		{
			float num = max;
			Enumerator<ItemSlot> enumerator = storage.ItemSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				if (num <= 0f)
				{
					break;
				}
				ItemInstance val = ((current != null) ? current.ItemInstance : null);
				CashInstance val2 = ((val != null) ? ((Il2CppObjectBase)val).TryCast<CashInstance>() : null);
				if (val2 != null)
				{
					float balance = val2.Balance;
					if (!(balance <= 0f))
					{
						float num2 = Math.Min(balance, num);
						val2.SetBalance(balance - num2, false);
						num -= num2;
					}
				}
			}
			return max - num;
		}

		public static bool IsLockedOut(string propertyCode)
		{
			if (string.IsNullOrEmpty(propertyCode))
			{
				return false;
			}
			if (!InstanceFinder.IsServer)
			{
				return HostStateSync.GetBool("rent_locked_" + propertyCode);
			}
			return LockedCodes.Contains(propertyCode);
		}

		private static void PublishState(string code, RentLocationState state)
		{
			if (!string.IsNullOrEmpty(code) && state != null)
			{
				HostStateSync.SetBool("rent_locked_" + code, state.LockedOut);
				HostStateSync.SetNumber("rent_owed_" + code, state.Owed);
				HostStateSync.SetNumber("rent_lastcharged_" + code, state.LastChargedDay);
				HostStateSync.SetNumber("rent_duesince_" + code, state.DueSinceDay);
			}
		}

		private void PublishAll()
		{
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			foreach (var (val, rentLocationConfiguration) in EnabledOwnedLocations())
			{
				if (Store.TryGet(val.PropertyCode, out var value))
				{
					PublishState(val.PropertyCode, value);
				}
			}
		}

		private bool TryGetViewState(string code, out RentLocationState state)
		{
			if (InstanceFinder.IsServer)
			{
				return Store.TryGet(code, out state);
			}
			state = new RentLocationState
			{
				LockedOut = HostStateSync.GetBool("rent_locked_" + code),
				Owed = HostStateSync.GetNumber("rent_owed_" + code),
				LastChargedDay = (int)HostStateSync.GetNumber("rent_lastcharged_" + code, -1f),
				DueSinceDay = (int)HostStateSync.GetNumber("rent_duesince_" + code, -1f)
			};
			return true;
		}

		public List<RentAppView> GetAppViews()
		{
			//IL_0049: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_0226: 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_0235: Unknown result type (might be due to invalid IL or missing references)
			List<RentAppView> list = new List<RentAppView>();
			if (!base.Configuration.Enabled)
			{
				return list;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			int num = (((Object)(object)instance != (Object)null) ? instance.ElapsedDays : (-1));
			EDay today = (EDay)(((Object)(object)instance != (Object)null) ? ((int)instance.CurrentDay) : 0);
			foreach (var item3 in EnabledOwnedLocations())
			{
				Property item = item3.Item1;
				RentLocationConfiguration item2 = item3.Item2;
				RentLocationState state;
				bool flag = TryGetViewState(item.PropertyCode, out state);
				RentAppView rentAppView = new RentAppView
				{
					PropertyName = item.PropertyName,
					PropertyCode = item.PropertyCode,
					WeeklyRent = item2.WeeklyRent,
					DeadDropName = (string.IsNullOrEmpty(item2.DeadDropName) ? "—" : item2.DeadDropName),
					ContactName = (string.IsNullOrEmpty(item2.ContactNpcName) ? "—" : item2.ContactNpcName),
					Owed = (flag ? state.Owed : 0f),
					LockedOut = (flag && state.LockedOut)
				};
				rentAppView.FirstWeek = !flag || state.LastChargedDay < 0 || (num >= 0 && state.LastChargedDay >= num && rentAppView.Owed <= 0f);
				rentAppView.Paid = rentAppView.Owed <= 0f;
				if (flag && state.LastChargedDay >= 0 && num >= 0)
				{
					rentAppView.DaysUntilDue = Math.Max(0, state.LastChargedDay + base.Configuration.RentIntervalDays - num);
					rentAppView.NextDueWeekday = Weekday(today, rentAppView.DaysUntilDue);
					rentAppView.HasNextDue = true;
				}
				if (flag && rentAppView.Owed > 0f && !rentAppView.FirstWeek && state.DueSinceDay >= 0 && num >= 0)
				{
					rentAppView.DaysOverdue = Math.Max(0, num - state.DueSinceDay);
					rentAppView.OwedDueWeekday = Weekday(today, state.DueSinceDay - num);
					rentAppView.HasOwedDue = true;
				}
				list.Add(rentAppView);
			}
			return list;
		}

		private static EDay Weekday(EDay today, int dayOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return (EDay)(((today + dayOffset) % 7 + 7) % 7);
		}

		private void RebuildLockedFromState()
		{
			try
			{
				LockedCodes.Clear();
				foreach (Property item in AllOwned())
				{
					if (Store.TryGet(item.PropertyCode, out var value) && value.LockedOut)
					{
						LockedCodes.Add(item.PropertyCode);
					}
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Failed to rebuild locked set: " + ex.Message);
			}
		}

		private void DiscoverLocations()
		{
			try
			{
				bool flag = false;
				foreach (Property item in AllProperties())
				{
					string propertyName = item.PropertyName;
					if (!string.IsNullOrEmpty(propertyName) && !base.Configuration.Locations.ContainsKey(propertyName))
					{
						base.Configuration.Locations[propertyName] = new RentLocationConfiguration();
						flag = true;
						Log.Info("[Rent] Discovered location '" + propertyName + "'");
					}
				}
				if (flag)
				{
					base.Configuration.SaveConfiguration();
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Location discovery failed: " + ex.Message);
			}
		}

		private IEnumerable<(Property, RentLocationConfiguration)> EnabledOwnedLocations()
		{
			foreach (Property prop in AllOwned())
			{
				if (base.Configuration.Locations.TryGetValue(prop.PropertyName, out var loc) && loc.Enabled && loc.WeeklyRent > 0f)
				{
					yield return (prop, loc);
				}
				loc = null;
			}
		}

		private static Property FindOwned(string propertyName)
		{
			foreach (Property item in AllOwned())
			{
				if (item.PropertyName == propertyName)
				{
					return item;
				}
			}
			return null;
		}

		private static IEnumerable<Property> AllOwned()
		{
			return Deduplicate(Property.OwnedProperties, Business.OwnedBusinesses);
		}

		private static IEnumerable<Property> AllProperties()
		{
			return Deduplicate(Property.Properties, Business.Businesses);
		}

		private static IEnumerable<Property> Deduplicate(List<Property> properties, List<Business> businesses)
		{
			HashSet<string> seen = new HashSet<string>();
			if (properties != null)
			{
				Enumerator<Property> enumerator = properties.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Property p = enumerator.Current;
					if (!((Object)(object)p == (Object)null))
					{
						string c = p.PropertyCode;
						if (!string.IsNullOrEmpty(c) && seen.Add(c))
						{
							yield return p;
						}
					}
				}
			}
			if (businesses == null)
			{
				yield break;
			}
			Enumerator<Business> enumerator2 = businesses.GetEnumerator();
			while (enumerator2.MoveNext())
			{
				Business b = enumerator2.Current;
				if (!((Object)(object)b == (Object)null))
				{
					Property p2 = (Property)(object)b;
					string c2 = p2.PropertyCode;
					if (!string.IsNullOrEmpty(c2) && seen.Add(c2))
					{
						yield return p2;
					}
				}
			}
		}
	}
	public class RentLocationState
	{
		public float Owed;

		public int LastChargedDay = -1;

		public int DueSinceDay = -1;

		public bool WarningSent;

		public bool LockedOut;
	}
	public static class RentMessenger
	{
		public static void Send(RentLocationConfiguration location, string message)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			if (location == null)
			{
				return;
			}
			try
			{
				NPC val = Resolve(location.ContactNpcName);
				if ((Object)(object)val == (Object)null)
				{
					Log.Warning("[Rent] Contact NPC '" + location.ContactNpcName + "' not found; message dropped: " + message);
					return;
				}
				MSGConversation mSGConversation = val.MSGConversation;
				if (mSGConversation != null)
				{
					mSGConversation.SetIsKnown(true);
				}
				NetworkSingleton<MessagingManager>.Instance.ReceiveMessage(new Message(message, (ESenderType)1, false, -1), true, val.ID);
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Failed to send message via '" + location.ContactNpcName + "': " + ex.Message);
			}
		}

		private static NPC Resolve(string fullName)
		{
			if (string.IsNullOrEmpty(fullName) || NPCManager.NPCRegistry == null)
			{
				return null;
			}
			foreach (NPC item in NPCManager.NPCRegistry.ToList<NPC>())
			{
				if ((Object)(object)item != (Object)null && string.Equals(item.fullName, fullName, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}
	}
	public static class RentDebug
	{
		public static void Dump()
		{
			//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_00d8: 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_010e: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== Lithium Dead Drops ===");
				if (DeadDrop.DeadDrops != null)
				{
					StringBuilder stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder3 = stringBuilder2;
					StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(7, 1, stringBuilder2);
					handler.AppendLiteral("Total: ");
					handler.AppendFormatted(DeadDrop.DeadDrops.Count);
					stringBuilder3.AppendLine(ref handler);
					Enumerator<DeadDrop> enumerator = DeadDrop.DeadDrops.GetEnumerator();
					while (enumerator.MoveNext())
					{
						DeadDrop current = enumerator.Current;
						if (!((Object)(object)current == (Object)null))
						{
							Vector3 position = ((Component)current).transform.position;
							stringBuilder2 = stringBuilder;
							StringBuilder stringBuilder4 = stringBuilder2;
							handler = new StringBuilder.AppendInterpolatedStringHandler(37, 6, stringBuilder2);
							handler.AppendLiteral("  name=\"");
							handler.AppendFormatted(current.DeadDropName);
							handler.AppendLiteral("\"  guid=");
							handler.AppendFormatted<Guid>(current.GUID);
							handler.AppendLiteral("  region=");
							handler.AppendFormatted<EMapRegion>(current.Region);
							handler.AppendLiteral("  pos=(");
							handler.AppendFormatted(position.x, "F1");
							handler.AppendLiteral(", ");
							handler.AppendFormatted(position.y, "F1");
							handler.AppendLiteral(", ");
							handler.AppendFormatted(position.z, "F1");
							handler.AppendLiteral(")");
							stringBuilder4.AppendLine(ref handler);
						}
					}
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("=== Properties & Businesses (owned=*) ===");
				HashSet<string> seen = new HashSet<string>();
				DumpProperties(stringBuilder, Property.Properties, seen);
				DumpBusinesses(stringBuilder, seen);
				stringBuilder.AppendLine();
				DumpContacts(stringBuilder);
				string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lithium");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "RentLocations.txt");
				File.WriteAllText(text2, stringBuilder.ToString());
				Log.Warning("[Rent] Wrote dead drop / property dump to " + text2);
			}
			catch (Exception value)
			{
				Log.Error($"[Rent] Dump failed: {value}");
			}
		}

		private static void DumpProperties(StringBuilder sb, List<Property> list, HashSet<string> seen)
		{
			if (list == null)
			{
				return;
			}
			Enumerator<Property> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Property current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					WriteProperty(sb, current, seen);
				}
			}
		}

		private static void DumpBusinesses(StringBuilder sb, HashSet<string> seen)
		{
			if (Business.Businesses == null)
			{
				return;
			}
			Enumerator<Business> enumerator = Business.Businesses.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Business current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					WriteProperty(sb, (Property)(object)current, seen);
				}
			}
		}

		private static void WriteProperty(StringBuilder sb, Property prop, HashSet<string> seen)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_011a: 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)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(prop.PropertyCode) || seen.Add(prop.PropertyCode))
			{
				Vector3 position = ((Component)prop).transform.position;
				float dist;
				DeadDrop val = NearestDrop(position, out dist);
				string value = (((Object)(object)val != (Object)null) ? $"\"{val.DeadDropName}\" ({dist:F0}m)" : "(none)");
				string value2 = (prop.IsOwned ? "* " : "  ");
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(40, 7, sb);
				handler.AppendFormatted(value2);
				handler.AppendLiteral("name=\"");
				handler.AppendFormatted(prop.PropertyName);
				handler.AppendLiteral("\"  code=");
				handler.AppendFormatted(prop.PropertyCode);
				handler.AppendLiteral("  pos=(");
				handler.AppendFormatted(position.x, "F1");
				handler.AppendLiteral(", ");
				handler.AppendFormatted(position.y, "F1");
				handler.AppendLiteral(", ");
				handler.AppendFormatted(position.z, "F1");
				handler.AppendLiteral(")  nearestDrop=");
				handler.AppendFormatted(value);
				sb.AppendLine(ref handler);
			}
		}

		private static void DumpContacts(StringBuilder sb)
		{
			sb.AppendLine("=== Available Contacts (set as ContactNpcName) ===");
			sb.AppendLine("** = good candidate (has a conversation, not a customer). Avoid customers — texting them may interfere with deals.");
			if (NPCManager.NPCRegistry == null)
			{
				sb.AppendLine("  (NPC registry not available — load into a save first)");
				return;
			}
			HashSet<string> hashSet = new HashSet<string>();
			if (Customer.UnlockedCustomers != null)
			{
				Enumerator<Customer> enumerator = Customer.UnlockedCustomers.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Customer current = enumerator.Current;
					if ((Object)(object)current != (Object)null && (Object)(object)current.NPC != (Object)null)
					{
						hashSet.Add(current.NPC.ID);
					}
				}
			}
			if (Customer.LockedCustomers != null)
			{
				Enumerator<Customer> enumerator2 = Customer.LockedCustomers.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					Customer current2 = enumerator2.Current;
					if ((Object)(object)current2 != (Object)null && (Object)(object)current2.NPC != (Object)null)
					{
						hashSet.Add(current2.NPC.ID);
					}
				}
			}
			Enumerator<NPC> enumerator3 = NPCManager.NPCRegistry.GetEnumerator();
			while (enumerator3.MoveNext())
			{
				NPC current3 = enumerator3.Current;
				if (!((Object)(object)current3 == (Object)null))
				{
					bool flag = hashSet.Contains(current3.ID);
					bool flag2 = current3.MSGConversation != null;
					bool flag3 = flag2 && !flag;
					string name = ((MemberInfo)((Object)current3).GetIl2CppType()).Name;
					StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(40, 5, sb);
					handler.AppendFormatted(flag3 ? "** " : "   ");
					handler.AppendLiteral("name=\"");
					handler.AppendFormatted(current3.fullName);
					handler.AppendLiteral("\"  type=");
					handler.AppendFormatted(name);
					handler.AppendLiteral("  customer=");
					handler.AppendFormatted(flag);
					handler.AppendLiteral("  conversation=");
					handler.AppendFormatted(flag2);
					sb.AppendLine(ref handler);
				}
			}
		}

		private static DeadDrop NearestDrop(Vector3 from, out float dist)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			DeadDrop result = null;
			dist = float.MaxValue;
			if (DeadDrop.DeadDrops == null)
			{
				return null;
			}
			Enumerator<DeadDrop> enumerator = DeadDrop.DeadDrops.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeadDrop current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					float num = Vector3.Distance(((Component)current).transform.position, from);
					if (num < dist)
					{
						dist = num;
						result = current;
					}
				}
			}
			return result;
		}
	}
}
namespace Lithium.Modules.Rent.Patches
{
	[HarmonyPatch(typeof(StorageMenu), "CloseMenu")]
	public class DeadDropClosePatch
	{
		[HarmonyPrefix]
		public static void Prefix(StorageMenu __instance)
		{
			ModRent modRent = Core.Get<ModRent>();
			if (modRent == null || !modRent.Configuration.Enabled)
			{
				return;
			}
			try
			{
				StorageEntity openedStorageEntity = __instance.OpenedStorageEntity;
				if ((Object)(object)openedStorageEntity != (Object)null)
				{
					modRent.ProcessPayment(openedStorageEntity);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Dead drop close handling failed: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class PropertyDoorAccessPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(PropertyDoorController __instance, EDoorSide side, ref string reason, ref bool __result)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			ModRent modRent = Core.Get<ModRent>();
			if (modRent == null || !modRent.Configuration.Enabled)
			{
				return true;
			}
			try
			{
				if ((int)side != 1)
				{
					return true;
				}
				Property property = __instance.Property;
				if ((Object)(object)property == (Object)null || !ModRent.IsLockedOut(property.PropertyCode))
				{
					return true;
				}
				reason = "The locks have been changed. Pay your overdue rent.";
				__result = false;
				return false;
			}
			catch (Exception ex)
			{
				Log.Warning("[Rent] Door access check failed: " + ex.Message);
				return true;
			}
		}
	}
}
namespace Lithium.Modules.Banking
{
	public enum EFeeMode
	{
		Percent,
		Fixed
	}
	public class TransferFeeConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = true;

		[JsonConverter(typeof(StringEnumConverter))]
		[JsonProperty(Order = 2)]
		public EFeeMode Mode = EFeeMode.Percent;

		[JsonProperty(Order = 3)]
		public float Percent = 5f;

		[JsonProperty(Order = 4)]
		public float MinFee = 5f;

		[JsonProperty(Order = 5)]
		public float MaxFee = 0f;

		[JsonProperty(Order = 6)]
		public float FixedAmount = 0f;

		[JsonProperty(Order = 7)]
		public bool ApplyToDeposits = false;

		[JsonProperty(Order = 8)]
		public bool ApplyToWithdrawals = true;

		public float Compute(float amount)
		{
			if (!Enabled || amount <= 0f)
			{
				return 0f;
			}
			float num;
			if (Mode == EFeeMode.Fixed)
			{
				num = FixedAmount;
			}
			else
			{
				num = amount * (Percent / 100f);
				if (MinFee > 0f && num < MinFee)
				{
					num = MinFee;
				}
				if (MaxFee > 0f && num > MaxFee)
				{
					num = MaxFee;
				}
			}
			if (num < 0f)
			{
				num = 0f;
			}
			if (num > amount)
			{
				num = amount;
			}
			return num;
		}

		public void Validate(string config)
		{
			Percent = ConfigValidator.InRange(config, "TransferFee.Percent", Percent, 0f, 100f);
			MinFee = ConfigValidator.AtLeast(config, "TransferFee.MinFee", MinFee, 0f);
			MaxFee = ConfigValidator.AtLeast(config, "TransferFee.MaxFee", MaxFee, 0f);
			FixedAmount = ConfigValidator.AtLeast(config, "TransferFee.FixedAmount", FixedAmount, 0f);
		}
	}
	public class AtmConfiguration
	{
		[JsonProperty(Order = 1)]
		public float WeeklyDepositLimit = 10000f;

		[JsonProperty(Order = 2)]
		public float DailyDepositLimit = -1f;

		[JsonIgnore]
		public bool WeeklyLimited => WeeklyDepositLimit >= 0f;

		[JsonIgnore]
		public bool DailyLimited => DailyDepositLimit >= 0f;

		public void Validate()
		{
			if (WeeklyDepositLimit < 0f)
			{
				WeeklyDepositLimit = -1f;
			}
			if (DailyDepositLimit < 0f)
			{
				DailyDepositLimit = -1f;
			}
		}
	}
	public class BusinessLaunderingConfiguration
	{
		[JsonProperty(Order = 1)]
		public float Capacity = -1f;

		[JsonProperty(Order = 2)]
		public float SpeedMultiplier = 1f;

		[JsonProperty(Order = 3)]
		public float Cut = 0f;
	}
	public class LaunderingXpScalingConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = false;

		[JsonProperty(Order = 2)]
		public Dictionary<string, float> CapacityMultiplierByRank = new Dictionary<string, float>
		{
			{ "Hustler", 1.5f },
			{ "Kingpin", 3f }
		};

		[JsonProperty(Order = 3)]
		public Dictionary<string, float> SpeedMultiplierByRank = new Dictionary<string, float>
		{
			{ "Hustler", 1.5f },
			{ "Kingpin", 3f }
		};
	}
	public class LaunderingReportConfiguration
	{
		[JsonProperty(Order = 1)]
		public bool Enabled = false;

		[JsonProperty(Order = 2)]
		public string ContactNpcName = "Herbert";

		[JsonProperty(Order = 3)]
		public string ContactDisplayName = "";
	}
	public class LaunderingConfiguration
	{
		[JsonProperty(Order = 1)]
		public Dictionary<string, BusinessLaunderingConfiguration> Businesses = new Dictionary<string, BusinessLaunderingConfiguration>
		{
			{
				"Laundromat",
				new BusinessLaunderingConfiguration()
			},
			{
				"Car Wash",
				new BusinessLaunderingConfiguration()
			},
			{
				"Post Office",
				new BusinessLaunderingConfiguration()
			},
			{
				"Taco Ticklers",
				new BusinessLaunderingConfiguration()
			}
		};

		[JsonProperty(Order = 2)]
		public LaunderingXpScalingConfiguration XpScaling = new LaunderingXpScalingConfiguration();

		[JsonProperty(Order = 3)]
		public LaunderingReportConfiguration DailyReport = new LaunderingReportConfiguration();
	}
	public class ModBankingConfiguration : ModuleConfiguration
	{
		public AtmConfiguration Atm = new AtmConfiguration();

		public TransferFeeConfiguration TransferFee = new TransferFeeConfiguration();

		public LaunderingConfiguration Laundering = new LaunderingConfiguration();

		public override string Name => "Banking";

		public override void Validate()
		{
			Atm.Validate();
			TransferFee.Validate(Name);
			foreach (string item in Laundering.Businesses.Keys.ToList())
			{
				BusinessLaunderingConfiguration businessLaunderingConfiguration = Laundering.Businesses[item];
				if (businessLaunderingConfiguration.Capacity < 0f)
				{
					businessLaunderingConfiguration.Capacity = -1f;
				}
				businessLaunderingConfiguration.SpeedMultiplier = ConfigValidator.AtLeast(Name, "Laundering.Businesses[" + item + "].SpeedMultiplier", businessLaunderingConfiguration.SpeedMultiplier, 0.01f);
				businessLaunderingConfiguration.Cut = ConfigValidator.InRange(Name, "Laundering.Businesses[" + item + "].Cut", businessLaunderingConfiguration.Cut, 0f, 100f);
			}
		}
	}
	public class ModBanking : ModuleBase<ModBankingConfiguration>
	{
		private sealed class LaunderTally
		{
			public float Laundered;

			public float Cut;
		}

		public const float Unlimited = 1E+09f;

		public static float DailyDepositSum;

		private static readonly Dictionary<string, LaunderTally> Tallies = new Dictionary<string, LaunderTally>();

		private int _lastElapsedDay = -1;

		private bool _initialised;

		public float WeeklyRemaining()
		{
			AtmConfiguration atm = base.Configuration.Atm;
			if (!atm.WeeklyLimited)
			{
				return 1E+09f;
			}
			return Mathf.Max(0f, atm.WeeklyDepositLimit - ATM.WeeklyDepositSum);
		}

		public float DailyRemaining()
		{
			AtmConfiguration atm = base.Configuration.Atm;
			if (!atm.DailyLimited)
			{
				return 1E+09f;
			}
			return Mathf.Max(0f, atm.DailyDepositLimit - DailyDepositSum);
		}

		public float EffectiveRemaining()
		{
			return Mathf.Min(WeeklyRemaining(), DailyRemaining());
		}

		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
				DailyDepositSum = 0f;
				Tallies.Clear();
				_lastElapsedDay = -1;
				_initialised = false;
				DiscoverBusinesses();
			}
		}

		private void DiscoverBusinesses()
		{
			List<Business> businesses = Business.Businesses;
			if (businesses == null)
			{
				return;
			}
			bool flag = false;
			Enumerator<Business> enumerator = businesses.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Business current = enumerator.Current;
				string text = ((current != null) ? ((Property)current).PropertyName : null);
				if (!string.IsNullOrEmpty(text))
				{
					if (!base.Configuration.Laundering.Businesses.TryGetValue(text, out var value))
					{
						value = new BusinessLaunderingConfiguration();
						base.Configuration.Laundering.Businesses[text] = value;
						flag = true;
						Log.Info("[Banking] Discovered laundering business '" + text + "'");
					}
					if (value.Capacity < 0f && current.LaunderCapacity > 0f)
					{
						value.Capacity = current.LaunderCapacity;
						flag = true;
					}
				}
			}
			if (flag)
			{
				base.Configuration.SaveConfiguration();
			}
		}

		public static float GetRankMultiplier(LaunderingXpScalingConfiguration xp, Dictionary<string, float> byRank)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected I4, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected I4, but got Unknown
			if (xp == null || !xp.Enabled || byRank == null || byRank.Count == 0)
			{
				return 1f;
			}
			LevelManager instance = NetworkSingleton<LevelManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 1f;
			}
			int num = (int)instance.Rank;
			float num2 = 1f;
			int num3 = int.MinValue;
			foreach (KeyValuePair<string, float> item in byRank)
			{
				if (Enum.TryParse<ERank>(item.Key, out ERank result))
				{
					int num4 = (int)result;
					if (num4 <= num && num4 > num3)
					{
						num3 = num4;
						num2 = item.Value;
					}
				}
			}
			return (num2 < 0f) ? 1f : num2;
		}

		public static void RecordLaundering(string businessName, float laundered, float cut)
		{
			if (string.IsNullOrEmpty(businessName))
			{
				businessName = "Unknown";
			}
			if (!Tallies.TryGetValue(businessName, out var value))
			{
				value = new LaunderTally();
				Tallies[businessName] = value;
			}
			value.Laundered += laundered;
			value.Cut += cut;
		}

		public void Tick()
		{
			if (!base.Configuration.Enabled)
			{
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				int elapsedDays = instance.ElapsedDays;
				if (!_initialised)
				{
					DiscoverBusinesses();
					_lastElapsedDay = elapsedDays;
					_initialised = true;
				}
				else if (elapsedDays != _lastElapsedDay)
				{
					_lastElapsedDay = elapsedDays;
					EmitDailyReport();
					Tallies.Clear();
				}
			}
		}

		private void EmitDailyReport()
		{
			LaunderingReportConfiguration dailyReport = base.Configuration.Laundering.DailyReport;
			if (!dailyReport.Enabled || Tallies.Count == 0)
			{
				return;
			}
			float num = 0f;
			float num2 = 0f;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Daily laundering report:");
			foreach (KeyValuePair<string, LaunderTally> tally in Tallies)
			{
				if (!(tally.Value.Laundered <= 0f))
				{
					num += tally.Value.Laundered;
					num2 += tally.Value.Cut;
					StringBuilder stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder3 = stringBuilder2;
					StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(22, 3, stringBuilder2);
					handler.AppendLiteral("- ");
					handler.AppendFormatted(tally.Key);
					handler.AppendLiteral(": laundered $");
					handler.AppendFormatted(tally.Value.Laundered, "N0");
					handler.AppendLiteral(", cut $");
					handler.AppendFormatted(tally.Value.Cut, "N0");
					stringBuilder3.AppendLine(ref handler);
				}
			}
			if (!(num <= 0f))
			{
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(33, 2, stringBuilder2);
				handler.AppendLiteral("Total: laundered $");
				handler.AppendFormatted(num, "N0");
				handler.AppendLiteral(", lost to cut $");
				handler.AppendFormatted(num2, "N0");
				stringBuilder4.Append(ref handler);
				BankingContact.Send(dailyReport.ContactNpcName, dailyReport.ContactDisplayName, stringBuilder.ToString());
			}
		}
	}
	public static class BankingContact
	{
		public static void Send(string contactNpcName, string displayName, string message)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			try
			{
				NPC val = Resolve(contactNpcName);
				if ((Object)(object)val == (Object)null)
				{
					Log.Warning("[Banking] Report contact NPC '" + contactNpcName + "' not found; report dropped.");
					return;
				}
				MSGConversation mSGConversation = val.MSGConversation;
				if (mSGConversation != null)
				{
					if (!string.IsNullOrEmpty(displayName) && mSGConversation.contactName != displayName)
					{
						mSGConversation.contactName = displayName;
					}
					mSGConversation.SetIsKnown(true);
				}
				NetworkSingleton<MessagingManager>.Instance.ReceiveMessage(new Message(message, (ESenderType)1, false, -1), true, val.ID);
			}
			catch (Exception ex)
			{
				Log.Warning("[Banking] Failed to send report via '" + contactNpcName + "': " + ex.Message);
			}
		}

		private static NPC Resolve(string name)
		{
			if (string.IsNullOrEmpty(name) || NPCManager.NPCRegistry == null)
			{
				return null;
			}
			foreach (NPC item in NPCManager.NPCRegistry.ToList<NPC>())
			{
				if ((Object)(object)item != (Object)null && string.Equals(item.fullName, name, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			foreach (NPC item2 in NPCManager.NPCRegistry.ToList<NPC>())
			{
				if ((Object)(object)item2 != (Object)null && !string.IsNullOrEmpty(item2.fullName) && item2.fullName.StartsWith(name, StringComparison.OrdinalIgnoreCase))
				{
					return item2;
				}
			}
			return null;
		}
	}
}
namespace Lithium.Modules.Banking.Patches
{
	[HarmonyPatch(typeof(Quest_CleanCash), "OnUncappedMinPass")]
	public class CleanCashQuestTriggerPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Quest_CleanCash __instance)
		{
			//IL_0038: 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_0070: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Invalid comparison between Unknown and I4
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			ModBanking modBanking = Core.Get<ModBanking>();
			AtmConfiguration atm = modBanking.Configuration.Atm;
			if (!modBanking.Configuration.Enabled || !atm.WeeklyLimited)
			{
				return true;
			}
			if ((int)((Quest)__instance).State == 0 && InstanceFinder.IsServer && ATM.WeeklyDepositSum >= atm.WeeklyDepositLimit)
			{
				((Quest)__instance).Begin(true);
			}
			if ((int)((Quest)__instance).State == 2)
			{
				return false;
			}
			if (InstanceFinder.IsServer && (int)__instance.BuyBusinessEntry.State == 1 && Business.OwnedBusinesses.Count > 0)
			{
				__instance.BuyBusinessEntry.Complete();
			}
			if ((int)__instance.GoToBusinessEntry.State == 1)
			{
				if (Business.OwnedBusinesses.Count > 0)
				{
					((Component)__instance.GoToBusinessEntry).transform.position = ((Component)((Property)Business.OwnedBusinesses[0]).PoI).transform.position;
				}
				if ((Object)(object)Player.Local.CurrentBusiness != (Object)null)
				{
					__instance.GoToBusinessEntry.Complete();
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ATMInterface), "Update")]
	public class AtmDepositDisplayPatch
	{
		private static readonly Color32 OverLimitColor = new Color32(byte.MaxValue, (byte)75, (byte)75, byte.MaxValue);

		[HarmonyPostfix]
		public static void Postfix(ATMInterface __instance)
		{
			//IL_00ba: 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_009b: 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)
			ModBanking modBanking = Core.Get<ModBanking>();
			AtmConfiguration atm = modBanking.Configuration.Atm;
			if (!modBanking.Configuration.Enabled || !__instance.isOpen)
			{
				return;
			}
			float weeklyDepositSum = ATM.WeeklyDepositSum;
			Text depositLimitText = __instance.depositLimitText;
			if ((Object)(object)depositLimitText != (Object)null)
			{
				if (atm.WeeklyLimited)
				{
					depositLimitText.text = MoneyManager.FormatAmount(weeklyDepositSum, false, false) + " / " + MoneyManager.FormatAmount(atm.WeeklyDepositLimit, false, false);
					((Graphic)depositLimitText).color = ((weeklyDepositSum >= atm.WeeklyDepositLimit) ? Color32.op_Implicit(OverLimitColor) : Color.white);
				}
				else
				{
					depositLimitText.text = MoneyManager.FormatAmount(weeklyDepositSum, false, false);
					((Graphic)depositLimitText).color = Color.white;
				}
			}
			Button menu_DepositButton = __instance.menu_DepositButton;
			if ((Object)(object)menu_DepositButton != (Object)null)
			{
				((Selectable)menu_DepositButton).interactable = modBanking.EffectiveRemaining() > 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ATMInterface), "UpdateAvailableAmounts")]
	public class AtmAvailableAmountsPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ATMInterface __instance)
		{
			ModBanking modBanking = Core.Get<ModBanking>();
			if (!modBanking.Configuration.Enabled || !__instance.depositing)
			{
				return;
			}
			List<Button> amountButtons = __instance.amountButtons;
			if (amountButtons == null || amountButtons.Count == 0)
			{
				return;
			}
			Il2CppStructArray<int> amounts = ATMInterface.amounts;
			float num = modBanking.EffectiveRemaining();
			float relevantBalance = __instance.relevantBalance;
			for (int i = 0; i < ((Il2CppArrayBase<int>)(object)amounts).Length && i < amountButtons.Count; i++)
			{
				if (i == ((Il2CppArrayBase<int>)(object)amounts).Length - 1)
				{
					((Selectable)amountButtons[amountButtons.Count - 1]).interactable = relevantBalance > 0f && num > 0f;
					break;
				}
				((Selectable)amountButtons[i]).interactable = relevantBalance >= (float)((Il2CppArrayBase<int>)(object)amounts)[i] && (float)((Il2CppArrayBase<int>)(object)amounts)[i] <= num;
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class AtmRemainingDepositPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ref float __result)
		{
			ModBanking modBanking = Core.Get<ModBanking>();
			if (modBanking.Configuration.Enabled)
			{
				__result = modBanking.EffectiveRemaining();
			}
		}
	}
	[HarmonyPatch(typeof(ATMInterface), "SetSelectedAmount")]
	public class AtmSelectedAmountPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ATMInterface __instance, float amount)
		{
			ModBanking modBanking = Core.Get<ModBanking>();
			if (!modBanking.Configuration.Enabled || !__instance.depositing)
			{
				return;
			}
			MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				float num = Mathf.Min(instance.cashBalance, modBanking.EffectiveRemaining());
				float num2 = (__instance.selectedAmount = Mathf.Clamp(amount, 0f, num));
				Text amountLabelText = __instance.amountLabelText;
				if ((Object)(object)amountLabelText != (Object)null)
				{
					amountLabelText.text = MoneyManager.FormatAmount(num2, false, false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ATMInterface), "GetAmountFromIndex")]
	public class AtmAmountFromIndexPatch
	{
		[HarmonyPostfix]
		public static void Postfix(int index, bool depositing, ref float __result)
		{
			if (!depositing)
			{
				return;
			}
			ModBanking modBanking = Core.Get<ModBanking>();
			if (modBanking.Configuration.Enabled && index == ((Il2CppArrayBase<int>)(object)ATMInterface.amounts).Length - 1)
			{
				MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					__result = Mathf.Min(instance.cashBalance, modBanking.EffectiveRemaining());
				}
			}
		}
	}
	[HarmonyPatch(typeof(ATM), "DayPass")]
	public class AtmDayPassPatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			if (Core.Get<ModBanking>().Configuration.Enabled)
			{
				ModBanking.DailyDepositSum = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ATMInterface), "ProcessTransaction")]
	public class AtmTransactionPatch
	{
		[HarmonyPrefix]
		public static void Prefix(float amount, bool depositing)
		{
			ModBankingConfiguration configuration = Core.Get<ModBanking>().Configuration;
			if (!configuration.Enabled)
			{
				return;
			}
			if (depositing && configuration.Atm.DailyLimited)
			{
				ModBanking.DailyDepositSum += amount;
			}
			TransferFeeConfiguration transferFee = configuration.TransferFee;
			if (!transferFee.Enabled || !(depositing ? transferFee.ApplyToDeposits : transferFee.ApplyToWithdrawals))
			{
				return;
			}
			float num = transferFee.Compute(amount);
			if (num <= 0f)
			{
				return;
			}
			MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				float num2 = instance.onlineBalance - (depositing ? 0f : amount);
				num = Mathf.Min(num, Mathf.Max(0f, num2));
				if (!(num <= 0f))
				{
					instance.CreateOnlineTransaction("Bank Transfer Fee", 0f - num, 1f, depositing ? "ATM deposit fee" : "ATM withdrawal fee");
				}
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class LaunderCapacityPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Business __instance, ref float __result)
		{
			ModBankingConfiguration configuration = Core.Get<ModBanking>().Configuration;
			if (configuration.Enabled)
			{
				LaunderingConfiguration laundering = configuration.Laundering;
				string propertyName = ((Property)__instance).PropertyName;
				if (!string.IsNullOrEmpty(propertyName) && laundering.Businesses.TryGetValue(propertyName, out var value) && value.Capacity >= 0f)
				{
					__result = value.Capacity;
				}
				__result *= ModBanking.GetRankMultiplier(laundering.XpScaling, laundering.XpScaling.CapacityMultiplierByRank);
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class LaunderSpeedPatch
	{
		[HarmonyPostfix]
		public static void Postfix(LaunderingOperation __instance)
		{
			ModBankingConfiguration configuration = Core.Get<ModBanking>().Configuration;
			if (!configuration.Enabled)
			{
				return;
			}
			Business business = __instance.business;
			if (!((Object)(object)business == (Object)null))
			{
				LaunderingConfiguration laundering = configuration.Laundering;
				float num = 1f;
				string propertyName = ((Property)business).PropertyName;
				if (!string.IsNullOrEmpty(propertyName) && laundering.Businesses.TryGetValue(propertyName, out var value))
				{
					num *= value.SpeedMultiplier;
				}
				num *= ModBanking.GetRankMultiplier(laundering.XpScaling, laundering.XpScaling.SpeedMultiplierByRank);
				if (!(num <= 0f) && !Mathf.Approximately(num, 1f))
				{
					__instance.completionTime_Minutes = Mathf.Max(1, Mathf.RoundToInt((float)__instance.completionTime_Minutes / num));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Business), "MinPass")]
	public class LaunderCutPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Business __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				LaunderCutSettler.Snapshot(__instance, 1);
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Business __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				LaunderCutSettler.Settle(__instance);
			}
		}
	}
	internal static class LaunderCutSettler
	{
		private static readonly Dictionary<IntPtr, float> Pending = new Dictionary<IntPtr, float>();

		public static void Snapshot(Business business, int mins)
		{
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			ModBankingConfiguration configuration = Core.Get<ModBanking>().Configuration;
			if (!configuration.Enabled || (Object)(object)business == (Object)null)
			{
				return;
			}
			List<LaunderingOperation> launderingOperations = business.LaunderingOperations;
			if (launderingOperations == null)
			{
				return;
			}
			float num = 0f;
			for (int i = 0; i < launderingOperations.Count; i++)
			{
				LaunderingOperation val = launderingOperations[i];
				if (val != null && val.minutesSinceStarted + mins >= val.completionTime_Minutes)
				{
					num += val.amount;
				}
			}
			if (num > 0f)
			{
				Pending[((Il2CppObjectBase)business).Pointer] = num;
			}
			else
			{
				Pending.Remove(((Il2CppObjectBase)business).Pointer);
			}
		}

		public static void Settle(Business business)
		{
			if ((Object)(object)business == (Object)null || !InstanceFinder.IsServer)
			{
				return;
			}
			IntPtr pointer = ((Il2CppObjectBase)business).Pointer;
			if (!Pending.TryGetValue(pointer, out var value))
			{
				return;
			}
			Pending.Remove(pointer);
			if (value <= 0f)
			{
				return;
			}
			ModBankingConfiguration configuration = Core.Get<ModBanking>().Configuration;
			if (!configuration.Enabled)
			{
				return;
			}
			string propertyName = ((Property)business).PropertyName;
			float num = 0f;
			if (!string.IsNullOrEmpty(propertyName) && configuration.Laundering.Businesses.TryGetValue(propertyName, out var value2))
			{
				num = value2.Cut;
			}
			float num2 = value * (num / 100f);
			if (num2 > 0f)
			{
				MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					num2 = Mathf.Min(num2, Mathf.Max(0f, instance.onlineBalance));
					if (num2 > 0f)
					{
						instance.CreateOnlineTransaction("Laundering Cut", 0f - num2, 1f, propertyName + " laundering cut");
					}
				}
				else
				{
					num2 = 0f;
				}
			}
			ModBanking.RecordLaundering(propertyName, value, num2);
		}
	}
	[HarmonyPatch(typeof(Business), "TimeSkipped")]
	public class LaunderCutSkipPatch
	{
		[HarmonyPrefix]
		public static void Prefix(Business __instance, int minsPassed)
		{
			LaunderCutSettler.Snapshot(__instance, minsPassed);
		}

		[HarmonyPostfix]
		public static void Postfix(Business __instance)
		{
			LaunderCutSettler.Settle(__instance);
		}
	}
	[HarmonyPatch(typeof(TimeManager), "PassMinute")]
	public class BankingDailyTickPatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			try
			{
				Core.Get<ModBanking>()?.Tick();
			}
			catch (Exception ex)
			{
				Log.Warning("[Banking] Daily tick failed: " + ex.Message);
			}
		}
	}
}
namespace Lithium.Modules.EndOfDayFreeze
{
	public class ModEndOfDayFreezeConfiguration : ModuleConfiguration
	{
		public override string Name => "EndOfDayFreeze";

		public ModEndOfDayFreezeConfiguration()
		{
			Enabled = true;
		}
	}
	public class ModEndOfDayFreeze : ModuleBase<ModEndOfDayFreezeConfiguration>
	{
		public override void Apply()
		{
		}
	}
	internal static class EndOfDayGate
	{
		public static bool ShouldFreeze()
		{
			ModEndOfDayFreeze modEndOfDayFreeze = Core.Get<ModEndOfDayFreeze>();
			if (modEndOfDayFreeze == null || !modEndOfDayFreeze.Configuration.Enabled)
			{
				return false;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			return (Object)(object)instance != (Object)null && instance.IsEndOfDay;
		}
	}
}
namespace Lithium.Modules.EndOfDayFreeze.Patches
{
	[HarmonyPatch(typeof(DryingRack), "OnMinPass")]
	public class DryingRackFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix()
		{
			return !EndOfDayGate.ShouldFreeze();
		}
	}
	[HarmonyPatch(typeof(Pot), "OnMinPass")]
	public class PlantGrowthFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix()
		{
			return !EndOfDayGate.ShouldFreeze();
		}
	}
	[HarmonyPatch(typeof(ChemistryStation), "OnTimePass")]
	public class ChemistryStationFreezePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix()
		{
			return !EndOfDayGate.ShouldFreeze();
		}
	}
	[HarmonyPatch]
	public class MixingStationFreezePatch
	{
		public static IEnumerable<MethodBase> TargetMethods()
		{
			MethodBase mk1 = AccessTools.DeclaredMethod(typeof(MixingStation), "OnMinPass", (Type[])null, (Type[])null);
			if (mk1 != null)
			{
				yield return mk1;
			}
			MethodBase mk2 = AccessTools.DeclaredMethod(typeof(MixingStationMk2), "OnMinPass", (Type[])null, (Type[])null);
			if (mk2 != null)
			{
				yield return mk2;
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		public static bool Prefix()
		{
			return !EndOfDayGate.ShouldFreeze();
		}
	}
}
namespace Lithium.Modules.ChemistryStation
{
	public class ModChemistryStationConfiguration : ModuleConfiguration
	{
		public float CookDurationMinutes = 60f;

		public override string Name => "ChemistryStation";
	}
	public class ModChemistryStation : ModuleBase<ModChemistryStationConfiguration>
	{
		public override void Apply()
		{
			if (base.Configuration.Enabled)
			{
			}
		}
	}
}
namespace Lithium.Modules.ChemistryStation.Patches
{
	[HarmonyPatch(typeof(ChemistryStation), "OnTimePass")]
	public class ChemistryStationDurationPatch
	{
		private static readonly Dictionary<IntPtr, float> Carry = new Dictionary<IntPtr, float>();

		[HarmonyPrefix]
		public static void Prefix(ChemistryStation __instance, ref int minutes, bool __runOriginal)
		{
			if (!__runOriginal)
			{
				return;
			}
			ModChemistryStation modChemistryStation = Core.Get<ModChemistryStation>();
			if (modChemistryStation == null || !modChemistryStation.Configuration.Enabled)
			{
				return;
			}
			ChemistryCookOperation currentCookOperation = __instance.CurrentCookOperation;
			if (currentCookOperation == null)
			{
				return;
			}
			StationRecipe recipe = currentCookOperation.Recipe;
			if ((Object)(object)recipe == (Object)null)
			{
				return;
			}
			float cookDurationMinutes = modChemistryStation.Configuration.CookDurationMinutes;
			if (cookDurationMinutes <= 0f)
			{
				return;
			}
			float num = recipe.CookTime_Mins;
			if (!(num <= 0f))
			{
				float num2 = num / cookDurationMinutes;
				if (!Mathf.Approximately(num2, 1f))
				{
					IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
					Carry.TryGetValue(pointer, out var value);
					float num3 = (float)minutes * num2 + value;
					int num4 = Mathf.FloorToInt(num3);
					Carry[pointer] = num3 - (float)num4;
					minutes = num4;
				}
			}
		}
	}
}
namespace Lithium.Modules.BrickPress
{
	public class ModBrickPressConfiguration : ModuleConfiguration
	{
		public bool InstantPress = true;

		public override string Name => "BrickPress";
	}
	public class ModBrickPress : ModuleBase<ModBrickPressConfiguration>
	{
		public override void Apply()
		{
		}
	}
}
namespace Lithium.Modules.BrickPress.Patches
{
	[HarmonyPatch(typeof(BrickPressCanvas), "BeginButtonPressed")]
	public class BrickPressBeginButtonPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(BrickPressCanvas __instance)
		{
			ModBrickPress modBrickPress = Core.Get<ModBrickPress>();
			if (modBrickPress == null || !modBrickPress.Configuration.Enabled || !modBrickPress.Configuration.InstantPress)
			{
				return true;
			}
			BrickPress press = __instance.Press;
			if ((Object)(object)press == (Object)null)
			{
				return true;
			}
			ProductItemInstance val = default(ProductItemInstance);
			if (!press.HasSufficientProduct(ref val) || val == null)
			{
				return true;
			}
			PackagingDefinition brickPackaging = press.BrickPackaging;
			if ((Object)(object)brickPackaging == (Object)null || brickPackaging.Quantity <= 0)
			{
				return true;
			}
			int quantity = brickPackaging.Quantity;
			ItemInstance val2 = default(ItemInstance);
			int num = default(int);
			ItemInstance val3 = default(ItemInstance);
			int num2 = default(int);
			press.GetMainInputs(ref val2, ref num, ref val3, ref num2);
			if (val2 == null)
			{
				return true;
			}
			Il2CppReferenceArray<ItemSlot> productSlots = press.ProductSlots;
			if (productSlots == null)
			{
				return true;
			}
			List<ItemSlot> list = new List<ItemSlot>();
			for (int i = 0; i < ((Il2CppArrayBase<ItemSlot>)(object)productSlots).Length; i++)
			{
				ItemSlot val4 = ((Il2CppArrayBase<ItemSlot>)(object)productSlots)[i];
				ItemInstance val5 = ((val4 != null) ? val4.ItemInstance : null);
				if (val5 != null && !val5.CanStackWith(val2, false))
				{
					list.Add(val4);
				}
			}
			int num3 = num / quantity;
			if (num3 <= 0)
			{
				return true;
			}
			ItemInstance copy = ((ItemInstance)val).GetCopy(1);
			ProductItemInstance val6 = ((copy != null) ? ((Il2CppObjectBase)copy).TryCast<ProductItemInstance>() : null);
			if (val6 == null)
			{
				return true;
			}
			val6.SetPackaging(brickPackaging);
			int num4 = ((press.OutputSlot != null) ? press.OutputSlot.GetCapacityForItem((ItemInstance)(object)val6, false) : 0);
			if (num4 < num3)
			{
				return true;
			}
			List<(ItemSlot, ItemInstance, int)> list2 = new List<(ItemSlot, ItemInstance, int)>();
			foreach (ItemSlot item in list)
			{
				list2.Add((item, item.ItemInstance, item.Quantity));
				item.ClearStoredInstance(false);
			}
			press.CompletePress(val);
			foreach (var (val7, val8, num5) in list2)
			{
				val7.SetStoredItem(val8, false);
				val7.SetQuantity(num5, false);
			}
			return false;
		}
	}
}
namespace Lithium.Helper
{
	public static class CollectionConverter
	{
		public static T[] ToArray<T>(this List<T> list)
		{
			if (list == null)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[list.Count];
			int num = 0;
			Enumerator<T> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array[num] = current;
				num++;
			}
			return array;
		}

		public static List<T> ToList<T>(this List<T> list)
		{
			if (list == null)
			{
				return new List<T>();
			}
			List<T> list2 = new List<T>(list.Count);
			Enumerator<T> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				list2.Add(current);
			}
			return list2;
		}

		public static List<T> ToIL2CPPList<T>(this List<T>? list)
		{
			List<T> val = new List<T>(list?.Count ?? 0);
			if (list == null)
			{
				return val;
			}
			foreach (T item in list)
			{
				val.Add(item);
			}
			return val;
		}
	}
	public static class ConfigValidator
	{
		public static float AtLeast(string config, string field, float value, float min)
		{
			if (value >= min)
			{
				return value;
			}
			Log.Warning($"[Lithium] {config}: '{field}' = {value} is below the minimum of {min}; using {min}.");
			return min;
		}

		public static int AtLeast(string config, string field, int value, int min)
		{
			if (value >= min)
			{
				return value;
			}
			Log.Warning($"[Lithium] {config}: '{field}' = {value} is below the minimum of {min}; using {min}.");
			return min;
		}

		public static float InRange(string config, string field, float value, float min, float max)
		{
			if (value < min)
			{
				Log.Warning($"[Lithium] {config}: '{field}' = {value} is below {min}; using {min}.");
				return min;
			}
			if (value > max)
			{
				Log.Warning($"[Lithium] {config}: '{field}' = {value} is above {max}; using {max}.");
				return max;
			}
			return value;
		}

		public static int InRange(string config, string field, int value, int min, int max)
		{
			if (value < min)
			{
				Log.Warning($"[Lithium] {config}: '{field}' = {value} is below {min}; using {min}.");
				return min;
			}
			if (value > max)
			{
				Log.Warning($"[Lithium] {config}: '{field}' = {value} is above {max}; using {max}.");
				return max;
			}
			return value;
		}

		public static void EnsureOrdered(string config, string minField, string maxField, ref int min, ref int max)
		{
			if (min > max)
			{
				Log.Warning($"[Lithium] {config}: '{minField}' ({min}) is greater than '{maxField}' ({max}); swapping them.");
				int num = max;
				int num2 = min;
				min = num;
				max = num2;
			}
		}

		public static void EnsureOrdered(string config, string minField, string maxField, ref float min, ref float max)
		{
			if (!(min <= max))
			{
				Log.Warning($"[Lithium] {config}: '{minField}' ({min}) is greater than '{maxField}' ({max}); swapping them.");
				float num = max;
				float num2 = min;
				min = num;
				max = num2;
			}
		}
	}
	public static class GameDay
	{
		private const int RolloverTime = 400;

		public static int CurrentIndex
		{
			get
			{
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return int.MinValue;
				}
				return BeforeRollover(instance) ? (instance.ElapsedDays - 1) : instance.ElapsedDays;
			}
		}

		public static EDay CurrentDay
		{
			get
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected I4, but got Unknown
				//IL_0013: 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_0035: Unknown result type (might be due to invalid IL or missing references)
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return (EDay)0;
				}
				int num = (int)instance.CurrentDay;
				if (BeforeRollover(instance))
				{
					num = (num - 1 + 7) % 7;
				}
				return (EDay)num;
			}
		}

		private static bool BeforeRollover(TimeManager time)
		{
			return time.CurrentTime < 400;
		}
	}
	public static class HostStateSync
	{
		public const string Prefix = "lithium_";

		private static VariableDatabase Db => NetworkSingleton<VariableDatabase>.InstanceExists ? NetworkSingleton<VariableDatabase>.Instance : null;

		public static bool IsHost => InstanceFinder.IsServer;

		public static void SetBool(string key, bool value)
		{
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			try
			{
				VariableDatabase db = Db;
				if (!((Object)(object)db == (Object)null))
				{
					string text = "lithium_" + key;
					EnsureBool(db, text, value);
					db.SetVariableValue(text, value ? "true" : "false", true);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Sync] SetBool '" + key + "' failed: " + ex.Message);
			}
		}

		public static void SetNumber(string key, float value)
		{
			if (!InstanceFinder.IsServer)
			{
				return;
			}
			try
			{
				VariableDatabase db = Db;
				if (!((Object)(object)db == (Object)null))
				{
					string text = "lithium_" + key;
					EnsureNumber(db, text, value);
					db.SetVariableValue(text, value.ToString("R", CultureInfo.InvariantCulture), true);
				}
			}
			catch (Exception ex)
			{
				Log.Warning("[Sync] SetNumber '" + key + "' failed: " + ex.Message);
			}
		}

		public static bool GetBool(string key, bool fallback = false)
		{
			try
			{
				VariableDatabase db = Db;
				if ((Object)(object)db == (Object)null)
				{
					return fallback;
				}
				string text = ("lithium_" + key).ToLower();
				if (!db.VariableDict.ContainsKey(text))
				{
					EnsureBool(db, "lithium_" + key, fallback);
					return fallback;
				}
				return db.GetValue<bool>(text);
			}
			catch
			{
				return fallback;
			}
		}

		public static float GetNumber(string key, float fallback = 0f)
		{
			try
			{
				VariableDatabase db = Db;
				if ((Object)(object)db == (Object)null)
				{
					return fallback;
				}
				string text = ("lithium_" + key).ToLower();
				if (!db.VariableDict.ContainsKey(text))
				{
					EnsureNumber(db, "lithium_" + key, fallback);
					return fallback;
				}
				return db.GetValue<float>(text);
			}
			catch
			{
				return fallback;
			}
		}

		private static void EnsureBool(VariableDatabase db, string name, bool initial)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!db.VariableDict.ContainsKey(name.ToLower()))
			{
				new BoolVariable(name, (EVariableReplicationMode)1, false, (EVariableMode)0, (Player)null, initial);
			}
		}

		private static void EnsureNumber(VariableDatabase db, string name, float initial)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!db.VariableDict.ContainsKey(name.ToLower()))
			{
				new NumberVariable(name, (EVariableReplicationMode)1, false, (EVariableMode)0, (Player)null, initial);
			}
		}
	}
	[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
	public static class SaveFlushPatch
	{
		[HarmonyPrefix]
		public static void Prefix(SaveManager __instance)
		{
			if (!InstanceFinder.IsServer || __instance.IsSaving)
			{
				return;
			}
			try
			{
				SaveSlotStores.FlushAll();
			}
			catch (Exception ex)
			{
				Log.Warning("[Lithium] Save flush failed: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(VariableDatabase), "SendValue")]
	public static class VariableSyncGuardPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(string variableName)
		{
			if (!InstanceFinder.IsServer && variableName != null && variableName.StartsWith("lithium_", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return true;
		}
	}
	public static class ProductHelper
	{
		public static bool DealerHasSuitableProduct(this Customer customer, out List<ItemInstance> dealerItems)
		{
			List<string> list = (from p in customer.CustomerData.PreferredProperties.ToList<Effect>()
				select p.Name).ToList();
			if (list.Count == 0)
			{
				dealerItems = new List<ItemInstance>();
				return true;
			}
			dealerItems = (from i in ((NPC)customer.AssignedDealer).Inventory.ItemSlots.ToList<ItemSlot>()
				where i.ItemInstance != null
				select i.ItemInstance).ToList();
			List<ProductDefinition> source = dealerItems.Select((ItemInstance d) => ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToList<ProductDefinition>()).FirstOrDefault((Func<ProductDefinition, bool>)((ProductDefinition p) => ((BaseItemDefinition)p).ID.Equals(((BaseItemInstance)d).ID)))).Distinct().ToList();
			List<string> source2 = (from p in source.Where((ProductDefinition p) => (Object)(object)p != (Object)null).SelectMany((ProductDefinition p) => ((PropertyItemDefinition)p).Properties.ToList<Effect>())
				select p.Name).Distinct().ToList();
			return list.Intersect(source2.Distinct().ToList()).Any();
		}

		public static List<string> GetDealerStockedEffects(this Dealer dealer)
		{
			List<ItemInstance> source = (from i in ((NPC)dealer).Inventory.ItemSlots.ToList<ItemSlot>()
				where i.ItemInstance != null
				select i.ItemInstance).ToList();
			List<ProductDefinition> source2 = (from d in source
				select ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToList<ProductDefinition>()).FirstOrDefault((Func<ProductDefinition, bool>)((ProductDefinition p) => ((BaseItemDefinition)p).ID.Equals(((BaseItemInstance)d).ID))) into p
				where (Object)(object)p != (Object)null
				select p).Distinct().ToList();
			return (from p in source2.SelectMany((ProductDefinition p) => ((PropertyItemDefinition)p).Properties.ToList<Effect>())
				select p.Name).Distinct().ToList();
		}

		public static bool IsServeable(this Customer customer)
		{
			return (Object)(object)customer != (Object)null && (Object)(object)customer.CustomerData != (Object)null && (Object)(object)customer.NPC != (Object)null;
		}

		public static List<string> GetDesireNames(CustomerData customerData, bool toLower = false)
		{
			IEnumerable<string> source = from p in customerData.PreferredProperties.ToList<Effect>()
				select p.Name;
			if (toLower)
			{
				source = source.Select((string n) => n.ToLowerInvariant());
			}
			return source.ToList();
		}

		public static int GetTotalQuantity(ProductList products)
		{
			return (products != null) ? products.GetTotalQuantity() : 0;
		}

		public static bool ProductMatchesDesires(ProductDefinition pd, List<string> desires)
		{
			return (from p in ((PropertyItemDefinition)pd).Properties.ToList<Effect>()
				select p.Name).Intersect(desires).Any();
		}

		public static int CoveredEffectCount(ProductDefinition pd, List<string> desires)
		{
			return (from p in ((PropertyItemDefinition)pd).Properties.ToList<Effect>()
				select p.Name).Intersect(desires).Count();
		}

		public static float DrugTypeAffinity(ProductDefinition pd, CustomerData customerData)
		{
			//IL_0053: 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)
			if ((Object)(object)pd == (Object)null || (Object)(object)customerData == (Object)null)
			{
				return 0f;
			}
			CustomerAffinityData defaultAffinityData = customerData.DefaultAffinityData;
			if (defaultAffinityData == null)
			{
				return 0f;
			}
			Enumerator<ProductTypeAffinity> enumerator = defaultAffinityData.ProductAffinities.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ProductTypeAffinity current = enumerator.Current;
				if (current.DrugType == pd.DrugType)
				{
					return current.Affinity;
				}
			}
			return 0f;
		}

		public static string FormatDesires(CustomerData customerData)
		{
			return (from p in customerData.PreferredProperties.ToList<Effect>()
				select p.Name).SmartJoin(", ", " or ");
		}

		public static int GetMatchCount(ProductDefinition pd, List<string> desires)
		{
			return ProductManager.DiscoveredProducts.ToList<ProductDefinition>().Count((ProductDefinition p) => (from val in ((PropertyItemDefinition)p).Properties.ToList<Effect>()
				select val.Name).Intersect(desires).Any());
		}
	}
	public static class RankHelper
	{
		public static float ToFloat(ERank rank, int tier)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return (float)rank + (float)Math.Clamp(tier, 1, 5) / 5f;
		}

		public static float PlayerRankFloat(float fallback)
		{
			//IL_0011: 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)
			LevelManager instance = NetworkSingleton<LevelManager>.Instance;
			float result;
			if (!((Object)(object)instance == (Object)null))
			{
				FullRank fullRank = instance.GetFullRank();
				result = ((FullRank)(ref fullRank)).ToFloat();
			}
			else
			{
				result = fallback;
			}
			return result;
		}

		public static bool PlayerRankAtLeast(ERank rank, int tier, bool defaultWhenUnavailable = true)
		{
			//IL_0017: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			LevelManager instance = NetworkSingleton<LevelManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return defaultWhenUnavailable;
			}
			FullRank fullRank = instance.GetFullRank();
			return ((FullRank)(ref fullRank)).ToFloat() >= ToFloat(rank, tier);
		}
	}
	public static class StableHash
	{
		public static int Compute(string s)
		{
			uint num = 2166136261u;
			if (s != null)
			{
				foreach (char c in s)
				{
					num ^= c;
					num *= 16777619;
				}
			}
			return (int)num;
		}
	}
	public static class StringExtensions
	{
		public static string SmartJoin<T>(this IEnumerable<T> source, string glue, string lastGlue)
		{
			T[] array = source.ToArray();
			switch (array.Length)
			{
			case 0:
				return string.Empty;
			case 1:
				return array[0].ToString();
			default:
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(string.Join(glue, array[..^1]));
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(0, 2, stringBuilder2);
				handler.AppendFormatted(lastGlue);
				handler.AppendFormatted(array.Last());
				stringBuilder2.Append(ref handler);
				return stringBuilder.ToString();
			}
			}
		}
	}
	public static class RandomExtensions
	{
		public static T PickRandom<T>(this IEnumerable<T> source)
		{
			return source.OrderBy((T _) => Random.value).FirstOrDefault();
		}
	}
}