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.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FishNet;
using FishNet.Managing;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using MoreRealisticLaundering;
using MoreRealisticLaundering.Cartel;
using MoreRealisticLaundering.Config;
using MoreRealisticLaundering.Laundering;
using MoreRealisticLaundering.Patches;
using MoreRealisticLaundering.PhoneApp;
using MoreRealisticLaundering.Util;
using Newtonsoft.Json;
using S1API.Cartel;
using S1API.Utils;
using ScheduleOne;
using ScheduleOne.Cartel;
using ScheduleOne.DevUtilities;
using ScheduleOne.GameTime;
using ScheduleOne.Map;
using ScheduleOne.Messaging;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.CharacterClasses;
using ScheduleOne.NPCs.Relation;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.Product;
using ScheduleOne.Property;
using ScheduleOne.UI;
using ScheduleOne.UI.Phone;
using ScheduleOne.UI.Phone.ProductManagerApp;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
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(MRLCore), "MoreRealisticLaundering", "1.3.3", "KampfBallerina", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonAdditionalDependencies(new string[] { "S1API" })]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("MoreRealisticLaundering-Mono")]
[assembly: AssemblyConfiguration("Release Mono")]
[assembly: AssemblyFileVersion("1.3.3.0")]
[assembly: AssemblyInformationalVersion("1.3.3+77d20a3692831cbe767141d0accd1814229e8113")]
[assembly: AssemblyProduct("MoreRealisticLaundering-Mono")]
[assembly: AssemblyTitle("MoreRealisticLaundering-Mono")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
internal static class ModVersion
{
	public const string Current = "1.3.3";
}
namespace MoreRealisticLaundering
{
	public class MRLCore : MelonMod
	{
		public static LaunderingApp launderingApp = new LaunderingApp();

		private bool isFirstStart = true;

		private bool isLegitVersion;

		public bool isWaitAndApplyCapsRunning;

		public ConfigState config;

		public MoneyManager moneyManager;

		public NotificationsManager notificationsManager;

		public Sprite CreditCardIcon;

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

		public Dictionary<string, string> aliasMap;

		public readonly HashSet<string> processedBusinesses = new HashSet<string>();

		public readonly HashSet<string> createdBusinessesEntries = new HashSet<string>();

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

		private readonly HashSet<LaunderingOperation> boostedOperations = new HashSet<LaunderingOperation>();

		public static MRLCore Instance { get; private set; }

		public override void OnInitializeMelon()
		{
			Instance = this;
			aliasMap = new Dictionary<string, string>
			{
				{ "Laundromat", "Laundromat" },
				{ "Taco Ticklers", "Taco Ticklers" },
				{ "TacoTicklers", "Taco Ticklers" },
				{ "Car Wash", "Car Wash" },
				{ "CarWash", "Car Wash" },
				{ "Post Office", "Post Office" },
				{ "PostOffice", "Post Office" }
			};
			((MelonBase)this).LoggerInstance.Msg("Loaded. Waiting for a save to start drip and cartel washes.");
		}

		public override void OnUpdate()
		{
			launderingApp?.TickUi();
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			if (sceneName == "Main")
			{
				try
				{
					((MelonBase)this).LoggerInstance.Msg("Main scene loaded. Starting laundering hooks.");
					config = ConfigManager.Load();
					isLegitVersion = config.Use_Legit_Version;
					FillCapDictionary();
					InitializeListeners();
					moneyManager = Object.FindObjectOfType<MoneyManager>();
					notificationsManager = Object.FindObjectOfType<NotificationsManager>();
					CartelService.Stop();
					DripTracker.Instance.Stop();
					DripTracker.Instance.Start();
					CartelService.Start();
					MelonCoroutines.Start(StartCoroutinesAfterDelay());
					isFirstStart = false;
					return;
				}
				catch (Exception ex)
				{
					((MelonBase)this).LoggerInstance.Error("Failed to start on Main: " + ex);
					return;
				}
			}
			if (sceneName.Equals("Menu", StringComparison.OrdinalIgnoreCase) && !isFirstStart)
			{
				ResetAllVariables();
			}
		}

		private void InitializeListeners()
		{
			try
			{
				Business.onOperationStarted = (Action<LaunderingOperation>)Delegate.Remove(Business.onOperationStarted, new Action<LaunderingOperation>(OnLaunderingStarted));
				Business.onOperationFinished = (Action<LaunderingOperation>)Delegate.Remove(Business.onOperationFinished, new Action<LaunderingOperation>(OnLaunderingFinished));
			}
			catch
			{
			}
			try
			{
				Business.onOperationStarted = (Action<LaunderingOperation>)Delegate.Combine(Business.onOperationStarted, new Action<LaunderingOperation>(OnLaunderingStarted));
				Business.onOperationFinished = (Action<LaunderingOperation>)Delegate.Combine(Business.onOperationFinished, new Action<LaunderingOperation>(OnLaunderingFinished));
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Failed to register laundering listeners: " + ex.Message);
			}
		}

		public IEnumerator StartCoroutinesAfterDelay()
		{
			if (isLegitVersion)
			{
				((MelonBase)this).LoggerInstance.Msg("Use_Legit_Version is true — Tax & Wash phone app will not be added.");
				MelonCoroutines.Start(WaitAndApplyCaps());
			}
			else
			{
				yield return (object)new WaitForSecondsRealtime(5f);
				MelonCoroutines.Start(WaitAndApplyCaps());
				MelonCoroutines.Start(launderingApp.InitializeLaunderApp());
			}
		}

		private void ResetAllVariables()
		{
			DripTracker.Instance.Stop();
			CartelService.Stop();
			config = null;
			isLegitVersion = false;
			maxiumumLaunderValues.Clear();
			createdAppEntries.Clear();
			processedBusinesses.Clear();
			createdBusinessesEntries.Clear();
			boostedOperations.Clear();
			moneyManager = null;
			notificationsManager = null;
			CreditCardIcon = null;
			if (launderingApp != null)
			{
				launderingApp.CancelPendingInit();
				launderingApp.ClearUiForMenu();
			}
			try
			{
				Business.onOperationStarted = (Action<LaunderingOperation>)Delegate.Remove(Business.onOperationStarted, new Action<LaunderingOperation>(OnLaunderingStarted));
				Business.onOperationFinished = (Action<LaunderingOperation>)Delegate.Remove(Business.onOperationFinished, new Action<LaunderingOperation>(OnLaunderingFinished));
			}
			catch
			{
			}
		}

		public void FillCapDictionary()
		{
			maxiumumLaunderValues.Clear();
			maxiumumLaunderValues["Laundromat"] = config.Businesses.Laundromat.Laundromat_Cap;
			maxiumumLaunderValues["Taco Ticklers"] = config.Businesses.TacoTicklers.Taco_Ticklers_Cap;
			maxiumumLaunderValues["Car Wash"] = config.Businesses.CarWash.Car_Wash_Cap;
			maxiumumLaunderValues["PostOffice"] = config.Businesses.PostOffice.Post_Office_Cap;
			maxiumumLaunderValues["Post Office"] = config.Businesses.PostOffice.Post_Office_Cap;
		}

		public IEnumerator WaitAndApplyCaps()
		{
			isWaitAndApplyCapsRunning = true;
			while (true)
			{
				if (Business.OwnedBusinesses != null)
				{
					foreach (Business business in Business.OwnedBusinesses)
					{
						if (!((Object)(object)business == (Object)null) && !processedBusinesses.Contains(((Object)business).name) && config != null)
						{
							ApplyCap(business);
							processedBusinesses.Add(((Object)business).name);
							if (!createdBusinessesEntries.Contains(((Object)business).name))
							{
								createdBusinessesEntries.Add(((Object)business).name);
								CreateAppEntryForBusiness(business);
							}
							if (processedBusinesses.Count >= 4)
							{
								isWaitAndApplyCapsRunning = false;
								yield break;
							}
						}
					}
				}
				yield return (object)new WaitForSeconds(3f);
			}
		}

		public void ApplyCap(Business business)
		{
			if (aliasMap.TryGetValue(((Object)business).name, out var value) && maxiumumLaunderValues.TryGetValue(value, out var value2))
			{
				business.LaunderCapacity = value2;
			}
		}

		public void CreateAppEntryForBusiness(Business business)
		{
			//IL_00c5: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if (isLegitVersion || createdAppEntries.Contains(((Object)business).name))
			{
				return;
			}
			if (!launderingApp._isLaunderingAppLoaded)
			{
				MelonCoroutines.Start(WaitForLaunderingAppAndCreateEntry(business));
			}
			else if (!((Object)(object)launderingApp.DansHardwareTemplate == (Object)null))
			{
				string text = BusinessUtil.Display(((Object)business).name);
				Color newBackgroundColor;
				string imagePath;
				string newSubtitle;
				switch (BusinessUtil.Canonical(((Object)business).name))
				{
				default:
					return;
				case "Laundromat":
					newBackgroundColor = Color32.op_Implicit(ColorUtil.GetColor("Yellow"));
					imagePath = "Laundromat.png";
					newSubtitle = "Efficient, subtle, and always turning dirty into clean.";
					break;
				case "Taco Ticklers":
					newBackgroundColor = Color32.op_Implicit(ColorUtil.GetColor("Orange"));
					imagePath = "TacoTickler.png";
					newSubtitle = "We wrap more than burritos.";
					break;
				case "Car Wash":
					newBackgroundColor = Color32.op_Implicit(ColorUtil.GetColor("Dark Blue"));
					imagePath = "CarWash.png";
					newSubtitle = "From powder to polish – all clean.";
					break;
				case "Post Office":
					newBackgroundColor = Color32.op_Implicit(ColorUtil.GetColor("Light Blue"));
					imagePath = "PostOffice.png";
					newSubtitle = "Dead drops, fake names but real profits.";
					break;
				}
				launderingApp.AddEntryFromTemplate(text, text, newSubtitle, business, launderingApp.DansHardwareTemplate, newBackgroundColor, imagePath);
				createdAppEntries.Add(((Object)business).name);
			}
		}

		private IEnumerator WaitForLaunderingAppAndCreateEntry(Business business)
		{
			while (!launderingApp._isLaunderingAppLoaded)
			{
				yield return (object)new WaitForSeconds(2f);
			}
			CreateAppEntryForBusiness(business);
		}

		public void ReapplyLaunderingTimes()
		{
			try
			{
				if (config == null || Business.OwnedBusinesses == null)
				{
					return;
				}
				foreach (Business ownedBusiness in Business.OwnedBusinesses)
				{
					if (ownedBusiness?.LaunderingOperations == null)
					{
						continue;
					}
					foreach (LaunderingOperation launderingOperation in ownedBusiness.LaunderingOperations)
					{
						AdjustLaunderingTime(launderingOperation);
					}
				}
			}
			catch
			{
			}
		}

		public void AdjustLaunderingTime(LaunderingOperation operation)
		{
			if (operation != null && !((Object)(object)operation.business == (Object)null) && aliasMap.TryGetValue(((Object)operation.business).name, out var value))
			{
				operation.completionTime_Minutes = ConfigManager.GetLaunderingTimeHours(config, value) * 60;
				boostedOperations.Add(operation);
			}
		}

		private void OnLaunderingStarted(LaunderingOperation operation)
		{
			if (operation != null)
			{
				bool flag = CartelService.TryClaimStart(operation);
				bool flag2 = flag || CartelJobStore.IsCartelJob(operation);
				string acceptedByPlayerCode = (flag ? CartelService.ConsumeArmedPlayerCode() : null);
				DripTracker.Instance.Track(operation, flag2);
				if (flag2)
				{
					CartelJobStore.Add(operation, acceptedByPlayerCode);
				}
				AdjustLaunderingTime(operation);
			}
		}

		private void OnLaunderingFinished(LaunderingOperation operation)
		{
			try
			{
				if ((Object)(object)operation?.business == (Object)null)
				{
					return;
				}
				bool flag = CartelService.IsCartelOperation(operation);
				DripTracker.Instance.OnFinished(operation);
				if (!flag && !config.Use_Drip_Payout)
				{
					string businessName = BusinessUtil.Display(((Object)operation.business).name);
					float amount = operation.amount;
					float num = Mathf.RoundToInt(amount * (ConfigManager.GetTaxationPercentage(config, ((Object)operation.business).name) / 100f));
					if (num > 0f)
					{
						RemoveTaxesFromBankBalance(num, businessName);
					}
					ApplyLumpSumProtection(amount);
				}
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Error("Error in OnLaunderingFinished: " + ex.Message);
			}
		}

		public MoneyManager EnsureMoneyManager()
		{
			if ((Object)(object)moneyManager == (Object)null)
			{
				try
				{
					moneyManager = Object.FindObjectOfType<MoneyManager>();
				}
				catch
				{
				}
			}
			return moneyManager;
		}

		private void RemoveTaxesFromBankBalance(float amount, string businessName)
		{
			if (!((Object)(object)moneyManager == (Object)null))
			{
				moneyManager.CreateOnlineTransaction("Tax for " + businessName, 0f - amount, 1f, "Tax for " + businessName);
				NotifyTaxDeduction(businessName, amount);
			}
		}

		private void ApplyLumpSumProtection(float gross)
		{
			if (config.Use_Protection_Cut && !CartelService.IsCartelDefeated() && !((Object)(object)moneyManager == (Object)null))
			{
				float num = Mathf.RoundToInt(gross * (config.Protection_Cut_Percentage / 100f));
				if (!(num <= 0f))
				{
					moneyManager.CreateOnlineTransaction("Cartel protection", 0f - num, 1f, "Cartel protection");
					NotifyCartelDues(num);
				}
			}
		}

		public void NotifyDripPayout(string businessName, float amount)
		{
			if (config != null && config.Notify_Drip_Payouts && !(amount < 1f))
			{
				SendMoneyNotification(businessName, $"<color=#54E717>${amount:N0}</color> deposited");
			}
		}

		public void NotifyTaxDeduction(string businessName, float amount)
		{
			if (config != null && config.Notify_Tax_Deductions && !(amount < 1f))
			{
				SendMoneyNotification(businessName, $"<color=#E60000>${amount:N0}</color> Lost in Taxes");
			}
		}

		public void NotifyCartelDues(float amount)
		{
			if (config != null && config.Notify_Cartel_Dues && !(amount < 1f))
			{
				SendMoneyNotification("Cartel", $"<color=#E60000>${amount:N0}</color> protection cut");
			}
		}

		private void SendMoneyNotification(string title, string message)
		{
			if (!((Object)(object)notificationsManager == (Object)null))
			{
				notificationsManager.SendNotification(title, message, GetCreditCardIcon(), 5f, true);
			}
		}

		public Sprite GetCreditCardIcon()
		{
			if ((Object)(object)CreditCardIcon != (Object)null)
			{
				return CreditCardIcon;
			}
			GameObject val = GameObject.Find("UI/HUD/HotbarContainer/Slots/CashSlotContainer/OnlineSlot/ItemUI_Cash/Icon");
			if ((Object)(object)val != (Object)null)
			{
				Image component = val.GetComponent<Image>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null && ((Object)component.sprite).name == "CreditCard")
				{
					CreditCardIcon = component.sprite;
					return component.sprite;
				}
			}
			return null;
		}

		public void ChangeAppIconImage(GameObject appIcon, string resourceName)
		{
			//IL_008a: 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_00b7: 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_00cf: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)appIcon == (Object)null || resourceName == null)
			{
				return;
			}
			Transform val = appIcon.transform.Find("Mask/Image");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Image component = ((Component)val).GetComponent<Image>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Sprite val2 = Utils.LoadPhoneHomeIcon(resourceName);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			component.sprite = val2;
			component.preserveAspect = false;
			component.type = (Type)0;
			((Graphic)component).color = Color.white;
			RectTransform val3 = (RectTransform)(object)((val is RectTransform) ? val : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.anchorMin = Vector2.zero;
				val3.anchorMax = Vector2.one;
				val3.offsetMin = Vector2.zero;
				val3.offsetMax = Vector2.zero;
				((Transform)val3).localScale = Vector3.one;
			}
			Transform parent = val.parent;
			if ((Object)(object)parent != (Object)null)
			{
				Image component2 = ((Component)parent).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = Color.white;
				}
			}
		}

		public void RegisterApp(GameObject app, string title = "Unknown App")
		{
			if (!((Object)(object)app == (Object)null))
			{
				GameObject val = Utils.FindAppIconsContainer();
				if ((Object)(object)val == (Object)null)
				{
					((MelonBase)this).LoggerInstance.Error("Could not find AppIcons container to register " + title);
				}
				else
				{
					app.transform.SetParent(val.transform, false);
				}
			}
		}
	}
}
namespace MoreRealisticLaundering.Util
{
	public static class ColorUtil
	{
		public static Dictionary<string, Color32> GetColors()
		{
			//IL_0017: 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_0052: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_011f: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			return new Dictionary<string, Color32>
			{
				{
					"Dark Blue",
					new Color32((byte)33, (byte)64, (byte)115, byte.MaxValue)
				},
				{
					"Light Blue",
					new Color32((byte)83, (byte)126, (byte)158, byte.MaxValue)
				},
				{
					"Light Purple",
					new Color32((byte)87, (byte)82, (byte)153, (byte)127)
				},
				{
					"Purple",
					new Color32((byte)108, (byte)35, (byte)114, byte.MaxValue)
				},
				{
					"Bright Green",
					new Color32((byte)85, (byte)198, (byte)30, byte.MaxValue)
				},
				{
					"Olive Green",
					new Color32((byte)67, (byte)99, (byte)33, byte.MaxValue)
				},
				{
					"Dark Green",
					new Color32((byte)91, (byte)127, (byte)9, byte.MaxValue)
				},
				{
					"Cyan",
					new Color32((byte)9, (byte)115, (byte)119, byte.MaxValue)
				},
				{
					"Dark Red",
					new Color32((byte)99, (byte)33, (byte)37, byte.MaxValue)
				},
				{
					"Yellow",
					new Color32((byte)208, (byte)174, (byte)54, byte.MaxValue)
				},
				{
					"Orange",
					new Color32((byte)178, (byte)78, (byte)44, byte.MaxValue)
				},
				{
					"Grey",
					new Color32((byte)49, (byte)49, (byte)49, byte.MaxValue)
				},
				{
					"Light Grey",
					new Color32((byte)90, (byte)90, (byte)90, byte.MaxValue)
				},
				{
					"Ultra Light Grey",
					new Color32((byte)150, (byte)150, (byte)150, byte.MaxValue)
				},
				{
					"Dark Grey",
					new Color32((byte)30, (byte)30, (byte)30, byte.MaxValue)
				},
				{
					"Redpurple",
					new Color32((byte)112, (byte)21, (byte)37, byte.MaxValue)
				},
				{
					"White",
					new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
				},
				{
					"Black",
					new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue)
				}
			};
		}

		public static Color32 GetColor(string colorName)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, Color32> colors = GetColors();
			if (colors.TryGetValue(colorName, out var value))
			{
				return value;
			}
			throw new KeyNotFoundException("Color '" + colorName + "' not found.");
		}
	}
	public static class FontLoader
	{
		public static Font openSansBold;

		public static bool openSansBoldIsInitialized;

		public static Font openSansSemiBold;

		public static bool openSansSemiBoldIsInitialized;

		public static IEnumerator InitializeFonts()
		{
			for (float timer = 0f; timer < 30f; timer += 0.5f)
			{
				TryLoadFonts();
				if (openSansBoldIsInitialized && openSansSemiBoldIsInitialized)
				{
					yield break;
				}
				yield return (object)new WaitForSecondsRealtime(0.5f);
			}
			TryLoadFontsFromResources();
			ApplyFallbackIfNeeded();
			MelonLogger.Warning("OpenSans fonts were not found on phone apps in time; using fallback fonts.");
		}

		public static Font FindFontFromOtherApp(string fontName)
		{
			TryLoadFonts();
			if (fontName == "openSansBold")
			{
				return openSansBold ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
			if (fontName == "openSansSemiBold")
			{
				return openSansSemiBold ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
			return Resources.GetBuiltinResource<Font>("Arial.ttf");
		}

		private static void TryLoadFonts()
		{
			if (!openSansBoldIsInitialized)
			{
				TryAssignFromObject(Utils.GetAppCanvasByName("ProductManagerApp/Container/Topbar"), preferBold: true);
			}
			if (!openSansBoldIsInitialized)
			{
				TryAssignFromObject(Utils.GetAppCanvasByName("ProductManagerApp"), preferBold: true);
			}
			if (!openSansSemiBoldIsInitialized)
			{
				TryAssignFromObject(Utils.GetAppCanvasByName("DeliveryApp/Container/Scroll View/Viewport/Content"), preferBold: false);
			}
			if (!openSansSemiBoldIsInitialized)
			{
				TryAssignFromObject(Utils.GetAppCanvasByName("DeliveryApp"), preferBold: false);
			}
			if (!openSansBoldIsInitialized || !openSansSemiBoldIsInitialized)
			{
				TryLoadFontsFromResources();
			}
			if ((Object)(object)openSansBold != (Object)null && (Object)(object)openSansSemiBold == (Object)null)
			{
				Assign(openSansBold, preferBold: false);
			}
			if ((Object)(object)openSansSemiBold != (Object)null && (Object)(object)openSansBold == (Object)null)
			{
				Assign(openSansSemiBold, preferBold: true);
			}
		}

		private static void TryAssignFromObject(GameObject root, bool preferBold)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Text[] componentsInChildren = root.GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null && (Object)(object)componentsInChildren[i].font != (Object)null)
				{
					Assign(componentsInChildren[i].font, preferBold);
				}
				if (preferBold ? openSansBoldIsInitialized : openSansSemiBoldIsInitialized)
				{
					return;
				}
			}
			TMP_Text[] componentsInChildren2 = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text obj in componentsInChildren2)
			{
				object obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					TMP_FontAsset font = obj.font;
					obj2 = ((font != null) ? font.sourceFontFile : null);
				}
				Font val = (Font)obj2;
				if ((Object)(object)val != (Object)null)
				{
					Assign(val, preferBold);
				}
				if (preferBold ? openSansBoldIsInitialized : openSansSemiBoldIsInitialized)
				{
					break;
				}
			}
		}

		private static void TryLoadFontsFromResources()
		{
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			if (array == null)
			{
				return;
			}
			foreach (Font val in array)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name) && (((Object)val).name.IndexOf("opensans", StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)val).name.IndexOf("open sans", StringComparison.OrdinalIgnoreCase) >= 0))
				{
					bool flag = ((Object)val).name.IndexOf("semi", StringComparison.OrdinalIgnoreCase) >= 0;
					Assign(val, !flag);
				}
			}
		}

		private static void Assign(Font font, bool preferBold)
		{
			if ((Object)(object)font == (Object)null)
			{
				return;
			}
			if (preferBold)
			{
				if (!openSansBoldIsInitialized)
				{
					openSansBold = font;
					openSansBoldIsInitialized = true;
				}
			}
			else if (!openSansSemiBoldIsInitialized)
			{
				openSansSemiBold = font;
				openSansSemiBoldIsInitialized = true;
			}
		}

		private static void ApplyFallbackIfNeeded()
		{
			Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
			if ((Object)(object)openSansBold == (Object)null)
			{
				openSansBold = openSansSemiBold ?? builtinResource;
			}
			if ((Object)(object)openSansSemiBold == (Object)null)
			{
				openSansSemiBold = openSansBold ?? builtinResource;
			}
			openSansBoldIsInitialized = true;
			openSansSemiBoldIsInitialized = true;
		}
	}
	public static class Utils
	{
		private const string AppsCanvasPath = "Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/AppsCanvas";

		private const string ScrollViewAppIconsPath = "Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIconsScrollView/Viewport/AppIcons";

		private const string StubAppIconsPath = "Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIcons";

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

		public static GameObject FindAppIconsContainer()
		{
			try
			{
				if (PlayerSingleton<HomeScreen>.InstanceExists && (Object)(object)PlayerSingleton<HomeScreen>.Instance.appIconContainer != (Object)null)
				{
					return ((Component)PlayerSingleton<HomeScreen>.Instance.appIconContainer).gameObject;
				}
			}
			catch
			{
			}
			GameObject val = GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIconsScrollView/Viewport/AppIcons");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIcons");
		}

		public static bool IsStubAppIconsContainer(GameObject container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			string transformPath = GetTransformPath(container.transform);
			return transformPath != null && transformPath.EndsWith("/HomeScreen/AppIcons", StringComparison.Ordinal) && transformPath.IndexOf("AppIconsScrollView", StringComparison.Ordinal) < 0;
		}

		private static string GetTransformPath(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return null;
			}
			List<string> list = new List<string>();
			while ((Object)(object)t != (Object)null)
			{
				list.Add(((Object)t).name);
				t = t.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		public static GameObject FindAppsCanvas()
		{
			return GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/AppsCanvas/") ?? GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/AppsCanvas");
		}

		public static IEnumerator WaitUntilFound(Func<GameObject> finder, Action<GameObject> callback, float timeout = 30f)
		{
			GameObject obj = null;
			float timer = 0f;
			while ((Object)(object)obj == (Object)null && timer < timeout)
			{
				obj = finder();
				if ((Object)(object)obj != (Object)null)
				{
					break;
				}
				yield return (object)new WaitForSecondsRealtime(0.1f);
				timer += 0.1f;
			}
			callback?.Invoke(obj);
		}

		public static GameObject GetAppIconByName(string Name, int? Index, string newObjectName = null)
		{
			int valueOrDefault = Index.GetValueOrDefault();
			GameObject val = FindAppIconsContainer();
			if ((Object)(object)val == (Object)null)
			{
				MelonLogger.Error("Could not find AppIcons container.");
				return null;
			}
			GameObject[] array = (from t in val.GetComponentsInChildren<Transform>(true)
				let labelText = GetLabelText(((Component)t).gameObject.transform.Find("Label"))
				where !string.IsNullOrEmpty(labelText) && labelText.StartsWith(Name)
				select ((Component)t).gameObject).ToArray();
			if (valueOrDefault >= array.Length)
			{
				MelonLogger.Error($"Index {valueOrDefault} is out of range. Returning null.");
				return null;
			}
			GameObject val2 = array[valueOrDefault];
			if (newObjectName != null)
			{
				((Object)val2).name = newObjectName;
			}
			return val2;
		}

		public static GameObject ChangeLabelFromAppIcon(string appIconName, string newLabel, bool allowOriginal = false)
		{
			if (string.IsNullOrEmpty(appIconName) || string.IsNullOrEmpty(newLabel))
			{
				MelonLogger.Error("AppIcon name or new label is null or empty.");
				return null;
			}
			GameObject appIconByName = GetAppIconByName(appIconName, 1, newLabel);
			if ((Object)(object)appIconByName == (Object)null && allowOriginal)
			{
				appIconByName = GetAppIconByName(appIconName, 0, newLabel);
			}
			if ((Object)(object)appIconByName == (Object)null)
			{
				return null;
			}
			SetLabelText(appIconByName.transform.Find("Label"), newLabel);
			return appIconByName;
		}

		public static GameObject GetAppCanvasByName(string Name)
		{
			GameObject val = FindAppsCanvas();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = val.transform.Find(Name);
			return ((Object)(object)val2 != (Object)null) ? ((Component)val2).gameObject : null;
		}

		public static string GetLabelText(Transform target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return null;
			}
			Text component = ((Component)target).GetComponent<Text>();
			if ((Object)(object)component != (Object)null && component.text != null)
			{
				return component.text;
			}
			TMP_Text component2 = ((Component)target).GetComponent<TMP_Text>();
			return ((Object)(object)component2 != (Object)null) ? component2.text : null;
		}

		public static void SetLabelText(Transform target, string value)
		{
			if (!((Object)(object)target == (Object)null))
			{
				Text component = ((Component)target).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.text = value;
				}
				TMP_Text component2 = ((Component)target).GetComponent<TMP_Text>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.text = value;
				}
			}
		}

		public static void SetLabelColor(Transform target, Color color)
		{
			//IL_0021: 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)
			if (!((Object)(object)target == (Object)null))
			{
				Text component = ((Component)target).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = color;
				}
				TMP_Text component2 = ((Component)target).GetComponent<TMP_Text>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = color;
				}
			}
		}

		public static void SetLabelAlignment(Transform target, TextAnchor alignment)
		{
			//IL_0021: 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)
			if (!((Object)(object)target == (Object)null))
			{
				Text component = ((Component)target).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.alignment = alignment;
				}
				TMP_Text component2 = ((Component)target).GetComponent<TMP_Text>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.alignment = ToTmpAlignment(alignment);
				}
			}
		}

		private static TextAlignmentOptions ToTmpAlignment(TextAnchor alignment)
		{
			//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_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0056: 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_004e: 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_0046: 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_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_0066: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			return (TextAlignmentOptions)((int)alignment switch
			{
				5 => 4100, 
				3 => 4097, 
				4 => 4098, 
				2 => 260, 
				0 => 257, 
				1 => 258, 
				8 => 1028, 
				6 => 1025, 
				7 => 1026, 
				_ => 4097, 
			});
		}

		public static IEnumerator WaitForObjectByFrame(string path, Action<GameObject> callback)
		{
			GameObject obj = null;
			while ((Object)(object)obj == (Object)null)
			{
				obj = GameObject.Find(path);
				yield return null;
			}
			callback?.Invoke(obj);
		}

		public static IEnumerator WaitForObject(string path, Action<GameObject> callback, float timeout = 30f)
		{
			GameObject obj = null;
			float timer = 0f;
			while ((Object)(object)obj == (Object)null && timer < timeout)
			{
				obj = GameObject.Find(path);
				if ((Object)(object)obj != (Object)null)
				{
					break;
				}
				yield return (object)new WaitForSecondsRealtime(0.1f);
				timer += 0.1f;
			}
			callback?.Invoke(obj);
		}

		public static void ClearChildren(Transform parent, Func<GameObject, bool> keepFilter = null)
		{
			GameObject[] array = (from t in ((Component)parent).GetComponentsInChildren<Transform>(true)
				select ((Component)t).gameObject into obj
				where (Object)(object)obj.transform != (Object)(object)parent
				select obj).ToArray();
			GameObject[] array2 = array;
			foreach (GameObject val in array2)
			{
				if (keepFilter == null || !keepFilter(val))
				{
					val.transform.parent = null;
					Object.Destroy((Object)(object)val);
				}
			}
		}

		public static Texture2D LoadCustomImage(string path)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			string path2 = Path.Combine(MelonEnvironment.UserDataDirectory, path);
			Texture2D result;
			if (!File.Exists(path2))
			{
				result = null;
				Debug.LogError((object)"Specified path does not exist.");
			}
			else
			{
				byte[] array = File.ReadAllBytes(path2);
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, array);
				result = val;
			}
			return result;
		}

		public static byte[] LoadEmbeddedResource(string resourceName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = "MoreRealisticLaundering.Assets." + resourceName;
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				MelonLogger.Warning("Embedded resource not found: " + text);
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			return array;
		}

		public static Texture2D LoadEmbeddedTexture(string resourceName)
		{
			return LoadEmbeddedTexture(resourceName, readable: false);
		}

		public static Texture2D LoadEmbeddedTexture(string resourceName, bool readable)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			byte[] array = LoadEmbeddedResource(resourceName);
			if (array == null)
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (ImageConversion.LoadImage(val, array, !readable))
			{
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				return val;
			}
			MelonLogger.Error("Failed to load texture from embedded resource: " + resourceName);
			return null;
		}

		public static Sprite LoadEmbeddedSprite(string resourceName)
		{
			//IL_0030: 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)
			Texture2D val = LoadEmbeddedTexture(resourceName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		public static Sprite LoadPhoneHomeIcon(string resourceName)
		{
			if (string.IsNullOrEmpty(resourceName))
			{
				return null;
			}
			if (PhoneHomeIcons.TryGetValue(resourceName, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Sprite val = BuildPhoneHomeIcon(resourceName) ?? LoadEmbeddedSprite(resourceName);
			if ((Object)(object)val != (Object)null)
			{
				PhoneHomeIcons[resourceName] = val;
			}
			return val;
		}

		private static Sprite BuildPhoneHomeIcon(string resourceName)
		{
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_0192: 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)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: 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)
			//IL_023a: 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_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = LoadEmbeddedTexture(resourceName, readable: true);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Color[] pixels = val.GetPixels();
			int width = ((Texture)val).width;
			int height = ((Texture)val).height;
			Object.DestroyImmediate((Object)(object)val);
			int num = width;
			int num2 = height;
			int num3 = -1;
			int num4 = -1;
			for (int i = 0; i < height; i++)
			{
				int num5 = i * width;
				for (int j = 0; j < width; j++)
				{
					if (!(pixels[num5 + j].a <= 0.08f))
					{
						if (j < num)
						{
							num = j;
						}
						if (i < num2)
						{
							num2 = i;
						}
						if (j > num3)
						{
							num3 = j;
						}
						if (i > num4)
						{
							num4 = i;
						}
					}
				}
			}
			if (num3 < num)
			{
				return null;
			}
			int num6 = num3 - num + 1;
			int num7 = num4 - num2 + 1;
			int num8 = Mathf.RoundToInt(40.96f);
			int num9 = 256 - num8 * 2;
			float num10 = Mathf.Min((float)num9 / (float)num6, (float)num9 / (float)num7);
			int num11 = Mathf.Max(1, Mathf.RoundToInt((float)num6 * num10));
			int num12 = Mathf.Max(1, Mathf.RoundToInt((float)num7 * num10));
			int num13 = (256 - num11) / 2;
			int num14 = (256 - num12) / 2;
			Color val2 = Color32.op_Implicit(ColorUtil.GetColor("Cyan"));
			Texture2D val3 = new Texture2D(256, 256, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			Color[] array = (Color[])(object)new Color[65536];
			for (int k = 0; k < array.Length; k++)
			{
				array[k] = val2;
			}
			for (int l = 0; l < num12; l++)
			{
				int num15 = num2 + Mathf.Clamp(Mathf.FloorToInt((float)l / num10), 0, num7 - 1);
				int num16 = num15 * width;
				int num17 = (num14 + l) * 256;
				for (int m = 0; m < num11; m++)
				{
					int num18 = num + Mathf.Clamp(Mathf.FloorToInt((float)m / num10), 0, num6 - 1);
					Color val4 = pixels[num16 + num18];
					if (!(val4.a < 0.01f))
					{
						int num19 = num17 + num13 + m;
						Color val5 = Color.Lerp(array[num19], val4, val4.a);
						val5.a = 1f;
						array[num19] = val5;
					}
				}
			}
			val3.SetPixels(array);
			val3.Apply(false, true);
			return Sprite.Create(val3, new Rect(0f, 0f, 256f, 256f), new Vector2(0.5f, 0.5f), 100f);
		}
	}
}
namespace MoreRealisticLaundering.PhoneApp
{
	public class LaunderingApp
	{
		private class HoverTarget
		{
			public RectTransform Hit;

			public CanvasGroup Border;

			public Transform ScaleRoot;

			public Vector3 BaseScale;

			public string SelectId;
		}

		public GameObject DansHardwareTemplate;

		public GameObject GasMartWestTemplate;

		public GameObject viewPortContentSpaceTemplate;

		public Transform launderingAppViewportContentTransform;

		public bool _isLaunderingAppLoaded;

		public Transform optionsTransform;

		public Transform globalOptionsTransform;

		public Transform cartelOptionsTransform;

		public Transform notificationOptionsTransform;

		public GameObject checkboxTemplate;

		public GameObject detailsTitleObject;

		public GameObject detailsSubtitleObject;

		public GameObject InstructionsTextObject;

		public Transform settingsContentTransform;

		public Sprite appIconSprite;

		public Sprite laundromatSprite;

		public Sprite tacoTicklersSprite;

		public Sprite carWashSprite;

		public Sprite postOfficeSprite;

		public Sprite inputBackgroundSprite;

		public bool isSaveStillRunning;

		private GameObject _appPanel;

		private GameObject _homeIcon;

		private ProductManagerApp _productApp;

		private Business _selectedBusiness;

		private Action _closeAppAction;

		private bool _openQueued;

		private int _openDelayFrames;

		private int _initGeneration;

		private bool _iconRecoverQueued;

		private string _lastIconId = "TaxNWash";

		private string _lastIconTitle = "Tax & Wash";

		private string _lastIconPath = "LaunderingIcon.png";

		private readonly List<HoverTarget> _hoverTargets = new List<HoverTarget>();

		private string _selectedCardName;

		private object _panelFade;

		private static Sprite _roundedFillSprite;

		private static Sprite _roundedBorderSprite;

		private static Sprite _roundedBorderThickSprite;

		public static bool OpeningTaxWash;

		public void CancelPendingInit()
		{
			_initGeneration++;
			_iconRecoverQueued = false;
		}

		public void ClearUiForMenu()
		{
			_isLaunderingAppLoaded = false;
			launderingAppViewportContentTransform = null;
			if ((Object)(object)_homeIcon != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)_homeIcon);
				}
				catch
				{
				}
				_homeIcon = null;
			}
			if ((Object)(object)_appPanel != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)_appPanel);
				}
				catch
				{
				}
				_appPanel = null;
			}
			if ((Object)(object)DansHardwareTemplate != (Object)null)
			{
				Object.Destroy((Object)(object)DansHardwareTemplate);
			}
			if ((Object)(object)GasMartWestTemplate != (Object)null)
			{
				Object.Destroy((Object)(object)GasMartWestTemplate);
			}
			if ((Object)(object)viewPortContentSpaceTemplate != (Object)null)
			{
				Object.Destroy((Object)(object)viewPortContentSpaceTemplate);
			}
			DansHardwareTemplate = null;
			GasMartWestTemplate = null;
			viewPortContentSpaceTemplate = null;
		}

		public IEnumerator InitializeLaunderApp()
		{
			int gen = ++_initGeneration;
			while (MRLCore.Instance == null)
			{
				if (gen != _initGeneration)
				{
					yield break;
				}
				yield return (object)new WaitForSecondsRealtime(0.5f);
			}
			MelonCoroutines.Start(FontLoader.InitializeFonts());
			while (!FontLoader.openSansBoldIsInitialized || !FontLoader.openSansSemiBoldIsInitialized)
			{
				if (gen != _initGeneration)
				{
					yield break;
				}
				yield return (object)new WaitForSecondsRealtime(0.5f);
			}
			if (gen == _initGeneration)
			{
				yield return MelonCoroutines.Start(CreateApp("TaxNWash", "Tax & Wash", "LaunderingIcon.png", gen));
			}
		}

		public IEnumerator CreateApp(string idName, string title, string iconPath)
		{
			yield return CreateApp(idName, title, iconPath, _initGeneration);
		}

		private IEnumerator CreateApp(string idName, string title, string iconPath, int gen)
		{
			_hoverTargets.Clear();
			_selectedCardName = null;
			_lastIconId = idName;
			_lastIconTitle = title;
			_lastIconPath = iconPath;
			yield return MelonCoroutines.Start(Utils.WaitUntilFound(Utils.FindAppIconsContainer, null, 45f));
			if (gen != _initGeneration)
			{
				yield break;
			}
			GameObject parentCanvas = null;
			GameObject productsApp = null;
			GameObject deliveriesApp = null;
			yield return MelonCoroutines.Start(Utils.WaitUntilFound(Utils.FindAppsCanvas, delegate(GameObject obj)
			{
				parentCanvas = obj;
			}, 45f));
			yield return MelonCoroutines.Start(Utils.WaitUntilFound(() => Utils.GetAppCanvasByName("ProductManagerApp"), delegate(GameObject obj)
			{
				productsApp = obj;
			}, 45f));
			yield return MelonCoroutines.Start(Utils.WaitUntilFound(() => Utils.GetAppCanvasByName("DeliveryApp"), delegate(GameObject obj)
			{
				deliveriesApp = obj;
			}, 45f));
			if (gen != _initGeneration)
			{
				yield break;
			}
			if ((Object)(object)parentCanvas == (Object)null || (Object)(object)productsApp == (Object)null || (Object)(object)deliveriesApp == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: phone AppsCanvas/ProductManagerApp/DeliveryApp was not found.");
				yield break;
			}
			Transform existing = parentCanvas.transform.Find(idName) ?? parentCanvas.transform.Find("MRL_TaxWash") ?? parentCanvas.transform.Find("TaxNWash");
			if ((Object)(object)existing != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)existing).gameObject);
			}
			DestroyDeadTaxWashIcons();
			DestroyLabeledIcons("DeliveriesCopy");
			DestroyLabeledIcons("ProductsCopy");
			KeepSingleIcon("Deliveries");
			KeepSingleIcon("Products");
			GameObject mrlApp = null;
			try
			{
				mrlApp = CreateVisualPanel(productsApp, deliveriesApp, parentCanvas.transform, title);
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Tax & Wash CreateApp failed: " + ex);
			}
			if ((Object)(object)mrlApp == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: visual panel was not created.");
				yield break;
			}
			if ((Object)(object)mrlApp.GetComponent<ProductManagerApp>() != (Object)null)
			{
				MelonLogger.Error("Tax & Wash: ProductManagerApp was present on the visual panel.");
			}
			DeactivateAppContainers(mrlApp.transform);
			mrlApp.SetActive(true);
			_appPanel = mrlApp;
			_productApp = null;
			KeepSingleIcon("Deliveries");
			KeepSingleIcon("Products");
			GameObject appIcon = null;
			for (int attempt = 0; attempt < 5; attempt++)
			{
				if (!((Object)(object)appIcon == (Object)null))
				{
					break;
				}
				if (gen != _initGeneration)
				{
					yield break;
				}
				if (attempt > 0)
				{
					yield return (object)new WaitForSecondsRealtime(1f);
				}
				try
				{
					appIcon = CreateIndependentIcon(idName, title, iconPath);
				}
				catch (Exception ex2)
				{
					MelonLogger.Error("Tax & Wash icon setup failed: " + ex2);
				}
			}
			_homeIcon = appIcon;
			DestroyExtraTaxWashIcons(appIcon);
			HookPhoneClose();
			if ((Object)(object)appIcon == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: could not create a home icon after retries.");
				yield break;
			}
			Transform parent = appIcon.transform.parent;
			MelonLogger.Msg("Tax & Wash home icon registered under '" + ((parent != null) ? ((Object)parent).name : null) + "'.");
			yield return MelonCoroutines.Start(EnsureIconOnLiveContainer(gen, idName, title, iconPath));
			if (gen == _initGeneration)
			{
				if ((Object)(object)settingsContentTransform != (Object)null)
				{
					((Component)settingsContentTransform).gameObject.SetActive(true);
					AddOptionsForBusiness(settingsContentTransform);
					AddGlobalOptions(settingsContentTransform);
					AddCartelOptions(settingsContentTransform);
					AddNotificationOptions(settingsContentTransform);
					PackDetailsContent();
				}
				if ((Object)(object)DansHardwareTemplate != (Object)null)
				{
					AddEntryFromTemplate("Global Settings", "Global Settings", "Payout timing, hours, and drip options.", null, DansHardwareTemplate, Color32.op_Implicit(ColorUtil.GetColor("Cyan")), "LaunderingIcon.png", null, isFirstEntry: true);
					AddEntryFromTemplate("Cartel Settings", "Cartel Settings", "Protection cut, wash jobs, and influence.", null, DansHardwareTemplate, Color32.op_Implicit(ColorUtil.GetColor("Dark Red")), "CartelIcon.png");
					AddEntryFromTemplate("Notification Settings", "Notification Settings", "Deposit, tax, and cartel alerts.", null, DansHardwareTemplate, Color32.op_Implicit(ColorUtil.GetColor("Purple")), "NotificationIcon.png");
				}
				_isLaunderingAppLoaded = (Object)(object)_homeIcon != (Object)null;
				if (_isLaunderingAppLoaded)
				{
					MelonLogger.Msg("Tax & Wash phone app ready.");
				}
			}
		}

		private IEnumerator EnsureIconOnLiveContainer(int gen, string idName, string title, string iconPath)
		{
			for (int i = 0; i < 12; i++)
			{
				if (gen != _initGeneration)
				{
					break;
				}
				yield return (object)new WaitForSecondsRealtime(0.5f);
				GameObject live = Utils.FindAppIconsContainer();
				bool iconAlive = (Object)(object)_homeIcon != (Object)null;
				try
				{
					if (iconAlive)
					{
						_ = _homeIcon.transform;
					}
				}
				catch
				{
					iconAlive = false;
				}
				if (!iconAlive)
				{
					MelonLogger.Warning("Tax & Wash home icon was destroyed — recreating.");
					_homeIcon = CreateIndependentIcon(idName, title, iconPath);
					DestroyExtraTaxWashIcons(_homeIcon);
				}
				else
				{
					if (!((Object)(object)live != (Object)null) || !((Object)(object)_homeIcon.transform.parent != (Object)(object)live.transform))
					{
						continue;
					}
					Transform parent = _homeIcon.transform.parent;
					int num;
					if (!Utils.IsStubAppIconsContainer((parent != null) ? ((Component)parent).gameObject : null))
					{
						Transform parent2 = _homeIcon.transform.parent;
						num = (((Object)(object)live != (Object)(object)((parent2 != null) ? ((Component)parent2).gameObject : null)) ? 1 : 0);
					}
					else
					{
						num = 1;
					}
					if (num == 0)
					{
						continue;
					}
					MelonLogger.Msg("Tax & Wash: re-parenting home icon to '" + ((Object)live).name + "'.");
					_homeIcon.transform.SetParent(live.transform, false);
					try
					{
						if (PlayerSingleton<HomeScreen>.InstanceExists && (Object)(object)PlayerSingleton<HomeScreen>.Instance.uiPanel != (Object)null)
						{
							UISelectable selectable = _homeIcon.GetComponent<UISelectable>() ?? _homeIcon.GetComponentInChildren<UISelectable>(true);
							if ((Object)(object)selectable != (Object)null)
							{
								PlayerSingleton<HomeScreen>.Instance.uiPanel.AddSelectable(selectable);
								selectable.SetSelectedImageVisible(false);
							}
						}
					}
					catch
					{
					}
				}
			}
		}

		private GameObject CreateVisualPanel(GameObject productsApp, GameObject deliveriesApp, Transform parent, string title)
		{
			GameObject val = InstantiateInactive(productsApp, parent, "MRL_TaxWash");
			StripPhoneBehaviours(val);
			RemoveOverlayCanvas(val);
			Transform val2 = FindMainAppContainer(val.transform);
			if ((Object)(object)val2 == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: cloned ProductManagerApp has no Container.");
				return val;
			}
			Transform val3 = val2.Find("Scroll View");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
				((Object)((Component)val3).gameObject).name = "DeactivatedScrollView";
			}
			ImportOriginalDeliveryScroll(deliveriesApp, val2);
			EnsureLeftListFrame(val2);
			CustomizeClonedApp(val, title);
			return val;
		}

		private static void RemoveOverlayCanvas(GameObject panel)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if ((Object)(object)panel == (Object)null)
			{
				return;
			}
			Canvas[] components = panel.GetComponents<Canvas>();
			foreach (Canvas val in components)
			{
				if (!((Object)(object)val == (Object)null) && (int)val.renderMode == 0)
				{
					Object.DestroyImmediate((Object)(object)val);
				}
			}
		}

		private static Transform FindDeep(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					if (((Object)child).name == name)
					{
						return child;
					}
					Transform val = FindDeep(child, name);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static Transform FindAncestorNamed(Transform start, string name)
		{
			Transform val = start;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
				val = val.parent;
			}
			return null;
		}

		private static bool IsShopCard(Transform child)
		{
			if ((Object)(object)child == (Object)null)
			{
				return false;
			}
			string name = ((Object)child).name;
			switch (name)
			{
			default:
				if (!(name == "Image"))
				{
					return (Object)(object)child.Find("Header") != (Object)null || (Object)(object)child.Find("Container") != (Object)null;
				}
				goto case "Header";
			case "Header":
			case "Topbar":
			case "Space":
			case "Viewport":
			case "Scrollbar Horizontal":
			case "Scrollbar Vertical":
			case "Dropshadow":
			case "Background":
			case "Instruction":
				return false;
			}
		}

		private static Transform FindCardChrome(Transform entry)
		{
			if ((Object)(object)entry == (Object)null)
			{
				return null;
			}
			return entry.Find("Header") ?? entry.Find("Container") ?? FindDeep(entry, "Header");
		}

		private static Transform FindFirstShopCard(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (IsShopCard(child))
				{
					return child;
				}
				Transform val = FindFirstShopCard(child);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static Transform FindListContent(Transform scrollView)
		{
			if ((Object)(object)scrollView == (Object)null)
			{
				return null;
			}
			if (CountShopCards(scrollView) >= 2)
			{
				return scrollView;
			}
			Transform val = scrollView.Find("Viewport/Content");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Transform val2 = scrollView.Find("Viewport") ?? FindDeep(scrollView, "Viewport");
			if ((Object)(object)val2 != (Object)null)
			{
				val = val2.Find("Content") ?? FindDeep(val2, "Content");
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			Transform val3 = FindFirstShopCard(scrollView);
			return ((Object)(object)val3 != (Object)null) ? val3.parent : null;
		}

		private static Transform FindMainAppContainer(Transform app)
		{
			if ((Object)(object)app == (Object)null)
			{
				return null;
			}
			Transform val = null;
			int num = -1;
			for (int i = 0; i < app.childCount; i++)
			{
				Transform child = app.GetChild(i);
				if (!((Object)(object)child == (Object)null) && !(((Object)child).name != "Container"))
				{
					int num2 = 0;
					if ((Object)(object)child.Find("Topbar") != (Object)null)
					{
						num2 += 10;
					}
					if ((Object)(object)child.Find("Details") != (Object)null)
					{
						num2 += 10;
					}
					if ((Object)(object)child.Find("Scroll View") != (Object)null)
					{
						num2 += 3;
					}
					if ((Object)(object)child.Find("Header") != (Object)null)
					{
						num2++;
					}
					if ((Object)(object)child.Find("Content") != (Object)null)
					{
						num2++;
					}
					if (num2 > num)
					{
						num = num2;
						val = child;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				val = app.Find("Container");
			}
			for (int j = 0; j < app.childCount; j++)
			{
				Transform child2 = app.GetChild(j);
				if ((Object)(object)child2 != (Object)null && ((Object)child2).name == "Container" && (Object)(object)child2 != (Object)(object)val)
				{
					((Component)child2).gameObject.SetActive(false);
				}
			}
			return val;
		}

		private static void DeactivateAppContainers(Transform app)
		{
			if ((Object)(object)app == (Object)null)
			{
				return;
			}
			for (int i = 0; i < app.childCount; i++)
			{
				Transform child = app.GetChild(i);
				if ((Object)(object)child != (Object)null && ((Object)child).name == "Container")
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private void ImportOriginalDeliveryScroll(GameObject deliveriesApp, Transform container)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)deliveriesApp == (Object)null || (Object)(object)container == (Object)null)
			{
				return;
			}
			Transform val = FindOriginalDeliveryListScroll(deliveriesApp.transform);
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = InstantiateInactive(((Component)val).gameObject, container, "Scroll View");
				Transform val3 = val2.transform.Find("OrderSubmitted");
				if ((Object)(object)val3 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)((Component)val3).gameObject);
				}
				RectTransform component = val2.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(-100f, -60f);
					component.anchoredPosition = new Vector2(-50f, -30f);
				}
				val2.SetActive(true);
			}
		}

		private void EnsureLeftListFrame(Transform container)
		{
			if ((Object)(object)container == (Object)null || (Object)(object)container.Find("Scroll View") != (Object)null)
			{
				return;
			}
			Transform val = container.Find("DeactivatedScrollView");
			if ((Object)(object)val == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: no left-list Scroll View is available.");
				return;
			}
			((Object)((Component)val).gameObject).name = "Scroll View";
			((Component)val).gameObject.SetActive(true);
			Transform val2 = val.Find("Viewport/Content");
			if ((Object)(object)val2 != (Object)null)
			{
				Utils.ClearChildren(val2);
			}
		}

		private static Transform FindOriginalDeliveryListScroll(Transform deliveryRoot)
		{
			if ((Object)(object)deliveryRoot == (Object)null)
			{
				return null;
			}
			Transform result = null;
			int num = 0;
			Transform[] componentsInChildren = ((Component)deliveryRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || ((Object)val).name != "Scroll View")
				{
					continue;
				}
				Transform val2 = val.Find("Viewport/Content");
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				int num2 = 0;
				for (int j = 0; j < val2.childCount; j++)
				{
					Transform child = val2.GetChild(j);
					if ((Object)(object)child != (Object)null && (Object)(object)child.Find("Header") != (Object)null)
					{
						num2++;
					}
				}
				if (num2 > num)
				{
					num = num2;
					result = val;
				}
			}
			return result;
		}

		private static int CountShopCards(Transform parent)
		{
			if ((Object)(object)parent == (Object)null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < parent.childCount; i++)
			{
				if (IsShopCard(parent.GetChild(i)))
				{
					num++;
				}
			}
			return num;
		}

		private static bool LooksLikeShopList(Transform listContent)
		{
			if ((Object)(object)listContent == (Object)null)
			{
				return false;
			}
			int num = 0;
			if ((Object)(object)listContent.Find("Dan's Hardware") != (Object)null)
			{
				num++;
			}
			if ((Object)(object)listContent.Find("Gas-Mart (West)") != (Object)null)
			{
				num++;
			}
			if ((Object)(object)listContent.Find("Gas-Mart (Central)") != (Object)null)
			{
				num++;
			}
			if ((Object)(object)listContent.Find("Gas-Mart (North)") != (Object)null)
			{
				num++;
			}
			if ((Object)(object)listContent.Find("Gas-Mart (South)") != (Object)null)
			{
				num++;
			}
			if (num >= 2)
			{
				return true;
			}
			return (Object)(object)listContent.Find("Space") != (Object)null && CountShopCards(listContent) >= 2;
		}

		private static Transform FindDeliveryShopListScroll(Transform deliveryRoot)
		{
			if ((Object)(object)deliveryRoot == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)deliveryRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name != "Scroll View") && LooksLikeShopList(FindListContent(val)))
				{
					return val;
				}
			}
			Transform val2 = FindDeep(deliveryRoot, "Dan's Hardware") ?? FindDeep(deliveryRoot, "Gas-Mart (West)");
			if ((Object)(object)val2 != (Object)null && LooksLikeShopList(val2.parent))
			{
				return FindAncestorNamed(val2, "Scroll View") ?? val2.parent;
			}
			Transform result = null;
			int num = 0;
			foreach (Transform val3 in componentsInChildren)
			{
				if (!((Object)(object)val3 == (Object)null) && !(((Object)val3).name != "Scroll View"))
				{
					int num2 = CountShopCards(FindListContent(val3));
					if (num2 > num)
					{
						num = num2;
						result = val3;
					}
				}
			}
			if (num >= 2)
			{
				return result;
			}
			for (int k = 0; k < deliveryRoot.childCount; k++)
			{
				Transform child = deliveryRoot.GetChild(k);
				if (!((Object)(object)child == (Object)null) && !(((Object)child).name != "Container"))
				{
					Transform val4 = child.Find("Scroll View");
					if ((Object)(object)val4 != (Object)null)
					{
						return val4;
					}
				}
			}
			return result;
		}

		private static void HideOverlappingProductUi(Transform parent, Transform keep)
		{
			if ((Object)(object)parent == (Object)null)
			{
				return;
			}
			bool flag = ((Object)parent).name == "Content";
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if ((Object)(object)child == (Object)null || (Object)(object)child == (Object)(object)keep)
				{
					continue;
				}
				string name = ((Object)child).name;
				switch (name)
				{
				case "Details":
				case "Instruction":
				case "Background":
				case "Header":
				case "Topbar":
					continue;
				}
				if (!(name == "Scroll View") && (flag || name.IndexOf("Favour", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Product", StringComparison.OrdinalIgnoreCase) >= 0 || name == "FiltersPanel"))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private static void CopyRectTransform(RectTransform source, RectTransform dest)
		{
			//IL_001c: 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_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_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)
			if (!((Object)(object)source == (Object)null) && !((Object)(object)dest == (Object)null))
			{
				dest.anchorMin = source.anchorMin;
				dest.anchorMax = source.anchorMax;
				dest.pivot = source.pivot;
				dest.anchoredPosition = source.anchoredPosition;
				dest.sizeDelta = source.sizeDelta;
				dest.offsetMin = source.offsetMin;
				dest.offsetMax = source.offsetMax;
				((Transform)dest).localScale = ((Transform)source).localScale;
				((Transform)dest).localRotation = ((Transform)source).localRotation;
			}
		}

		private void CustomizeClonedApp(GameObject mrlApp, string title)
		{
			//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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0120: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			Transform val = FindMainAppContainer(mrlApp.transform);
			if ((Object)(object)val == (Object)null)
			{
				MelonLogger.Error("Tax & Wash: visual panel has no Container.");
				return;
			}
			Transform val2 = FindDeep(val, "FiltersPanel");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
			}
			Transform val3 = val.Find("Topbar") ?? val.Find("Header") ?? FindDeep(val, "Topbar") ?? FindDeep(val, "Header");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(true);
				Color val4 = Color32.op_Implicit(ColorUtil.GetColor("Cyan"));
				Image component = ((Component)val3).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					Color color = val4;
					color.a = 1f;
					((Graphic)component).color = color;
				}
				Transform val5 = val3.Find("Background");
				if ((Object)(object)val5 != (Object)null)
				{
					Image component2 = ((Component)val5).GetComponent<Image>();
					if ((Object)(object)component2 != (Object)null)
					{
						Color color2 = val4;
						color2.a = 1f;
						((Graphic)component2).color = color2;
					}
					((Component)val5).gameObject.SetActive(true);
				}
				Transform target = val3.Find("Title") ?? FindDeep(val3, "Title");
				Utils.SetLabelText(target, title);
				Utils.SetLabelColor(target, Color32.op_Implicit(ColorUtil.GetColor("White")));
				Transform val6 = val3.Find("Subtitle") ?? FindDeep(val3, "Subtitle");
				if ((Object)(object)val6 != (Object)null)
				{
					((Component)val6).gameObject.SetActive(true);
					Utils.SetLabelText(val6, "by KampfBallerina");
					Utils.SetLabelAlignment(val6, (TextAnchor)5);
					Utils.SetLabelColor(val6, Color32.op_Implicit(ColorUtil.GetColor("White")));
					RectTransform component3 = ((Component)val6).GetComponent<RectTransform>();
					if ((Object)(object)component3 != (Object)null)
					{
						component3.anchorMax = new Vector2(0.98f, 1f);
					}
				}
			}
			Transform val7 = val.Find("Details") ?? FindDeep(val, "Details");
			if ((Object)(object)val7 == (Object)null)
			{
				Transform val8 = FindDeep(val, "Instruction");
				if ((Object)(object)val8 != (Object)null)
				{
					val7 = val8.parent;
				}
			}
			if ((Object)(object)val7 != (Object)null)
			{
				((Component)val7).gameObject.SetActive(true);
				ApplyOriginalTwoColumnLayout(val);
				MakeOpaqueChrome(val);
				Transform val9 = val7.Find("Scroll View/Viewport/Content/Title") ?? FindDeep(val7, "Title");
				if ((Object)(object)val9 != (Object)null)
				{
					detailsTitleObject = ((Component)val9).gameObject;
					detailsTitleObject.SetActive(false);
					Utils.SetLabelText(val9, "DetailsTitleText");
				}
				Transform val10 = val7.Find("Scroll View/Viewport/Content/Description") ?? FindDeep(val7, "Description");
				if ((Object)(object)val10 != (Object)null)
				{
					Utils.SetLabelText(val10, "This is going to be the description of the app.");
					((Component)val10).gameObject.SetActive(false);
					detailsSubtitleObject = ((Component)val10).gameObject;
				}
				settingsContentTransform = val7.Find("Scroll View/Viewport/Content");
				if ((Object)(object)settingsContentTransform == (Object)null)
				{
					Transform val11 = FindDeep(val7, "Scroll View");
					settingsContentTransform = (((Object)(object)val11 != (Object)null) ? val11.Find("Viewport/Content") : null);
				}
				string[] array = new string[9] { "Value", "Effects", "Addiction", "Recipes", "RecipesContainer", "Listed", "Delisted", "NotDiscovered", "Properties" };
				foreach (string text in array)
				{
					Transform val12 = (((Object)(object)settingsContentTransform != (Object)null) ? (settingsContentTransform.Find(text) ?? FindDeep(settingsContentTransform, text)) : null);
					if ((Object)(object)val12 != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)val12).gameObject);
					}
				}
				Transform val13 = val7.Find("Instruction") ?? FindDeep(val7, "Instruction");
				if ((Object)(object)val13 != (Object)null)
				{
					InstructionsTextObject = ((Component)val13).gameObject;
					((Component)val13).gameObject.SetActive(true);
					Utils.SetLabelText(val13, "Select a section to adjust settings");
					Utils.SetLabelColor(val13, Color.white);
				}
			}
			CreateTemplates(val, settingsContentTransform);
			StripLeftoverDetailsWidgets(settingsContentTransform);
			PackDetailsContent();
			RestoreTaxWashChrome(mrlApp);
		}

		private static void ApplyOriginalTwoColumnLayout(Transform container)
		{
			//IL_005b: 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)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			Transform val = container.Find("Scroll View");
			Transform val2 = container.Find("Details");
			if ((Object)(object)val != (Object)null)
			{
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchorMin = new Vector2(0f, 0f);
					component.anchorMax = new Vector2(0.48f, 1f);
					component.pivot = new Vector2(0.5f, 0.5f);
					component.offsetMin = new Vector2(8f, 8f);
					component.offsetMax = new Vector2(-4f, -60f);
				}
				StretchLeftList(val);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				RectTransform component2 = ((Component)val2).GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.anchorMin = new Vector2(0.49f, 0f);
					component2.anchorMax = new Vector2(1f, 1f);
					component2.pivot = new Vector2(0.5f, 0.5f);
					component2.offsetMin = new Vector2(4f, 8f);
					component2.offsetMax = new Vector2(-8f, -60f);
				}
				Transform val3 = val2.Find("Image");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				EnsureRectMask(val2);
				val2.SetAsLastSibling();
				Transform val4 = val2.Find("Scroll View");
				if ((Object)(object)val4 != (Object)null)
				{
					RectTransform component3 = ((Component)val4).GetComponent<RectTransform>();
					StretchFill(component3);
				}
			}
		}

		private static void MakeOpaqueChrome(Transform container)
		{
			//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)
			//IL_0022: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			Color color = Color32.op_Implicit(ColorUtil.GetColor("Dark Grey"));
			Color color2 = default(Color);
			((Color)(ref color2))..ctor(0.10980392f, 0.10980392f, 0.10980392f, 1f);
			MakeSolidNamed(container, "Background", color);
			MakeSolidNamed(container, "Wallpaper", color);
			Transform val = container.Find("Gradient");
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
			Transform val2 = container.Find("Details");
			if ((Object)(object)val2 != (Object)null)
			{
				Transform val3 = val2.Find("Image");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				if ((Object)(object)val2.Find("Background") == (Object)null)
				{
					CreateSolidBackdrop(val2, "Background", color2);
				}
				else
				{
					MakeSolidNamed(val2, "Background", color2);
				}
				Canvas[] components = ((Component)val2).GetComponents<Canvas>();
				for (int i = 0; i < components.Length; i++)
				{
					if ((Object)(object)components[i] != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)components[i]);
					}
				}
			}
			CanvasGroup[] componentsInChildren = ((Component)container).GetComponentsInChildren<CanvasGroup>(true);
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				if ((Object)(object)componentsInChildren[j] != (Object)null)
				{
					componentsInChildren[j].alpha = 1f;
				}
			}
		}

		private static void MakeSolidNamed(Transform parent, string name, Color color)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)parent == (Object)null))
			{
				Transform val = parent.Find(name);
				if (!((Object)(object)val == (Object)null))
				{
					Image val2 = ((Component)val).GetComponent<Image>() ?? ((Component)val).gameObject.AddComponent<Image>();
					val2.sprite = null;
					((Graphic)val2).color = new Color(color.r, color.g, color.b, 1f);
					val2.type = (Type)0;
					((Graphic)val2).raycastTarget = true;
					((Component)val).gameObject.SetActive(true);
					StretchFill(((Component)val).GetComponent<RectTransform>());
				}
			}
		}

		private static void CreateSolidBackdrop(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_0040: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.transform.SetAsFirstSibling();
			RectTransform rt = val.AddComponent<RectTransform>();
			StretchFill(rt);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = null;
			((Graphic)val2).color = color;
			((Graphic)val2).raycastTarget = true;
		}

		private static void EnsureRectMask(Transform panel)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				if ((Object)(object)((Component)panel).GetComponent<RectMask2D>() == (Object)null)
				{
					((Component)panel).gameObject.AddComponent<RectMask2D>();
				}
				Transform val = panel.Find("Viewport");
				if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponent<RectMask2D>() == (Object)null)
				{
					((Component)val).gameObject.AddComponent<RectMask2D>();
				}
			}
		}

		private static void StretchFill(RectTransform rt)
		{
			//IL_000f: 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_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)
			if (!((Object)(object)rt == (Object)null))
			{
				rt.anchorMin = Vector2.zero;
				rt.anchorMax = Vector2.one;
				rt.offsetMin = Vector2.zero;
				rt.offsetMax = Vector2.zero;
			}
		}

		private static void StretchLeftList(Transform scroll)
		{
			//IL_00f0: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			if ((Object)(object)scroll == (Object)null)
			{
				return;
			}
			RectMask2D component = ((Component)scroll).GetComponent<RectMask2D>();
			if ((Object)(object)component != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)component);
			}
			Transform val = scroll.Find("Scrollbar Vertical");
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
			Transform val2 = scroll.Find("Scrollbar Horizontal");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
			ScrollRect component2 = ((Component)scroll).GetComponent<ScrollRect>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.verticalScrollbar = null;
				component2.horizontalScrollbar = null;
				component2.horizontal = false;
			}
			Transform val3 = scroll.Find("Viewport");
			if ((Object)(object)val3 != (Object)null)
			{
				RectTransform component3 = ((Component)val3).GetComponent<RectTransform>();
				StretchFill(component3);
				if ((Object)(object)component3 != (Object)null)
				{
					component3.offsetMin = new Vector2(10f, 8f);
					component3.offsetMax = new Vector2(-10f, -8f);
				}
				if ((Object)(object)((Component)val3).GetComponent<RectMask2D>() == (Object)null)
				{
					((Component)val3).gameObject.AddComponent<RectMask2D>();
				}
			}
			Transform val4 = (((Object)(object)val3 != (Object)null) ? val3.Find("Content") : null);
			if (!((Object)(object)val4 == (Object)null))
			{
				RectTransform component4 = ((Component)val4).GetComponent<RectTransform>();
				if ((Object)(object)component4 != (Object)null)
				{
					component4.anchorMin = new Vector2(0f, 1f);
					component4.anchorMax = new Vector2(1f, 1f);
					component4.pivot = new Vector2(0.5f, 1f);
					component4.offsetMin = new Vector2(0f, component4.offsetMin.y);
					component4.offsetMax = new Vector2(0f, component4.offsetMax.y);
					component4.sizeDelta = new Vector2(0f, component4.sizeDelta.y);
				}
				VerticalLayoutGroup val5 = ((Component)val4).GetComponent<VerticalLayoutGroup>() ?? ((Component)val4).gameObject.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)val5).childAlignment = (TextAnchor)0;
				((HorizontalOrVerticalLayoutGroup)val5).spacing = 8f;
				((LayoutGroup)val5).padding = new RectOffset(6, 6, 6, 8);
				((HorizontalOrVerticalLayoutGroup)val5).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)val5).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)val5).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)val5).childForceExpandHeight = false;
			}
		}

		private static Sprite RoundedFillSprite()
		{
			return _roundedFillSprite ?? (_roundedFillSprite = CreateRoundedSprite(64, 14, 0, fill: true));
		}

		private static Sprite RoundedBorderSprite(bool thick = false)
		{
			if (thick)
			{
				return _roundedBorderThickSprite ?? (_roundedBorderThickSprite = CreateRoundedSprite(64, 14, 4, fill: false));
			}
			return _roundedBorderSprite ?? (_roundedBorderSprite = CreateRoundedSprite(64, 14, 2, fill: false));
		}

		private static Sprite CreateRoundedSprite(int size, int radius, int borderWidth, bool fill)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float num = (float)size * 0.5f;
			float num2 = radius;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num3 = (float)j + 0.5f - num;
					float num4 = (float)i + 0.5f - num;
					float num5 = Mathf.Abs(num3) - (num - num2);
					float num6 = Mathf.Abs(num4) - (num - num2);
					float num7 = Mathf.Sqrt(Mathf.Max(num5, 0f) * Mathf.Max(num5, 0f) + Mathf.Max(num6, 0f) * Mathf.Max(num6, 0f));
					float num8 = num7 + Mathf.Min(Mathf.Max(num5, num6), 0f) - num2;
					float num9;
					if (fill)
					{
						num9 = Mathf.Clamp01(0.5f - num8);
					}
					else
					{
						float num10 = Mathf.Clamp01(0.5f - num8);
						float num11 = Mathf.Clamp01(0.5f - (num8 + (float)borderWidth));
						num9 = num10 * (1f - num11);
					}
					array[i * size + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)Mathf.RoundToInt(num9 * 255f));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			((Object)val).hideFlags = (HideFlags)61;
			int num12 = Mathf.Max(radius + 1, radius + borderWidth);
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)num12, (float)num12, (float)num12, (float)num12));
			((Object)val2).hideFlags = (HideFlags)61;
			return val2;
		}

		private static void StripLeftoverDetailsWidgets(Transform content)
		{
			if ((Object)(object)content == (Object)null)
			{
				return;
			}
			for (int num = content.childCount - 1; num >= 0; num--)
			{
				Transform child = content.GetChild(num);
				if (!((Object)(object)child == (Object)null))
				{
					string name = ((Object)child).name;
					switch (name)
					{
					default:
						if (!(name == "Checkbox Template"))
						{
							Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
						}
						break;
					case "Title":
					case "Description":
					case "Options":
					case "GlobalOptions":
					case "CartelOptions":
					case "NotificationOptions":
						break;
					}
				}
			}
		}

		private void PackDetailsContent()
		{
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: 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_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Expected O, but got Unknown
			Transform val = settingsContentTransform;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = val.Find("Space");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
			}
			if ((Object)(object)detailsTitleObject != (Object)null && (Object)(object)detailsTitleObject.transform.parent != (Object)(object)val)
			{
				detailsTitleObject.transform.SetParent(val, false);
			}
			if ((Object)(object)detailsSubtitleObject != (Object)null && (Object)(object)detailsSubtitleObject.transform.parent != (Object)(object)val)
			{
				detailsSubtitleObject.transform.SetParent(val, false);
			}
			if ((Object)(object)detailsTitleObject != (Object)null)
			{
				detailsTitleObject.transform.SetSiblingIndex(0);
			}
			if ((Object)(object)detailsSubtitleObject != (Object)null)
			{
				detailsSubtitleObject.transform.SetSiblingIndex(((Object)(object)detailsTitleObject != (Object)null) ? 1 : 0);
			}
			int num = (((Object)(object)detailsTitleObject != (Object)null) ? 1 : 0) + (((Object)(object)detailsSubtitleObject != (Object)null) ? 1 : 0);
			int index = num;
			index = PlaceOptionPanel(optionsTransform, val, index);
			index = PlaceOptionPanel(globalOptionsTransform, val, index);
			index = PlaceOptionPanel(cartelOptionsTransform, val, index);
			PlaceOptionPanel(notificationOptionsTransform, val, index);
			CompactDetailsLabel(((Object)(object)detailsTitleObject != (Object)null) ? detailsTitleObject.transform : null, 32f);
			CompactDetailsLabel(((Object)(object)detailsSubtitleObject != (Object)null) ? detailsSubtitleObject.transform : null, 36f);
			if ((Object)(object)detailsTitleObject != (Object)null)
			{
				Utils.SetLabelAlignment(detailsTitleObject.transform, (TextAnchor)0);
			}
			if ((Object)(object)detailsSubtitleObject != (Object)null)
			{
				Utils.SetLabelAlignment(detailsSubtitleObject.transform, (TextAnchor)0);
			}
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
				component.anchoredPosition = Vector2.zero;
				component.sizeDelta = new Vector2(0f, component.sizeDelta.y);
			}
			VerticalLayoutGroup val3 = ((Component)val).GetComponent<VerticalLayoutGroup>() ?? ((Component)val).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val3).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 4f;
			((LayoutGroup)val3).padding = new RectOffset(8, 8, 4, 8);
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			ContentSizeFitter val4 = ((Component)val).GetComponent<ContentSizeFitter>() ?? ((Component)val).gameObject.AddComponent<ContentSizeFitter>();
			val4.horizontalFit = (FitMode)0;
			val4.verticalFit = (FitMode)2;
			for (int i = 0; i < val.childCount; i++)
			{
				Transform child = val.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					LayoutElement component2 = ((Component)child).GetComponent<LayoutElement>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.flexibleHeight = 0f;
					}
				}
			}
			ScrollRect componentInParent = ((Component)val).GetComponentInParent<ScrollRect>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.horizontal = false;
				componentInParent.content = component;
				componentInParent.verticalNormalizedPosition = 1f;
			}
			if ((Object)(object)component != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(component);
			}
		}

		private static int PlaceOptionPanel(Transform panel, Transform content, int index)
		{
			if ((Object)(object)panel != (Object)null && (Object)(object)panel.parent == (Object)(object)content)
			{
				panel.SetSiblingIndex(index);
				return index + 1;
			}
			return index;
		}

		private static void CompactDetailsLabel(Transform label, float height)
		{
			if (!((Object)(object)label == (Object)null))
			{
				LayoutElement val = ((Component)label).GetComponent<LayoutElement>() ?? ((Component)label).gameObject.AddComponent<LayoutElement>();
				val.minHeight = 0f;
				val.preferredHeight = height;
				val.flexibleHeight = 0f;
				val.flexibleWidth = 1f;
				val.minWidth = 0f;
				val.ignoreLayout = false;
			}
		}

		public static bool IsTaxWash(Component component)
		{
			if ((Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null)
			{
				return false;
			}
			return IsTaxWashPanel(component.gameObject);
		}

		public static bool IsTaxWashPanel(GameObject panel)
		{
			if ((Object)(object)panel == (Object)null)
			{
				return false;
			}
			if ((Object)(object)MRLCore.launderingApp?._appPanel != (Object)null && (Object)(object)panel == (Object)(object)MRLCore.launderingApp._appPanel)
			{
				return true;
			}
			string name = ((Object)panel).name;
			return name == "MRL_TaxWash" || name == "TaxNWash";
		}

		public static void RestoreTaxWashChrome(GameObject mrlApp)
		{
			if ((Object)(object)mrlApp == (Object)null)
			{
				return;
			}
			Transform val = FindMainAppContainer(mrlApp.transform);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			((Component)val).gameObject.SetActive(true);
			string[] array = new string[5] { "Background", "Header", "Topbar", "Details", "Scroll View" };
			for (int i = 0; i < array.Length; i++)
			{
				Transform val2 = val.Find(array[i]) ?? ((array[i] == "Details" || array[i] == "Scroll View") ? FindDeep(val, array[i]) : null);
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name != "DeactivatedScrollView")
				{
					((Component)val2).gameObject.SetActive(true);
				}
			}
			Transform val3 = val.Find("DeactivatedScrollView");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
			}
			Transform keep = val.Find("Scroll View") ?? FindDeep(val, "Scroll View");
			HideOverlappingProductUi(val, keep);
			Transform val4 = val.Find("Content");
			if ((Object)(object)val4 != (Object)null)
			{
				HideOverlappingProductUi(val4, keep);
			}
			ApplyOriginalTwoColumnLayout(val);
			MakeOpaqueChrome(val);
			MRLCore.launderingApp?.PackDetailsContent();
		}

		public static void ShowTaxWashInsteadOfProducts()
		{
			HideVanillaProductsContainer();
			GameObject val = MRLCore.launderingApp?._appPanel;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			RestoreTaxWashChrome(val);
			try
			{
				Phone.ActiveApp = val;
			}
			catch
			{
			}
		}

		public static void HideVanillaProductsContainer()
		{
			try
			{
				if (PlayerSingleton<ProductManagerApp>.InstanceExists)
				{
					ProductManagerApp instance = PlayerSingleton<ProductManagerApp>.Instance;
					if ((Object)(object)instance != (Object)null && !IsTaxWash((Component)(object)instance))
					{
						SetAppIsOpen(instance, open: false);
						Type type = ((object)instance).GetType();
						while (type != null)
						{
							FieldInfo field = type.GetField("appContainer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (!(field == null))
							{
								object? value = field.GetValue(instance);
								Component val = (Component)((value is Component) ? value : null);
								if ((Object)(object)val != (Object)null)
								{
									val.gameObject.SetActive(false);
								}
								break;
							}
							type = type.BaseType;
						}
						Transform val2 = ((Component)instance).transform.Find("Container");
						if ((Object)(object)val2 != (Object)null)
						{
							((Component)val2).gameObject.SetActive(false);
						}
						DeactivateAppContainers(((Component)instance).transform);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Tax & Wash could not close vanilla Products: " + ex.Message);
			}
			GameObject appCanvasByName = Utils.GetAppCanvasByName("ProductManagerApp");
			if (!((Object)(object)appCanvasByName == (Object)null) && !IsTaxWashPanel(appCanvasByName))
			{
				Transform val3 = appCanvasByName.transform.Find("Container");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				DeactivateAppContainers(appCanvasByName.transform);
			}
		}

		public static void ApplyAppOpen(GameObject panel, bool open)
		{
			if ((Object)(object)panel == (Object)null)
			{
				return;
			}
			try
			{
				panel.SetActive(true);
				panel.transform.SetAsLastSibling();
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Tax & Wash panel.SetActive failed: " + ex);
			}
			if (open)
			{
				RestoreTaxWashChrome(panel);
				HideVanillaProductsContainer();
			}
			else
			{
				DeactivateAppContainers(panel.transform);
			}
			try
			{
				if (PlayerSingleton<Phone>.InstanceExists)
				{
					PlayerSingleton<Phone>.Instance.SetIsHorizontal(open);
					PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(open ? 0.6f : 1f);
				}
			}
			catch (Exception ex2)
			{
				MelonLogger.Error("Tax & Wash phone orientation failed: " + ex2);
			}
			try
			{
				if (PlayerSingleton<HomeScreen>.InstanceExists)
				{
					PlayerSingleton<HomeScreen>.Instance.SetIsOpen(!open);
				}
			}
			catch (Exception ex3)
			{
				MelonLogger.Error("Tax & Wash HomeScreen.SetIsOpen failed: " + ex3);
			}
			try
			{
				if (PlayerSingleton<AppsCanvas>.InstanceExists)
				{
					PlayerSingleton<AppsCanvas>.Instance.SetIsOpen(open);
				}
			}
			catch (Exception ex4)
			{
				MelonLogger.Error("Tax & Wash AppsCanvas.SetIsOpen failed: " + ex4);
			}
			try
			{
				if (open)
				{
					Phone.ActiveApp = panel;
				}
				else if ((Object)(object)Phone.ActiveApp == (Object)(object)panel)
				{
					Phone.ActiveApp = null;
				}
			}
			catch (Exception ex5)
			{
				MelonLogger.Error("Tax & Wash ActiveApp failed: " + ex5);
			}
		}

		public static void OpenFromIcon()
		{
			MRLCore.launderingApp?.OpenTaxWash();
		}

		public void OpenTaxWash()
		{
			if (!((Object)(object)_appPanel == (Object)null) && !_openQueued && CanOpenFromHomeScreen())
			{
				OpeningTaxWash = true;
				_openQueued = true;
				_openDelayFrames = 1;
				HideVanillaProductsContainer();
			}
		}

		public static bool CanOpenFromHomeScreen()
		{
			try
			{
				if (!PlayerSingleton<HomeScreen>.InstanceExists || !PlayerSingleton<HomeScreen>.Instance.isOpen)
				{
					return false;
				}
				if ((Object)(object)Phone.ActiveApp != (Object)null)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void ApplyQueuedOpen()
		{
			if (!_openQueued)
			{
				return;
			}
			if (_openDelayFrames > 0)
			{
				_openDelayFrames--;
				return;
			}
			_openQueued = false;
			try
			{
				ApplyAppOpen(_appPanel, open: true);
				SetAppIsOpen(_productApp, open: true);
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Tax & Wash open failed: " + ex);
			}
		}

		public static bool IsUnderOurIcon(GameObject obj)
		{
			GameObject val = MRLCore.launderingApp?._homeIcon;
			if ((Object)(object)val == (Object)null || (Object)(object)obj == (Object)null)
			{
				return false;
			}
			Transform val2 = obj.transform;
			while ((Object)(object)val2 != (Object)null)
			{
				if ((Object)(object)((Component)val2).gameObject == (Object)(object)val)
				{
					return true;
				}
				val2 = val2.parent;
			}
			return false;
		}

		public static bool IsPointerOverOurIcon()
		{
			//IL_00ab: 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)
			if (!CanOpenFromHomeScreen())
			{
				return false;
			}
			GameObject val = MRLCore.launderingApp?._homeIcon;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				if (!val.activeInHierarchy)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			RectTransform component = val.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			Camera val2 = null;
			Canvas componentInParent = val.GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				object obj2 = componentInParent.worldCamera;
				if (obj2 == null)
				{
					Canvas rootCanvas = componentInParent.rootCanvas;
					obj2 = ((rootCanvas != null) ? rootCanvas.worldCamera : null);
				}
				val2 = (Camera)obj2;
			}
			return RectTransformUtility.RectangleContainsScreenPoint(component, Vector2.op_Implicit(Input.mousePosition), val2);
		}

		private void CloseTaxWashIfOpen()
		{
			if ((Object)(object)_appPanel != (Object)null && (Object)(object)Phone.ActiveApp == (Object)(object)_appPanel)
			{
				OpeningTaxWash = false;
				ApplyAppOpen(_appPanel, open: false);
				SetAppIsOpen(_productApp, open: false);
			}
		}

		private void HookPhoneClose()
		{
			if (PlayerSingleton<Phone>.InstanceExists)
			{
				if (_closeAppAction != null)
				{
					Phone instance = PlayerSingleton<Phone>.Instance;
					instance.closeApps = (Action)Delegate.Remove(instance.closeApps, _closeAppAction);
				}
				_closeAppAction = CloseTaxWashIfOpen;
				Phone instance2 = PlayerSingleton<Phone>.Instance;
				instance2.closeApps = (Action)Delegate.Combine(instance2.closeApps, _closeAppAction);
			}
		}

		private static void StripPhoneBehaviours(GameObject root)
		{
			if (!((Object)(object)root == (Object)null))
			{
				DestroyComponents<ProductManagerApp>(root);
				DestroyComponents<ProductAppDetailPanel>(root);
				DestroyComponents<ProductTypeContainer>(root);
				DestroyComponents<ProductEntry>(root);
			}
		}

		private static void DestroyComponents<T>(GameObject root) where T : Component
		{
			T[] componentsInChildren = root.GetComponentsInChildren<T>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
				}
			}
		}

		private void SilenceProductBehaviour(ProductManagerApp productApp)
		{
			if (!((Object)(object)productApp == (Object)null))
			{
				try
				{
					((App<ProductManagerApp>)(object)productApp).SetNotificationCount(0);
				}
				catch
				{
				}
				if ((Object)(object)((App<ProductManagerApp>)(object)productApp).notificationContainer != (Object)null)
				{
					((Component)((App<ProductManagerApp>)(object)productApp).notificationContainer).gameObject.SetActive(false);
				}
				if ((Object)(object)productApp.FavouritesContainer != (Object)null)
				{
					((Component)productApp.FavouritesContainer).gameObject.SetActive(false);
				}
			}
		}

		private static void SilenceIconClicks(GameObject icon)
		{
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			Button[] componentsInChildren = icon.GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					try
					{
						ButtonUtils.ClearListeners(val);
					}
					catch
					{
					}
					((Selectable)val).interactable = false;
					((Behaviour)val).enabled = false;
				}
			}
			UISelectable[] componentsInChildren2 = icon.GetComponentsInChildren<UISelectable>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if ((Object)(object)componentsInChildren2[j] != (Object)null)
				{
					((Behaviour)componentsInChildren2[j]).enabled = false;
				}
			}
			UITrigger[] componentsInChildren3 = icon.GetComponentsInChildren<UITrigger>(true);
			for (int k = 0; k < componentsInChildren3.Length; k++)
			{
				if ((Object)(object)componentsInChildren3[k] != (Object)null)
				{
					((Behaviour)componentsInChildren3[k]).enabled = false;
				}
			}
		}

		private static void RebindCloneToOwnContainer(GameObject clone, ProductManagerApp productApp)
		{
			if ((Object)(object)clone == (Object)null || (Object)(object)productApp == (Object)null)
			{
				return;
			}
			Transform val = clone.transform.Find("Container");
			if (!((Object)(object)val == (Object)null))
			{
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					SetInstanceField(productApp, "appContainer", component);
				}
			}
		}

		private void WireNativeIcon(GameObject icon)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			Button val = icon.GetComponent<Button>() ?? icon.GetComponentInChildren<Button>(true);
			if (!((Object)(object)val == (Object)null))
			{
				try
				{
					ButtonUtils.ClearListeners(val);
				}
				catch
				{
				}
				try
				{
					val.onClick = new ButtonClickedEvent();
				}
				catch
				{
				}
				ButtonUtils.AddListener(val, (Action)OpenTaxWash);
				((Selectable)val).interactable = true;
				((Behaviour)val).enabled = true;
			}
		}

		private static void SetAppIsOpen(ProductManagerApp productApp, bool open)
		{
			if ((Object)(object)productApp == (Object)null)
			{
				return;
			}
			try
			{
				Type type = ((object)productApp).GetType();
				while (type != null)
				{
					PropertyInfo property = type.GetProperty("isOpen", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (property != null && property.CanWrite)
					{
						property.SetValue(productApp, open);
						return;
					}
					type = type.BaseType;
				}
			}
			catch
			{
			}
			SetInstanceField(productApp, "<isOpen>k__BackingField", open);
		}

		private static void SetInstanceField(object obj, string fieldName, object value)
		{
			if (obj == null)
			{
				return;
			}
			Type type = obj.GetType();
			while (type != null)
			{
				FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field == null))
				{
					try
					{
						field.SetValue(obj, value);
						break;
					}
					catch (Exception ex)
					{
						MelonLogger.Error("Tax & Wash could not set " + fieldName + ": " + ex.Message);
						break;
					}
				}
				type = type.BaseType;
			}
		}

		private static HashSet<int> SnapshotHomeIcons()
		{
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < val.transform.childCount; j++)
				{
					Transform child = val.transform.GetChild(j);
					if ((Object)(object)child != (Object)null)
					{
						hashSet.Add(((Object)((Component)child).gameObject).GetInstanceID());
					}
				}
			}
			return hashSet;
		}

		private static GameObject TakeNewHomeIcon(HashSet<int> before, string title)
		{
			List<GameObject> list = new List<GameObject>();
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < val.transform.childCount; j++)
				{
					Transform child = val.transform.GetChild(j);
					if (!((Object)(object)child == (Object)null) && hashSet.Add(((Object)((Component)child).gameObject).GetInstanceID()) && (before == null || !before.Contains(((Object)((Component)child).gameObject).GetInstanceID())))
					{
						list.Add(((Component)child).gameObject);
					}
				}
			}
			GameObject val2 = null;
			for (int k = 0; k < list.Count; k++)
			{
				string labelText = Utils.GetLabelText(list[k].transform.Find("Label"));
				if (labelText == title || labelText == "Tax & Wash")
				{
					val2 = list[k];
					break;
				}
			}
			if ((Object)(object)val2 == (Object)null && list.Count > 0)
			{
				val2 = list[0];
			}
			for (int l = 0; l < list.Count; l++)
			{
				if ((Object)(object)list[l] != (Object)null && (Object)(object)list[l] != (Object)(object)val2)
				{
					Object.DestroyImmediate((Object)(object)list[l]);
				}
			}
			return val2;
		}

		private static void DestroyExtraTaxWashIcons(GameObject keep)
		{
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int num = val.transform.childCount - 1; num >= 0; num--)
				{
					Transform child = val.transform.GetChild(num);
					if (!((Object)(object)child == (Object)null) && hashSet.Add(((Object)((Component)child).gameObject).GetInstanceID()) && (!((Object)(object)keep != (Object)null) || !((Object)(object)((Component)child).gameObject == (Object)(object)keep)))
					{
						string labelText = Utils.GetLabelText(child.Find("Label"));
						if (((Object)child).name == "TaxNWash" || ((Object)child).name == "MRL_TaxWash" || labelText == "Tax & Wash")
						{
							Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
						}
					}
				}
			}
		}

		private static void HideIconSelection(GameObject icon)
		{
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			try
			{
				UISelectable val = icon.GetComponent<UISelectable>() ?? icon.GetComponentInChildren<UISelectable>(true);
				if ((Object)(object)val != (Object)null)
				{
					val.SetSelectedImageVisible(false);
				}
			}
			catch
			{
			}
			Transform[] componentsInChildren = icon.GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)icon.transform))
				{
					string name = ((Object)val2).name;
					if (name.IndexOf("select", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("highlight", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("outline", StringComparison.OrdinalIgnoreCase) >= 0 || name == "Border" || name == "Hover")
					{
						((Component)val2).gameObject.SetActive(false);
					}
				}
			}
		}

		private static GameObject FindIconRoot(Component button)
		{
			if ((Object)(object)button == (Object)null)
			{
				return null;
			}
			HashSet<Transform> hashSet = new HashSet<Transform>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					hashSet.Add(val.transform);
				}
			}
			Transform val2 = button.transform;
			while ((Object)(object)val2 != (Object)null)
			{
				if ((Object)(object)val2.parent != (Object)null && hashSet.Contains(val2.parent))
				{
					return ((Component)val2).gameObject;
				}
				val2 = val2.parent;
			}
			return button.gameObject;
		}

		private static GameObject[] AllIconContainers()
		{
			GameObject[] obj = new GameObject[4]
			{
				Utils.FindAppIconsContainer(),
				GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIcons"),
				GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIconsScrollView/Viewport/AppIcons"),
				default(GameObject)
			};
			object obj2;
			if (!PlayerSingleton<HomeScreen>.InstanceExists)
			{
				obj2 = null;
			}
			else
			{
				RectTransform appIconContainer = PlayerSingleton<HomeScreen>.Instance.appIconContainer;
				obj2 = ((appIconContainer != null) ? ((Component)appIconContainer).gameObject : null);
			}
			obj[3] = (GameObject)obj2;
			return (GameObject[])(object)obj;
		}

		private static void DestroyDeadTaxWashIcons()
		{
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int num = val.transform.childCount - 1; num >= 0; num--)
				{
					Transform child = val.transform.GetChild(num);
					if (!((Object)(object)child == (Object)null))
					{
						string labelText = Utils.GetLabelText(child.Find("Label"));
						if (((Object)child).name == "TaxNWash" || ((Object)child).name == "MRL_TaxWash" || labelText == "Tax & Wash")
						{
							Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
						}
					}
				}
			}
		}

		private static GameObject InstantiateInactive(GameObject source, Transform parent, string name)
		{
			bool activeSelf = source.activeSelf;
			source.SetActive(false);
			GameObject val = Object.Instantiate<GameObject>(source, parent);
			((Object)val).name = name;
			val.SetActive(false);
			source.SetActive(activeSelf);
			return val;
		}

		private static Component GetAppIconButton(GameObject app)
		{
			if ((Object)(object)app == (Object)null)
			{
				return null;
			}
			MonoBehaviour[] components = app.GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val in components)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string name = ((object)val).GetType().Name;
				if (name != "ProductManagerApp" && name != "DeliveryApp" && name != "App")
				{
					continue;
				}
				Type type = ((object)val).GetType();
				while (type != null)
				{
					FieldInfo field = type.GetField("appIconButton", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value = field.GetValue(val);
						return (Component)((value is Component) ? value : null);
					}
					type = type.BaseType;
				}
			}
			return null;
		}

		private GameObject CreateIndependentIcon(string name, string title, string iconPath)
		{
			GameObject val = Utils.FindAppIconsContainer();
			GameObject val2 = GameObject.Find("Player_Local/CameraContainer/Camera/OverlayCamera/GameplayMenu/Phone/phone/HomeScreen/AppIconsScrollView/Viewport/AppIcons");
			if ((Object)(object)val2 != (Object)null)
			{
				val = val2;
			}
			try
			{
				if (PlayerSingleton<HomeScreen>.InstanceExists && (Object)(object)PlayerSingleton<HomeScreen>.Instance.appIconContainer != (Object)null)
				{
					val = ((Component)PlayerSingleton<HomeScreen>.Instance.appIconContainer).gameObject;
				}
			}
			catch
			{
			}
			GameObject val3 = (PlayerSingleton<HomeScreen>.InstanceExists ? PlayerSingleton<HomeScreen>.Instance.appIconPrefab : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val4;
			if ((Object)(object)val3 != (Object)null)
			{
				val4 = Object.Instantiate<GameObject>(val3, val.transform);
			}
			else
			{
				GameObject val5 = Utils.GetAppIconByName("Deliveries", 0) ?? Utils.GetAppIconByName("Products", 0);
				if ((Object)(object)val5 == (Object)null)
				{
					return null;
				}
				val4 = Object.Instantiate<GameObject>(val5, val.transform);
			}
			((Object)val4).name = name;
			Utils.SetLabelText(val4.transform.Find("Label"), title);
			MRLCore.Instance.ChangeAppIconImage(val4, iconPath);
			Transform val6 = val4.transform.Find("Notifications");
			if ((Object)(object)val6 != (Object)null)
			{
				((Component)val6).gameObject.SetActive(false);
			}
			HideIconNotification(val4);
			WireNativeIcon(val4);
			try
			{
				if (PlayerSingleton<HomeScreen>.InstanceExists && (Object)(object)PlayerSingleton<HomeScreen>.Instance.uiPanel != (Object)null)
				{
					UISelectable val7 = val4.GetComponent<UISelectable>() ?? val4.GetComponentInChildren<UISelectable>(true);
					if ((Object)(object)val7 != (Object)null)
					{
						PlayerSingleton<HomeScreen>.Instance.uiPanel.AddSelectable(val7);
						val7.SetSelectedImageVisible(false);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Tax & Wash icon hover setup failed: " + ex);
			}
			return val4;
		}

		public void TickUi()
		{
			TryRecoverMissingHomeIcon();
			SyncHomeIconInteractable();
			TickIconClick();
			TickHover();
		}

		private void SyncHomeIconInteractable()
		{
			if ((Object)(object)_homeIcon == (Object)null)
			{
				return;
			}
			bool flag = CanOpenFromHomeScreen();
			try
			{
				Button[] componentsInChildren = _homeIcon.GetComponentsInChildren<Button>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null)
					{
						((Selectable)componentsInChildren[i]).interactable = flag;
					}
				}
				CanvasGroup component = _homeIcon.GetComponent<CanvasGroup>();
				if ((Object)(object)component != (Object)null)
				{
					component.blocksRaycasts = flag;
					component.interactable = flag;
				}
			}
			catch
			{
			}
		}

		private void TryRecoverMissingHomeIcon()
		{
			if (!_isLaunderingAppLoaded || (Object)(object)_appPanel == (Object)null || _iconRecoverQueued)
			{
				return;
			}
			bool flag = (Object)(object)_homeIcon != (Object)null;
			try
			{
				if (flag)
				{
					_ = _homeIcon.activeInHierarchy;
				}
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				_iconRecoverQueued = true;
				MelonCoroutines.Start(RecoverHomeIconCoroutine());
			}
		}

		private IEnumerator RecoverHomeIconCoroutine()
		{
			try
			{
				yield return (object)new WaitForSecondsRealtime(1f);
				if ((Object)(object)_appPanel == (Object)null)
				{
					yield break;
				}
				bool iconAlive = (Object)(object)_homeIcon != (Object)null;
				try
				{
					if (iconAlive)
					{
						_ = _homeIcon.transform;
					}
				}
				catch
				{
					iconAlive = false;
				}
				if (!iconAlive)
				{
					MelonLogger.Warning("Tax & Wash: home icon missing after load — recovering.");
					GameObject icon = (_homeIcon = CreateIndependentIcon(_lastIconId, _lastIconTitle, _lastIconPath));
					DestroyExtraTaxWashIcons(icon);
					if ((Object)(object)icon != (Object)null)
					{
						MelonLogger.Msg("Tax & Wash home icon recovered.");
					}
					else
					{
						MelonLogger.Error("Tax & Wash: home icon recovery failed.");
					}
				}
			}
			finally
			{
				_iconRecoverQueued = false;
			}
		}

		private void TickHover()
		{
			//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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: 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)
			bool flag = (Object)(object)_appPanel != (Object)null && (Object)(object)Phone.ActiveApp == (Object)(object)_appPanel;
			Camera val = (((Object)(object)_appPanel != (Object)null) ? GetPhoneCanvasCamera(_appPanel.transform) : null);
			Vector3 mousePosition = Input.mousePosition;
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			for (int i = 0; i < _hoverTargets.Count; i++)
			{
				HoverTarget hoverTarget = _hoverTargets[i];
				if (hoverTarget != null && !((Object)(object)hoverTarget.Hit == (Object)null))
				{
					bool flag2 = flag && ((Component)hoverTarget.Hit).gameObject.activeInHierarchy && RectTransformUtility.RectangleContainsScreenPoint(hoverTarget.Hit, Vector2.op_Implicit(mousePosition), val);
					bool flag3 = flag && !string.IsNullOrEmpty(hoverTarget.SelectId) && hoverTarget.SelectId == _selectedCardName;
					float num = (flag3 ? 1f : (flag2 ? 0.72f : 0f));
					if ((Object)(object)hoverTarget.Border != (Object)null)
					{
						hoverTarget.Border.alpha = Mathf.MoveTowards(hoverTarget.Border.alpha, num, unscaledDeltaTime * 10f);
					}
					SetBorderSolid(hoverTarget.Border, flag3);
					if ((Object)(object)hoverTarget.ScaleRoot != (Object)null)
					{
						float num2 = (flag2 ? 1.012f : 1f);
						Vector3 val2 = hoverTarget.BaseScale * num2;
						hoverTarget.ScaleRoot.localScale = Vector3.Lerp(hoverTarget.ScaleRoot.localScale, val2, 1f - Mathf.Exp(-14f * unscaledDeltaTime));
					}
				}
			}
		}

		private void SelectCard(string name)
		{
			_selectedCardName = name;
		}

		private void RegisterHoverTarget(Transform host, string selectId, bool scaleOnHover)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)host == (Object)null))
			{
				RectTransform hit = ((Component)host).GetComponent<RectTransform>() ?? ((Component)host).gameObject.AddComponent<RectTransform>();
				CanvasGroup border = CreateSelectionBorder(host);
				_hoverTargets.Add(new HoverTarget
				{
					Hit = hit,
					Border = border,
					ScaleRoot = (scaleOnHover ? host : null),
					BaseScale = host.localScale,
					SelectId = selectId
				});
			}
		}

		private CanvasGroup CreateSelectionBorder(Transform host)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Transform val = host.Find("SelectionBorder");
			if ((Object)(object)val != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
			}
			GameObject val2 = new GameObject("SelectionBorder");
			val2.transform.SetParent(host, false);
			RectTransform rt = val2.AddComponent<RectTransform>();
			StretchFill(rt);
			Image image = val2.AddComponent<Image>();
			ApplyRoundedBorder(image, solid: false);
			CanvasGroup val3 = val2.AddComponent<CanvasGroup>();
			val3.alpha = 0f;
			val3.blocksRaycasts = false;
			val3.interactable = false;
			val2.transform.SetAsLastSibling();
			return val3;
		}

		private static void ApplyRoundedBorder(Image image, bool solid)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				image.sprite = RoundedBorderSprite(solid);
				image.type = (Type)1;
				image.fillCenter = false;
				((Graphic)image).color = Color.white;
				((Graphic)image).raycastTarget = false;
			}
		}

		private static void SetBorderSolid(CanvasGroup border, bool solid)
		{
			if (!((Object)(object)border == (Object)null))
			{
				ApplyRoundedBorder(((Component)border).GetComponent<Image>(), solid);
			}
		}

		private Sprite FindVanillaOutlineSprite()
		{
			GameObject val = _homeIcon ?? Utils.GetAppIconByName("Deliveries", 0) ?? Utils.GetAppIconByName("Products", 0);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				UISelectable val2 = val.GetComponent<UISelectable>() ?? val.GetComponentInChildren<UISelectable>(true);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.selectedImage != (Object)null)
				{
					Image val3 = val2.selectedImage.GetComponent<Image>() ?? val2.selectedImage.GetComponentInChildren<Image>(true);
					if ((Object)(object)val3 != (Object)null && (Object)(object)val3.sprite != (Object)null)
					{
						return val3.sprite;
					}
				}
			}
			catch
			{
			}
			string[] array = new string[4] { "Selected", "Outline", "Highlight", "Hover" };
			for (int i = 0; i < array.Length; i++)
			{
				Transform val4 = val.transform.Find(array[i]) ?? FindDeep(val.transform, array[i]);
				if (!((Object)(object)val4 == (Object)null))
				{
					Image val5 = ((Component)val4).GetComponent<Image>() ?? ((Component)val4).GetComponentInChildren<Image>(true);
					if ((Object)(object)val5 != (Object)null && (Object)(object)val5.sprite != (Object)null)
					{
						return val5.sprite;
					}
				}
			}
			return null;
		}

		private static Camera GetPhoneCanvasCamera(Transform from)
		{
			if ((Object)(object)from == (Object)null)
			{
				return null;
			}
			Canvas componentInParent = ((Component)from).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return null;
			}
			object obj = componentInParent.worldCamera;
			if (obj == null)
			{
				Canvas rootCanvas = componentInParent.rootCanvas;
				obj = ((rootCanvas != null) ? rootCanvas.worldCamera : null);
			}
			return (Camera)obj;
		}

		private static void StyleVanillaButton(Button button)
		{
			//IL_001a: 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_0022: 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_0064: 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_008a: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				((Selectable)button).transition = (Transition)1;
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = Color.white;
				((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 1f);
				((ColorBlock)(ref colors)).pressedColor = new Color(0.82f, 0.82f, 0.82f, 1f);
				((ColorBlock)(ref colors)).selectedColor = Color.white;
				((ColorBlock)(ref colors)).fadeDuration = 0.12f;
				((Selectable)button).colors = colors;
				Navigation navigation = default(Navigation);
				((Navigation)(ref navigation)).mode = (Mode)0;
				((Selectable)button).navigation = navigation;
			}
		}

		private IEnumerator FadeCanvas(CanvasGroup group, float from, float to, float duration)
		{
			if (!((Object)(object)group == (Object)null))
			{
				group.alpha = from;
				float t = 0f;
				while (t < duration)
				{
					t += Time.unscaledDeltaTime;
					float u = Mathf.Clamp01(t / duration);
					float ease = 1f - (1f - u) * (1f - u);
					group.alpha = Mathf.Lerp(from, to, ease);
					yield return null;
				}
				group.alpha = to;
			}
		}

		private void TweenPanelIn(Transform panel)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				CanvasGroup val = ((Component)panel).GetComponent<CanvasGroup>() ?? ((Component)panel).gameObject.AddComponent<CanvasGroup>();
				if (_panelFade != null)
				{
					MelonCoroutines.Stop(_panelFade);
				}
				_panelFade = MelonCoroutines.Start(FadeCanvas(val, 0f, 1f, 0.16f));
			}
		}

		public void TickIconClick()
		{
			if (_openQueued)
			{
				ApplyQueuedOpen();
			}
			else if ((Object)(object)_appPanel != (Object)null && (Object)(object)Phone.ActiveApp == (Object)(object)_appPanel && Input.GetMouseButtonDown(0) && IsHoveringPhoneHomeButton())
			{
				OpeningTaxWash = false;
				ApplyAppOpen(_appPanel, open: false);
			}
			else if (!((Object)(object)_homeIcon == (Object)null) && !((Object)(object)_appPanel == (Object)null) && CanOpenFromHomeScreen() && Input.GetMouseButtonDown(0) && IsPointerOverOurIcon())
			{
				OpenTaxWash();
			}
		}

		private static bool IsHoveringPhoneHomeButton()
		{
			//IL_0050: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Singleton<GameplayMenu>.InstanceExists)
				{
					return false;
				}
				Camera overlayCamera = Singleton<GameplayMenu>.Instance.OverlayCamera;
				if ((Object)(object)overlayCamera == (Object)null)
				{
					return false;
				}
				int num = LayerMask.NameToLayer("Overlay");
				if (num < 0)
				{
					return false;
				}
				Ray val = overlayCamera.ScreenPointToRay(Input.mousePosition);
				RaycastHit val2 = default(RaycastHit);
				if (!Physics.Raycast(val, ref val2, 2f, 1 << num))
				{
					return false;
				}
				return (Object)(object)((RaycastHit)(ref val2)).collider != (Object)null && ((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "Button";
			}
			catch
			{
				return false;
			}
		}

		private static void HideIconNotification(GameObject icon)
		{
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = icon.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)icon.transform))
				{
					string name = ((Object)val).name;
					if (name.IndexOf("notif", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("badge", StringComparison.OrdinalIgnoreCase) >= 0 || name == "Amount" || name == "Count" || name == "Notification")
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
		}

		private static void KeepSingleIcon(string exactLabel)
		{
			List<GameObject> list = new List<GameObject>();
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < val.transform.childCount; j++)
				{
					Transform child = val.transform.GetChild(j);
					if (!((Object)(object)child == (Object)null) && hashSet.Add(((Object)((Component)child).gameObject).GetInstanceID()) && Utils.GetLabelText(child.Find("Label")) == exactLabel)
					{
						list.Add(((Component)child).gameObject);
					}
				}
			}
			for (int k = 1; k < list.Count; k++)
			{
				if ((Object)(object)list[k] != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)list[k]);
				}
			}
		}

		private static void DestroyLabeledIcons(string exactLabel)
		{
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = AllIconContainers();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				for (int num = val.transform.childCount - 1; num >= 0; num--)
				{
					Transform child = val.transform.GetChild(num);
					if (!((Object)(object)child == (Object)null) && hashSet.Add(((Object)((Component)child).gameObject).GetInstanceID()) && Utils.GetLabelText(child.Find("Label")) == exactLabel)
					{
						Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
					}
				}
			}
		}

		private void CreateTemplates(Transform deliveriesContainer, Transform productsContainer = null)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: 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_04d9: Expected O, but got Unknown
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)deliveriesContainer == (Object)null)
			{
				MelonLogger.Error("Container not found!");
				return;
			}
			if ((Object)(object)productsContainer != (Object)null)
			{
				Transform val = productsContainer.Find("Toggle") ?? FindDeep(productsContainer, "Toggle");
				if ((Object)(object)val == (Object)null)
				{
					Toggle[] componentsInChildren = ((Component)productsContainer).GetComponentsInChildren<Toggle>(true);
					if (componentsInChildren != null && componentsInChildren.Length != 0 && (Object)(object)componentsInChildren[0] != (Object)null)
					{
						val = ((Component)componentsInChildren[0]).transform;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					if ((Object)(object)((Component)val).GetComponent<HorizontalLayoutGroup>() == (Object)null)
					{
						HorizontalLayoutGroup val2 = ((Component)val).gameObject.AddComponent<HorizontalLayoutGroup>();
						((HorizontalOrVerticalLayoutGroup)val2).spacing = 100f;
						((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
						((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
						((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
						((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
						((LayoutGroup)val2).childAlignment = (TextAnchor)3;
					}
					if ((Object)(object)((Component)val).GetComponent<ContentSizeFitter>() == (Object)null)
					{
						ContentSizeFitter val3 = ((Component)val).gameObject.AddComponent<ContentSizeFitter>();
						val3.horizontalFit = (FitMode)2;
						val3.verticalFit = (FitMode)0;
					}
					Transform val4 = val.Find("Text");
					if ((Object)(object)val4 != (Object)null)
					{
						Utils.SetLabelText(val4, "toggleTransformText");
						Utils.SetLabelColor(val4, Color32.op_Implicit(ColorUtil.GetColor("White")));
						val4.SetAsFirstSibling();
						RectTransform component = ((Component)val4).GetComponent<RectTransform>();
						if ((Object)(object)component != (Object)null)
						{
							component.sizeDelta = new Vector2(325f, 30f);
						}
						if ((Object)(object)((Component)val4).GetComponent<LayoutElement>() == (Object)null)
						{
							LayoutElement val5 = ((Component)val4).gameObject.AddComponent<LayoutElement>();
							val5.minWidth = 325f;
						}
					}
					Toggle component2 = ((Component)val).GetComponent<Toggle>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.isOn = false;
						((UnityEventBase)component2.onValueChanged).RemoveAllListeners();
					}
					Transform val6 = val.Find("Background");
					if ((Object)(object)val6 != (Object)null)
					{
						((Object)val6).name = "CheckboxBackground";
						if ((Object)(object)((Component)val6).GetComponent<LayoutElement>() == (Object)null)
						{
							LayoutElement val7 = ((Component)val6).gameObject.AddComponent<LayoutElement>();
							val7.minWidth = 30f;
							val7.preferredWidth = 30f;
							val7.minHeight = 30f;
							val7.preferredHeight = 30f;
						}
						Transform val8 = val6.Find("Checkmark");
						if ((Object)(object)val8 != (Object)null)
						{
							Image component3 = ((Component)val8).GetComponent<Image>();
							if ((Object)(object)component3 != (Object)null)
							{
								((Graphic)component3).color = Color32.op_Implicit(ColorUtil.GetColor("Bright Green"));
							}
						}
					}
					RectTransform component4 = ((Component)val).GetComponent<RectTransform>();
					if ((Object)(object)component4 != (Object)null)
					{
						component4.sizeDelta = new Vector2(30f, 30f);
					}
					checkboxTemplate = Object.Instantiate<GameObject>(((Component)val).gameObject);
					((Object)checkboxTemplate).name = "Checkbox Template";
					checkboxTemplate.SetActive(false);
					checkboxTemplate.transform.SetParent(deliveriesContainer, false);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			Transform val9 = deliveriesContainer.Find("Scroll View");
			if ((Object)(object)val9 == (Object)null)
			{
				return;
			}
			Transform val10 = val9.Find("OrderSubmitted");
			if ((Object)(object)val10 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val10).gameObject);
			}
			Transform val11 = val9.Find("Viewport/Content");
			if ((Object)(object)val11 == (Object)null)
			{
				MelonLogger.Error("Viewport Content not found!");
				return;
			}
			launderingAppViewportContentTransform = val11;
			if (DansHardwareTemplate == null)
			{
				DansHardwareTemplate = CaptureTemplate(val11.Find("Dan's Hardware"), "Dan's Hardware Template");
			}
			if (GasMartWestTemplate == null)
			{
				GasMartWestTemplate = CaptureTemplate(val11.Find("Gas-Mart (West)"), "Gas-Mart (West) Template");
			}
			if ((Object)(object)DansHardwareTemplate == (Object)null)
			{
				DansHardwareTemplate = CaptureFirstHeaderEntry(val11);
			}
			if ((Object)(object)DansHardwareTemplate == (Object)null || (Object)(object)DansHardwareTemplate.transform.Find("Header") == (Object)null)
			{
				DansHardwareTemplate = CreateOriginalHeaderCardTemplate(deliveriesContainer);
			}
			if (viewPortContentSpaceTemplate == null)
			{
				viewPortContentSpaceTemplate = CaptureTemplate(val11.Find("Space"), "Space Template");
			}
			if ((Object)(object)((Component)val11).GetComponent<VerticalLayoutGroup>() == (Object)null)
			{
				VerticalLayoutGroup val12 = ((Component)val11).gameObject.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)val12).childAlignment = (TextAnchor)0;
				((HorizontalOrVerticalLayoutGroup)val12).spacing = 8f;
				((LayoutGroup)val12).padding = new RectOffset(6, 6, 6, 8);
				((HorizontalOrVerticalLayoutGroup)val12).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)val12).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)val12).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)val12).childForceExpandHeight = false;
			}
			Utils.ClearChildren(val11);
			AddSpaceFromTemplate(val11);
		}

		private static GameObject CaptureFirstHeaderEntry(Transform sourceContent)
		{
			if ((Object)(object)sourceContent == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < sourceContent.childCount; i++)
			{
				Transform child = sourceContent.GetChild(i);
				if (!((Object)(object)child == (Object)null) && !(((Object)child).name == "Space") && !((Object)(object)child.Find("Header") == (Object)null))
				{
					return CaptureTemplate(child, "Dan's Hardware Template");
				}
			}
			return null;
		}

		private static GameObject CaptureTemplate(Transform source, string templateName)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)source).gameObject);
			((Object)val).name = templateName;
			val.SetActive(false);
			Transform val2 = val.transform.Find("Contents");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
			}
			return val;
		}

		private GameObject CreateOriginalHeaderCardTemplate(Transform container)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0046: 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_008c: Expected O, but got Unknown
			//IL_00ab: 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_00c5: 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_0103: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_01ad: 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_01c4: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Expected O, but got Unknown
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			Font val = FontLoader.openSansBold ?? FontLoader.openSansSemiBold ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			Font font = FontLoader.openSansSemiBold ?? val;
			GameObject val2 = new GameObject("Dan's Hardware Template");
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.sizeDelta = new Vector2(0f, 74f);
			LayoutElement val4 = val2.AddComponent<LayoutElement>();
			val4.minHeight = 74f;
			val4.preferredHeight = 74f;
			val4.flexibleWidth = 1f;
			GameObject val5 = new GameObject("Header");
			val5.transform.SetParent(val2.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Image val7 = val5.AddComponent<Image>();
			val7.sprite = RoundedFillSprite();
			val7.type = (Type)1;
			((Graphic)val7).color = Color32.op_Implicit(ColorUtil.GetColor("Cyan"));
			val5.AddComponent<Button>();
			GameObject val8 = new GameObject("Icon");
			val8.transform.SetParent(val5.transform, false);
			RectTransform val9 = val8.AddComponent<RectTransform>();
			val9.anchorMin = new Vector2(0f, 0.5f);
			val9.anchorMax = new Vector2(0f, 0.5f);
			val9.pivot = new Vector2(0f, 0.5f);
			val9.anchoredPosition = new Vector2(10f, 0f);
			val9.sizeDelta = new Vector2(52f, 52f);
			GameObject val10 = new GameObject("Image");
			val10.transform.SetParent(val8.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = Vector2.zero;
			val11.anchorMax = Vector2.one;
			val11.offsetMin = Vector2.zero;
			val11.offsetMax = Vector2.zero;
			Image val12 = val10.AddComponent<Image>();
			val12.preserveAspect = true;
			((Graphic)val12).color = Color.white;
			GameObject val13 = new GameObject("Title");
			val13.transform.SetParent(val5.transform, false);
			RectTransform val14 = val13.AddComponent<RectTransform>();
			val14.anchorMin = new Vector2(0f, 1f);
			val14.anchorMax = new Vector2(1f, 1f);
			val14.pivot = new Vector2(0f, 1f);
			val14.anchoredPosition = new Vector2(72f, -8f);
			val14.sizeDelta = new Vector2(-82f, 26f);
			Text val15 = val13.AddComponent<Text>();
			val15.font = val;
			val15.fontSize = 20;
			((Graphic)val15).color = Color.white;
			val15.alignment = (TextAnchor)3;
			val15.horizontalOverflow = (HorizontalWrapMode)1;
			val15.verticalOverflow = (VerticalWrapMode)1;
			GameObject val16 = new GameObject("Description");
			val16.transform.SetParent(val5.transform, false);
			RectTransform val17 = val16.AddComponent<RectTransform>();
			val17.anchorMin = new Vector2(0f, 0f);
			val17.anchorMax = new Vector2(1f, 0f);
			val17.pivot = new Vector2(0f, 0f);
			val17.anchoredPosition = new Vector2(72f, 8f);
			val17.sizeDelta = new Vector2(-82f, 24f);
			Text val18 = val16.AddComponent<Text>();
			val18.font = font;
			val18.fontSize = 14;
			((Graphic)val18).color = new Color(1f, 1f, 1f, 0.85f);
			val18.alignment = (TextAnchor)3;
			val18.horizontalOverflow = (HorizontalWrapMode)1;
			val18.verticalOverflow = (VerticalWrapMode)1;
			val2.SetActive(false);
			return val2;
		}

		public void AddSpaceFromTemplate(Transform viewportContentTransform = null)
		{
			if (viewportContentTransform == null)
			{
				viewportContentTransform = launderingAppViewportContentTransform;
			}
			if (!((Object)(object)viewportContentTransform == (Object)null) && !((Object)(object)viewPortContentSpaceTemplate == (Object)null))
			{
				Transform val = viewportContentTransform.Find("Space");
				if ((Object)(object)val != (Object)null)
				{
					val.SetAsLastSibling();
					return;
				}
				GameObject val2 = Object.Instantiate<GameObject>(viewPortContentSpaceTemplate, viewportContentTransform);
				((Object)val2).name = "Space";
				val2.SetActive(true);
				val2.transform.SetAsLastSibling();
			}
		}

		private static void HideIconBacking(Transform iconRoot)
		{
			//IL_00a9: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)iconRoot == (Object)null)
			{
				return;
			}
			Mask[] componentsInChildren = ((Component)iconRoot).GetComponentsInChildren<Mask>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null))
				{
					componentsInChildren[i].showMaskGraphic = false;
					Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
				}
			}
			Image[] componentsInChildren2 = ((Component)iconRoot).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren2)
			{
				if (!((Object)(object)val == (Object)null) && (!(((Object)((Component)val).gameObject).name == "Image") || !((Object)(object)((Component)val).transform != (Object)(object)iconRoot)))
				{
					Color color = ((Graphic)val).color;
					color.a = 0f;
					((Graphic)val).color = color;
				}
			}
		}

		private static void PrepareCardIcon(Transform header, Sprite sprite)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)header == (Object)null)
			{
				return;
			}
			Transform val = header.Find("Icon") ?? FindDeep(header, "Icon");
			Transform val2 = null;
			if ((Object)(object)val != (Object)null)
			{
				HideIconBacking(val);
				val2 = val.Find("Image") ?? FindDeep(val, "Image") ?? val;
			}
			else
			{
				val2 = header.Find("Icon/Image") ?? FindDeep(header, "Image");
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			Image component = ((Component)val2).GetComponent<Image>();
			if (!((Object)(object)component == (Object)null))
			{
				component.preserveAspect = true;
				((Graphic)component).color = Color.white;
				component.type = (Type)0;
				if ((Object)(object)sprite != (Object)null)
				{
					component.sprite = sprite;
				}
			}
		}

		public void AddEntryFromTemplate(string newObjectName, string newTitle, string newSubtitle, Business business, GameObject template = null, Color newBackgroundColor = default(Color), string imagePath = null, Transform viewportContentTransform = null, bool isFirstEntry = false)
		{
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			if (viewportContentTransform == null)
			{
				viewportContentTransform = launderingAppViewportContentTransform;
			}
			if (template == null)
			{
				template = GasMartWestTemplate ?? DansHardwareTemplate;
			}
			if ((Object)(object)viewportContentTransform == (Object)null || (Object)(object)template == (Object)null || (Object)(object)viewportContentTransform.Find(newObjectName) != (Object)null)
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(template, viewportContentTransform);
			((Object)val).name = newObjectName;
			Transform val2 = val.transform.Find("Header");
			if ((Object)(object)val2 == (Object)null)
			{
				Object.DestroyImmediate((Object)(object)val);
				MelonLogger.Error("Tax & Wash: shop card template has no Header.");
				return;
			}
			Transform val3 = val2.Find("Title");
			Transform val4 = val2.Find("Description");
			Transform val5 = val2.Find("Arrow");
			if ((Object)(object)val5 != (Object)null)
			{
				((Component)val5).gameObject.SetActive(false);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				Utils.SetLabelText(val3, newTitle);
			}
			if ((Object)(object)val4 != (Object)null)
			{
				Utils.SetLabelText(val4, newSubtitle);
			}
			Image component = ((Component)val2).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				component.sprite = RoundedFillSprite();
				component.type = (Type)1;
				if (newBackgroundColor != default(Color))
				{
					Color color = newBackgroundColor;
					color.a = 1f;
					((Graphic)component).color = color;
				}
			}
			Sprite val6 = null;
			if (!string.IsNullOrEmpty(imagePath))
			{
				val6 = Utils.LoadEmbeddedSprite(Path.GetFileName(imagePath));
				if ((Object)(object)val6 != (Object)null)
				{
					switch (Path.GetFileName(imagePath))
					{
					case "Laundromat.png":
						laundromatSprite = val6;
						break;
					case "TacoTickler.png":
						tacoTicklersSprite = val6;
						break;
					case "CarWash.png":
						carWashSprite = val6;
						break;
					case "PostOffice.png":
						postOfficeSprite = val6;
						break;
					case "LaunderingIcon.png":
						appIconSprite = val6;
						break;
					}
				}
			}
			PrepareCardIcon(val2, val6);
			Button val7 = ((Component)val2).GetComponent<Button>() ?? ((Component)val2).gameObject.AddComponent<Button>();
			StyleVanillaButton(val7);
			((UnityEventBase)val7.onClick).RemoveAllListeners();
			if ((Object)(object)business != (Object)null)
			{
				Business captured = business;
				((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
				{
					BusinessButtonClicked(captured);
				});
			}
			else
			{
				switch (newObjectName)
				{
				case "Global Settings":
					((UnityEvent)val7.onClick).AddListener(new UnityAction(GlobalButtonClicked));
					break;
				case "Cartel Settings":
					((UnityEvent)val7.onClick).AddListener(new UnityAction(CartelButtonClicked));
					break;
				case "Notification Settings":
					((UnityEvent)val7.onClick).AddListener(new UnityAction(NotificationButtonClicked));
					break;
				}
			}
			RegisterHoverTarget(val2, newObjectName, scaleOnHover: true);
			if (isFirstEntry)
			{
				val.transform.SetAsFirstSibling();
			}
			val.SetActive(true);
			AddSpaceFromTemplate(viewportContentTransform);
		}

		private void HideOptionPanels()
		{
			ShowPanel(optionsTransform, show: false);
			ShowPanel(globalOptionsTransform, show: false);
			ShowPanel(cartelOptionsTransform, show: false);
			ShowPanel(notificationOptionsTransform, show: false);
		}

		private void BusinessButtonClicked(Business business)
		{
			_selectedBusiness = business;
			SelectCard(BusinessUtil.Display(((Object)business).name));
			HideOptionPanels();
			ShowPanel(optionsTransform, show: true);
			SetDetails(BusinessUtil.Display(((Object)business).name), "Maximum amount, hours to finish, and tax rate.");
			SetInput(optionsTransform, "Maximum Launder", business.LaunderCapacity.ToString("0"));
			SetInput(optionsTransform, "Launder Time", ConfigManager.GetLaunderingTimeHours(MRLCore.Instance.config, ((Object)business).name).ToString());
			SetInput(optionsTransform, "Taxation", ConfigManager.GetTaxationPercentage(MRLCore.Instance.config, ((Object)business).name).ToString("0.##"));
			(int, int) businessHours = ConfigManager.GetBusinessHours(MRLCore.Instance.config, ((Object)business).name);
			SetInput(optionsTransform, "Open Hour", businessHours.Item1.ToString());
			SetInput(optionsTransform, "Close Hour", businessHours.Item2.ToString());
		}

		private void GlobalButtonClicked()
		{
			_selectedBusiness = null;
			SelectCard("Global Settings");
			HideOptionPanels();
			ShowPanel(globalOptionsTransform, show: true);
			SetDetails("Global Settings", "How money is paid out over time.");
			ConfigState config = MRLCore.Instance.config;
			SetToggle(globalOptionsTransform, "Use Drip Payout", config.Use_Drip_Payout);
			SetInput(globalOptionsTransform, "Drip Interval", config.Drip_Interval_Minutes.ToString());
			SetToggle(globalOptionsTransform, "Business Hours", config.Use_Business_Hours);
			SetToggle(globalOptionsTransform, "Peak Hour Variance", config.Use_Peak_Hour_Variance);
		}

		private void CartelButtonClicked()
		{
			_selectedBusiness = null;
			SelectCard("Cartel Settings");
			HideOptionPanels();
			ShowPanel(cartelOptionsTransform, show: true);
			SetDetails("Cartel Settings", "Protection cut, wash jobs, and influence.");
			ConfigState config = MRLCore.Instance.config;
			SetToggle(cartelOptionsTransform, "Protection Cut", config.Use_Protection_Cut);
			SetInput(cartelOptionsTransform, "Protection Cut %", config.Protection_Cut_Percentage.ToString("0.##"));
			SetToggle(cartelOptionsTransform, "Cartel Requests", config.Use_Cartel_Requests);
			SetInput(cartelOptionsTransform, "Wash Cut %", config.Cartel_Wash_Cut_Percentage.ToString("0.##"));
			SetInput(cartelOptionsTransform, "Request Min Influence", config.Cartel_Request_Min_Influence.ToString("0.##"));
			SetInput(cartelOptionsTransform, "Request Min Amount", config.Cartel_Request_Min_Amount.ToString());
			SetInput(cartelOptionsTransform, "Request Cooldown", config.Cartel_Request_Cooldown_Hours.ToString());
			SetInput(cartelOptionsTransform, "Request Timeout", config.Cartel_Timeout_Minutes_IRL.ToString());
			SetInput(cartelOptionsTransform, "Accept Influence", config.Cartel_Accept_Influence.ToString("0.##"));
			SetInput(cartelOptionsTransform, "Deny Influence", config.Cartel_Deny_Influence.ToString("0.##"));
		}

		private void NotificationButtonClicked()
		{
			_selectedBusiness = null;
			SelectCard("Notification Settings");
			HideOptionPanels();
			ShowPanel(notificationOptionsTransform, show: true);
			SetDetails("Notification Settings", "Choose which money alerts to show.");
			ConfigState config = MRLCore.Instance.config;
			SetToggle(notificationOptionsTransform, "Notify Drip Payouts", config.Notify_Drip_Payouts);
			SetToggle(notificationOptionsTransform, "Notify Tax Deductions", config.Notify_Tax_Deductions);
			SetToggle(notificationOptionsTransform, "Notify Cartel Dues", config.Notify_Cartel_Dues);
		}

		public void AddOptionsForBusiness(Transform parent)
		{
			optionsTransform = CreateOptionsRoot(parent, "Options");
			AddLabelInputPair("Maximum Launder", optionsTransform, "$", "Maximum amount");
			AddLabelInputPair("Launder Time", optionsTransform, "hours", "Hours to finish");
			AddLabelInputPair("Taxation", optionsTransform, "%", "Tax rate");
			AddLabelInputPair("Open Hour", optionsTransform, "", "Opens at hour");
			AddLabelInputPair("Close Hour", optionsTransform, "", "Closes at hour");
			AddSaveButton(optionsTransform, "business");
			((Component)optionsTransform).gameObject.SetActive(false);
		}

		public void AddGlobalOptions(Transform parent)
		{
			globalOptionsTransform = CreateOptionsRoot(parent, "GlobalOptions");
			AddToggle("Use Drip Payout", globalOptionsTransform, "Pay out over time");
			AddLabelInputPair("Drip Interval", globalOptionsTransform, "minutes", "Minutes between deposits");
			AddToggle("Business Hours", globalOptionsTransform, "Only during business hours");
			AddToggle("Peak Hour Variance", globalOptionsTransform, "Vary deposits at busy hours");
			AddSaveButton(globalOptionsTransform, "global");
			((Component)globalOptionsTransform).gameObject.SetActive(false);
		}

		public void AddCartelOptions(Transform parent)
		{
			cartelOptionsTransform = CreateOptionsRoot(parent, "CartelOptions");
			AddToggle("Protection Cut", cartelOptionsTransform, "Cartel takes a protection cut");
			AddLabelInputPair("Protection Cut %", cartelOptionsTransform, "%", "Protection cut");
			AddToggle("Cartel Requests", cartelOptionsTransform, "Allow cartel wash requests");
			AddLabelInputPair("Wash Cut %", cartelOptionsTransform, "%", "Your cut of cartel washes");
			AddLabelInputPair("Request Min Influence", cartelOptionsTransform, "", "Min. influence to request");
			AddLabelInputPair("Request Min Amount", cartelOptionsTransform, "$", "Floor; max of 85% of one front");
			AddLabelInputPair("Request Cooldown", cartelOptionsTransform, "hours", "Hours between requests");
			AddLabelInputPair("Request Timeout", cartelOptionsTransform, "minutes", "Minutes to answer texts");
			AddLabelInputPair("Accept Influence", cartelOptionsTransform, "", "Influence if you accept");
			AddLabelInputPair("Deny Influence", cartelOptionsTransform, "", "Influence if you refuse");
			AddSaveButton(cartelOptionsTransform, "cartel");
			((Component)cartelOptionsTransform).gameObject.SetActive(false);
		}

		public void AddNotificationOptions(Transform parent)
		{
			notificationOptionsTransform = CreateOptionsRoot(parent, "NotificationOptions");
			AddToggle("Notify Drip Payouts", notificationOptionsTransform, "Notify each deposit");
			AddToggle("Notify Tax Deductions", notificationOptionsTransform, "Notify tax deductions");
			AddToggle("Notify Cartel Dues", notificationOptionsTransform, "Notify cartel dues");
			AddSaveButton(notificationOptionsTransform, "notify");
			((Component)notificationOptionsTransform).gameObject.SetActive(false);
		}

		private Transform CreateOptionsRoot(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_0024: 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_0050: 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_00a5: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			RectTransform val2 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			VerticalLayoutGroup val3 = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val3).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 12f;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			((LayoutGroup)val3).padding = new RectOffset(4, 4, 4, 8);
			LayoutElement val4 = val.AddComponent<LayoutElement>();
			val4.flexibleHeight = 0f;
			val4.flexibleWidth = 1f;
			val4.minHeight = 0f;
			ContentSizeFitter val5 = val.AddComponent<ContentSizeFitter>();
			val5.verticalFit = (FitMode)2;
			val5.horizontalFit = (FitMode)0;
			val.AddComponent<CanvasGroup>();
			val.transform.SetParent(parent, false);
			return val.transform;
		}

		private static Font OptionFont()
		{
			return FontLoader.openSansSemiBold ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
		}

		private static void SetFixedSize(RectTransform rt, float width, float height)
		{
			//IL_0019: 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_0045: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rt == (Object)null))
			{
				rt.anchorMin = new Vector2(0f, 0.5f);
				rt.anchorMax = new Vector2(0f, 0.5f);
				rt.pivot = new Vector2(0f, 0.5f);
				rt.sizeDelta = new Vector2(width, height);
				rt.anchoredPosition = Vector2.zero;
			}
		}

		private static LayoutElement SetBoxLayout(GameObject obj, float width, float height)
		{
			LayoutElement val = obj.GetComponent<LayoutElement>() ?? obj.AddComponent<LayoutElement>();
			val.minWidth = width;
			val.preferredWidth = width;
			val.minHeight = height;
			val.preferredHeight = height;
			val.flexibleWidth = 0f;
			val.flexibleHeight = 0f;
			return val;
		}

		private static void MakeSolidImage(Image image, Color color)
		{
			//IL_0017: 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_0023: 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)
			if (!((Object)(object)image == (Object)null))
			{
				image.sprite = null;
				((Graphic)image).color = new Color(color.r, color.g, color.b, 1f);
				image.type = (Type)0;
			}
		}

		private void AddLabelInputPair(string id, Transform parent, string unit, string displayLabel)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: 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_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: 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_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Expected O, but got Unknown
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = unit == "$" || unit == "%";
			bool flag2 = unit == "minutes" || unit == "hours";
			GameObject val = new GameObject(id + " Horizontal Container");
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup val2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 10f;
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.minHeight = 30f;
			val3.preferredHeight = 30f;
			val3.flexibleWidth = 1f;
			GameObject val4 = new GameObject(id + " Label");
			val4.transform.SetParent(val.transform, false);
			Text val5 = val4.AddComponent<Text>();
			val5.text = displayLabel;
			val5.font = OptionFont();
			val5.fontSize = ((displayLabel.Length > 24) ? 15 : 16);
			((Graphic)val5).color = Color.white;
			val5.alignment = (TextAnchor)3;
			val5.horizontalOverflow = (HorizontalWrapMode)1;
			val5.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement val6 = val4.AddComponent<LayoutElement>();
			val6.flexibleWidth = 0f;
			val6.minWidth = 0f;
			val6.preferredWidth = Mathf.Clamp(val5.preferredWidth + 8f, 120f, 230f);
			val6.preferredHeight = 30f;
			val6.minHeight = 30f;
			GameObject val7 = new GameObject(id + " Input");
			val7.transform.SetParent(val.transform, false);
			Image image = val7.AddComponent<Image>();
			MakeSolidImage(image, Color32.op_Implicit(ColorUtil.GetColor("Grey")));
			InputField val8 = val7.AddComponent<InputField>();
			SetBoxLayout(val7, 96f, 30f);
			GameObject val9 = new GameObject(id + " Input Text");
			val9.transform.SetParent(val7.transform, false);
			Text val10 = val9.AddComponent<Text>();
			val10.font = OptionFont();
			val10.fontSize = 16;
			((Graphic)val10).color = Color32.op_Implicit(ColorUtil.GetColor("Bright Green"));
			val10.alignment = (TextAnchor)5;
			val10.horizontalOverflow = (HorizontalWrapMode)1;
			val10.verticalOverflow = (VerticalWrapMode)1;
			RectTransform component = val9.GetComponent<RectTransform>();
			StretchFill(component);
			component.offsetMin = new Vector2(flag ? 18f : 6f, 0f);
			component.offsetMax = new Vector2(-6f, 0f);
			val8.textComponent = val10;
			val8.characterLimit = 7;
			val8.lineType = (LineType)0;
			val8.contentType = (ContentType)((unit == "%" || string.IsNullOrEmpty(unit)) ? 3 : 2);
			val8.text = "0";
			if (flag)
			{
				GameObject val11 = new GameObject(id + " Prefix");
				val11.transform.SetParent(val7.transform, false);
				Text val12 = val11.AddComponent<Text>();
				val12.text = unit;
				val12.font = OptionFont();
				val12.fontSize = 16;
				((Graphic)val12).color = Color32.op_Implicit(ColorUtil.GetColor("Bright Green"));
				val12.alignment = (TextAnchor)3;
				RectTransform component2 = val11.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 0.5f);
				component2.anchorMax = new Vector2(0f, 0.5f);
				component2.pivot = new Vector2(0f, 0.5f);
				component2.sizeDelta = new Vector2(16f, 30f);
				component2.anchoredPosition = new Vector2(4f, 0f);
			}
			if (flag2)
			{
				GameObject val13 = new GameObject(id + " Suffix");
				val13.transform.SetParent(val.transform, false);
				Text val14 = val13.AddComponent<Text>();
				val14.text = unit;
				val14.font = OptionFont();
				val14.fontSize = 15;
				((Graphic)val14).color = Color.white;
				val14.alignment = (TextAnchor)3;
				val14.horizontalOverflow = (HorizontalWrapMode)1;
				val14.verticalOverflow = (VerticalWrapMode)1;
				SetBoxLayout(val13, (unit == "minutes") ? 72f : 56f, 30f);
			}
		}

		private void AddToggle(string id, Transform parent, string displayLabel)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00d4: 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_016c: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected O, but got Unknown
			//IL_0271: 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_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(id + " Toggle Container");
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup val2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 8f;
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.minHeight = 30f;
			val3.preferredHeight = 30f;
			val3.flexibleWidth = 1f;
			GameObject val4 = new GameObject(id + " Label");
			val4.transform.SetParent(val.transform, false);
			Text val5 = val4.AddComponent<Text>();
			val5.text = displayLabel;
			val5.font = OptionFont();
			val5.fontSize = 16;
			((Graphic)val5).color = Color.white;
			val5.alignment = (TextAnchor)3;
			val5.horizontalOverflow = (HorizontalWrapMode)1;
			val5.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement val6 = val4.AddComponent<LayoutElement>();
			val6.flexibleWidth = 0f;
			val6.minWidth = 0f;
			val6.preferredWidth = Mathf.Clamp(val5.preferredWidth + 8f, 80f, 280f);
			val6.preferredHeight = 30f;
			val6.minHeight = 30f;
			GameObject val7 = new GameObject(id + " Toggle");
			val7.transform.SetParent(val.transform, false);
			RectTransform rt = val7.GetComponent<RectTransform>() ?? val7.AddComponent<RectTransform>();
			SetFixedSize(rt, 30f, 30f);
			SetBoxLayout(val7, 30f, 30f);
			Toggle val8 = val7.AddComponent<Toggle>();
			GameObject val9 = new GameObject("Background");
			val9.transform.SetParent(val7.transform, false);
			RectTransform rt2 = val9.GetComponent<RectTransform>() ?? val9.AddComponent<RectTransform>();
			StretchFill(rt2);
			Image val10 = val9.AddComponent<Image>();
			MakeSolidImage(val10, Color32.op_Implicit(ColorUtil.GetColor("Grey")));
			((Selectable)val8).targetGraphic = (Graphic)(object)val10;
			GameObject val11 = new GameObject("Checkmark");
			val11.transform.SetParent(val9.transform, false);
			RectTransform val12 = val11.GetComponent<RectTransform>() ?? val11.AddComponent<RectTransform>();
			StretchFill(val12);
			val12.offsetMin = new Vector2(4f, 4f);
			val12.offsetMax = new Vector2(-4f, -4f);
			Image val13 = val11.AddComponent<Image>();
			MakeSolidImage(val13, Color32.op_Implicit(ColorUtil.GetColor("Bright Green")));
			val8.graphic = (Graphic)(object)val13;
			val8.isOn = false;
		}

		private static void ClampCheckboxGraphics(Transform row)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)row == (Object)null)
			{
				return;
			}
			LayoutElement val = ((Component)row).GetComponent<LayoutElement>() ?? ((Component)row).gameObject.AddComponent<LayoutElement>();
			val.minHeight = 30f;
			val.preferredHeight = 30f;
			val.flexibleWidth = 1f;
			Transform val2 = row.Find("CheckboxBackground") ?? row.Find("Background") ?? FindDeep(row, "CheckboxBackground") ?? FindDeep(row, "Background");
			if ((Object)(object)val2 != (Object)null)
			{
				SetBoxLayout(((Component)val2).gameObject, 30f, 30f);
				RectTransform component = ((Component)val2).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(30f, 30f);
				}
				MakeSolidImage(((Component)val2).GetComponent<Image>(), Color32.op_Implicit(ColorUtil.GetColor("Light Grey")));
				Transform val3 = val2.Find("Checkmark");
				if ((Object)(object)val3 != (Object)null)
				{
					RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
					StretchFill(component2);
					if ((Object)(object)component2 != (Object)null)
					{
						component2.offsetMin = new Vector2(4f, 4f);
						component2.offsetMax = new Vector2(-4f, -4f);
					}
					MakeSolidImage(((Component)val3).GetComponent<Image>(), Color32.op_Implicit(ColorUtil.GetColor("Bright Green")));
				}
			}
			Transform val4 = row.Find("Toggle");
			if ((Object)(object)val4 != (Object)null && (Object)(object)val4 != (Object)(object)row)
			{
				SetBoxLayout(((Component)val4).gameObject, 30f, 30f);
			}
		}

		private void AddSaveButton(Transform parent, string kind)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0043: 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_006a: Expected O, but got Unknown
			//IL_009d: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			GameObject val = new GameObject("SaveSpace");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(100f, 50f);
			SetBoxLayout(val, 100f, 0f);
			GameObject val3 = new GameObject("Save Button");
			val3.transform.SetParent(parent, false);
			Image val4 = val3.AddComponent<Image>();
			val4.sprite = RoundedFillSprite();
			val4.type = (Type)1;
			((Graphic)val4).color = Color32.op_Implicit(ColorUtil.GetColor("Dark Green"));
			Button val5 = val3.AddComponent<Button>();
			StyleVanillaButton(val5);
			RegisterHoverTarget(val3.transform, null, scaleOnHover: false);
			GameObject val6 = new GameObject("Save Button Text");
			val6.transform.SetParent(val3.transform, false);
			Text text = val6.AddComponent<Text>();
			text.text = "Save & Apply";
			text.font = OptionFont();
			text.fontSize = 18;
			text.alignment = (TextAnchor)4;
			((Graphic)text).color = Color.white;
			StretchFill(val6.GetComponent<RectTransform>());
			LayoutElement val7 = val3.AddComponent<LayoutElement>();
			val7.minHeight = 35f;
			val7.preferredHeight = 35f;
			val7.flexibleWidth = 1f;
			val7.minWidth = 160f;
			switch (kind)
			{
			case "global":
				((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
				{
					SaveGlobal(text);
				});
				break;
			case "cartel":
				((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
				{
					SaveCartel(text);
				});
				break;
			case "notify":
				((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
				{
					SaveNotifications(text);
				});
				break;
			default:
				((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
				{
					SaveBusinessDetails(text);
				});
				break;
			}
		}

		private void SaveBusinessDetails(Text buttonText)
		{
			if (!((Object)(object)_selectedBusiness == (Object)null) && MRLCore.Instance.config != null)
			{
				float num = ReadFloat(optionsTransform, "Maximum Launder", _selectedBusiness.LaunderCapacity);
				int num2 = ReadInt(optionsTransform, "Launder Time", 24);
				float num3 = ReadFloat(optionsTransform, "Taxation", 19f);
				int open_Hour = Mathf.Clamp(ReadInt(optionsTransform, "Open Hour", 8), 0, 23);
				int close_Hour = Mathf.Clamp(ReadInt(optionsTransform, "Close Hour", 22), 0, 24);
				switch (BusinessUtil.Canonical(((Object)_selectedBusiness).name))
				{
				case "Laundromat":
					MRLCore.Instance.config.Businesses.Laundromat.Laundromat_Cap = num;
					MRLCore.Instance.config.Businesses.Laundromat.Laundromat_Laundering_time_hours = num2;
					MRLCore.Instance.config.Businesses.Laundromat.Laundromat_Tax_Percentage = num3;
					MRLCore.Instance.config.Businesses.Laundromat.Open_Hour = open_Hour;
					MRLCore.Instance.config.Businesses.Laundromat.Close_Hour = close_Hour;
					break;
				case "Taco Ticklers":
					MRLCore.Instance.config.Businesses.TacoTicklers.Taco_Ticklers_Cap = num;
					MRLCore.Instance.config.Businesses.TacoTicklers.Taco_Ticklers_Laundering_time_hours = num2;
					MRLCore.Instance.config.Businesses.TacoTicklers.Taco_Ticklers_Tax_Percentage = num3;
					MRLCore.Instance.config.Businesses.TacoTicklers.Open_Hour = open_Hour;
					MRLCore.Instance.config.Businesses.TacoTicklers.Close_Hour = close_Hour;
					break;
				case "Car Wash":
					MRLCore.Instance.config.Businesses.CarWash.Car_Wash_Cap = num;
					MRLCore.Instance.config.Businesses.CarWash.Car_Wash_Laundering_time_hours = num2;
					MRLCore.Instance.config.Businesses.CarWash.Car_Wash_Tax_Percentage = num3;
					MRLCore.Instance.config.Businesses.CarWash.Open_Hour = open_Hour;
					MRLCore.Instance.config.Businesses.CarWash.Close_Hour = close_Hour;
					break;
				case "Post Office":
					MRLCore.Instance.config.Businesses.PostOffice.Post_Office_Cap = num;
					MRLCore.Instance.config.Businesses.PostOffice.Post_Office_Laundering_time_hours = num2;
					MRLCore.Instance.config.Businesses.PostOffice.Post_Office_Tax_Percentage = num3;
					MRLCore.Instance.config.Businesses.PostOffice.Open_Hour = open_Hour;
					MRLCore.Instance.config.Businesses.PostOffice.Close_Hour = close_Hour;
					break;
				}
				ConfigManager.Save(MRLCore.Instance.config);
				MRLCore.Instance.FillCapDictionary();
				MRLCore.Instance.processedBusinesses.Remove(((Object)_selectedBusiness).name);
				if (!MRLCore.Instance.isWaitAndApplyCapsRunning)
				{
					MelonCoroutines.Start(MRLCore.Instance.WaitAndApplyCaps());
				}
				NotifySaved(BusinessUtil.Display(((Object)_selectedBusiness).name));
				buttonText.text = "Save & Apply";
			}
		}

		private void SaveGlobal(Text buttonText)
		{
			ConfigState config = MRLCore.Instance.config;
			config.Use_Drip_Payout = ReadToggle(globalOptionsTransform, "Use Drip Payout", config.Use_Drip_Payout);
			config.Drip_Interval_Minutes = Mathf.Max(1, ReadInt(globalOptionsTransform, "Drip Interval", config.Drip_Interval_Minutes));
			config.Use_Business_Hours = ReadToggle(globalOptionsTransform, "Business Hours", config.Use_Business_Hours);
			config.Use_Peak_Hour_Variance = ReadToggle(globalOptionsTransform, "Peak Hour Variance", config.Use_Peak_Hour_Variance);
			ConfigManager.Save(config);
			NotifySaved("Global Settings");
			buttonText.text = "Save & Apply";
		}

		private void SaveCartel(Text buttonText)
		{
			ConfigState config = MRLCore.Instance.config;
			config.Use_Protection_Cut = ReadToggle(cartelOptionsTransform, "Protection Cut", config.Use_Protection_Cut);
			config.Protection_Cut_Percentage = ReadFloat(cartelOptionsTransform, "Protection Cut %", config.Protection_Cut_Percentage);
			config.Use_Cartel_Requests = ReadToggle(cartelOptionsTransform, "Cartel Requests", config.Use_Cartel_Requests);
			config.Cartel_Wash_Cut_Percentage = ReadFloat(cartelOptionsTransform, "Wash Cut %", config.Cartel_Wash_Cut_Percentage);
			config.Cartel_Request_Min_Influence = Mathf.Clamp01(ReadFloat(cartelOptionsTransform, "Request Min Influence", config.Cartel_Request_Min_Influence));
			config.Cartel_Request_Min_Amount = Mathf.Max(1, ReadInt(cartelOptionsTransform, "Request Min Amount", config.Cartel_Request_Min_Amount));
			config.Cartel_Request_Cooldown_Hours = Mathf.Max(1, ReadInt(cartelOptionsTransform, "Request Cooldown", config.Cartel_Request_Cooldown_Hours));
			config.Cartel_Timeout_Minutes_IRL = Mathf.Max(1, ReadInt(cartelOptionsTransform, "Request Timeout", config.Cartel_Timeout_Minutes_IRL));
			config.Cartel_Accept_Influence = Mathf.Clamp01(ReadFloat(cartelOptionsTransform, "Accept Influence", config.Cartel_Accept_Influence));
			config.Cartel_Deny_Influence = Mathf.Clamp01(ReadFloat(cartelOptionsTransform, "Deny Influence", config.Cartel_Deny_Influence));
			ConfigManager.Save(config);
			NotifySaved("Cartel Settings");
			buttonText.text = "Save & Apply";
		}

		private void SaveNotifications(Text buttonText)
		{
			ConfigState config = MRLCore.Instance.config;
			config.Notify_Drip_Payouts = ReadToggle(notificationOptionsTransform, "Notify Drip Payouts", config.Notify_Drip_Payouts);
			config.Notify_Tax_Deductions = ReadToggle(notificationOptionsTransform, "Notify Tax Deductions", config.Notify_Tax_Deductions);
			config.Notify_Cartel_Dues = ReadToggle(notificationOptionsTransform, "Notify Cartel Dues", config.Notify_Cartel_Dues);
			ConfigManager.Save(config);
			NotifySaved("Notification Settings");
			buttonText.text = "Save & Apply";
		}

		private void NotifySaved(string name)
		{
			if (!((Object)(object)MRLCore.Instance.notificationsManager == (Object)null))
			{
				if (appIconSprite == null)
				{
					appIconSprite = Utils.LoadEmbeddedSprite("LaunderingIcon.png");
				}
				MRLCore.Instance.notificationsManager.SendNotification("Saved Changes", "for <color=#329AC5>" + name + "</color>", appIconSprite, 5f, true);
			}
		}

		private void SetDetails(string title, string subtitle)
		{
			if ((Object)(object)InstructionsTextObject != (Object)null)
			{
				InstructionsTextObject.SetActive(false);
			}
			if ((Object)(object)detailsTitleObject != (Object)null)
			{
				detailsTitleObject.SetActive(true);
				Utils.SetLabelText(detailsTitleObject.transform, title);
			}
			if ((Object)(object)detailsSubtitleObject != (Object)null)
			{
				detailsSubtitleObject.SetActive(true);
				Utils.SetLabelText(detailsSubtitleObject.transform, subtitle);
			}
		}

		private void ShowPanel(Transform panel, bool show)
		{
			if ((Object)(object)panel == (Object)null)
			{
				return;
			}
			if (!show)
			{
				((Component)panel).gameObject.SetActive(false);
				return;
			}
			((Component)panel).gameObject.SetActive(true);
			Transform obj = settingsContentTransform;
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val);
				ScrollRect componentInParent = ((Component)val).GetComponentInParent<ScrollRect>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					componentInParent.verticalNormalizedPosition = 1f;
				}
			}
			TweenPanelIn(panel);
		}

		private static void SetInput(Transform root, string label, string value)
		{
			object obj;
			if (root == null)
			{
				obj = null;
			}
			else
			{
				Transform obj2 = root.Find(label + " Horizontal Container/" + label + " Input");
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<InputField>() : null);
			}
			InputField val = (InputField)obj;
			if ((Object)(object)val != (Object)null)
			{
				val.text = value;
			}
		}

		private static float ReadFloat(Transform root, string label, float fallback)
		{
			object obj;
			if (root == null)
			{
				obj = null;
			}
			else
			{
				Transform obj2 = root.Find(label + " Horizontal Container/" + label + " Input");
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<InputField>() : null);
			}
			InputField val = (InputField)obj;
			float result;
			return ((Object)(object)val != (Object)null && float.TryParse(val.text, out result)) ? result : fallback;
		}

		private static int ReadInt(Transform root, string label, int fallback)
		{
			object obj;
			if (root == null)
			{
				obj = null;
			}
			else
			{
				Transform obj2 = root.Find(label + " Horizontal Container/" + label + " Input");
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<InputField>() : null);
			}
			InputField val = (InputField)obj;
			int result;
			return ((Object)(object)val != (Object)null && int.TryParse(val.text, out result)) ? result : fallback;
		}

		private static Toggle FindToggle(Transform root, string label)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform val = root.Find(label + " Toggle Container");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			object obj = ((Component)val).GetComponent<Toggle>();
			if (obj == null)
			{
				Transform obj2 = val.Find(label + " Toggle");
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<Toggle>() : null) ?? ((Component)val).GetComponentInChildren<Toggle>(true);
			}
			return (Toggle)obj;
		}

		private static void SetToggle(Transform root, string label, bool value)
		{
			Toggle val = FindToggle(root, label);
			if ((Object)(object)val != (Object)null)
			{
				val.isOn = value;
			}
		}

		private static bool ReadToggle(Transform root, string label, bool fallback)
		{
			Toggle val = FindToggle(root, label);
			return ((Object)(object)val != (Object)null) ? val.isOn : fallback;
		}
	}
}
namespace MoreRealisticLaundering.Patches
{
	[HarmonyPatch(typeof(Business), "CompleteOperation")]
	public class Business_CompleteOperation_Patch
	{
		public static bool Prefix(LaunderingOperation op, ref bool __state)
		{
			__state = false;
			if (op == null)
			{
				__state = true;
				return true;
			}
			if (CartelService.IsCartelOperation(op) && !CartelService.IsOperationComplete(op))
			{
				return false;
			}
			if (CartelService.IsCartelOperation(op))
			{
				DripTracker.Instance.PrepareCartelCompletion(op);
			}
			if (DripTracker.Instance.ShouldSuppressVanillaPayout(op))
			{
				op.amount = 0f;
			}
			__state = true;
			return true;
		}

		public static void Postfix(LaunderingOperation op, bool __state)
		{
			if (__state && op != null)
			{
				DripState state = DripTracker.Instance.GetState(op);
				if (CartelService.IsCartelOperation(op) || (state != null && state.IsCartel))
				{
					DripTracker.Instance.OnFinished(op);
				}
			}
		}
	}
	[HarmonyPatch(typeof(LaunderingInterface), "CreateEntry")]
	public class LaunderingInterface_CreateEntry_Patch
	{
		public static void Prefix(LaunderingOperation op)
		{
			if (!((Object)(object)op?.business == (Object)null) && MRLCore.Instance != null)
			{
				if (MRLCore.Instance.aliasMap.TryGetValue(((Object)op.business).name, out var _))
				{
					MRLCore.Instance.AdjustLaunderingTime(op);
				}
				DripTracker.Instance.Track(op, CartelJobStore.IsCartelJob(op));
			}
		}

		public static void Postfix(LaunderingOperation op)
		{
			LaunderingInterface_Open_Patch.RefreshEntryProgress(op);
		}
	}
	[HarmonyPatch(typeof(LaunderingInterface), "Open")]
	public class LaunderingInterface_Open_Patch
	{
		public static void Postfix(LaunderingInterface __instance)
		{
			if (!((Object)(object)((__instance != null) ? __instance.Business : null) == (Object)null) && MRLCore.Instance?.config != null)
			{
				string name = ((Object)__instance.Business).name;
				if (MRLCore.Instance.maxiumumLaunderValues.TryGetValue(name, out var value))
				{
					((TMP_Text)__instance.launderCapacityLabel).text = value.ToString("N0");
				}
				int launderingTimeHours = ConfigManager.GetLaunderingTimeHours(MRLCore.Instance.config, name);
				RewriteHourLabels(__instance, launderingTimeHours);
				ApplyProgressTexts(__instance);
			}
		}

		public static void RefreshInterface(LaunderingInterface ui)
		{
			if (!((Object)(object)ui == (Object)null) && MRLCore.Instance != null)
			{
				ApplyProgressTexts(ui);
			}
		}

		public static void RefreshOpenInterfaces()
		{
			try
			{
				LaunderingInterface[] array = Object.FindObjectsOfType<LaunderingInterface>();
				LaunderingInterface[] array2 = array;
				foreach (LaunderingInterface val in array2)
				{
					if (!((Object)(object)val == (Object)null) && val.IsOpen)
					{
						ApplyProgressTexts(val);
					}
				}
			}
			catch
			{
			}
		}

		public static void RefreshEntryProgress(LaunderingOperation op)
		{
			if (op == null || MRLCore.Instance == null)
			{
				return;
			}
			try
			{
				LaunderingInterface[] array = Object.FindObjectsOfType<LaunderingInterface>();
				LaunderingInterface[] array2 = array;
				foreach (LaunderingInterface val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Business != (Object)(object)op.business))
					{
						ApplyProgressTexts(val);
					}
				}
			}
			catch
			{
			}
		}

		private static void ApplyProgressTexts(LaunderingInterface ui)
		{
			if (((ui == null) ? null : ui.Business?.LaunderingOperations) == null)
			{
				return;
			}
			foreach (LaunderingOperation launderingOperation in ui.Business.LaunderingOperations)
			{
				if (launderingOperation == null)
				{
					continue;
				}
				DripTracker.Instance.GetDisplayProgress(launderingOperation, out var deposited, out var remaining);
				string text = $"${deposited:N0} / ${remaining:N0}";
				RectTransform val = null;
				try
				{
					if (ui.operationToEntry != null && ui.operationToEntry.ContainsKey(launderingOperation))
					{
						val = ui.operationToEntry[launderingOperation];
					}
				}
				catch
				{
				}
				if ((Object)(object)val == (Object)null)
				{
					val = FindEntryFallback(ui, launderingOperation);
				}
				SetAmountText(val, text, 22f);
				try
				{
					if (ui.operationToNotch != null && ui.operationToNotch.ContainsKey(launderingOperation))
					{
						SetAmountText(ui.operationToNotch[launderingOperation], text, 16f);
					}
				}
				catch
				{
				}
			}
		}

		private static RectTransform FindEntryFallback(LaunderingInterface ui, LaunderingOperation op)
		{
			if ((Object)(object)ui?.entryContainer == (Object)null || op == null || ui.Business?.LaunderingOperations == null)
			{
				return null;
			}
			int num = 0;
			foreach (LaunderingOperation launderingOperation in ui.Business.LaunderingOperations)
			{
				if (launderingOperation == op)
				{
					break;
				}
				num++;
			}
			if (num < 0 || num >= ((Transform)ui.entryContainer).childCount)
			{
				return null;
			}
			Transform child = ((Transform)ui.entryContainer).GetChild(num);
			return (RectTransform)(object)((child is RectTransform) ? child : null);
		}

		private static Transform FindNamed(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			Transform val = root.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val2 = FindNamed(root.GetChild(i), name);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		private static void SetAmountText(RectTransform root, string text, float maxSize)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform val = FindNamed((Transform)(object)root, "AmountLabel") ?? FindNamed((Transform)(object)root, "Amount");
			TextMeshProUGUI val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<TextMeshProUGUI>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
				if (componentsInChildren != null)
				{
					TextMeshProUGUI[] array = componentsInChildren;
					foreach (TextMeshProUGUI val3 in array)
					{
						if (!((Object)(object)val3 == (Object)null))
						{
							string name = ((Object)((Component)val3).gameObject).name;
							if (name.IndexOf("Time", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("Business", StringComparison.OrdinalIgnoreCase) < 0 && (name.IndexOf("Amount", StringComparison.OrdinalIgnoreCase) >= 0 || (((TMP_Text)val3).text != null && (((TMP_Text)val3).text.IndexOf('$') >= 0 || ((TMP_Text)val3).text.IndexOf('/') >= 0))))
							{
								val2 = val3;
								break;
							}
						}
					}
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
				((TMP_Text)val2).enableAutoSizing = true;
				((TMP_Text)val2).fontSizeMin = 8f;
				((TMP_Text)val2).fontSizeMax = maxSize;
				((TMP_Text)val2).text = text;
			}
		}

		private static void RewriteHourLabels(LaunderingInterface ui, int hours)
		{
			if ((Object)(object)ui == (Object)null || hours <= 0)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)ui).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val in array)
			{
				if (!((Object)(object)val == (Object)null) && (((TMP_Text)val).text == "12 Hrs" || ((TMP_Text)val).text == "24 Hrs"))
				{
					((TMP_Text)val).text = (((TMP_Text)val).text.StartsWith("12") ? $"{hours / 2} Hrs" : $"{hours} Hrs");
				}
			}
		}
	}
	[HarmonyPatch(typeof(LaunderingInterface), "UpdateTimeline")]
	public class LaunderingInterface_UpdateTimeline_Patch
	{
		public static void Postfix(LaunderingInterface __instance)
		{
			LaunderingInterface_Open_Patch.RefreshInterface(__instance);
		}
	}
	[HarmonyPatch(typeof(LaunderingInterface), "UpdateEntryTimes")]
	public class LaunderingInterface_UpdateEntryTimes_Patch
	{
		public static void Postfix(LaunderingInterface __instance)
		{
			if (((__instance == null) ? null : __instance.Business?.LaunderingOperations) != null)
			{
				LaunderingInterface_Open_Patch.RefreshInterface(__instance);
			}
		}
	}
	[HarmonyPatch]
	public class MessagingManager_SendMessage_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo[] methods = typeof(MessagingManager).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo method in methods)
			{
				if (IsCommandTarget(method.Name))
				{
					ParameterInfo[] parameters = method.GetParameters();
					if (parameters.Length == 3 && parameters[0].ParameterType == typeof(Message) && parameters[2].ParameterType == typeof(string))
					{
						yield return method;
					}
				}
			}
		}

		private static bool IsCommandTarget(string name)
		{
			return name == "SendMessage";
		}

		private static bool Prefix(Message __0)
		{
			if (__0 == null || string.IsNullOrEmpty(__0.text))
			{
				return true;
			}
			if (!__0.text.StartsWith("\u2063MRLCMD:ACCEPT", StringComparison.Ordinal) && !__0.text.StartsWith("\u2063MRLCMD:DENY", StringComparison.Ordinal))
			{
				return true;
			}
			if (!GameAccess.HasAuthority())
			{
				return true;
			}
			CartelContact.TryHandleCommand(__0);
			return false;
		}
	}
	[HarmonyPatch(typeof(MSGConversation), "SendMessage")]
	public class MSGConversation_SendMessage_Patch
	{
		private static bool Prefix(Message __0)
		{
			if (!CartelContact.TryFilterIncoming(__0, out var showLocally))
			{
				return true;
			}
			return showLocally;
		}
	}
	[HarmonyPatch]
	public class MessagingManager_ReceiveShowResponses_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo[] methods = typeof(MessagingManager).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo method in methods)
			{
				if (IsResponseTarget(method.Name))
				{
					ParameterInfo[] parameters = method.GetParameters();
					if (parameters.Length >= 1 && parameters[0].ParameterType == typeof(string))
					{
						yield return method;
					}
				}
			}
		}

		private static bool IsResponseTarget(string name)
		{
			return name == "ReceiveShowResponses";
		}

		private static bool Prefix(string __0)
		{
			if (string.IsNullOrEmpty(__0))
			{
				return true;
			}
			if (!string.Equals(__0, CartelContact.ResolvedId, StringComparison.OrdinalIgnoreCase) && !string.Equals(__0, "thomas_benzies", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return CartelContact.LocalOfferActive;
		}
	}
	[HarmonyPatch(typeof(MSGConversation), "ResponseChosen")]
	public class MSGConversation_ResponseChosen_Patch
	{
		private static void Prefix(Response __0)
		{
			if (__0 != null && (!(__0.label != "mrl_accept") || !(__0.label != "mrl_deny")) && !GameAccess.HasAuthority())
			{
				CartelContact.SendChoice(__0.label == "mrl_accept");
			}
		}
	}
	[HarmonyPatch(typeof(ProductManagerApp), "SetOpen")]
	public class ProductManagerApp_SetOpen_Patch
	{
		public static void Prefix(bool open)
		{
			if (open && LaunderingApp.IsPointerOverOurIcon())
			{
				LaunderingApp.OpeningTaxWash = true;
			}
		}

		public static void Postfix(bool open)
		{
			if (open && LaunderingApp.OpeningTaxWash)
			{
				LaunderingApp.ShowTaxWashInsteadOfProducts();
			}
		}
	}
}
namespace MoreRealisticLaundering.Laundering
{
	public static class BusinessUtil
	{
		public static string Canonical(string name)
		{
			return ConfigManager.Resolve(name);
		}

		public static string Display(string name)
		{
			string text = Canonical(name);
			return (text == "Post Office" || name == "PostOffice") ? "Post Office" : text;
		}

		public static bool IsKnown(string name)
		{
			switch (Canonical(name))
			{
			case "Laundromat":
			case "Taco Ticklers":
			case "Car Wash":
			case "Post Office":
				return true;
			default:
				return false;
			}
		}

		public static float PeakWeight(int hour)
		{
			if (hour < 6)
			{
				return 0.25f;
			}
			if (hour < 11)
			{
				return 0.75f;
			}
			if (hour < 14)
			{
				return 1.75f;
			}
			if (hour < 17)
			{
				return 1f;
			}
			if (hour < 21)
			{
				return 1.5f;
			}
			return 0.5f;
		}

		public static bool IsOpenAt(ConfigState config, string businessName, int hour)
		{
			if (config == null || !config.Use_Business_Hours)
			{
				return true;
			}
			var (num, num2) = ConfigManager.GetBusinessHours(config, businessName);
			if (num == num2)
			{
				return true;
			}
			if (num < num2)
			{
				return hour >= num && hour < num2;
			}
			return hour >= num || hour < num2;
		}
	}
	public class DripState
	{
		public LaunderingOperation Operation;

		public string BusinessName;

		public float Gross;

		public float Net;

		public float AlreadyPaid;

		public float TaxPaid;

		public bool IsCartel;

		public bool HasPaidAny;

		public bool CutPaid;

		public string AcceptedByPlayerCode;
	}
	public class DripTracker
	{
		private readonly Dictionary<LaunderingOperation, DripState> _states = new Dictionary<LaunderingOperation, DripState>();

		private bool _listening;

		public static DripTracker Instance { get; } = new DripTracker();

		public void Start()
		{
			if (!_listening)
			{
				try
				{
					TimeManager time = GameAccess.Time;
					if ((Object)(object)time != (Object)null)
					{
						time.onMinutePass += (Action)OnMinutePass;
						time.onTimeSkip = (Action<int>)Delegate.Combine(time.onTimeSkip, new Action<int>(OnTimeSkip));
					}
					_listening = true;
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Failed to subscribe TimeManager: " + ex.Message);
				}
			}
			CatchUpAll();
		}

		public void Stop()
		{
			if (!_listening)
			{
				return;
			}
			try
			{
				TimeManager time = GameAccess.Time;
				if ((Object)(object)time != (Object)null)
				{
					time.onMinutePass -= (Action)OnMinutePass;
					time.onTimeSkip = (Action<int>)Delegate.Remove(time.onTimeSkip, new Action<int>(OnTimeSkip));
				}
			}
			catch
			{
			}
			_listening = false;
			_states.Clear();
		}

		public void Track(LaunderingOperation operation, bool isCartel = false)
		{
			if (operation == null || (Object)(object)operation.business == (Object)null)
			{
				return;
			}
			CartelJobRecord cartelJobRecord = CartelJobStore.Find(operation);
			bool flag = isCartel || cartelJobRecord != null;
			float num = cartelJobRecord?.Amount ?? 0f;
			if (_states.TryGetValue(operation, out var value))
			{
				if (flag)
				{
					value.IsCartel = true;
				}
				if (value.Gross <= 1f && num > 1f)
				{
					value.Gross = num;
				}
				if (cartelJobRecord != null && string.IsNullOrEmpty(value.AcceptedByPlayerCode))
				{
					value.AcceptedByPlayerCode = cartelJobRecord.AcceptedByPlayerCode;
				}
				return;
			}
			float num2 = ((operation.amount > 1f) ? operation.amount : num);
			if (num2 <= 1f)
			{
				num2 = operation.amount;
			}
			float num3 = (flag ? 0f : (ConfigManager.GetTaxationPercentage(MRLCore.Instance.config, ((Object)operation.business).name) / 100f));
			float net = Mathf.Max(0f, num2 - (float)Mathf.RoundToInt(num2 * num3));
			_states[operation] = new DripState
			{
				Operation = operation,
				BusinessName = BusinessUtil.Display(((Object)operation.business).name),
				Gross = num2,
				Net = net,
				AlreadyPaid = 0f,
				IsCartel = flag,
				AcceptedByPlayerCode = cartelJobRecord?.AcceptedByPlayerCode
			};
		}

		public void PrepareCartelCompletion(LaunderingOperation operation)
		{
			Track(operation, isCartel: true);
			if (_states.TryGetValue(operation, out var value))
			{
				value.IsCartel = true;
				CartelJobRecord cartelJobRecord = CartelJobStore.Find(operation);
				if (value.Gross <= 1f && cartelJobRecord != null)
				{
					value.Gross = cartelJobRecord.Amount;
				}
				if (cartelJobRecord != null && string.IsNullOrEmpty(value.AcceptedByPlayerCode))
				{
					value.AcceptedByPlayerCode = cartelJobRecord.AcceptedByPlayerCode;
				}
			}
		}

		public DripState GetState(LaunderingOperation operation)
		{
			if (operation == null)
			{
				return null;
			}
			if (_states.TryGetValue(operation, out var value))
			{
				return value;
			}
			return null;
		}

		public void GetDisplayProgress(LaunderingOperation operation, out float deposited, out float remaining)
		{
			deposited = 0f;
			remaining = 0f;
			if (operation != null)
			{
				Track(operation, CartelJobStore.IsCartelJob(operation));
				DripState state = GetState(operation);
				if (state != null && state.IsCartel)
				{
					deposited = 0f;
					remaining = state.Gross;
					return;
				}
				float num = state?.Net ?? operation.amount;
				int num2 = Mathf.Max(1, operation.completionTime_Minutes);
				int num3 = Mathf.Clamp(operation.minutesSinceStarted, 0, num2);
				deposited = Mathf.Floor(num * (float)num3 / (float)num2);
				remaining = Mathf.Max(0f, num - deposited);
			}
		}

		public float GetDeposited(LaunderingOperation operation)
		{
			GetDisplayProgress(operation, out var deposited, out var _);
			return deposited;
		}

		public float GetRemaining(LaunderingOperation operation)
		{
			if (operation == null)
			{
				return 0f;
			}
			float num = GetState(operation)?.Net ?? operation.amount;
			return Mathf.Max(0f, num - GetDeposited(operation));
		}

		public bool ShouldSuppressVanillaPayout(LaunderingOperation operation)
		{
			if (operation == null || MRLCore.Instance?.config == null)
			{
				return false;
			}
			if (!CartelJobStore.IsCartelJob(operation))
			{
				DripState state = GetState(operation);
				if (state == null || !state.IsCartel)
				{
					DripState state2 = GetState(operation);
					if (state2 != null && (state2.IsCartel || state2.HasPaidAny))
					{
						return true;
					}
					return MRLCore.Instance.config.Use_Drip_Payout;
				}
			}
			return true;
		}

		public void OnFinished(LaunderingOperation operation)
		{
			if (operation == null)
			{
				return;
			}
			Track(operation, CartelService.IsCartelOperation(operation));
			if (!_states.TryGetValue(operation, out var value))
			{
				return;
			}
			if (value.IsCartel || CartelService.IsCartelOperation(operation))
			{
				if (value.CutPaid)
				{
					_states.Remove(operation);
					return;
				}
				value.IsCartel = true;
				value.CutPaid = true;
				CartelJobRecord cartelJobRecord = CartelJobStore.Find(operation);
				if (value.Gross <= 1f && cartelJobRecord != null)
				{
					value.Gross = cartelJobRecord.Amount;
				}
				if (cartelJobRecord != null && string.IsNullOrEmpty(value.AcceptedByPlayerCode))
				{
					value.AcceptedByPlayerCode = cartelJobRecord.AcceptedByPlayerCode;
				}
				CartelService.OnCartelJobFinished(value);
				CartelJobStore.Remove(operation);
				_states.Remove(operation);
			}
			else
			{
				if (MRLCore.Instance.config.Use_Drip_Payout)
				{
					PayDifference(value, value.Net);
				}
				_states.Remove(operation);
			}
		}

		private void OnMinutePass()
		{
			CatchUpAll();
		}

		private void OnTimeSkip(int minutes)
		{
			CatchUpAll();
		}

		public void CatchUpAll()
		{
			if (MRLCore.Instance?.config == null)
			{
				return;
			}
			MRLCore.Instance.ReapplyLaunderingTimes();
			if (!GameAccess.IsHost())
			{
				return;
			}
			try
			{
				if (Business.OwnedBusinesses == null)
				{
					return;
				}
				foreach (Business ownedBusiness in Business.OwnedBusinesses)
				{
					if (ownedBusiness?.LaunderingOperations == null)
					{
						continue;
					}
					foreach (LaunderingOperation launderingOperation in ownedBusiness.LaunderingOperations)
					{
						if (launderingOperation != null)
						{
							Track(launderingOperation, CartelJobStore.IsCartelJob(launderingOperation));
							if (_states.TryGetValue(launderingOperation, out var value) && !value.IsCartel && MRLCore.Instance.config.Use_Drip_Payout)
							{
								PayDifference(value, ExpectedAmount(value, launderingOperation));
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Drip catch-up failed: " + ex.Message);
			}
			CartelService.TickJobs();
		}

		private float ExpectedAmount(DripState state, LaunderingOperation live = null)
		{
			LaunderingOperation val = ((live != null) ? live : state.Operation);
			if (val == null)
			{
				return 0f;
			}
			int num = Mathf.Max(1, val.completionTime_Minutes);
			int num2 = Mathf.Clamp(val.minutesSinceStarted, 0, num);
			if (num2 >= num)
			{
				return state.Net;
			}
			int num3 = Mathf.Max(1, MRLCore.Instance.config.Drip_Interval_Minutes);
			int num4 = Mathf.Max(1, num / num3);
			int num5 = Mathf.Min(num4, num2 / num3);
			float num6 = 0f;
			float num7 = 0f;
			int num8 = GameAccess.CurrentHour();
			for (int i = 1; i <= num4; i++)
			{
				int num9 = i * num3 - num2;
				int hour = ModHour(num8 + Mathf.FloorToInt((float)num9 / 60f));
				bool flag = BusinessUtil.IsOpenAt(MRLCore.Instance.config, state.BusinessName, hour);
				float num10 = 0f;
				if (flag)
				{
					num10 = (MRLCore.Instance.config.Use_Peak_Hour_Variance ? BusinessUtil.PeakWeight(hour) : 1f);
				}
				num6 += num10;
				if (i <= num5)
				{
					num7 += num10;
				}
			}
			if (num6 <= 0f)
			{
				return Mathf.Floor(state.Net * (float)num2 / (float)num);
			}
			return Mathf.Min(state.Net, state.Net * (num7 / num6));
		}

		private static int ModHour(int hour)
		{
			hour %= 24;
			if (hour < 0)
			{
				hour += 24;
			}
			return hour;
		}

		private void PayDifference(DripState state, float expected)
		{
			float num = Mathf.Floor(expected - state.AlreadyPaid);
			if (!(num < 1f))
			{
				float num2 = Mathf.Max(0f, state.Gross - state.Net);
				float num3 = ((expected >= state.Net - 0.5f) ? Mathf.Max(0f, num2 - state.TaxPaid) : ((!(state.Net <= 0f)) ? Mathf.Round(num / state.Net * num2) : 0f));
				if (Deposit(state, num, num3))
				{
					state.AlreadyPaid += num;
					state.TaxPaid += num3;
					state.HasPaidAny = true;
					LaunderingInterface_Open_Patch.RefreshOpenInterfaces();
				}
			}
		}

		private bool Deposit(DripState state, float netSlice, float taxSlice)
		{
			MoneyManager moneyManager = MRLCore.Instance.moneyManager;
			if ((Object)(object)moneyManager == (Object)null || netSlice <= 0f)
			{
				return false;
			}
			ConfigState config = MRLCore.Instance.config;
			float num = 0f;
			if (!state.IsCartel && config.Use_Protection_Cut && !CartelService.IsCartelDefeated())
			{
				num = Mathf.RoundToInt(netSlice * (config.Protection_Cut_Percentage / 100f));
			}
			float num2 = netSlice + Mathf.Max(0f, taxSlice);
			if (num2 > 0f)
			{
				moneyManager.CreateOnlineTransaction(state.BusinessName + " laundering", num2, 1f, state.BusinessName + " laundering");
			}
			if (taxSlice > 0f)
			{
				moneyManager.CreateOnlineTransaction("Tax for " + state.BusinessName, 0f - taxSlice, 1f, "Tax for " + state.BusinessName);
			}
			if (num > 0f)
			{
				moneyManager.CreateOnlineTransaction("Cartel protection", 0f - num, 1f, "Cartel protection");
			}
			float num3 = netSlice - num;
			if (num3 > 0f)
			{
				MRLCore.Instance.NotifyDripPayout(state.BusinessName, num3);
			}
			if (taxSlice > 0f)
			{
				MRLCore.Instance.NotifyTaxDeduction(state.BusinessName, taxSlice);
			}
			if (num > 0f)
			{
				MRLCore.Instance.NotifyCartelDues(num);
			}
			return true;
		}
	}
	public static class GameAccess
	{
		public static TimeManager Time => NetworkSingleton<TimeManager>.Instance;

		public static bool HasAuthority()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if ((Object)(object)networkManager == (Object)null)
				{
					return true;
				}
				if (networkManager.IsServer)
				{
					return true;
				}
				if (!networkManager.IsClient)
				{
					return true;
				}
				return false;
			}
			catch
			{
				return true;
			}
		}

		public static bool IsHost()
		{
			return HasAuthority();
		}

		public static bool IsDedicatedServer()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				return (Object)(object)networkManager != (Object)null && networkManager.IsServer && !networkManager.IsClient;
			}
			catch
			{
				return false;
			}
		}

		public static bool IsWorldLoaded()
		{
			try
			{
				LoadManager instance = Singleton<LoadManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				if (instance.IsLoading)
				{
					return false;
				}
				return instance.IsGameLoaded;
			}
			catch
			{
				return false;
			}
		}

		public static string LocalPlayerCode()
		{
			try
			{
				foreach (Player item in EnumeratePlayers())
				{
					if (item.IsLocalPlayer)
					{
						return item.PlayerCode;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		public static List<Player> CollectPlayers()
		{
			List<Player> list = new List<Player>();
			try
			{
				foreach (Player item in EnumeratePlayers())
				{
					if (!string.IsNullOrEmpty(item.PlayerCode))
					{
						list.Add(item);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to list players: " + ex.Message);
			}
			return list.OrderBy<Player, string>((Player p) => p.PlayerCode, StringComparer.Ordinal).ToList();
		}

		public static Player FindPlayer(string playerCode)
		{
			if (string.IsNullOrEmpty(playerCode))
			{
				return null;
			}
			foreach (Player item in CollectPlayers())
			{
				if (string.Equals(item.PlayerCode, playerCode, StringComparison.Ordinal))
				{
					return item;
				}
			}
			return null;
		}

		private static IEnumerable<Player> EnumeratePlayers()
		{
			List<Player> list = Player.PlayerList;
			if (list == null)
			{
				yield break;
			}
			for (int i = 0; i < list.Count; i++)
			{
				Player player = list[i];
				if ((Object)(object)player != (Object)null)
				{
					yield return player;
				}
			}
		}

		public static int CurrentHour()
		{
			try
			{
				TimeManager time = Time;
				if ((Object)(object)time == (Object)null)
				{
					return 12;
				}
				return Mathf.Clamp(time.CurrentTime / 100, 0, 23);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to read game hour: " + ex.Message);
				return 12;
			}
		}

		public static int ElapsedDays()
		{
			try
			{
				TimeManager time = Time;
				return ((Object)(object)time != (Object)null) ? time.ElapsedDays : 0;
			}
			catch
			{
				return 0;
			}
		}
	}
}
namespace MoreRealisticLaundering.Config
{
	public class CleanFloatConverter : JsonConverter
	{
		public override bool CanConvert(Type objectType)
		{
			return objectType == typeof(float);
		}

		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			return Convert.ToSingle(reader.Value);
		}

		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			writer.WriteRawValue(((float)value).ToString("0.##", CultureInfo.InvariantCulture));
		}
	}
	public static class ConfigManager
	{
		private static bool isConfigUpdated;

		private static bool isFirstFailure = true;

		private static readonly string ConfigFolder = Path.Combine(MelonEnvironment.UserDataDirectory, "MoreRealisticLaundering");

		public static readonly string FilePath = Path.Combine(ConfigFolder, "MoreRealisticLaundering.json");

		public static ConfigState Load()
		{
			ConfigState configState = new ConfigState();
			if (!Directory.Exists(ConfigFolder))
			{
				Directory.CreateDirectory(ConfigFolder);
			}
			if (!File.Exists(FilePath))
			{
				MelonLogger.Warning("Config file not found. Creating a new one with default values.");
				Save(configState);
				return configState;
			}
			try
			{
				string text = File.ReadAllText(FilePath);
				ConfigState configState2 = JsonConvert.DeserializeObject<ConfigState>(text) ?? new ConfigState();
				isConfigUpdated = false;
				ValidateConfigSettings(configState2, configState, ref isConfigUpdated);
				if (isConfigUpdated)
				{
					Save(configState2);
					isConfigUpdated = false;
				}
				return configState2;
			}
			catch
			{
				if (isFirstFailure)
				{
					MelonLogger.Warning("Failed to read MoreRealisticLaundering config. Recreating config file. Please restart the game.");
					isFirstFailure = false;
					ResetConfig();
					return MRLCore.Instance.config = Load();
				}
				MelonLogger.Error("Failed to read MoreRealisticLaundering config. Please check the file structure.");
				return configState;
			}
		}

		public static void ResetConfig()
		{
			try
			{
				if (File.Exists(FilePath))
				{
					File.Delete(FilePath);
				}
				Save(new ConfigState());
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Failed to reset MoreRealisticLaundering.json: " + ex.Message);
			}
		}

		public static void Save(ConfigState config)
		{
			try
			{
				File.WriteAllText(FilePath, JsonConvert.SerializeObject((object)config, (Formatting)1));
				MelonLogger.Msg("Configuration saved successfully.");
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Failed to save MoreRealisticLaundering config: " + ex.Message);
			}
		}

		public static int GetLaunderingTimeHours(ConfigState config, string businessName)
		{
			string text = Resolve(businessName);
			if (1 == 0)
			{
			}
			int result = text switch
			{
				"Laundromat" => config.Businesses.Laundromat.Laundromat_Laundering_time_hours, 
				"Taco Ticklers" => config.Businesses.TacoTicklers.Taco_Ticklers_Laundering_time_hours, 
				"Car Wash" => config.Businesses.CarWash.Car_Wash_Laundering_time_hours, 
				"Post Office" => config.Businesses.PostOffice.Post_Office_Laundering_time_hours, 
				_ => 24, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetTaxationPercentage(ConfigState config, string businessName)
		{
			string text = Resolve(businessName);
			if (1 == 0)
			{
			}
			float result = text switch
			{
				"Laundromat" => config.Businesses.Laundromat.Laundromat_Tax_Percentage, 
				"Taco Ticklers" => config.Businesses.TacoTicklers.Taco_Ticklers_Tax_Percentage, 
				"Car Wash" => config.Businesses.CarWash.Car_Wash_Tax_Percentage, 
				"Post Office" => config.Businesses.PostOffice.Post_Office_Tax_Percentage, 
				_ => 19f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetCap(ConfigState config, string businessName)
		{
			string text = Resolve(businessName);
			if (1 == 0)
			{
			}
			float result = text switch
			{
				"Laundromat" => config.Businesses.Laundromat.Laundromat_Cap, 
				"Taco Ticklers" => config.Businesses.TacoTicklers.Taco_Ticklers_Cap, 
				"Car Wash" => config.Businesses.CarWash.Car_Wash_Cap, 
				"Post Office" => config.Businesses.PostOffice.Post_Office_Cap, 
				_ => 2000f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static (int open, int close) GetBusinessHours(ConfigState config, string businessName)
		{
			string text = Resolve(businessName);
			if (1 == 0)
			{
			}
			(int, int) result = text switch
			{
				"Laundromat" => (config.Businesses.Laundromat.Open_Hour, config.Businesses.Laundromat.Close_Hour), 
				"Taco Ticklers" => (config.Businesses.TacoTicklers.Open_Hour, config.Businesses.TacoTicklers.Close_Hour), 
				"Car Wash" => (config.Businesses.CarWash.Open_Hour, config.Businesses.CarWash.Close_Hour), 
				"Post Office" => (config.Businesses.PostOffice.Open_Hour, config.Businesses.PostOffice.Close_Hour), 
				_ => (0, 24), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string Resolve(string businessName)
		{
			if (string.IsNullOrEmpty(businessName))
			{
				return string.Empty;
			}
			string text = businessName.Trim().ToLowerInvariant().Replace("_", " ");
			if (1 == 0)
			{
			}
			string result;
			switch (text)
			{
			case "laundromat":
				result = "Laundromat";
				break;
			case "taco ticklers":
			case "tacoticklers":
				result = "Taco Ticklers";
				break;
			case "car wash":
			case "carwash":
				result = "Car Wash";
				break;
			case "post office":
			case "postoffice":
				result = "Post Office";
				break;
			default:
				result = businessName;
				break;
			}
			if (1 == 0)
			{
			}
			return result;
		}

		private static void ValidateConfigSettings(ConfigState loaded, ConfigState defaults, ref bool updated)
		{
			if (loaded.Drip_Interval_Minutes < 1)
			{
				loaded.Drip_Interval_Minutes = defaults.Drip_Interval_Minutes;
				updated = true;
			}
			if (loaded.Cartel_Timeout_Minutes_IRL < 1)
			{
				loaded.Cartel_Timeout_Minutes_IRL = defaults.Cartel_Timeout_Minutes_IRL;
				updated = true;
			}
			if (loaded.Cartel_Request_Cooldown_Hours < 1)
			{
				loaded.Cartel_Request_Cooldown_Hours = defaults.Cartel_Request_Cooldown_Hours;
				updated = true;
			}
			if (loaded.Cartel_Request_Min_Amount < 1)
			{
				loaded.Cartel_Request_Min_Amount = defaults.Cartel_Request_Min_Amount;
				updated = true;
			}
			ClampPercent(ref loaded.Protection_Cut_Percentage, defaults.Protection_Cut_Percentage, ref updated, "Protection_Cut_Percentage");
			ClampPercent(ref loaded.Cartel_Wash_Cut_Percentage, defaults.Cartel_Wash_Cut_Percentage, ref updated, "Cartel_Wash_Cut_Percentage");
			if (loaded.Cartel_Request_Min_Influence < 0f || loaded.Cartel_Request_Min_Influence > 1f)
			{
				loaded.Cartel_Request_Min_Influence = defaults.Cartel_Request_Min_Influence;
				updated = true;
			}
			if (loaded.Cartel_Accept_Influence < 0f || loaded.Cartel_Accept_Influence > 1f)
			{
				loaded.Cartel_Accept_Influence = defaults.Cartel_Accept_Influence;
				updated = true;
			}
			if (loaded.Cartel_Deny_Influence < 0f || loaded.Cartel_Deny_Influence > 1f)
			{
				loaded.Cartel_Deny_Influence = defaults.Cartel_Deny_Influence;
				updated = true;
			}
			ValidateBusiness(ref loaded.Businesses.Laundromat.Laundromat_Cap, defaults.Businesses.Laundromat.Laundromat_Cap, ref updated, "Laundromat_Cap");
			ValidateHours(ref loaded.Businesses.Laundromat.Laundromat_Laundering_time_hours, defaults.Businesses.Laundromat.Laundromat_Laundering_time_hours, ref updated, "Laundromat_Laundering_time_hours");
			ClampPercent(ref loaded.Businesses.Laundromat.Laundromat_Tax_Percentage, defaults.Businesses.Laundromat.Laundromat_Tax_Percentage, ref updated, "Laundromat_Tax_Percentage");
			ValidateBusiness(ref loaded.Businesses.PostOffice.Post_Office_Cap, defaults.Businesses.PostOffice.Post_Office_Cap, ref updated, "Post_Office_Cap");
			ValidateHours(ref loaded.Businesses.PostOffice.Post_Office_Laundering_time_hours, defaults.Businesses.PostOffice.Post_Office_Laundering_time_hours, ref updated, "Post_Office_Laundering_time_hours");
			ClampPercent(ref loaded.Businesses.PostOffice.Post_Office_Tax_Percentage, defaults.Businesses.PostOffice.Post_Office_Tax_Percentage, ref updated, "Post_Office_Tax_Percentage");
			ValidateBusiness(ref loaded.Businesses.CarWash.Car_Wash_Cap, defaults.Businesses.CarWash.Car_Wash_Cap, ref updated, "Car_Wash_Cap");
			ValidateHours(ref loaded.Businesses.CarWash.Car_Wash_Laundering_time_hours, defaults.Businesses.CarWash.Car_Wash_Laundering_time_hours, ref updated, "Car_Wash_Laundering_time_hours");
			ClampPercent(ref loaded.Businesses.CarWash.Car_Wash_Tax_Percentage, defaults.Businesses.CarWash.Car_Wash_Tax_Percentage, ref updated, "Car_Wash_Tax_Percentage");
			ValidateBusiness(ref loaded.Businesses.TacoTicklers.Taco_Ticklers_Cap, defaults.Businesses.TacoTicklers.Taco_Ticklers_Cap, ref updated, "Taco_Ticklers_Cap");
			ValidateHours(ref loaded.Businesses.TacoTicklers.Taco_Ticklers_Laundering_time_hours, defaults.Businesses.TacoTicklers.Taco_Ticklers_Laundering_time_hours, ref updated, "Taco_Ticklers_Laundering_time_hours");
			ClampPercent(ref loaded.Businesses.TacoTicklers.Taco_Ticklers_Tax_Percentage, defaults.Businesses.TacoTicklers.Taco_Ticklers_Tax_Percentage, ref updated, "Taco_Ticklers_Tax_Percentage");
		}

		private static void ValidateBusiness(ref float value, float fallback, ref bool updated, string name)
		{
			if (value <= 0f)
			{
				MelonLogger.Warning($"Invalid {name} in config. Reverting to default ({fallback}).");
				value = fallback;
				updated = true;
			}
		}

		private static void ValidateHours(ref int value, int fallback, ref bool updated, string name)
		{
			if (value < 2 || value % 2 != 0)
			{
				MelonLogger.Warning($"Invalid {name} in config. Reverting to default ({fallback}).");
				value = fallback;
				updated = true;
			}
		}

		private static void ClampPercent(ref float value, float fallback, ref bool updated, string name)
		{
			if (value < 0f || value > 100f)
			{
				MelonLogger.Warning($"Invalid {name} in config. Reverting to default ({fallback}).");
				value = fallback;
				updated = true;
			}
		}
	}
	public class ConfigState
	{
		public bool Use_Legit_Version = false;

		public bool Use_Drip_Payout = true;

		public int Drip_Interval_Minutes = 60;

		public bool Use_Business_Hours = false;

		public bool Use_Peak_Hour_Variance = true;

		public bool Use_Protection_Cut = true;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Protection_Cut_Percentage = 10f;

		public bool Use_Cartel_Requests = true;

		public bool Notify_Drip_Payouts = true;

		public bool Notify_Tax_Deductions = true;

		public bool Notify_Cartel_Dues = true;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Cartel_Wash_Cut_Percentage = 15f;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Cartel_Request_Min_Influence = 0.25f;

		public int Cartel_Request_Cooldown_Hours = 12;

		public int Cartel_Request_Min_Amount = 200;

		public int Cartel_Timeout_Minutes_IRL = 5;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Cartel_Accept_Influence = 0.02f;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Cartel_Deny_Influence = 0.03f;

		public BusinessSettings Businesses { get; set; } = new BusinessSettings();
	}
	public class BusinessSettings
	{
		public LaundromatSettings Laundromat { get; set; } = new LaundromatSettings();

		public PostOfficeSettings PostOffice { get; set; } = new PostOfficeSettings();

		public CarWashSettings CarWash { get; set; } = new CarWashSettings();

		public TacoTicklersSettings TacoTicklers { get; set; } = new TacoTicklersSettings();
	}
	public class LaundromatSettings
	{
		[JsonConverter(typeof(CleanFloatConverter))]
		public float Laundromat_Cap = 2000f;

		public int Laundromat_Laundering_time_hours = 24;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Laundromat_Tax_Percentage = 19f;

		public int Open_Hour = 6;

		public int Close_Hour = 22;
	}
	public class PostOfficeSettings
	{
		[JsonConverter(typeof(CleanFloatConverter))]
		public float Post_Office_Cap = 4000f;

		public int Post_Office_Laundering_time_hours = 24;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Post_Office_Tax_Percentage = 19f;

		public int Open_Hour = 8;

		public int Close_Hour = 17;
	}
	public class CarWashSettings
	{
		[JsonConverter(typeof(CleanFloatConverter))]
		public float Car_Wash_Cap = 6000f;

		public int Car_Wash_Laundering_time_hours = 24;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Car_Wash_Tax_Percentage = 19f;

		public int Open_Hour = 8;

		public int Close_Hour = 18;
	}
	public class TacoTicklersSettings
	{
		[JsonConverter(typeof(CleanFloatConverter))]
		public float Taco_Ticklers_Cap = 8000f;

		public int Taco_Ticklers_Laundering_time_hours = 24;

		[JsonConverter(typeof(CleanFloatConverter))]
		public float Taco_Ticklers_Tax_Percentage = 19f;

		public int Open_Hour = 11;

		public int Close_Hour = 23;
	}
}
namespace MoreRealisticLaundering.Cartel
{
	internal static class CartelContact
	{
		internal const string ThomasId = "thomas_benzies";

		internal const string AcceptLabel = "mrl_accept";

		internal const string DenyLabel = "mrl_deny";

		internal const string TargetMarker = "\u2063MRLTO:";

		internal const string CommandAccept = "\u2063MRLCMD:ACCEPT";

		internal const string CommandDeny = "\u2063MRLCMD:DENY";

		internal const char MarkerEnd = '\u2063';

		private static readonly string[] CandidateIds = new string[4] { "thomas_benzies", "thomas", "ThomasBenzies", "thomasbenzies" };

		private static NPC _npc;

		internal static bool LocalOfferActive;

		internal static string ResolvedId
		{
			get
			{
				try
				{
					NPC obj = Resolve();
					string text = ((obj != null) ? obj.ID : null);
					return string.IsNullOrEmpty(text) ? "thomas_benzies" : text;
				}
				catch
				{
					return "thomas_benzies";
				}
			}
		}

		internal static void Reset()
		{
			_npc = null;
			LocalOfferActive = false;
		}

		internal static NPC Resolve()
		{
			if (IsUsable(_npc))
			{
				return _npc;
			}
			_npc = null;
			string[] candidateIds = CandidateIds;
			foreach (string text in candidateIds)
			{
				try
				{
					NPC nPC = NPCManager.GetNPC(text);
					if (IsUsable(nPC))
					{
						_npc = nPC;
						return _npc;
					}
				}
				catch
				{
				}
			}
			try
			{
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				if (nPCRegistry != null)
				{
					foreach (NPC item in nPCRegistry)
					{
						if (IsThomas(item) && IsUsable(item))
						{
							_npc = item;
							return _npc;
						}
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to scan NPC registry for Thomas Benzies: " + ex.Message);
			}
			try
			{
				Thomas npc = Object.FindObjectOfType<Thomas>(true);
				if (IsUsable((NPC)(object)npc))
				{
					_npc = (NPC)(object)npc;
					return _npc;
				}
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("Failed to find Thomas Benzies in the scene: " + ex2.Message);
			}
			return null;
		}

		internal static bool AskToWash(float amount, string targetPlayerCode)
		{
			return TrySend($"Need ${amount:N0} cleaned. Can you run it through one of your fronts?", withChoices: true, targetPlayerCode);
		}

		internal static bool EnsureReady()
		{
			if (!GameAccess.IsWorldLoaded())
			{
				return false;
			}
			NPC val = Resolve();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			EnsureKnown(val);
			return val.MSGConversation != null;
		}

		internal static void SendPaid(float cut, string businessName, string targetPlayerCode = null)
		{
			TrySend($"It's clean. Your cut for {businessName} is ${cut:N0}. Don't make us wait next time.", withChoices: false, targetPlayerCode);
		}

		internal static void SendDenied(string targetPlayerCode)
		{
			TrySend("Your loss. We remember who helps.", withChoices: false, targetPlayerCode);
		}

		internal static void SendAccepted(string businessName, string targetPlayerCode)
		{
			TrySend("Good. It's going through " + businessName + ". Keep the machines running.", withChoices: false, targetPlayerCode);
		}

		internal static void SendNoRoom(string targetPlayerCode)
		{
			TrySend("You accepted, but none of your fronts have room. Don't waste our time.", withChoices: false, targetPlayerCode);
		}

		internal static void SendChoice(bool accept)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			try
			{
				NPC val = Resolve();
				MessagingManager instance = NetworkSingleton<MessagingManager>.Instance;
				if (!((Object)(object)val == (Object)null) && !((Object)(object)instance == (Object)null))
				{
					string text = (accept ? "\u2063MRLCMD:ACCEPT" : "\u2063MRLCMD:DENY");
					Message val2 = new Message(text, (ESenderType)1, false, Random.Range(int.MinValue, int.MaxValue));
					instance.SendMessage(val2, false, val.ID);
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to send wash reply to the server: " + ex.Message);
			}
		}

		internal static bool TryHandleCommand(Message message)
		{
			if (message == null || string.IsNullOrEmpty(message.text))
			{
				return false;
			}
			if (message.text.StartsWith("\u2063MRLCMD:ACCEPT", StringComparison.Ordinal))
			{
				CartelService.AcceptPending();
				return true;
			}
			if (message.text.StartsWith("\u2063MRLCMD:DENY", StringComparison.Ordinal))
			{
				CartelService.DenyPending();
				return true;
			}
			return false;
		}

		internal static bool TryFilterIncoming(Message message, out bool showLocally)
		{
			showLocally = true;
			if (message == null || string.IsNullOrEmpty(message.text))
			{
				return false;
			}
			if (message.text.StartsWith("\u2063MRLCMD:ACCEPT", StringComparison.Ordinal) || message.text.StartsWith("\u2063MRLCMD:DENY", StringComparison.Ordinal))
			{
				showLocally = false;
				return true;
			}
			if (!TryStripTarget(message, out var targetCode))
			{
				return false;
			}
			showLocally = (LocalOfferActive = string.Equals(targetCode, GameAccess.LocalPlayerCode(), StringComparison.Ordinal));
			return true;
		}

		private static bool IsUsable(NPC npc)
		{
			//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)
			if ((Object)(object)npc == (Object)null)
			{
				return false;
			}
			try
			{
				int result;
				if ((Object)(object)((Component)npc).gameObject != (Object)null)
				{
					Scene scene = ((Component)npc).gameObject.scene;
					result = (((Scene)(ref scene)).IsValid() ? 1 : 0);
				}
				else
				{
					result = 0;
				}
				return (byte)result != 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsThomas(NPC npc)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return false;
			}
			if (npc is Thomas)
			{
				return true;
			}
			try
			{
				string name = ((object)npc).GetType().Name;
				if (name.IndexOf("Thomas", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				string iD = npc.ID;
				if (!string.IsNullOrEmpty(iD) && (string.Equals(iD, "thomas_benzies", StringComparison.OrdinalIgnoreCase) || string.Equals(iD, "thomas", StringComparison.OrdinalIgnoreCase) || iD.IndexOf("benzies", StringComparison.OrdinalIgnoreCase) >= 0))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (string.Equals(npc.LastName, "Benzies", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				return string.Equals(npc.FirstName, "Thomas", StringComparison.OrdinalIgnoreCase) && (npc.FullName ?? string.Empty).IndexOf("Benzies", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			catch
			{
				return false;
			}
		}

		private static void EnsureKnown(NPC npc)
		{
			if (!GameAccess.IsWorldLoaded())
			{
				return;
			}
			try
			{
				if (npc.RelationData != null)
				{
					bool flag = false;
					try
					{
						flag = npc.RelationData.Unlocked || npc.RelationData.IsKnown();
					}
					catch
					{
						flag = npc.RelationData.Unlocked;
					}
					if (!flag)
					{
						npc.RelationData.Unlock((EUnlockType)1, false);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to unlock Thomas Benzies: " + ex.Message);
			}
			try
			{
				if (npc.MSGConversation == null)
				{
					npc.CreateMessageConversation();
				}
				MSGConversation mSGConversation = npc.MSGConversation;
				if (mSGConversation == null)
				{
					return;
				}
				try
				{
					if ((Object)(object)mSGConversation.sender == (Object)null)
					{
						mSGConversation.sender = npc;
					}
				}
				catch
				{
				}
				string text = null;
				try
				{
					text = npc.GetMessagingName();
				}
				catch
				{
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					try
					{
						text = npc.FullName;
					}
					catch
					{
					}
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "Thomas Benzies";
				}
				try
				{
					mSGConversation.contactName = text;
				}
				catch
				{
				}
				mSGConversation.SetIsKnown(true);
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("Failed to open Thomas Benzies' conversation: " + ex2.Message);
			}
		}

		private static bool TrySend(string message, bool withChoices = false, string targetPlayerCode = null)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			if (!GameAccess.HasAuthority())
			{
				return false;
			}
			try
			{
				NPC val = Resolve();
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				EnsureKnown(val);
				MSGConversation mSGConversation = val.MSGConversation;
				if (mSGConversation == null)
				{
					MelonLogger.Warning("Thomas Benzies has no message conversation.");
					return false;
				}
				mSGConversation.SetIsKnown(true);
				Player val2 = GameAccess.FindPlayer(targetPlayerCode);
				bool flag = (Object)(object)val2 != (Object)null && val2.IsLocalPlayer && !GameAccess.IsDedicatedServer();
				bool flag2 = !flag && !string.IsNullOrEmpty(targetPlayerCode);
				if (withChoices)
				{
					LocalOfferActive = flag;
				}
				string text = (flag2 ? ("\u2063MRLTO:" + targetPlayerCode + "\u2063" + message) : message);
				Message val3 = new Message(text, (ESenderType)1, true, Random.Range(int.MinValue, int.MaxValue));
				if (flag || (Object)(object)val2 == (Object)null)
				{
					if (withChoices)
					{
						LocalOfferActive = true;
					}
					mSGConversation.SendMessage(val3, true, false);
				}
				if (flag2 || ((Object)(object)val2 == (Object)null && GameAccess.IsDedicatedServer()))
				{
					MessagingManager instance = NetworkSingleton<MessagingManager>.Instance;
					if ((Object)(object)instance == (Object)null)
					{
						return false;
					}
					instance.SendMessage(val3, true, val.ID);
				}
				if (!withChoices)
				{
					return true;
				}
				mSGConversation.ClearResponses(false);
				List<Response> list = new List<Response>();
				list.Add(new Response("I'll wash it.", "mrl_accept", (Action)CartelService.AcceptPending, false));
				list.Add(new Response("Not this time.", "mrl_deny", (Action)CartelService.DenyPending, false));
				List<Response> list2 = list;
				if (flag || (Object)(object)val2 == (Object)null)
				{
					mSGConversation.ShowResponses(list2, 1f, false);
				}
				if (flag2 || ((Object)(object)val2 == (Object)null && GameAccess.IsDedicatedServer()))
				{
					MessagingManager instance2 = NetworkSingleton<MessagingManager>.Instance;
					if ((Object)(object)instance2 != (Object)null)
					{
						instance2.ShowResponses(val.ID, list2, 1f);
					}
				}
				string text2 = (((Object)(object)val2 != (Object)null) ? (val2.PlayerName + " (" + val2.PlayerCode + ")") : "the session");
				MelonLogger.Msg("Thomas Benzies sent a wash text to " + text2 + ".");
				return true;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Thomas Benzies text failed: " + ex.Message);
				return false;
			}
		}

		private static bool TryStripTarget(Message message, out string targetCode)
		{
			targetCode = null;
			string text = message.text;
			if (string.IsNullOrEmpty(text) || !text.StartsWith("\u2063MRLTO:", StringComparison.Ordinal))
			{
				return false;
			}
			int length = "\u2063MRLTO:".Length;
			int num = text.IndexOf('\u2063', length);
			if (num <= length)
			{
				return false;
			}
			targetCode = text.Substring(length, num - length);
			message.text = text.Substring(num + 1);
			return true;
		}
	}
	public class CartelJobRecord
	{
		public string BusinessName;

		public float Amount;

		public string AcceptedByPlayerCode;
	}
	public class CartelJobState
	{
		public long LastRequestGameMinutes;

		public bool PendingRequest;

		public float PendingAmount;

		public string PendingBusinessName;

		public string PendingTargetPlayerCode;

		public DateTime PendingStartedUtc;

		public string ContactNpcId;

		public List<CartelJobRecord> Jobs { get; set; } = new List<CartelJobRecord>();

		public List<string> OfferedPlayerCodes { get; set; } = new List<string>();
	}
	public static class CartelJobStore
	{
		private static readonly string FilePath = Path.Combine(MelonEnvironment.UserDataDirectory, "MoreRealisticLaundering", "CartelJobs.json");

		public static CartelJobState State { get; private set; } = new CartelJobState();

		public static void Load()
		{
			try
			{
				if (!File.Exists(FilePath))
				{
					State = new CartelJobState();
					return;
				}
				State = JsonConvert.DeserializeObject<CartelJobState>(File.ReadAllText(FilePath)) ?? new CartelJobState();
				if (State.Jobs == null)
				{
					State.Jobs = new List<CartelJobRecord>();
				}
				if (State.OfferedPlayerCodes == null)
				{
					State.OfferedPlayerCodes = new List<string>();
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to load cartel job store: " + ex.Message);
				State = new CartelJobState();
			}
		}

		public static void Save()
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(FilePath));
				File.WriteAllText(FilePath, JsonConvert.SerializeObject((object)State, (Formatting)1));
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save cartel job store: " + ex.Message);
			}
		}

		public static void Add(LaunderingOperation operation, string acceptedByPlayerCode = null)
		{
			if ((Object)(object)operation?.business == (Object)null)
			{
				return;
			}
			CartelJobRecord cartelJobRecord = Find(operation);
			if (cartelJobRecord != null)
			{
				if (string.IsNullOrEmpty(cartelJobRecord.AcceptedByPlayerCode) && !string.IsNullOrEmpty(acceptedByPlayerCode))
				{
					cartelJobRecord.AcceptedByPlayerCode = acceptedByPlayerCode;
					Save();
				}
				return;
			}
			float amount = operation.amount;
			if (!(amount <= 1f))
			{
				State.Jobs.Add(new CartelJobRecord
				{
					BusinessName = BusinessUtil.Canonical(((Object)operation.business).name),
					Amount = amount,
					AcceptedByPlayerCode = acceptedByPlayerCode
				});
				Save();
			}
		}

		public static void Remove(LaunderingOperation operation)
		{
			CartelJobRecord cartelJobRecord = Find(operation);
			if (cartelJobRecord != null)
			{
				State.Jobs.Remove(cartelJobRecord);
				Save();
			}
		}

		public static void Remove(CartelJobRecord job)
		{
			if (job != null && State?.Jobs != null)
			{
				State.Jobs.Remove(job);
				Save();
			}
		}

		public static CartelJobRecord Find(LaunderingOperation operation)
		{
			if ((Object)(object)operation?.business == (Object)null || State?.Jobs == null)
			{
				return null;
			}
			CartelJobRecord cartelJobRecord = State.Jobs.FirstOrDefault((CartelJobRecord j) => Matches(j, operation));
			if (cartelJobRecord != null)
			{
				return cartelJobRecord;
			}
			string name = BusinessUtil.Canonical(((Object)operation.business).name);
			List<CartelJobRecord> list = State.Jobs.Where((CartelJobRecord j) => j.BusinessName == name).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			if (operation.amount <= 1f)
			{
				return list.OrderByDescending((CartelJobRecord j) => j.Amount).First();
			}
			return list.FirstOrDefault((CartelJobRecord j) => MathfApproximately(j.Amount, operation.amount));
		}

		public static bool HasJobs()
		{
			return State?.Jobs != null && State.Jobs.Count > 0;
		}

		public static bool Matches(CartelJobRecord job, LaunderingOperation operation)
		{
			if (job == null || (Object)(object)operation?.business == (Object)null)
			{
				return false;
			}
			return job.BusinessName == BusinessUtil.Canonical(((Object)operation.business).name) && MathfApproximately(job.Amount, operation.amount);
		}

		public static bool IsCartelJob(LaunderingOperation operation)
		{
			return Find(operation) != null;
		}

		private static bool MathfApproximately(float a, float b)
		{
			return Math.Abs(a - b) < 1f;
		}
	}
	public static class CartelService
	{
		private static bool _running;

		private static bool _timeoutRunning;

		private static bool _hourListener;

		private static bool _offerDelivered;

		private static bool _worldReady;

		private static bool _armedStart;

		private static float _armedAmount;

		private static float _armedAt;

		private static string _armedPlayerCode;

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

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

		private static float _opsHydratedAt;

		private static float _worldReadyAt;

		private const float RequestCapFraction = 0.85f;

		public static void Start()
		{
			CartelJobStore.Load();
			if (!_running)
			{
				_running = true;
				_timeoutRunning = false;
				_offerDelivered = false;
				MelonLogger.Msg("Cartel wash service starting.");
				MelonCoroutines.Start(BootRoutine());
			}
		}

		public static void Stop()
		{
			_running = false;
			_timeoutRunning = false;
			_offerDelivered = false;
			_worldReady = false;
			_worldReadyAt = 0f;
			_seenLiveJobs.Clear();
			_paidJobKeys.Clear();
			_opsHydratedAt = 0f;
			UnsubscribeHour();
			CartelContact.Reset();
		}

		public static bool IsCartelDefeated()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			try
			{
				Cartel instance = Cartel.Instance;
				if (instance != null && (int)instance.Status == 3)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		public static void OnHourPass()
		{
			if (!_running || !GameAccess.HasAuthority() || MRLCore.Instance?.config == null || !MRLCore.Instance.config.Use_Cartel_Requests)
			{
				return;
			}
			CartelContact.EnsureReady();
			if (IsCartelDefeated())
			{
				return;
			}
			if (HasActiveCartelWash())
			{
				if (CartelJobStore.State.PendingRequest)
				{
					ClearPending();
				}
			}
			else if (CartelJobStore.State.PendingRequest)
			{
				if (!_offerDelivered)
				{
					TryOfferToNextPlayer();
				}
			}
			else
			{
				TrySendRequest();
			}
		}

		public static void TrySendRequest()
		{
			if (!GameAccess.HasAuthority() || MRLCore.Instance?.config == null)
			{
				return;
			}
			ConfigState config = MRLCore.Instance.config;
			CartelJobState state = CartelJobStore.State;
			if (!config.Use_Cartel_Requests || state.PendingRequest || HasActiveCartelWash() || GetMaxInfluence() < config.Cartel_Request_Min_Influence)
			{
				return;
			}
			AdoptContact();
			long num = CurrentGameMinutes();
			if ((state.LastRequestGameMinutes <= 0 || num - state.LastRequestGameMinutes >= config.Cartel_Request_Cooldown_Hours * 60) && TryRollAmount(out var amount, out var assignedHint))
			{
				state.PendingRequest = true;
				state.PendingAmount = amount;
				state.PendingBusinessName = (((Object)(object)assignedHint != (Object)null) ? BusinessUtil.Canonical(((Object)assignedHint).name) : null);
				state.PendingTargetPlayerCode = null;
				state.OfferedPlayerCodes = new List<string>();
				state.PendingStartedUtc = DateTime.UtcNow;
				state.LastRequestGameMinutes = num;
				CartelJobStore.Save();
				if (!TryOfferToNextPlayer())
				{
					MelonLogger.Warning("Cartel wash request is ready but no player could receive the text yet. Will retry.");
				}
			}
		}

		public static void AcceptPending()
		{
			if (!GameAccess.HasAuthority())
			{
				return;
			}
			CartelJobState state = CartelJobStore.State;
			if (state.PendingRequest)
			{
				float pendingAmount = state.PendingAmount;
				string pendingBusinessName = state.PendingBusinessName;
				string pendingTargetPlayerCode = state.PendingTargetPlayerCode;
				ClearPending();
				if (HasActiveCartelWash())
				{
					CartelContact.SendNoRoom(pendingTargetPlayerCode);
					return;
				}
				if (!TryAssignBusiness(pendingAmount, pendingBusinessName, out var business))
				{
					AdjustInfluence(0f - MRLCore.Instance.config.Cartel_Deny_Influence);
					CartelContact.SendNoRoom(pendingTargetPlayerCode);
					return;
				}
				ArmStart(pendingAmount, pendingTargetPlayerCode);
				business.StartLaunderingOperation(pendingAmount, 0);
				AdjustInfluence(MRLCore.Instance.config.Cartel_Accept_Influence);
				CartelContact.SendAccepted(BusinessUtil.Display(((Object)business).name), pendingTargetPlayerCode);
			}
		}

		public static void DenyPending()
		{
			if (GameAccess.HasAuthority() && CartelJobStore.State.PendingRequest)
			{
				PassCurrentOffer();
			}
		}

		public static void OnCartelJobFinished(DripState state)
		{
			if (state == null || !GameAccess.HasAuthority())
			{
				return;
			}
			string item = BusinessUtil.Canonical(state.BusinessName) + "|" + state.Gross.ToString("0");
			if (_paidJobKeys.Add(item))
			{
				MoneyManager val = MRLCore.Instance?.EnsureMoneyManager();
				float num = state.Gross;
				if (num <= 1f)
				{
					num = 0f;
				}
				float num2 = Mathf.RoundToInt(num * ((MRLCore.Instance?.config?.Cartel_Wash_Cut_Percentage ?? 15f) / 100f));
				if (num2 > 0f && (Object)(object)val != (Object)null)
				{
					val.CreateOnlineTransaction("Cartel wash cut", num2, 1f, "Cartel wash cut");
				}
				else if (num2 > 0f)
				{
					MelonLogger.Warning("Cartel wash finished but MoneyManager was missing; still sending the completion text.");
				}
				CartelContact.EnsureReady();
				CartelContact.SendPaid(num2, state.BusinessName, state.AcceptedByPlayerCode);
				MelonLogger.Msg("Cartel wash finished at " + state.BusinessName + ". Cut $" + num2.ToString("N0") + " sent.");
			}
		}

		private static void ClearPending()
		{
			CartelJobStore.State.PendingRequest = false;
			CartelJobStore.State.PendingAmount = 0f;
			CartelJobStore.State.PendingBusinessName = null;
			CartelJobStore.State.PendingTargetPlayerCode = null;
			CartelJobStore.State.OfferedPlayerCodes = new List<string>();
			CartelJobStore.Save();
			_timeoutRunning = false;
			_offerDelivered = false;
		}

		private static IEnumerator BootRoutine()
		{
			float waited = 0f;
			while (_running && (Object)(object)GameAccess.Time == (Object)null && waited < 30f)
			{
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			SubscribeHour();
			waited = 0f;
			while (_running && !GameAccess.IsWorldLoaded() && waited < 120f)
			{
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			waited = 0f;
			while (_running && (Object)(object)CartelContact.Resolve() == (Object)null && waited < 120f)
			{
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			if (!_running)
			{
				yield break;
			}
			waited = 0f;
			while (_running && waited < 15f && !CartelContact.EnsureReady())
			{
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			if ((Object)(object)CartelContact.Resolve() != (Object)null)
			{
				AdoptContact();
			}
			waited = 0f;
			while (_running && CollectOwned().Count == 0 && waited < 45f)
			{
				CartelContact.EnsureReady();
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			waited = 0f;
			while (_running && CollectLiveOperations().Count == 0 && CollectOwned().Count > 0 && waited < 8f)
			{
				CartelContact.EnsureReady();
				yield return (object)new WaitForSeconds(0.5f);
				waited += 0.5f;
			}
			if (_running)
			{
				_worldReady = CollectOwned().Count > 0;
				if (_worldReady)
				{
					_worldReadyAt = Time.realtimeSinceStartup;
					ReconcileJobs();
					MRLCore.Instance?.ReapplyLaunderingTimes();
					MelonLogger.Msg("Cartel wash service is ready.");
				}
				else
				{
					MelonLogger.Warning("Cartel wash service started but no owned fronts were ready yet.");
				}
				ResumeOrSend();
			}
		}

		private static void ResumeOrSend()
		{
			if (!_running || !GameAccess.HasAuthority() || MRLCore.Instance?.config == null || !MRLCore.Instance.config.Use_Cartel_Requests || IsCartelDefeated())
			{
				return;
			}
			if (HasActiveCartelWash())
			{
				if (CartelJobStore.State.PendingRequest)
				{
					ClearPending();
				}
				return;
			}
			CartelJobState state = CartelJobStore.State;
			if (!state.PendingRequest)
			{
				TrySendRequest();
			}
			else if (_offerDelivered && IsPendingExpired())
			{
				PassCurrentOffer();
			}
			else if (!_offerDelivered)
			{
				TryOfferToNextPlayer();
			}
		}

		public static void ArmStart(float amount, string playerCode = null)
		{
			_armedStart = true;
			_armedAmount = amount;
			_armedAt = Time.realtimeSinceStartup;
			_armedPlayerCode = playerCode;
		}

		public static bool TryClaimStart(LaunderingOperation operation)
		{
			if (!_armedStart || operation == null)
			{
				return false;
			}
			if (Time.realtimeSinceStartup - _armedAt > 15f)
			{
				_armedStart = false;
				_armedPlayerCode = null;
				return false;
			}
			if (Math.Abs(operation.amount - _armedAmount) > 1f)
			{
				return false;
			}
			_armedStart = false;
			return true;
		}

		public static string ConsumeArmedPlayerCode()
		{
			string armedPlayerCode = _armedPlayerCode;
			_armedPlayerCode = null;
			return armedPlayerCode;
		}

		public static bool IsCartelOperation(LaunderingOperation operation)
		{
			if (operation == null)
			{
				return false;
			}
			if (CartelJobStore.IsCartelJob(operation))
			{
				return true;
			}
			DripState state = DripTracker.Instance.GetState(operation);
			if (state != null && state.IsCartel)
			{
				return true;
			}
			return FindLiveMatch(operation) != null;
		}

		public static bool IsOperationComplete(LaunderingOperation operation)
		{
			if (operation == null)
			{
				return true;
			}
			int num = Mathf.Max(1, operation.completionTime_Minutes);
			return operation.minutesSinceStarted >= num;
		}

		public static bool HasActiveCartelWash()
		{
			foreach (LaunderingOperation item in CollectLiveOperations())
			{
				if (IsCartelOperation(item))
				{
					return true;
				}
			}
			return CartelJobStore.HasJobs();
		}

		private static void AdoptContact()
		{
			if ((Object)(object)CartelContact.Resolve() == (Object)null)
			{
				return;
			}
			string resolvedId = CartelContact.ResolvedId;
			CartelJobState state = CartelJobStore.State;
			if (!string.Equals(state.ContactNpcId, resolvedId, StringComparison.OrdinalIgnoreCase))
			{
				state.ContactNpcId = resolvedId;
				if (!state.PendingRequest && !CartelJobStore.HasJobs())
				{
					state.LastRequestGameMinutes = 0L;
				}
				CartelJobStore.Save();
				MelonLogger.Msg("Cartel wash texts now come from " + resolvedId + ".");
			}
		}

		private static bool TryDeliverOffer(float amount, string targetPlayerCode)
		{
			if (!CartelContact.EnsureReady())
			{
				MelonLogger.Warning("Thomas Benzies is not in the world yet.");
				return false;
			}
			if (!CartelContact.AskToWash(amount, targetPlayerCode))
			{
				return false;
			}
			_offerDelivered = true;
			return true;
		}

		private static bool TryOfferToNextPlayer()
		{
			CartelJobState state = CartelJobStore.State;
			if (!state.PendingRequest)
			{
				return false;
			}
			List<Player> list = GameAccess.CollectPlayers();
			if (list.Count == 0)
			{
				return false;
			}
			if (state.OfferedPlayerCodes == null)
			{
				state.OfferedPlayerCodes = new List<string>();
			}
			foreach (Player item in list)
			{
				if (state.OfferedPlayerCodes.Contains(item.PlayerCode) || !TryDeliverOffer(state.PendingAmount, item.PlayerCode))
				{
					continue;
				}
				state.OfferedPlayerCodes.Add(item.PlayerCode);
				state.PendingTargetPlayerCode = item.PlayerCode;
				state.PendingStartedUtc = DateTime.UtcNow;
				CartelJobStore.Save();
				StartTimeout(MRLCore.Instance.config.Cartel_Timeout_Minutes_IRL);
				return true;
			}
			return false;
		}

		private static void PassCurrentOffer()
		{
			_timeoutRunning = false;
			_offerDelivered = false;
			if (!TryOfferToNextPlayer())
			{
				ExpirePending();
			}
		}

		private static void ExpirePending()
		{
			string pendingTargetPlayerCode = CartelJobStore.State.PendingTargetPlayerCode;
			ClearPending();
			AdjustInfluence(0f - MRLCore.Instance.config.Cartel_Deny_Influence);
			CartelContact.SendDenied(pendingTargetPlayerCode);
		}

		private static bool IsPendingExpired()
		{
			DateTime pendingStartedUtc = CartelJobStore.State.PendingStartedUtc;
			if (pendingStartedUtc == default(DateTime) || pendingStartedUtc.Year < 2000)
			{
				return true;
			}
			int num = Mathf.Max(1, MRLCore.Instance.config.Cartel_Timeout_Minutes_IRL);
			return (DateTime.UtcNow - pendingStartedUtc).TotalMinutes >= (double)num;
		}

		private static void SubscribeHour()
		{
			if (_hourListener)
			{
				return;
			}
			try
			{
				TimeManager time = GameAccess.Time;
				if (!((Object)(object)time == (Object)null))
				{
					time.onHourPass = (Action)Delegate.Combine(time.onHourPass, new Action(OnHourPass));
					_hourListener = true;
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Cartel hour listener failed: " + ex.Message);
			}
		}

		private static void UnsubscribeHour()
		{
			if (!_hourListener)
			{
				return;
			}
			try
			{
				TimeManager time = GameAccess.Time;
				if ((Object)(object)time != (Object)null)
				{
					time.onHourPass = (Action)Delegate.Remove(time.onHourPass, new Action(OnHourPass));
				}
			}
			catch
			{
			}
			_hourListener = false;
		}

		private static void StartTimeout(int minutes)
		{
			_timeoutRunning = true;
			MelonCoroutines.Start(TimeoutRoutine(minutes));
		}

		private static IEnumerator TimeoutRoutine(int minutes)
		{
			DateTime started = CartelJobStore.State.PendingStartedUtc;
			yield return (object)new WaitForSeconds((float)Mathf.Max(1, minutes) * 60f);
			if (_timeoutRunning && CartelJobStore.State.PendingRequest && !(CartelJobStore.State.PendingStartedUtc != started))
			{
				PassCurrentOffer();
			}
		}

		private static bool TryRollAmount(out float amount, out Business assignedHint)
		{
			amount = 0f;
			assignedHint = null;
			List<Business> list = CollectOwned();
			if (list.Count == 0)
			{
				return false;
			}
			float num = MRLCore.Instance.config.Cartel_Request_Min_Amount;
			float num2 = -1f;
			foreach (Business item in list)
			{
				float num3 = MaxOfferFor(item);
				if (!(num3 < num))
				{
					float cap = ConfigManager.GetCap(MRLCore.Instance.config, ((Object)item).name);
					if ((!((Object)(object)assignedHint != (Object)null) || !(num3 < amount)) && (!((Object)(object)assignedHint != (Object)null) || !(Mathf.Abs(num3 - amount) < 0.5f) || !(cap <= num2)))
					{
						amount = num3;
						num2 = cap;
						assignedHint = item;
					}
				}
			}
			return (Object)(object)assignedHint != (Object)null;
		}

		private static float MaxOfferFor(Business business)
		{
			if ((Object)(object)business == (Object)null || MRLCore.Instance?.config == null)
			{
				return 0f;
			}
			float cap = ConfigManager.GetCap(MRLCore.Instance.config, ((Object)business).name);
			float num = Mathf.Floor(cap * 0.85f);
			float num2 = RemainingRoom(business);
			return Mathf.Floor(Mathf.Min(num, num2));
		}

		private static bool TryAssignBusiness(float amount, string preferred, out Business business)
		{
			List<Business> source = CollectOwned();
			if (!string.IsNullOrEmpty(preferred))
			{
				business = ((IEnumerable<Business>)source).FirstOrDefault((Func<Business, bool>)((Business b) => BusinessUtil.Canonical(((Object)b).name) == preferred && RemainingRoom(b) >= amount));
				if ((Object)(object)business != (Object)null)
				{
					return true;
				}
			}
			business = (from b in source
				where RemainingRoom(b) >= amount
				orderby ConfigManager.GetCap(MRLCore.Instance.config, ((Object)b).name) descending
				select b).FirstOrDefault();
			return (Object)(object)business != (Object)null;
		}

		private static void ReconcileJobs()
		{
			CartelJobState state = CartelJobStore.State;
			if (state?.Jobs == null || state.Jobs.Count == 0)
			{
				return;
			}
			List<LaunderingOperation> live = CollectLiveOperations();
			foreach (CartelJobRecord job in state.Jobs)
			{
				LaunderingOperation val = FindLiveMatch(job, live);
				if (val != null)
				{
					DripTracker.Instance.Track(val, isCartel: true);
					_seenLiveJobs.Add(JobKey(job));
				}
			}
		}

		public static void TickJobs()
		{
			if (_running && GameAccess.HasAuthority())
			{
				ReconcileJobs();
				SettleMissingJobs();
			}
		}

		private static void SettleMissingJobs()
		{
			if (!_worldReady)
			{
				return;
			}
			CartelJobState state = CartelJobStore.State;
			if (state?.Jobs == null || state.Jobs.Count == 0)
			{
				return;
			}
			List<Business> list = CollectOwned();
			if (list.Count == 0 || !list.Any((Business b) => b.LaunderingOperations != null))
			{
				return;
			}
			List<LaunderingOperation> list2 = CollectLiveOperations();
			if (_opsHydratedAt <= 0f && (list2.Count > 0 || list.All((Business b) => b.LaunderingOperations != null)))
			{
				_opsHydratedAt = Time.realtimeSinceStartup;
			}
			List<CartelJobRecord> list3 = new List<CartelJobRecord>();
			foreach (CartelJobRecord job in state.Jobs.ToList())
			{
				if (FindLiveMatch(job, list2) != null)
				{
					continue;
				}
				Business val = ((IEnumerable<Business>)list).FirstOrDefault((Func<Business, bool>)((Business b) => BusinessUtil.Canonical(((Object)b).name) == job.BusinessName));
				if (!((Object)(object)val == (Object)null) && val.LaunderingOperations != null)
				{
					bool flag = _seenLiveJobs.Contains(JobKey(job));
					bool flag2 = _worldReadyAt > 0f && Time.realtimeSinceStartup - _worldReadyAt >= 90f;
					if (flag || flag2)
					{
						list3.Add(job);
					}
				}
			}
			foreach (CartelJobRecord item in list3)
			{
				OnCartelJobFinished(new DripState
				{
					BusinessName = BusinessUtil.Display(item.BusinessName),
					Gross = item.Amount,
					IsCartel = true,
					CutPaid = true,
					AcceptedByPlayerCode = item.AcceptedByPlayerCode
				});
				CartelJobStore.Remove(item);
				_seenLiveJobs.Remove(JobKey(item));
			}
		}

		private static string JobKey(CartelJobRecord job)
		{
			if (job == null)
			{
				return string.Empty;
			}
			return job.BusinessName + "|" + job.Amount.ToString("0");
		}

		private static LaunderingOperation FindLiveMatch(LaunderingOperation operation)
		{
			if (operation == null || !CartelJobStore.HasJobs())
			{
				return null;
			}
			foreach (CartelJobRecord job in CartelJobStore.State.Jobs)
			{
				if (FindLiveMatch(job, new List<LaunderingOperation> { operation }) == operation)
				{
					return operation;
				}
			}
			return null;
		}

		private static LaunderingOperation FindLiveMatch(CartelJobRecord job, List<LaunderingOperation> live)
		{
			if (job == null || live == null)
			{
				return null;
			}
			foreach (LaunderingOperation item in live)
			{
				if (CartelJobStore.Matches(job, item))
				{
					return item;
				}
			}
			List<LaunderingOperation> list = live.Where((LaunderingOperation op) => (Object)(object)op?.business != (Object)null && BusinessUtil.Canonical(((Object)op.business).name) == job.BusinessName).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			LaunderingOperation val = ((IEnumerable<LaunderingOperation>)list).FirstOrDefault((Func<LaunderingOperation, bool>)((LaunderingOperation op) => Math.Abs(op.amount - job.Amount) <= 1f));
			if (val != null)
			{
				return val;
			}
			List<LaunderingOperation> list2 = list.Where((LaunderingOperation op) => op.amount <= 1f).ToList();
			if (list2.Count == 1)
			{
				return list2[0];
			}
			return null;
		}

		private static List<LaunderingOperation> CollectLiveOperations()
		{
			List<LaunderingOperation> list = new List<LaunderingOperation>();
			foreach (Business item in CollectOwned())
			{
				if (item?.LaunderingOperations == null)
				{
					continue;
				}
				foreach (LaunderingOperation launderingOperation in item.LaunderingOperations)
				{
					if (launderingOperation != null)
					{
						list.Add(launderingOperation);
					}
				}
			}
			return list;
		}

		private static float RemainingRoom(Business business)
		{
			if ((Object)(object)business == (Object)null)
			{
				return 0f;
			}
			float cap = ConfigManager.GetCap(MRLCore.Instance.config, ((Object)business).name);
			float num = 0f;
			try
			{
				num = business.currentLaunderTotal;
			}
			catch
			{
				if (business.LaunderingOperations != null)
				{
					foreach (LaunderingOperation launderingOperation in business.LaunderingOperations)
					{
						if (launderingOperation != null)
						{
							num += launderingOperation.amount;
						}
					}
				}
			}
			return Mathf.Max(0f, cap - num);
		}

		private static List<Business> CollectOwned()
		{
			List<Business> list = new List<Business>();
			if (Business.OwnedBusinesses == null)
			{
				return list;
			}
			foreach (Business ownedBusiness in Business.OwnedBusinesses)
			{
				if ((Object)(object)ownedBusiness != (Object)null && BusinessUtil.IsKnown(((Object)ownedBusiness).name))
				{
					list.Add(ownedBusiness);
				}
			}
			return list;
		}

		private static long CurrentGameMinutes()
		{
			return (long)GameAccess.ElapsedDays() * 1440L + (long)GameAccess.CurrentHour() * 60L;
		}

		private static float GetMaxInfluence()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Cartel instance = NetworkSingleton<Cartel>.Instance;
				if ((Object)(object)instance?.Influence == (Object)null)
				{
					return 0f;
				}
				float num = 0f;
				foreach (EMapRegion value in Enum.GetValues(typeof(EMapRegion)))
				{
					try
					{
						num = Mathf.Max(num, instance.Influence.GetInfluence(value));
					}
					catch
					{
					}
				}
				return num;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to read cartel influence: " + ex.Message);
				return 0f;
			}
		}

		private static void AdjustInfluence(float delta)
		{
			//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_0073: 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_003d: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			if (Math.Abs(delta) < 0.0001f)
			{
				return;
			}
			try
			{
				Cartel instance = NetworkSingleton<Cartel>.Instance;
				if ((Object)(object)instance?.Influence == (Object)null)
				{
					return;
				}
				EMapRegion val = (EMapRegion)0;
				float num = -1f;
				foreach (EMapRegion value in Enum.GetValues(typeof(EMapRegion)))
				{
					try
					{
						float influence = instance.Influence.GetInfluence(value);
						if (influence > num)
						{
							num = influence;
							val = value;
						}
					}
					catch
					{
					}
				}
				instance.Influence.ChangeInfluence(val, delta);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to change cartel influence: " + ex.Message);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}