using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Eremite;
using Eremite.Buildings;
using Eremite.Buildings.UI;
using Eremite.Characters;
using Eremite.Characters.Villagers;
using Eremite.MapObjects;
using Eremite.MapObjects.UI;
using Eremite.Model;
using Eremite.Model.Configs;
using Eremite.Model.Meta;
using Eremite.Model.State;
using Eremite.Services;
using Eremite.Services.Monitors;
using Eremite.View.HUD;
using Eremite.View.HUD.Monitors;
using Eremite.View.HUD.TradeRoutes;
using Eremite.View.Menu.Pick;
using Eremite.View.UI;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using StockAlert.Config;
using StockAlert.Core.Models;
using StockAlert.Game;
using StockAlert.Game.Discovery;
using StockAlert.Infrastructure.Bootstrap;
using StockAlert.Infrastructure.Plugin;
using StockAlert.UI.HUD;
using StockAlert.UI.Panels;
using StockAlert.UI.World;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
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: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("StockAlert")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+83db0f3a9403369fd5cb6d6c1db7f7fe789d8f9b")]
[assembly: AssemblyProduct("StockAlert")]
[assembly: AssemblyTitle("StockAlert")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StockAlert
{
	public static class StockAlertInfo
	{
		public const string Id = "com.stockalert.ats";

		public const string Name = "StockAlert";

		public const string Version = "1.1.8";
	}
}
namespace StockAlert.UI.World
{
	internal static class BuilderStatusIndicators
	{
		private sealed class BuilderIndicator
		{
			private readonly GameObject _iconObject;

			private readonly SpriteRenderer _renderer;

			private readonly Transform _transform;

			public BuilderIndicator(Villager villager)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				//IL_009d: 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)
				_iconObject = new GameObject("BuilderStatusIcon");
				_renderer = _iconObject.AddComponent<SpriteRenderer>();
				((Renderer)_renderer).material = new Material(Shader.Find("Sprites/Default"));
				((Renderer)_renderer).sortingLayerName = "UI";
				((Renderer)_renderer).sortingOrder = 5000;
				_iconObject.transform.SetParent(((Component)((Actor)villager).ActorView).transform, false);
				_iconObject.transform.localPosition = new Vector3(0f, 1.6f, 0f);
				_transform = _iconObject.transform;
				_transform.localScale = Vector3.one;
				_iconObject.AddComponent<BillboardToCamera>();
			}

			public void Show(Sprite sprite)
			{
				if (!((Object)(object)_renderer == (Object)null) && !((Object)(object)sprite == (Object)null))
				{
					if ((Object)(object)_renderer.sprite != (Object)(object)sprite)
					{
						_renderer.sprite = sprite;
					}
					UpdateScale(sprite);
					if (!((Renderer)_renderer).enabled)
					{
						((Renderer)_renderer).enabled = true;
					}
				}
			}

			private void UpdateScale(Sprite sprite)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_transform == (Object)null) && !((Object)(object)sprite == (Object)null))
				{
					Bounds bounds = sprite.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num = Mathf.Max(size.x, size.y);
					if (num <= 0.001f)
					{
						_transform.localScale = Vector3.one;
						return;
					}
					float num2 = 0.5f / num;
					_transform.localScale = Vector3.one * num2;
				}
			}

			public void Destroy()
			{
				if ((Object)(object)_iconObject != (Object)null)
				{
					Object.Destroy((Object)(object)_iconObject);
				}
			}
		}

		private sealed class BillboardToCamera : MonoBehaviour
		{
			private void LateUpdate()
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				Camera main = Camera.main;
				if ((Object)(object)main != (Object)null)
				{
					((Component)this).transform.forward = ((Component)main).transform.forward;
				}
			}
		}

		private static readonly Dictionary<int, BuilderIndicator> ActiveIndicators = new Dictionary<int, BuilderIndicator>();

		private static PropertyInfo _piVillagersService;

		private static PropertyInfo _piVillagers;

		private static FieldInfo _fiActorBrain;

		private static FieldInfo _fiBrainStack;

		private static Sprite _idleSprite;

		private static Sprite _builderSprite;

		public static void Refresh()
		{
			if (!ConfigManager.ShowBuilderStatusIcons || !GameAPI.IsGameActive())
			{
				Clear();
			}
			else
			{
				if (!EnsureSprites())
				{
					return;
				}
				HashSet<int> seenVillagers = new HashSet<int>();
				foreach (Villager builderVillager in GetBuilderVillagers())
				{
					if ((Object)(object)builderVillager == (Object)null || !builderVillager.IsAlive())
					{
						continue;
					}
					ActorView actorView = ((Actor)builderVillager).ActorView;
					if ((Object)(object)actorView == (Object)null)
					{
						continue;
					}
					seenVillagers.Add(((Actor)builderVillager).Id);
					Sprite val = (IsVillagerIdle(builderVillager) ? _idleSprite : _builderSprite);
					if (!((Object)(object)val == (Object)null))
					{
						if (!ActiveIndicators.TryGetValue(((Actor)builderVillager).Id, out var value))
						{
							value = new BuilderIndicator(builderVillager);
							ActiveIndicators[((Actor)builderVillager).Id] = value;
						}
						value.Show(val);
					}
				}
				List<int> list = ActiveIndicators.Keys.Where((int id) => !seenVillagers.Contains(id)).ToList();
				foreach (int item in list)
				{
					ActiveIndicators[item].Destroy();
					ActiveIndicators.Remove(item);
				}
			}
		}

		public static void Clear()
		{
			foreach (BuilderIndicator value in ActiveIndicators.Values)
			{
				value.Destroy();
			}
			ActiveIndicators.Clear();
		}

		public static int GetIdleBuilderCount()
		{
			return GetBuilderVillagers().Count((Villager villager) => (Object)(object)villager != (Object)null && villager.IsAlive() && IsVillagerIdle(villager));
		}

		public static bool HasIdleBuilderOfRace(string raceName)
		{
			if (string.IsNullOrWhiteSpace(raceName))
			{
				return false;
			}
			return GetIdleBuilderRaceIds().Contains(raceName);
		}

		public static bool HasIdleBuilderOfRace(RaceModel race)
		{
			if ((Object)(object)race == (Object)null || string.IsNullOrWhiteSpace(((SO)race).Name))
			{
				return false;
			}
			return GetIdleBuilderRaceIds().Contains(((SO)race).Name);
		}

		public static Sprite GetIdleBuilderSprite()
		{
			EnsureSprites();
			return _idleSprite;
		}

		public static IReadOnlyList<string> GetIdleBuilderRaceSummaries()
		{
			return (from villager in GetBuilderVillagers()
				where (Object)(object)villager != (Object)null && villager.IsAlive() && IsVillagerIdle(villager)
				group villager by villager.Race into @group
				orderby GetRaceDisplayName(@group.First(), @group.Count())
				select $"{GetRaceDisplayName(@group.First(), 1)}: {@group.Count()}").ToList();
		}

		private static HashSet<string> GetIdleBuilderRaceIds()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (Villager builderVillager in GetBuilderVillagers())
			{
				if (!((Object)(object)builderVillager == (Object)null) && builderVillager.IsAlive() && IsVillagerIdle(builderVillager))
				{
					if (!string.IsNullOrWhiteSpace(builderVillager.Race))
					{
						hashSet.Add(builderVillager.Race);
					}
					RaceModel raceModel = builderVillager.raceModel;
					if (!string.IsNullOrWhiteSpace((raceModel != null) ? ((SO)raceModel).Name : null))
					{
						hashSet.Add(((SO)builderVillager.raceModel).Name);
					}
				}
			}
			return hashSet;
		}

		private static string GetRaceDisplayName(Villager villager, int count)
		{
			return ((Object)(object)villager.raceModel != (Object)null) ? villager.raceModel.GetDisplayNameFor(count) : villager.Race;
		}

		private static IEnumerable<Villager> GetBuilderVillagers()
		{
			Settings settings = GameAPI.GetSettings();
			object obj;
			if (settings == null)
			{
				obj = null;
			}
			else
			{
				ProfessionModel defaultProfession = settings.DefaultProfession;
				obj = ((defaultProfession != null) ? ((SO)defaultProfession).Name : null);
			}
			string builderProfession = (string)obj;
			if (string.IsNullOrWhiteSpace(builderProfession))
			{
				yield break;
			}
			if (_piVillagersService == null)
			{
				_piVillagersService = typeof(GameMB).GetProperty("VillagersService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			object villagersService = _piVillagersService?.GetValue(null, null);
			if (villagersService == null)
			{
				yield break;
			}
			if ((object)_piVillagers == null)
			{
				_piVillagers = villagersService.GetType().GetProperty("Villagers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(_piVillagers?.GetValue(villagersService, null) is IDictionary villagers))
			{
				yield break;
			}
			foreach (DictionaryEntry item in villagers)
			{
				object value = item.Value;
				Villager villager = (Villager)((value is Villager) ? value : null);
				if (villager != null && string.Equals(((Actor)villager).Profession, builderProfession, StringComparison.OrdinalIgnoreCase))
				{
					yield return villager;
				}
			}
		}

		private static bool IsVillagerIdle(Villager villager)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Invalid comparison between Unknown and I4
			try
			{
				if ((object)_fiActorBrain == null)
				{
					_fiActorBrain = typeof(Actor).GetField("brain", BindingFlags.Instance | BindingFlags.NonPublic);
				}
				object obj = _fiActorBrain?.GetValue(villager);
				if (obj == null)
				{
					return false;
				}
				if ((object)_fiBrainStack == null)
				{
					_fiBrainStack = obj.GetType().GetField("stack", BindingFlags.Instance | BindingFlags.NonPublic);
				}
				if (!(_fiBrainStack?.GetValue(obj) is Stack<ActorTask> stack) || stack.Count == 0)
				{
					return false;
				}
				ActorTask val = stack.Peek();
				return val != null && (int)val.WorkStatus == 0;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static bool EnsureSprites()
		{
			if ((Object)(object)_idleSprite == (Object)null)
			{
				_idleSprite = FindHudSprite("/HUD/GoodsHUD/SacrificeMarker/Content") ?? GameAPI.GetSettings()?.monitorsConfig?.noBuildersIcon;
			}
			if ((Object)(object)_builderSprite == (Object)null)
			{
				_builderSprite = FindBuilderHudSprite() ?? GameAPI.GetSettings()?.monitorsConfig?.noBuildersIcon;
			}
			return (Object)(object)_idleSprite != (Object)null && (Object)(object)_builderSprite != (Object)null;
		}

		private static Sprite FindBuilderHudSprite()
		{
			RacesStatsHUD val = Object.FindObjectOfType<RacesStatsHUD>();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = FindDescendantByName(((Component)val).transform, "BuildersIcon");
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Image componentInChildren = ((Component)val2).GetComponentInChildren<Image>(true);
			return (componentInChildren != null) ? componentInChildren.sprite : null;
		}

		private static Sprite FindHudSprite(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return null;
			}
			GameObject val = GameObject.Find(path);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Image component = val.GetComponent<Image>();
			if ((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null)
			{
				return component.sprite;
			}
			Image componentInChildren = val.GetComponentInChildren<Image>(true);
			return (componentInChildren != null) ? componentInChildren.sprite : null;
		}

		private static Transform FindDescendantByName(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (string.Equals(((Object)child).name, name, StringComparison.Ordinal))
				{
					return child;
				}
				Transform val = FindDescendantByName(child, name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
	internal static class BuildingAlertIndicators
	{
		private readonly struct IndicatorSnapshot : IEquatable<IndicatorSnapshot>
		{
			public bool Active { get; }

			public Color Color { get; }

			public bool ShowProductIcons { get; }

			public float ProductIconScale { get; }

			public string ProductGoodsKey { get; }

			public IndicatorSnapshot(bool active, Color color, IReadOnlyList<string> productGoodIds)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				Active = active;
				Color = color;
				ShowProductIcons = ConfigManager.ShowBuildingSpecificItemIndicators;
				ProductIconScale = ConfigManager.BuildingShortageIconScale;
				ProductGoodsKey = ((productGoodIds == null || productGoodIds.Count == 0) ? string.Empty : string.Join("|", productGoodIds.Select(BuildProductGoodsKey)));
			}

			public bool Equals(IndicatorSnapshot other)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				int result;
				if (Active == other.Active)
				{
					Color color = Color;
					if (((Color)(ref color)).Equals(other.Color) && ShowProductIcons == other.ShowProductIcons && Mathf.Approximately(ProductIconScale, other.ProductIconScale))
					{
						result = (string.Equals(ProductGoodsKey, other.ProductGoodsKey, StringComparison.Ordinal) ? 1 : 0);
						goto IL_0060;
					}
				}
				result = 0;
				goto IL_0060;
				IL_0060:
				return (byte)result != 0;
			}

			private static string BuildProductGoodsKey(string goodId)
			{
				GoodInfo goodInfo = Discovery.Goods.FirstOrDefault((GoodInfo g) => string.Equals(g.Id, goodId, StringComparison.OrdinalIgnoreCase));
				return goodId + ((goodInfo != null && goodInfo.IsIngredientBlocked) ? ":blocked" : ":normal");
			}
		}

		private const int MaxProductIcons = 4;

		private const int ProductIconGridRows = 2;

		private const float ProductIconBorderThicknessScale = 0.08f;

		private const string ProductIconBorderRootName = "IngredientBlockedBorder";

		private const string ProductIconsRootName = "StockAlertProductIcons";

		private static readonly Color WhiteColor = Color.white;

		private static readonly Color RedColor = new Color(1f, 0.25f, 0.25f, 1f);

		private static readonly Color YellowColor = new Color(1f, 0.85f, 0.2f, 1f);

		private static readonly Color BorderRedColor = new Color(0.62f, 0.04f, 0.04f, 1f);

		private static readonly Dictionary<int, IndicatorSnapshot> LastApplied = new Dictionary<int, IndicatorSnapshot>();

		private static Sprite _solidSprite;

		public static void Refresh()
		{
			if (!ConfigManager.ShowBuildingAlertIndicators)
			{
				RestoreVanilla();
				return;
			}
			Settings settings = GameAPI.GetSettings();
			HashSet<string> lowGoods = new HashSet<string>(from g in Discovery.Goods
				where g.IsBelowThreshold
				select g.Id, StringComparer.OrdinalIgnoreCase);
			HashSet<string> blockedIngredientGoods = new HashSet<string>(Discovery.BlockedIngredientGoods, StringComparer.OrdinalIgnoreCase);
			HashSet<int> seenBuildings = new HashSet<int>();
			foreach (IWorkshop recipeBuilding in GetRecipeBuildings())
			{
				ProductionBuilding @base = recipeBuilding.Base;
				if (!((Object)(object)@base == (Object)null))
				{
					seenBuildings.Add(((Building)@base).Id);
					ApplyIndicatorState(@base, recipeBuilding, lowGoods, blockedIngredientGoods, settings);
				}
			}
			foreach (ProductionBuilding gatheringSourceBuilding in GameAPI.GetGatheringSourceBuildings())
			{
				if (!((Object)(object)gatheringSourceBuilding == (Object)null))
				{
					seenBuildings.Add(((Building)gatheringSourceBuilding).Id);
					ApplyGatheringIndicatorState(gatheringSourceBuilding, blockedIngredientGoods);
				}
			}
			List<int> list = LastApplied.Keys.Where((int id) => !seenBuildings.Contains(id)).ToList();
			foreach (int item in list)
			{
				RemoveProductIcons(item);
				LastApplied.Remove(item);
			}
		}

		public static void RefreshForView(ProductionBuildingView buildingView)
		{
			if (!ConfigManager.ShowBuildingAlertIndicators || (Object)(object)buildingView == (Object)null)
			{
				return;
			}
			IWorkshop val = GetRecipeBuildings().FirstOrDefault((Func<IWorkshop, bool>)delegate(IWorkshop w)
			{
				object obj;
				if (w == null)
				{
					obj = null;
				}
				else
				{
					ProductionBuilding @base = w.Base;
					obj = ((@base != null) ? ((Building)@base).BuildingView : null);
				}
				return obj == buildingView;
			});
			if (!((Object)(object)((val != null) ? val.Base : null) == (Object)null))
			{
				Settings settings = GameAPI.GetSettings();
				HashSet<string> lowGoods = new HashSet<string>(from g in Discovery.Goods
					where g.IsBelowThreshold
					select g.Id, StringComparer.OrdinalIgnoreCase);
				HashSet<string> blockedIngredientGoods = new HashSet<string>(Discovery.BlockedIngredientGoods, StringComparer.OrdinalIgnoreCase);
				ApplyIndicatorState(val.Base, val, lowGoods, blockedIngredientGoods, settings);
			}
		}

		public static void RestoreVanilla()
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			foreach (IWorkshop recipeBuilding in GetRecipeBuildings())
			{
				ProductionBuilding @base = recipeBuilding.Base;
				if ((Object)(object)@base == (Object)null)
				{
					continue;
				}
				BuildingView buildingView = ((Building)@base).BuildingView;
				object obj;
				if (buildingView == null)
				{
					obj = null;
				}
				else
				{
					Transform transform = ((Component)buildingView).transform;
					if (transform == null)
					{
						obj = null;
					}
					else
					{
						Transform obj2 = transform.Find("ToRotate/UI/NoWorkersIcon");
						obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					}
				}
				GameObject val = (GameObject)obj;
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MakeIconClickThrough(val);
				bool active = ((Building)@base).BuildingState != null && ((Building)@base).BuildingState.finished && !((Building)@base).BuildingState.isSleeping && @base.CountWorkers() == 0;
				val.SetActive(active);
				foreach (SpriteRenderer baseIconRenderer in GetBaseIconRenderers(val))
				{
					baseIconRenderer.color = WhiteColor;
				}
				DestroyProductIcons(val);
			}
			LastApplied.Clear();
		}

		private static IEnumerable<IWorkshop> GetRecipeBuildings()
		{
			foreach (IWorkshop recipeBuilding in GameAPI.GetRecipeBuildings())
			{
				yield return recipeBuilding;
			}
		}

		private static void ApplyIndicatorState(ProductionBuilding building, IWorkshop workshop, HashSet<string> lowGoods, HashSet<string> blockedIngredientGoods, Settings settings)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			BuildingView buildingView = ((Building)building).BuildingView;
			object obj;
			if (buildingView == null)
			{
				obj = null;
			}
			else
			{
				Transform transform = ((Component)buildingView).transform;
				if (transform == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = transform.Find("ToRotate/UI/NoWorkersIcon");
					obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
				}
			}
			GameObject val = (GameObject)obj;
			if (!((Object)(object)val == (Object)null))
			{
				MakeIconClickThrough(val);
				int num = building.CountWorkers();
				WorkplaceModel[] workplaces = building.Workplaces;
				int num2 = ((workplaces != null) ? workplaces.Length : 0);
				List<string> enabledLowRecipeGoods = GetEnabledLowRecipeGoods(workshop, lowGoods);
				bool flag = enabledLowRecipeGoods.Count > 0;
				bool flag2 = workshop.Recipes.Any((WorkshopRecipeState r) => IsEnabledGatheringSupplyRecipe(r, blockedIngredientGoods, settings));
				bool flag3 = flag || flag2;
				bool flag4 = false;
				Color color = WhiteColor;
				if (num == 0)
				{
					flag4 = true;
					color = (flag3 ? RedColor : WhiteColor);
				}
				else if (flag3 && num < num2)
				{
					flag4 = true;
					color = YellowColor;
				}
				ApplySnapshot(((Building)building).Id, val, flag4, color, (flag4 && flag && ConfigManager.ShowBuildingSpecificItemIndicators) ? enabledLowRecipeGoods : null);
			}
		}

		private static void ApplyGatheringIndicatorState(ProductionBuilding building, HashSet<string> blockedIngredientGoods)
		{
			//IL_006d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			BuildingView buildingView = ((Building)building).BuildingView;
			object obj;
			if (buildingView == null)
			{
				obj = null;
			}
			else
			{
				Transform transform = ((Component)buildingView).transform;
				if (transform == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = transform.Find("ToRotate/UI/NoWorkersIcon");
					obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
				}
			}
			GameObject val = (GameObject)obj;
			if (!((Object)(object)val == (Object)null))
			{
				MakeIconClickThrough(val);
				int num = building.CountWorkers();
				WorkplaceModel[] workplaces = building.Workplaces;
				int num2 = ((workplaces != null) ? workplaces.Length : 0);
				bool flag = HasRelevantGatheringRecipe(building, blockedIngredientGoods);
				bool active = false;
				Color color = WhiteColor;
				if (num == 0)
				{
					active = true;
					color = (flag ? RedColor : WhiteColor);
				}
				else if (flag && num < num2)
				{
					active = true;
					color = YellowColor;
				}
				ApplySnapshot(((Building)building).Id, val, active, color, null);
			}
		}

		private static bool HasRelevantGatheringRecipe(ProductionBuilding building, HashSet<string> blockedIngredientGoods)
		{
			if ((Object)(object)((building != null) ? ((Building)building).BuildingModel : null) == (Object)null || blockedIngredientGoods == null || blockedIngredientGoods.Count == 0)
			{
				return false;
			}
			List<RecipeState> recipeStates = GetRecipeStates(building);
			if (recipeStates == null || recipeStates.Count == 0)
			{
				return false;
			}
			foreach (string blockedIngredientGood in blockedIngredientGoods)
			{
				if (string.IsNullOrWhiteSpace(blockedIngredientGood))
				{
					continue;
				}
				Settings settings = GameAPI.GetSettings();
				GoodModel val = ((settings != null) ? settings.GetGood(blockedIngredientGood) : null);
				if ((Object)(object)val == (Object)null || !((Building)building).BuildingModel.IsSourceOf(val))
				{
					continue;
				}
				foreach (RecipeState item in recipeStates)
				{
					if (item == null || !item.active || !RecipeProducesGood(building, item, blockedIngredientGood))
					{
						continue;
					}
					return true;
				}
			}
			return false;
		}

		private static List<RecipeState> GetRecipeStates(ProductionBuilding building)
		{
			GathererHut val = (GathererHut)(object)((building is GathererHut) ? building : null);
			if (val == null)
			{
				return ((Camp)(((building is Camp) ? building : null)?)).state?.recipes;
			}
			return val.state?.recipes;
		}

		private static bool RecipeProducesGood(ProductionBuilding building, RecipeState recipeState, string blockedGood)
		{
			GathererHut val = (GathererHut)(object)((building is GathererHut) ? building : null);
			if (val == null)
			{
				Camp val2 = (Camp)(object)((building is Camp) ? building : null);
				if (val2 != null)
				{
					CampRecipeModel recipeModel = val2.GetRecipeModel(recipeState);
					return string.Equals((recipeModel != null) ? ((RecipeModel)recipeModel).GetProducedGood() : null, blockedGood, StringComparison.OrdinalIgnoreCase);
				}
				return false;
			}
			GathererHutRecipeModel recipeModel2 = val.GetRecipeModel(recipeState);
			return string.Equals((recipeModel2 != null) ? ((RecipeModel)recipeModel2).GetProducedGood() : null, blockedGood, StringComparison.OrdinalIgnoreCase);
		}

		private static void ApplySnapshot(int buildingId, GameObject icon, bool active, Color color, IReadOnlyList<string> productGoodIds)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			IndicatorSnapshot indicatorSnapshot = new IndicatorSnapshot(active, color, productGoodIds);
			bool activeSelf = icon.activeSelf;
			Color currentIconColor = GetCurrentIconColor(icon);
			if (LastApplied.TryGetValue(buildingId, out var value) && value.Equals(indicatorSnapshot) && activeSelf == active && ColorsEqual(currentIconColor, color))
			{
				return;
			}
			icon.SetActive(active);
			foreach (SpriteRenderer baseIconRenderer in GetBaseIconRenderers(icon))
			{
				baseIconRenderer.color = color;
			}
			ApplyProductIcons(buildingId, icon, active ? productGoodIds : null);
			LastApplied[buildingId] = indicatorSnapshot;
		}

		private static Color GetCurrentIconColor(GameObject icon)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)icon == (Object)null)
			{
				return Color.clear;
			}
			SpriteRenderer val = GetBaseIconRenderers(icon).FirstOrDefault();
			return ((Object)(object)val != (Object)null) ? val.color : Color.clear;
		}

		private static List<string> GetEnabledLowRecipeGoods(IWorkshop workshop, HashSet<string> lowGoods)
		{
			List<string> list = new List<string>();
			if (((workshop != null) ? workshop.Recipes : null) == null || lowGoods == null || lowGoods.Count == 0)
			{
				return list;
			}
			foreach (WorkshopRecipeState recipe in workshop.Recipes)
			{
				if (IsEnabledLowRecipe(recipe, lowGoods) && !list.Any((string g) => string.Equals(g, recipe.productName, StringComparison.OrdinalIgnoreCase)))
				{
					list.Add(recipe.productName);
					if (list.Count >= 4)
					{
						break;
					}
				}
			}
			return list;
		}

		private static void ApplyProductIcons(int buildingId, GameObject icon, IReadOnlyList<string> productGoodIds)
		{
			//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_00b4: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)icon == (Object)null || productGoodIds == null || productGoodIds.Count == 0)
			{
				DestroyProductIcons(icon);
				return;
			}
			SpriteRenderer val = GetBaseIconRenderers(icon).FirstOrDefault((Func<SpriteRenderer, bool>)((SpriteRenderer r) => (Object)(object)((r != null) ? r.sprite : null) != (Object)null));
			if ((Object)(object)val == (Object)null)
			{
				DestroyProductIcons(icon);
				return;
			}
			GameObject orCreateProductIconsRoot = GetOrCreateProductIconsRoot(icon);
			if ((Object)(object)orCreateProductIconsRoot == (Object)null)
			{
				return;
			}
			Vector2 rendererSizeInIconSpace = GetRendererSizeInIconSpace(icon.transform, val);
			float num = Mathf.Max(0.01f, rendererSizeInIconSpace.y * ConfigManager.BuildingShortageIconScale);
			float num2 = num / 2.08f;
			float num3 = num2 * 0.08f;
			float num4 = Mathf.Max(rendererSizeInIconSpace.x * 0.55f + num2 * 0.5f, num2 * 1.15f);
			int num5 = 0;
			int i;
			for (i = 0; i < productGoodIds.Count; i++)
			{
				GoodInfo goodInfo = Discovery.Goods.FirstOrDefault((GoodInfo g) => string.Equals(g.Id, productGoodIds[i], StringComparison.OrdinalIgnoreCase));
				Sprite val2 = goodInfo?.Icon;
				if (!((Object)(object)val2 == (Object)null))
				{
					GameObject orCreateProductIcon = GetOrCreateProductIcon(orCreateProductIconsRoot, num5);
					SpriteRenderer component = orCreateProductIcon.GetComponent<SpriteRenderer>();
					if (!((Object)(object)component == (Object)null))
					{
						component.sprite = val2;
						component.color = WhiteColor;
						((Renderer)component).sortingLayerName = ((Renderer)val).sortingLayerName;
						((Renderer)component).sortingOrder = ((Renderer)val).sortingOrder + 1;
						ApplyProductIconBorder(orCreateProductIcon, val2, goodInfo.IsIngredientBlocked, val);
						int num6 = num5 % 2;
						int num7 = num5 / 2;
						float num8 = ((num6 == 0) ? ((num2 + num3) * 0.5f) : ((0f - (num2 + num3)) * 0.5f));
						orCreateProductIcon.transform.localPosition = new Vector3(num4 + (float)num7 * (num2 + num3), num8, 0f);
						orCreateProductIcon.transform.localRotation = Quaternion.identity;
						orCreateProductIcon.transform.localScale = Vector3.one * GetScaleForHeight(val2, num2);
						orCreateProductIcon.SetActive(true);
						num5++;
					}
				}
			}
			for (int j = num5; j < orCreateProductIconsRoot.transform.childCount; j++)
			{
				((Component)orCreateProductIconsRoot.transform.GetChild(j)).gameObject.SetActive(false);
			}
			orCreateProductIconsRoot.SetActive(num5 > 0);
			if (num5 == 0)
			{
				DestroyProductIcons(icon);
				LastApplied.Remove(buildingId);
			}
		}

		private static GameObject GetOrCreateProductIconsRoot(GameObject icon)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			Transform val = icon.transform.Find("StockAlertProductIcons");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("StockAlertProductIcons");
			val2.transform.SetParent(icon.transform, false);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			return val2;
		}

		private static GameObject GetOrCreateProductIcon(GameObject root, int index)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			while (root.transform.childCount <= index)
			{
				GameObject val = new GameObject("ProductIcon");
				val.transform.SetParent(root.transform, false);
				SpriteRenderer val2 = val.AddComponent<SpriteRenderer>();
				((Renderer)val2).material = new Material(Shader.Find("Sprites/Default"));
			}
			return ((Component)root.transform.GetChild(index)).gameObject;
		}

		private static void ApplyProductIconBorder(GameObject productIcon, Sprite sprite, bool active, SpriteRenderer baseRenderer)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject orCreateProductIconBorder = GetOrCreateProductIconBorder(productIcon);
			if (!((Object)(object)orCreateProductIconBorder == (Object)null))
			{
				orCreateProductIconBorder.SetActive(active);
				if (active && !((Object)(object)sprite == (Object)null))
				{
					Bounds bounds = sprite.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num = Mathf.Max(size.y * 0.08f, 0.01f);
					float num2 = size.x + num * 2f;
					float num3 = size.y + num * 2f;
					Transform obj = orCreateProductIconBorder.transform.Find("Top");
					ConfigureBorderPart((obj != null) ? ((Component)obj).GetComponent<SpriteRenderer>() : null, 0f, num3 * 0.5f - num * 0.5f, num2, num, baseRenderer);
					Transform obj2 = orCreateProductIconBorder.transform.Find("Bottom");
					ConfigureBorderPart((obj2 != null) ? ((Component)obj2).GetComponent<SpriteRenderer>() : null, 0f, (0f - num3) * 0.5f + num * 0.5f, num2, num, baseRenderer);
					Transform obj3 = orCreateProductIconBorder.transform.Find("Left");
					ConfigureBorderPart((obj3 != null) ? ((Component)obj3).GetComponent<SpriteRenderer>() : null, (0f - num2) * 0.5f + num * 0.5f, 0f, num, num3, baseRenderer);
					Transform obj4 = orCreateProductIconBorder.transform.Find("Right");
					ConfigureBorderPart((obj4 != null) ? ((Component)obj4).GetComponent<SpriteRenderer>() : null, num2 * 0.5f - num * 0.5f, 0f, num, num3, baseRenderer);
				}
			}
		}

		private static GameObject GetOrCreateProductIconBorder(GameObject productIcon)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)productIcon == (Object)null)
			{
				return null;
			}
			Transform val = productIcon.transform.Find("IngredientBlockedBorder");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject("IngredientBlockedBorder");
			val2.transform.SetParent(productIcon.transform, false);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			CreateBorderPart(val2.transform, "Top");
			CreateBorderPart(val2.transform, "Bottom");
			CreateBorderPart(val2.transform, "Left");
			CreateBorderPart(val2.transform, "Right");
			val2.SetActive(false);
			return val2;
		}

		private static void CreateBorderPart(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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			SpriteRenderer val2 = val.AddComponent<SpriteRenderer>();
			val2.sprite = GetSolidSprite();
			((Renderer)val2).material = new Material(Shader.Find("Sprites/Default"));
		}

		private static void ConfigureBorderPart(SpriteRenderer renderer, float x, float y, float width, float height, SpriteRenderer baseRenderer)
		{
			//IL_0010: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)renderer == (Object)null))
			{
				renderer.color = BorderRedColor;
				((Renderer)renderer).sortingLayerName = ((Renderer)baseRenderer).sortingLayerName;
				((Renderer)renderer).sortingOrder = ((Renderer)baseRenderer).sortingOrder + 2;
				((Component)renderer).transform.localPosition = new Vector3(x, y, 0f);
				((Component)renderer).transform.localRotation = Quaternion.identity;
				((Component)renderer).transform.localScale = new Vector3(width, height, 1f);
			}
		}

		private static Vector2 GetRendererSizeInIconSpace(Transform iconTransform, SpriteRenderer renderer)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_006b: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)iconTransform == (Object)null || (Object)(object)((renderer != null) ? renderer.sprite : null) == (Object)null)
			{
				return Vector2.one;
			}
			Bounds bounds = renderer.sprite.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			Vector3 val = iconTransform.InverseTransformVector(((Component)renderer).transform.TransformVector(new Vector3(size.x, 0f, 0f)));
			float magnitude = ((Vector3)(ref val)).magnitude;
			val = iconTransform.InverseTransformVector(((Component)renderer).transform.TransformVector(new Vector3(0f, size.y, 0f)));
			float magnitude2 = ((Vector3)(ref val)).magnitude;
			return new Vector2(Mathf.Max(0.01f, magnitude), Mathf.Max(0.01f, magnitude2));
		}

		private static float GetScaleForHeight(Sprite sprite, float targetHeight)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			float num;
			if (sprite == null)
			{
				num = 0f;
			}
			else
			{
				Bounds bounds = sprite.bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			float num2 = num;
			return (num2 > 0.001f) ? (targetHeight / num2) : 1f;
		}

		private static Sprite GetSolidSprite()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_solidSprite != (Object)null)
			{
				return _solidSprite;
			}
			Texture2D val = new Texture2D(4, 4, (TextureFormat)5, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			val.SetPixels(Enumerable.Repeat<Color>(Color.white, 16).ToArray());
			val.Apply(false, true);
			_solidSprite = Sprite.Create(val, new Rect(0f, 0f, 4f, 4f), new Vector2(0.5f, 0.5f), 4f);
			return _solidSprite;
		}

		private static IEnumerable<SpriteRenderer> GetBaseIconRenderers(GameObject icon)
		{
			return from r in icon.GetComponentsInChildren<SpriteRenderer>(true)
				where (Object)(object)r != (Object)null && !IsProductIconTransform(((Component)r).transform)
				select r;
		}

		private static bool IsProductIconTransform(Transform transform)
		{
			while ((Object)(object)transform != (Object)null)
			{
				if (string.Equals(((Object)transform).name, "StockAlertProductIcons", StringComparison.Ordinal))
				{
					return true;
				}
				transform = transform.parent;
			}
			return false;
		}

		private static void RemoveProductIcons(int buildingId)
		{
			foreach (IWorkshop recipeBuilding in GetRecipeBuildings())
			{
				if (recipeBuilding == null)
				{
					continue;
				}
				ProductionBuilding @base = recipeBuilding.Base;
				if (((@base != null) ? new int?(((Building)@base).Id) : null) != buildingId)
				{
					continue;
				}
				BuildingView buildingView = ((Building)recipeBuilding.Base).BuildingView;
				object obj;
				if (buildingView == null)
				{
					obj = null;
				}
				else
				{
					Transform transform = ((Component)buildingView).transform;
					if (transform == null)
					{
						obj = null;
					}
					else
					{
						Transform obj2 = transform.Find("ToRotate/UI/NoWorkersIcon");
						obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					}
				}
				GameObject icon = (GameObject)obj;
				DestroyProductIcons(icon);
				break;
			}
		}

		private static void DestroyProductIcons(GameObject icon)
		{
			object obj;
			if (icon == null)
			{
				obj = null;
			}
			else
			{
				Transform transform = icon.transform;
				obj = ((transform != null) ? transform.Find("StockAlertProductIcons") : null);
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private static bool ColorsEqual(Color a, Color b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Approximately(a.r, b.r) && Mathf.Approximately(a.g, b.g) && Mathf.Approximately(a.b, b.b) && Mathf.Approximately(a.a, b.a);
		}

		private static void MakeIconClickThrough(GameObject icon)
		{
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			Graphic[] componentsInChildren = icon.GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val in componentsInChildren)
			{
				val.raycastTarget = false;
			}
			Selectable[] componentsInChildren2 = icon.GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val2 in componentsInChildren2)
			{
				val2.interactable = false;
			}
			GraphicRaycaster[] componentsInChildren3 = icon.GetComponentsInChildren<GraphicRaycaster>(true);
			foreach (GraphicRaycaster val3 in componentsInChildren3)
			{
				((Behaviour)val3).enabled = false;
			}
			EventTrigger[] componentsInChildren4 = icon.GetComponentsInChildren<EventTrigger>(true);
			foreach (EventTrigger val4 in componentsInChildren4)
			{
				((Behaviour)val4).enabled = false;
			}
			Component[] componentsInChildren5 = icon.GetComponentsInChildren<Component>(true);
			foreach (Component val5 in componentsInChildren5)
			{
				Type type = ((object)val5)?.GetType();
				if (type == null)
				{
					continue;
				}
				string name = type.Name;
				if (name.IndexOf("Collider", StringComparison.Ordinal) >= 0)
				{
					PropertyInfo property = type.GetProperty("enabled");
					if (property != null && property.CanWrite)
					{
						property.SetValue(val5, false, null);
					}
				}
			}
		}

		private static bool IsEnabledLowRecipe(WorkshopRecipeState recipeState, HashSet<string> lowGoods)
		{
			if (recipeState == null || !((RecipeState)recipeState).active || string.IsNullOrWhiteSpace(recipeState.productName) || !lowGoods.Contains(recipeState.productName))
			{
				return false;
			}
			return true;
		}

		private static bool IsEnabledGatheringSupplyRecipe(WorkshopRecipeState recipeState, HashSet<string> blockedIngredientGoods, Settings settings)
		{
			if (recipeState == null || !((RecipeState)recipeState).active || blockedIngredientGoods == null || blockedIngredientGoods.Count == 0 || string.IsNullOrWhiteSpace(recipeState.productName) || !blockedIngredientGoods.Contains(recipeState.productName))
			{
				return false;
			}
			WorkshopRecipeModel val = ((settings != null) ? settings.GetWorkshopRecipe(((RecipeState)recipeState).model) : null);
			return val?.requiredGoods == null || val.requiredGoods.Length == 0;
		}
	}
	[HarmonyPatch(typeof(ProductionBuildingView), "ShowWorkers")]
	internal static class BuildingAlertIndicatorsViewPatch
	{
		[HarmonyPostfix]
		private static void ShowWorkersPostfix(ProductionBuildingView __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && GameAPI.IsGameActive())
			{
				BuildingAlertIndicators.RefreshForView(__instance);
			}
		}
	}
	internal sealed class IdleBuilderRaceMenuMarker : MonoBehaviour
	{
		private RacesMenuSlot _slot;

		private GameObject _markerObject;

		private Image _markerImage;

		private float _nextRefreshTime;

		public static void Attach(RacesMenuSlot slot)
		{
			if (!((Object)(object)slot == (Object)null))
			{
				IdleBuilderRaceMenuMarker component = ((Component)slot).GetComponent<IdleBuilderRaceMenuMarker>();
				if ((Object)(object)component == (Object)null)
				{
					component = ((Component)slot).gameObject.AddComponent<IdleBuilderRaceMenuMarker>();
					component.Initialize(slot);
				}
				else
				{
					component.Initialize(slot);
				}
			}
		}

		private void Initialize(RacesMenuSlot slot)
		{
			_slot = slot;
			CleanupLegacyMarkers();
			Refresh();
		}

		private void OnEnable()
		{
			Refresh();
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextRefreshTime))
			{
				_nextRefreshTime = Time.unscaledTime + 0.25f;
				Refresh();
			}
		}

		private void Refresh()
		{
			if ((Object)(object)_slot == (Object)null || !ConfigManager.ShowBuilderStatusIcons)
			{
				Hide();
				return;
			}
			RaceModel race = _slot.GetRace();
			if ((Object)(object)race == (Object)null || !BuilderStatusIndicators.HasIdleBuilderOfRace(race))
			{
				Hide();
				return;
			}
			Sprite idleBuilderSprite = BuilderStatusIndicators.GetIdleBuilderSprite();
			if ((Object)(object)idleBuilderSprite == (Object)null)
			{
				Hide();
				return;
			}
			EnsureMarker();
			if (!((Object)(object)_markerImage == (Object)null))
			{
				_markerImage.sprite = idleBuilderSprite;
				_markerObject.SetActive(true);
			}
		}

		private void EnsureMarker()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_markerObject != (Object)null) && !((Object)(object)_slot == (Object)null))
			{
				Transform obj = ((Component)_slot).transform.Find("Content");
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)_slot).GetComponent<RectTransform>();
				}
				if (!((Object)(object)val == (Object)null))
				{
					_markerObject = new GameObject("StockAlertIdleBuilderRaceMarker", new Type[3]
					{
						typeof(RectTransform),
						typeof(CanvasRenderer),
						typeof(Image)
					});
					_markerObject.transform.SetParent((Transform)(object)val, false);
					_markerImage = _markerObject.GetComponent<Image>();
					((Graphic)_markerImage).raycastTarget = false;
					_markerImage.preserveAspect = true;
					RectTransform component = _markerObject.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(0f, 0.5f);
					component.anchorMax = new Vector2(0f, 0.5f);
					component.pivot = new Vector2(0.5f, 0.5f);
					component.sizeDelta = new Vector2(22f, 22f);
					component.anchoredPosition = new Vector2(-2f, 0f);
					_markerObject.transform.SetAsLastSibling();
					_markerObject.SetActive(false);
				}
			}
		}

		private void CleanupLegacyMarkers()
		{
			if (!((Object)(object)_slot == (Object)null))
			{
				Transform val = ((Component)_slot).transform.Find("Content");
				if (!((Object)(object)val == (Object)null))
				{
					DestroyChild(val, "IdleBuilderRaceMarker");
					DestroyChild(val, "StockAlertIdleBuilderRaceMarker");
					_markerObject = null;
					_markerImage = null;
				}
			}
		}

		private static void DestroyChild(Transform parent, string childName)
		{
			Transform val = parent.Find(childName);
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private void Hide()
		{
			if ((Object)(object)_markerObject != (Object)null)
			{
				_markerObject.SetActive(false);
			}
		}
	}
	internal static class IdleBuildersAlert
	{
		public const string AlertPrefix = "You have idle builders:";

		private static News _activeNews;

		private static string _lastContent;

		public static void Refresh()
		{
			if (!ConfigManager.ShowIdleBuildersAlert || !GameAPI.IsGameActive())
			{
				Clear();
				return;
			}
			int idleBuilderCount = BuilderStatusIndicators.GetIdleBuilderCount();
			if (idleBuilderCount <= 0)
			{
				Clear();
				return;
			}
			string content = BuildContent(idleBuilderCount);
			List<News> currentNews = GameAPI.GetCurrentNews();
			News val = ((IEnumerable<News>)currentNews).FirstOrDefault((Func<News, bool>)((News news) => news != null && news.content == content));
			if (val != null)
			{
				_activeNews = val;
				_lastContent = content;
				return;
			}
			if (_activeNews != null)
			{
				GameAPI.RemoveNews(_activeNews);
				_activeNews = null;
			}
			if (!(_lastContent == content) || !currentNews.Any((News news) => news != null && news.content != null && news.content.StartsWith("You have idle builders:")))
			{
				_activeNews = GameAPI.PublishNews(content, null, (AlertSeverity)1);
				_lastContent = content;
			}
		}

		public static void Clear()
		{
			if (_activeNews != null)
			{
				GameAPI.RemoveNews(_activeNews);
				_activeNews = null;
			}
			_lastContent = null;
		}

		private static string BuildContent(int count)
		{
			IReadOnlyList<string> idleBuilderRaceSummaries = BuilderStatusIndicators.GetIdleBuilderRaceSummaries();
			if (idleBuilderRaceSummaries.Count == 0)
			{
				return string.Format("{0} {1}", "You have idle builders:", count);
			}
			string arg = string.Join("\n", idleBuilderRaceSummaries);
			return string.Format("{0} {1}\n{2}", "You have idle builders:", count, arg);
		}
	}
	internal static class ItemLocatorOverlay
	{
		private const float MarkerHeightOffset = 0.55f;

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

		private static string _trackedGoodId;

		private static GameObject _template;

		private static string _lastToggledGoodId;

		private static int _lastToggleFrame = -1;

		public static bool IsTracking => !string.IsNullOrWhiteSpace(_trackedGoodId);

		public static void Toggle(string goodId)
		{
			if (!string.IsNullOrWhiteSpace(goodId) && (_lastToggleFrame != Time.frameCount || !string.Equals(_lastToggledGoodId, goodId, StringComparison.OrdinalIgnoreCase)))
			{
				_lastToggleFrame = Time.frameCount;
				_lastToggledGoodId = goodId;
				if (string.Equals(_trackedGoodId, goodId, StringComparison.OrdinalIgnoreCase))
				{
					Clear();
					return;
				}
				_trackedGoodId = goodId;
				Refresh();
			}
		}

		public static void Clear()
		{
			_trackedGoodId = null;
			foreach (GameObject value in Markers.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			Markers.Clear();
		}

		public static void Refresh()
		{
			if (!GameAPI.IsGameActive() || string.IsNullOrWhiteSpace(_trackedGoodId))
			{
				Clear();
				return;
			}
			Settings settings = GameAPI.GetSettings();
			Sprite val = ((settings != null) ? settings.GetGood(_trackedGoodId) : null)?.icon;
			if ((Object)(object)val == (Object)null)
			{
				Clear();
				return;
			}
			GameObject val2 = ResolveTemplate();
			if ((Object)(object)val2 == (Object)null)
			{
				Clear();
				return;
			}
			List<TrackedItemLocation> trackedItemLocations = GameAPI.GetTrackedItemLocations(_trackedGoodId);
			HashSet<string> seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (TrackedItemLocation item in trackedItemLocations.Where((TrackedItemLocation l) => l != null && !string.IsNullOrWhiteSpace(l.Key)))
			{
				UpsertMarker(item, val, val2);
				seen.Add(item.Key);
			}
			List<string> list = Markers.Keys.Where((string key) => !seen.Contains(key)).ToList();
			foreach (string item2 in list)
			{
				if (Markers.TryGetValue(item2, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				Markers.Remove(item2);
			}
		}

		private static void UpsertMarker(TrackedItemLocation location, Sprite icon, GameObject template)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Vector3 markerWorldPosition = GetMarkerWorldPosition(location);
			if (!Markers.TryGetValue(location.Key, out var value) || (Object)(object)value == (Object)null)
			{
				value = Object.Instantiate<GameObject>(template, template.transform.parent);
				((Object)value).name = "StockAlertItemLocator_" + location.Key;
				Markers[location.Key] = value;
			}
			ApplyVisuals(value, icon, location);
			ApplyTarget(value, markerWorldPosition);
			value.SetActive(true);
		}

		private static void ApplyVisuals(GameObject marker, Sprite icon, TrackedItemLocation location)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = marker.transform.Find("Icon");
			object obj2 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if (obj2 == null)
			{
				Transform obj3 = marker.transform.Find("Mask/Icon");
				obj2 = ((obj3 != null) ? ((Component)obj3).GetComponent<Image>() : null);
			}
			Image val = (Image)obj2;
			if ((Object)(object)val != (Object)null)
			{
				val.sprite = icon;
				val.preserveAspect = true;
				((Graphic)val).color = Color.white;
				((Graphic)val).raycastTarget = false;
			}
			Transform val2 = marker.transform.Find("Grade");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
			Transform obj4 = marker.transform.Find("BG");
			Image val3 = ((obj4 != null) ? ((Component)obj4).GetComponent<Image>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				((Graphic)val3).raycastTarget = false;
			}
			Image[] componentsInChildren = marker.GetComponentsInChildren<Image>(true);
			foreach (Image val4 in componentsInChildren)
			{
				((Graphic)val4).raycastTarget = false;
			}
			ApplyAmountBadge(marker, location);
		}

		private static void ApplyAmountBadge(GameObject marker, TrackedItemLocation location)
		{
			GameObject orCreateAmountBadge = GetOrCreateAmountBadge(marker);
			if ((Object)(object)orCreateAmountBadge == (Object)null)
			{
				return;
			}
			bool flag = location != null && location.Amount > 0 && location.Key.StartsWith("building:", StringComparison.OrdinalIgnoreCase);
			orCreateAmountBadge.SetActive(flag);
			if (flag)
			{
				TextMeshProUGUI componentInChildren = orCreateAmountBadge.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = location.Amount.ToString();
				}
			}
		}

		private static GameObject GetOrCreateAmountBadge(GameObject marker)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			Transform val = marker.transform.Find("StockAlertAmountBadge");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			RectTransform val2 = marker.GetComponent<RectTransform>() ?? marker.GetComponentInChildren<RectTransform>(true);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObject val3 = new GameObject("StockAlertAmountBadge", new Type[1] { typeof(RectTransform) });
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)val2, false);
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(1f, 0f);
			component.anchoredPosition = new Vector2(8f, -8f);
			component.sizeDelta = new Vector2(32f, 20f);
			GameObject val4 = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			RectTransform component2 = val4.GetComponent<RectTransform>();
			((Transform)component2).SetParent((Transform)(object)component, false);
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			TextMeshProUGUI component3 = val4.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).font = TMP_Settings.defaultFontAsset;
			((TMP_Text)component3).fontSize = 15f;
			((TMP_Text)component3).enableAutoSizing = false;
			((TMP_Text)component3).fontStyle = (FontStyles)1;
			((TMP_Text)component3).alignment = (TextAlignmentOptions)514;
			((Graphic)component3).color = new Color(1f, 0.99f, 0.9f, 1f);
			((Graphic)component3).raycastTarget = false;
			((TMP_Text)component3).margin = new Vector4(1f, 0f, 1f, 0f);
			((TMP_Text)component3).fontSharedMaterial = ((TMP_Text)component3).fontMaterial;
			((TMP_Text)component3).outlineWidth = 0.25f;
			((TMP_Text)component3).outlineColor = Color32.op_Implicit(new Color(0.05f, 0.05f, 0.05f, 1f));
			return val3;
		}

		private static void ApplyTarget(GameObject marker, Vector3 worldPosition)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			WorldIndicator val = marker.GetComponent<WorldIndicator>();
			if ((Object)(object)val == (Object)null)
			{
				val = marker.GetComponentInChildren<WorldIndicator>(true);
			}
			if (val != null)
			{
				val.SetTarget(worldPosition);
			}
		}

		private static Vector3 GetMarkerWorldPosition(TrackedItemLocation location)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			Object source = location.Source;
			Component val = (Component)(object)((source is Component) ? source : null);
			if (val != null && (Object)(object)val != (Object)null)
			{
				Renderer[] array = (from renderer in val.GetComponentsInChildren<Renderer>(true)
					where (Object)(object)renderer != (Object)null && !IsLocatorRenderer(((Component)renderer).transform)
					select renderer).ToArray();
				if (array.Length != 0)
				{
					Bounds bounds = array[0].bounds;
					for (int i = 1; i < array.Length; i++)
					{
						((Bounds)(ref bounds)).Encapsulate(array[i].bounds);
					}
					return new Vector3(((Bounds)(ref bounds)).center.x, ((Bounds)(ref bounds)).max.y + 0.55f, ((Bounds)(ref bounds)).center.z);
				}
			}
			return location.FallbackPosition + new Vector3(0f, 0.55f, 0f);
		}

		private static bool IsLocatorRenderer(Transform transform)
		{
			while ((Object)(object)transform != (Object)null)
			{
				if (((Object)transform).name.StartsWith("StockAlertItemLocator_", StringComparison.Ordinal))
				{
					return true;
				}
				transform = transform.parent;
			}
			return false;
		}

		private static GameObject ResolveTemplate()
		{
			if ((Object)(object)_template != (Object)null)
			{
				return _template;
			}
			DepositIndicator? obj = ((IEnumerable<DepositIndicator>)Resources.FindObjectsOfTypeAll<DepositIndicator>()).FirstOrDefault((Func<DepositIndicator, bool>)IsSceneObject);
			object obj2 = ((obj != null) ? ((Component)obj).gameObject : null);
			if (obj2 == null)
			{
				LakeIndicator? obj3 = ((IEnumerable<LakeIndicator>)Resources.FindObjectsOfTypeAll<LakeIndicator>()).FirstOrDefault((Func<LakeIndicator, bool>)IsSceneObject);
				obj2 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
				if (obj2 == null)
				{
					OreIndicator? obj4 = ((IEnumerable<OreIndicator>)Resources.FindObjectsOfTypeAll<OreIndicator>()).FirstOrDefault((Func<OreIndicator, bool>)IsSceneObject);
					obj2 = ((obj4 != null) ? ((Component)obj4).gameObject : null);
					if (obj2 == null)
					{
						BuildingIndicator? obj5 = ((IEnumerable<BuildingIndicator>)Resources.FindObjectsOfTypeAll<BuildingIndicator>()).FirstOrDefault((Func<BuildingIndicator, bool>)IsSceneObject);
						obj2 = ((obj5 != null) ? ((Component)obj5).gameObject : null);
					}
				}
			}
			_template = (GameObject)obj2;
			return _template;
		}

		private static bool IsSceneObject(Component component)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if ((Object)(object)component != (Object)null)
			{
				Scene scene = component.gameObject.scene;
				result = (((Scene)(ref scene)).IsValid() ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}
	}
	internal sealed class QueuedWorkerSlotCompanion : MonoBehaviour
	{
		private static readonly List<QueuedWorkerSlotCompanion> Instances = new List<QueuedWorkerSlotCompanion>();

		private static FieldInfo _fiBuilding;

		private static FieldInfo _fiWorkplace;

		private static FieldInfo _fiRaceIcon;

		private static PropertyInfo _piIsRemoved;

		private static PropertyInfo _piReactiveValue;

		private BuildingWorkerSlot _slot;

		private GameObject _queuedIconObject;

		private Image _queuedIconImage;

		private Button _queuedIconButton;

		private float _nextRefreshTime;

		public static void Attach(BuildingWorkerSlot slot)
		{
			if (!((Object)(object)slot == (Object)null) && !((Object)(object)((Component)slot).GetComponent<QueuedWorkerSlotCompanion>() != (Object)null))
			{
				((Component)slot).gameObject.AddComponent<QueuedWorkerSlotCompanion>().Initialize(slot);
			}
		}

		public static void ClearAll()
		{
			QueuedWorkerSlotCompanion[] array = Instances.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				array[i]?.Hide();
			}
		}

		private void Initialize(BuildingWorkerSlot slot)
		{
			_slot = slot;
			Instances.Add(this);
			EnsureUi();
			Refresh();
		}

		private void OnDestroy()
		{
			Instances.Remove(this);
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextRefreshTime))
			{
				_nextRefreshTime = Time.unscaledTime + 0.25f;
				Refresh();
			}
		}

		private void Refresh()
		{
			if ((Object)(object)_slot == (Object)null)
			{
				Hide();
				return;
			}
			if (!ConfigManager.EnableQueuedWorkerAssignments)
			{
				Hide();
				return;
			}
			if (!TryGetContext(out var building, out var _, out var workplaceIndex))
			{
				Hide();
				return;
			}
			if (IsBuildingRemoved(building))
			{
				WorkerAssignmentQueue.ClearQueuedRace(building, workplaceIndex);
				Hide();
				return;
			}
			RaceModel queuedRace = WorkerAssignmentQueue.GetQueuedRace(building, workplaceIndex);
			if ((Object)(object)queuedRace == (Object)null)
			{
				Hide();
				return;
			}
			EnsureUi();
			_queuedIconImage.sprite = queuedRace.roundIcon;
			((Graphic)_queuedIconImage).material = null;
			_queuedIconObject.SetActive(true);
		}

		private bool TryGetContext(out ProductionBuilding building, out WorkplaceModel workplace, out int workplaceIndex)
		{
			building = null;
			workplace = null;
			workplaceIndex = -1;
			if ((Object)(object)_slot == (Object)null)
			{
				return false;
			}
			if ((object)_fiBuilding == null)
			{
				_fiBuilding = typeof(BuildingWorkerSlot).GetField("building", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			if ((object)_fiWorkplace == null)
			{
				_fiWorkplace = typeof(BuildingWorkerSlot).GetField("workplace", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _fiBuilding?.GetValue(_slot);
			building = (ProductionBuilding)((obj is ProductionBuilding) ? obj : null);
			object? obj2 = _fiWorkplace?.GetValue(_slot);
			workplace = (WorkplaceModel)((obj2 is WorkplaceModel) ? obj2 : null);
			if ((Object)(object)building == (Object)null || workplace == null)
			{
				return false;
			}
			workplaceIndex = building.GetIndexOf(workplace);
			return workplaceIndex >= 0;
		}

		private void EnsureUi()
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0119: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_queuedIconObject != (Object)null)
			{
				return;
			}
			if ((object)_fiRaceIcon == null)
			{
				_fiRaceIcon = typeof(BuildingWorkerSlot).GetField("raceIcon", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _fiRaceIcon?.GetValue(_slot);
			Image val = (Image)((obj is Image) ? obj : null);
			if (!((Object)(object)val == (Object)null))
			{
				_queuedIconObject = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent, false);
				((Object)_queuedIconObject).name = "QueuedWorkerIcon";
				_queuedIconImage = _queuedIconObject.GetComponent<Image>();
				_queuedIconButton = _queuedIconObject.GetComponent<Button>();
				if ((Object)(object)_queuedIconButton == (Object)null)
				{
					_queuedIconButton = _queuedIconObject.AddComponent<Button>();
				}
				((UnityEventBase)_queuedIconButton.onClick).RemoveAllListeners();
				((UnityEvent)_queuedIconButton.onClick).AddListener(new UnityAction(OpenQueueMenu));
				RectTransform component = _queuedIconObject.GetComponent<RectTransform>();
				Rect rect = component.rect;
				float num;
				if (!(((Rect)(ref rect)).width > 0f))
				{
					num = Mathf.Max(32f, component.sizeDelta.x);
				}
				else
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num;
				component.anchoredPosition += new Vector2(0f - (num2 + 8f), 0f);
				_queuedIconObject.SetActive(false);
			}
		}

		private void OpenQueueMenu()
		{
			if (!ConfigManager.EnableQueuedWorkerAssignments || !TryGetContext(out var building, out var workplace, out var _))
			{
				return;
			}
			RacesMenu val = FindRacesMenu();
			if (!((Object)(object)val == (Object)null))
			{
				val.SetUp(_queuedIconObject.GetComponent<RectTransform>(), (Building)(object)building, (Action<RaceModel>)delegate(RaceModel race)
				{
					WorkerAssignmentQueue.SetQueuedRace(building, workplace, race);
				}, (Action)delegate
				{
					WorkerAssignmentQueue.ClearQueuedRace(building, workplace);
				});
			}
		}

		private static RacesMenu FindRacesMenu()
		{
			return ((IEnumerable<RacesMenu>)Resources.FindObjectsOfTypeAll<RacesMenu>()).FirstOrDefault((Func<RacesMenu, bool>)delegate(RacesMenu menu)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				int result;
				if ((Object)(object)menu != (Object)null)
				{
					Scene scene = ((Component)menu).gameObject.scene;
					result = (((Scene)(ref scene)).IsValid() ? 1 : 0);
				}
				else
				{
					result = 0;
				}
				return (byte)result != 0;
			});
		}

		private static bool IsBuildingRemoved(ProductionBuilding building)
		{
			try
			{
				if ((object)_piIsRemoved == null)
				{
					_piIsRemoved = typeof(Building).GetProperty("IsRemoved", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				object obj = _piIsRemoved?.GetValue(building, null);
				if (obj == null)
				{
					return false;
				}
				if ((object)_piReactiveValue == null)
				{
					_piReactiveValue = obj.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				object obj2 = _piReactiveValue?.GetValue(obj, null);
				bool flag = default(bool);
				int num;
				if (obj2 is bool)
				{
					flag = (bool)obj2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private void Hide()
		{
			if ((Object)(object)_queuedIconObject != (Object)null)
			{
				_queuedIconObject.SetActive(false);
			}
		}
	}
	internal sealed class TrackedGoodClickTarget : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		public string GoodId;

		public static void Attach(Component target, string goodId)
		{
			if (!((Object)(object)target == (Object)null) && !string.IsNullOrWhiteSpace(goodId))
			{
				TrackedGoodClickTarget trackedGoodClickTarget = target.GetComponent<TrackedGoodClickTarget>();
				if ((Object)(object)trackedGoodClickTarget == (Object)null)
				{
					trackedGoodClickTarget = target.gameObject.AddComponent<TrackedGoodClickTarget>();
				}
				trackedGoodClickTarget.GoodId = goodId;
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (eventData != null && (int)eventData.button == 0 && IsModifierPressed() && !string.IsNullOrWhiteSpace(GoodId))
			{
				ItemLocatorOverlay.Toggle(GoodId);
				((AbstractEventData)eventData).Use();
			}
		}

		private static bool IsModifierPressed()
		{
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				return ((ButtonControl)current.leftCtrlKey).isPressed || ((ButtonControl)current.rightCtrlKey).isPressed || current.ctrlKey.isPressed;
			}
			return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
		}
	}
}
namespace StockAlert.UI.Panels
{
	public static class UI
	{
		private sealed class SettingsPanelBehaviour : MonoBehaviour
		{
			private static Texture2D _windowBackground;

			private static Texture2D _panelBackground;

			private static Texture2D _buttonBackground;

			private static Texture2D _buttonHoverBackground;

			private static Texture2D _fieldBackground;

			private static Font _uiFont;

			private static GUIStyle _windowStyle;

			private static GUIStyle _titleStyle;

			private static GUIStyle _bodyStyle;

			private static GUIStyle _hintStyle;

			private static GUIStyle _toggleStyle;

			private static GUIStyle _buttonStyle;

			private static GUIStyle _fieldStyle;

			private static GUIStyle _sectionStyle;

			private Rect _windowRect = new Rect(40f, 40f, 430f, 415f);

			private string _multiplierInput = "2.0";

			private string _buildingShortageIconScaleInput = "0.90";

			private GameObject _clickBlockerCanvasObject;

			private RectTransform _clickBlockerRect;

			public bool Visible { get; private set; }

			public void Toggle()
			{
				Visible = !Visible;
				EnsureClickBlocker();
				UpdateClickBlockerState();
			}

			private void OnGUI()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				if (!Visible)
				{
					UpdateClickBlockerState();
					return;
				}
				EnsureStyles();
				EnsureClickBlocker();
				_windowRect = GUILayout.Window(((Object)this).GetInstanceID(), _windowRect, new WindowFunction(DrawWindow), GUIContent.none, _windowStyle, Array.Empty<GUILayoutOption>());
				UpdateClickBlockerRect();
				UpdateClickBlockerState();
			}

			private void DrawWindow(int windowId)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(20f, 14f, ((Rect)(ref _windowRect)).width - 40f, 36f);
				GUI.Label(val, "Stock Alert Settings (1.1.8)", _titleStyle);
				GUI.Box(new Rect(18f, 50f, ((Rect)(ref _windowRect)).width - 36f, 1f), GUIContent.none, _sectionStyle);
				GUILayout.Space(42f);
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				KeyboardShortcut toggleSettingsKey = ConfigManager.ToggleSettingsKey;
				GUILayout.Label("Toggle key: " + ((object)(KeyboardShortcut)(ref toggleSettingsKey)).ToString(), _bodyStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Use these settings to control the HUD and optional production automation.", _hintStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(12f);
				bool flag = GUILayout.Toggle(ConfigManager.ShowHud, "Show HUD", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag != ConfigManager.ShowHud)
				{
					ConfigManager.ShowHud = flag;
				}
				bool flag2 = GUILayout.Toggle(ConfigManager.MovableHud, "Movable HUD", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag2 != ConfigManager.MovableHud)
				{
					ConfigManager.MovableHud = flag2;
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(20f);
				GUILayout.Label("HUD anchor", _bodyStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(92f) });
				if (GUILayout.Toggle(ConfigManager.HudAnchor == ConfigManager.HudHorizontalAnchor.Left, "Left", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(72f) }) && ConfigManager.HudAnchor != 0)
				{
					ConfigManager.HudAnchor = ConfigManager.HudHorizontalAnchor.Left;
					ConfigManager.HudPosition = new Vector2(-1f, -1f);
				}
				if (GUILayout.Toggle(ConfigManager.HudAnchor == ConfigManager.HudHorizontalAnchor.Right, "Right", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(72f) }) && ConfigManager.HudAnchor != ConfigManager.HudHorizontalAnchor.Right)
				{
					ConfigManager.HudAnchor = ConfigManager.HudHorizontalAnchor.Right;
					ConfigManager.HudPosition = new Vector2(-1f, -1f);
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				bool flag3 = GUILayout.Toggle(ConfigManager.ShowBuildingAlertIndicators, "Building shortage indicators", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag3 != ConfigManager.ShowBuildingAlertIndicators)
				{
					ConfigManager.ShowBuildingAlertIndicators = flag3;
					if (flag3)
					{
						BuildingAlertIndicators.Refresh();
					}
					else
					{
						BuildingAlertIndicators.RestoreVanilla();
					}
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(20f);
				bool flag4 = GUILayout.Toggle(ConfigManager.ShowBuildingSpecificItemIndicators, "Specific item indicator", _toggleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(210f) });
				if (flag4 != ConfigManager.ShowBuildingSpecificItemIndicators)
				{
					ConfigManager.ShowBuildingSpecificItemIndicators = flag4;
					if (ConfigManager.ShowBuildingAlertIndicators)
					{
						BuildingAlertIndicators.Refresh();
					}
				}
				bool enabled = GUI.enabled;
				GUI.enabled = enabled && ConfigManager.ShowBuildingSpecificItemIndicators;
				GUILayout.Label("Size", _bodyStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(34f) });
				string text = GUILayout.TextField(_buildingShortageIconScaleInput ?? string.Empty, _fieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(64f) });
				if (text != _buildingShortageIconScaleInput)
				{
					_buildingShortageIconScaleInput = text;
					if (TryParseBuildingShortageIconScale(_buildingShortageIconScaleInput, out var value))
					{
						ConfigManager.BuildingShortageIconScale = value;
						_buildingShortageIconScaleInput = ConfigManager.BuildingShortageIconScale.ToString("0.00");
						if (ConfigManager.ShowBuildingAlertIndicators)
						{
							BuildingAlertIndicators.Refresh();
						}
					}
				}
				GUILayout.Label("(0.20 - 2.00)", _hintStyle, Array.Empty<GUILayoutOption>());
				GUI.enabled = enabled;
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				bool flag5 = GUILayout.Toggle(ConfigManager.ShowBuilderStatusIcons, "Builder status icons", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag5 != ConfigManager.ShowBuilderStatusIcons)
				{
					ConfigManager.ShowBuilderStatusIcons = flag5;
					if (flag5)
					{
						BuilderStatusIndicators.Refresh();
					}
					else
					{
						BuilderStatusIndicators.Clear();
					}
				}
				bool flag6 = GUILayout.Toggle(ConfigManager.ShowIdleBuildersAlert, "Idle builders alert", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag6 != ConfigManager.ShowIdleBuildersAlert)
				{
					ConfigManager.ShowIdleBuildersAlert = flag6;
					if (!flag6)
					{
						IdleBuildersAlert.Clear();
					}
				}
				bool flag7 = GUILayout.Toggle(ConfigManager.EnableQueuedWorkerAssignments, "Queued worker assignments", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag7 != ConfigManager.EnableQueuedWorkerAssignments)
				{
					ConfigManager.EnableQueuedWorkerAssignments = flag7;
					if (!flag7)
					{
						WorkerAssignmentQueue.ClearAll();
						QueuedWorkerSlotCompanion.ClearAll();
					}
				}
				bool flag8 = GUILayout.Toggle(ConfigManager.ShowIngredientWheelBuildingStock, "Ingredient wheel building stock", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag8 != ConfigManager.ShowIngredientWheelBuildingStock)
				{
					ConfigManager.ShowIngredientWheelBuildingStock = flag8;
				}
				bool flag9 = GUILayout.Toggle(ConfigManager.ShowEmbarkationCostRanges, "Embarkation cost ranges", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag9 != ConfigManager.ShowEmbarkationCostRanges)
				{
					ConfigManager.ShowEmbarkationCostRanges = flag9;
				}
				bool flag10 = GUILayout.Toggle(ConfigManager.ShowTradeRouteProfit, "Trade route profit", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag10 != ConfigManager.ShowTradeRouteProfit)
				{
					ConfigManager.ShowTradeRouteProfit = flag10;
				}
				bool flag11 = GUILayout.Toggle(ConfigManager.SeasonEndingTradeRoutesAlert, "Season ending trade routes alert", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag11 != ConfigManager.SeasonEndingTradeRoutesAlert)
				{
					ConfigManager.SeasonEndingTradeRoutesAlert = flag11;
				}
				GUILayout.Space(10f);
				bool flag12 = GUILayout.Toggle(ConfigManager.AutoAdjustProductionLimits, "Auto-adjust production limits from consumers", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag12 != ConfigManager.AutoAdjustProductionLimits)
				{
					ConfigManager.AutoAdjustProductionLimits = flag12;
					if (flag12)
					{
						AutoProductionLimits.ApplyCurrentTargets();
					}
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(20f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Consumer multiplier", _bodyStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(140f) });
				string text2 = GUILayout.TextField(_multiplierInput ?? string.Empty, _fieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(64f) });
				if (text2 != _multiplierInput)
				{
					_multiplierInput = text2;
					if (TryParseMultiplier(_multiplierInput, out var value2))
					{
						ConfigManager.AutoAdjustMultiplier = value2;
						_multiplierInput = ConfigManager.AutoAdjustMultiplier.ToString("0.0");
						if (ConfigManager.AutoAdjustProductionLimits)
						{
							AutoProductionLimits.ApplyCurrentTargets();
						}
					}
				}
				GUILayout.Label("(1.0 - 9.0)", _hintStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				GUILayout.Space(4f);
				bool flag13 = GUILayout.Toggle(ConfigManager.AutoAdjustPurgingFire, "Auto-adjust Purging Fire to cysts + 1", _toggleStyle, Array.Empty<GUILayoutOption>());
				if (flag13 != ConfigManager.AutoAdjustPurgingFire)
				{
					ConfigManager.AutoAdjustPurgingFire = flag13;
					if (flag13)
					{
						AutoProductionLimits.ApplyCurrentTargets();
					}
				}
				GUILayout.Space(12f);
				if (GUILayout.Button("Close", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					Visible = false;
				}
				GUILayout.EndVertical();
				GUI.DragWindow(new Rect(0f, 0f, 10000f, 24f));
			}

			public void RefreshInputs()
			{
				_multiplierInput = ConfigManager.AutoAdjustMultiplier.ToString("0.0");
				_buildingShortageIconScaleInput = ConfigManager.BuildingShortageIconScale.ToString("0.00");
			}

			private void EnsureClickBlocker()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_clickBlockerCanvasObject != (Object)null))
				{
					_clickBlockerCanvasObject = new GameObject("StockAlertClickBlockerCanvas");
					Object.DontDestroyOnLoad((Object)(object)_clickBlockerCanvasObject);
					Canvas val = _clickBlockerCanvasObject.AddComponent<Canvas>();
					val.renderMode = (RenderMode)0;
					val.sortingOrder = 32767;
					_clickBlockerCanvasObject.AddComponent<GraphicRaycaster>();
					GameObject val2 = new GameObject("StockAlertClickBlocker");
					val2.transform.SetParent(_clickBlockerCanvasObject.transform, false);
					_clickBlockerRect = val2.AddComponent<RectTransform>();
					_clickBlockerRect.anchorMin = new Vector2(0f, 1f);
					_clickBlockerRect.anchorMax = new Vector2(0f, 1f);
					_clickBlockerRect.pivot = new Vector2(0f, 1f);
					Image val3 = val2.AddComponent<Image>();
					((Graphic)val3).color = new Color(0f, 0f, 0f, 0.001f);
					((Graphic)val3).raycastTarget = true;
				}
			}

			private void UpdateClickBlockerRect()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_clickBlockerRect == (Object)null))
				{
					_clickBlockerRect.anchoredPosition = new Vector2(((Rect)(ref _windowRect)).x, 0f - ((Rect)(ref _windowRect)).y);
					_clickBlockerRect.sizeDelta = new Vector2(((Rect)(ref _windowRect)).width, ((Rect)(ref _windowRect)).height);
				}
			}

			private void UpdateClickBlockerState()
			{
				if ((Object)(object)_clickBlockerCanvasObject != (Object)null)
				{
					_clickBlockerCanvasObject.SetActive(Visible);
				}
			}

			private static void EnsureStyles()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: 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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Expected O, but got Unknown
				//IL_0117: 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_012a: Expected O, but got Unknown
				//IL_0130: Expected O, but got Unknown
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_027c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_029f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0313: Unknown result type (might be due to invalid IL or missing references)
				//IL_0323: Expected O, but got Unknown
				//IL_0339: Unknown result type (might be due to invalid IL or missing references)
				//IL_033e: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_035b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0363: Unknown result type (might be due to invalid IL or missing references)
				//IL_0368: Unknown result type (might be due to invalid IL or missing references)
				//IL_0372: Expected O, but got Unknown
				//IL_0373: Unknown result type (might be due to invalid IL or missing references)
				//IL_038d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0392: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a2: Expected O, but got Unknown
				//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e4: Expected O, but got Unknown
				//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0408: Unknown result type (might be due to invalid IL or missing references)
				//IL_040d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0417: Expected O, but got Unknown
				//IL_0418: Unknown result type (might be due to invalid IL or missing references)
				//IL_041e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0428: Expected O, but got Unknown
				//IL_0429: Unknown result type (might be due to invalid IL or missing references)
				//IL_0431: Unknown result type (might be due to invalid IL or missing references)
				//IL_044b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0450: Unknown result type (might be due to invalid IL or missing references)
				//IL_045b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0475: Unknown result type (might be due to invalid IL or missing references)
				//IL_047a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0485: Unknown result type (might be due to invalid IL or missing references)
				//IL_049f: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_04af: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_04de: Expected O, but got Unknown
				//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0502: Unknown result type (might be due to invalid IL or missing references)
				//IL_0513: Unknown result type (might be due to invalid IL or missing references)
				//IL_052d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0532: Unknown result type (might be due to invalid IL or missing references)
				//IL_053d: Unknown result type (might be due to invalid IL or missing references)
				//IL_054e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0568: Unknown result type (might be due to invalid IL or missing references)
				//IL_056d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0578: Unknown result type (might be due to invalid IL or missing references)
				//IL_0589: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c2: Expected O, but got Unknown
				//IL_05c8: Expected O, but got Unknown
				//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fb: Expected O, but got Unknown
				//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_060d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0627: Unknown result type (might be due to invalid IL or missing references)
				//IL_062c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0637: Unknown result type (might be due to invalid IL or missing references)
				//IL_0648: Unknown result type (might be due to invalid IL or missing references)
				//IL_0662: Unknown result type (might be due to invalid IL or missing references)
				//IL_0667: Unknown result type (might be due to invalid IL or missing references)
				//IL_0672: Unknown result type (might be due to invalid IL or missing references)
				//IL_0677: Unknown result type (might be due to invalid IL or missing references)
				//IL_0681: Expected O, but got Unknown
				//IL_0687: Expected O, but got Unknown
				//IL_0691: Unknown result type (might be due to invalid IL or missing references)
				//IL_0696: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b6: Expected O, but got Unknown
				//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c6: Expected O, but got Unknown
				//IL_06c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d6: Expected O, but got Unknown
				//IL_06dc: Expected O, but got Unknown
				if (_windowStyle == null)
				{
					_windowBackground = MakeTexture(new Color32((byte)24, (byte)26, (byte)28, (byte)235), new Color32((byte)112, (byte)90, (byte)56, byte.MaxValue));
					_panelBackground = MakeTexture(new Color32((byte)34, (byte)37, (byte)40, (byte)210), new Color32((byte)72, (byte)60, (byte)42, byte.MaxValue));
					_buttonBackground = MakeTexture(new Color32((byte)70, (byte)56, (byte)37, (byte)235), new Color32((byte)145, (byte)116, (byte)66, byte.MaxValue));
					_buttonHoverBackground = MakeTexture(new Color32((byte)96, (byte)73, (byte)44, (byte)245), new Color32((byte)182, (byte)146, (byte)82, byte.MaxValue));
					_fieldBackground = MakeTexture(new Color32((byte)28, (byte)30, (byte)33, (byte)240), new Color32((byte)114, (byte)97, (byte)63, byte.MaxValue));
					_uiFont = ResolveUIFont();
					_windowStyle = new GUIStyle(GUI.skin.window)
					{
						border = new RectOffset(3, 3, 3, 3),
						padding = new RectOffset(14, 14, 16, 12)
					};
					_windowStyle.normal.background = _windowBackground;
					_windowStyle.hover.background = _windowBackground;
					_windowStyle.onNormal.background = _windowBackground;
					_windowStyle.onHover.background = _windowBackground;
					_windowStyle.active.background = _windowBackground;
					_windowStyle.onActive.background = _windowBackground;
					_windowStyle.focused.background = _windowBackground;
					_windowStyle.onFocused.background = _windowBackground;
					_windowStyle.normal.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.hover.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.onNormal.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.onHover.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.active.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.onActive.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.focused.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					_windowStyle.onFocused.textColor = Color32.op_Implicit(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
					GUIStyle val = new GUIStyle(GUI.skin.label)
					{
						font = _uiFont,
						fontSize = 16,
						richText = true
					};
					val.normal.textColor = Color32.op_Implicit(new Color32((byte)222, (byte)196, (byte)132, byte.MaxValue));
					_titleStyle = val;
					_titleStyle.clipping = (TextClipping)0;
					GUIStyle val2 = new GUIStyle(GUI.skin.label)
					{
						font = _uiFont,
						fontSize = 13,
						wordWrap = true,
						clipping = (TextClipping)0,
						padding = new RectOffset(0, 0, 1, 3)
					};
					val2.normal.textColor = Color32.op_Implicit(new Color32((byte)220, (byte)216, (byte)204, byte.MaxValue));
					_bodyStyle = val2;
					GUIStyle val3 = new GUIStyle(_bodyStyle)
					{
						fontSize = 12
					};
					val3.normal.textColor = Color32.op_Implicit(new Color32((byte)176, (byte)170, (byte)156, byte.MaxValue));
					_hintStyle = val3;
					GUIStyle val4 = new GUIStyle(GUI.skin.toggle)
					{
						font = _uiFont,
						fontSize = 13,
						margin = new RectOffset(4, 4, 3, 3),
						padding = new RectOffset(20, 4, 1, 4),
						clipping = (TextClipping)0
					};
					val4.normal.textColor = Color32.op_Implicit(new Color32((byte)226, (byte)221, (byte)210, byte.MaxValue));
					val4.onNormal.textColor = Color32.op_Implicit(new Color32((byte)236, (byte)228, (byte)214, byte.MaxValue));
					val4.hover.textColor = Color32.op_Implicit(new Color32((byte)245, (byte)235, (byte)216, byte.MaxValue));
					val4.onHover.textColor = Color32.op_Implicit(new Color32((byte)245, (byte)235, (byte)216, byte.MaxValue));
					_toggleStyle = val4;
					GUIStyle val5 = new GUIStyle(GUI.skin.button)
					{
						font = _uiFont,
						fontSize = 13
					};
					val5.normal.background = _buttonBackground;
					val5.normal.textColor = Color32.op_Implicit(new Color32((byte)241, (byte)231, (byte)207, byte.MaxValue));
					val5.hover.background = _buttonHoverBackground;
					val5.hover.textColor = Color32.op_Implicit(new Color32(byte.MaxValue, (byte)245, (byte)221, byte.MaxValue));
					val5.active.background = _buttonBackground;
					val5.active.textColor = Color32.op_Implicit(new Color32((byte)228, (byte)215, (byte)188, byte.MaxValue));
					val5.border = new RectOffset(3, 3, 3, 3);
					_buttonStyle = val5;
					GUIStyle val6 = new GUIStyle(GUI.skin.textField)
					{
						font = _uiFont,
						fontSize = 13,
						padding = new RectOffset(6, 6, 2, 4)
					};
					val6.normal.background = _fieldBackground;
					val6.normal.textColor = Color32.op_Implicit(new Color32((byte)235, (byte)229, (byte)216, byte.MaxValue));
					val6.focused.background = _fieldBackground;
					val6.focused.textColor = Color32.op_Implicit(new Color32((byte)248, (byte)240, (byte)223, byte.MaxValue));
					val6.border = new RectOffset(3, 3, 3, 3);
					_fieldStyle = val6;
					GUIStyle val7 = new GUIStyle(GUI.skin.box);
					val7.normal.background = _panelBackground;
					val7.border = new RectOffset(1, 1, 1, 1);
					val7.margin = new RectOffset(0, 0, 0, 0);
					val7.padding = new RectOffset(0, 0, 0, 0);
					_sectionStyle = val7;
				}
			}

			private static Texture2D MakeTexture(Color32 fill, Color32 border)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_0056: 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_0057: Unknown result type (might be due to invalid IL or missing references)
				Texture2D val = new Texture2D(8, 8, (TextureFormat)5, false)
				{
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)1,
					hideFlags = (HideFlags)61
				};
				Color32[] array = (Color32[])(object)new Color32[64];
				for (int i = 0; i < 8; i++)
				{
					for (int j = 0; j < 8; j++)
					{
						bool flag = j == 0 || j == 7 || i == 0 || i == 7;
						array[i * 8 + j] = (flag ? border : fill);
					}
				}
				val.SetPixels32(array);
				val.Apply(false, true);
				return val;
			}

			private static Font ResolveUIFont()
			{
				try
				{
					Text[] array = Resources.FindObjectsOfTypeAll<Text>();
					foreach (Text val in array)
					{
						if ((Object)(object)val != (Object)null && (Object)(object)val.font != (Object)null)
						{
							return val.font;
						}
					}
				}
				catch
				{
				}
				try
				{
					Font val2 = Font.CreateDynamicFontFromOSFont(new string[6] { "Segoe UI", "Liberation Sans", "DejaVu Sans", "Noto Sans", "Ubuntu", "Arial" }, 14);
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
				catch
				{
				}
				try
				{
					return Resources.GetBuiltinResource<Font>("Arial.ttf");
				}
				catch
				{
					GUISkin skin = GUI.skin;
					return (skin != null) ? skin.font : null;
				}
			}

			private static bool TryParseMultiplier(string raw, out float value)
			{
				value = 0f;
				if (string.IsNullOrWhiteSpace(raw))
				{
					return false;
				}
				string s = raw.Trim().Replace(',', '.');
				if (!float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
				{
					return false;
				}
				value = Mathf.Clamp(Mathf.Round(value * 10f) / 10f, 1f, 9f);
				return true;
			}

			private static bool TryParseBuildingShortageIconScale(string raw, out float value)
			{
				value = 0f;
				if (string.IsNullOrWhiteSpace(raw))
				{
					return false;
				}
				string s = raw.Trim().Replace(',', '.');
				if (!float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
				{
					return false;
				}
				value = Mathf.Clamp(Mathf.Round(value * 100f) / 100f, 0.2f, 2f);
				return true;
			}
		}

		private static GameObject _uiRoot;

		private static SettingsPanelBehaviour _panel;

		public static void Initialize()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (!((Object)(object)_uiRoot != (Object)null))
			{
				Plugin.Log("UI.Initialize()");
				_uiRoot = new GameObject("StockAlertUI");
				Object.DontDestroyOnLoad((Object)(object)_uiRoot);
				_panel = _uiRoot.AddComponent<SettingsPanelBehaviour>();
			}
		}

		public static void Refresh()
		{
			_panel?.RefreshInputs();
		}

		public static void Toggle()
		{
			if (!((Object)(object)_panel == (Object)null))
			{
				_panel.Toggle();
				Plugin.Log("UI toggled: " + _panel.Visible);
			}
		}
	}
}
namespace StockAlert.UI.HUD
{
	public static class HUD
	{
		private sealed class AlertHudBehaviour : MonoBehaviour
		{
			private const float IconSize = 22.5f;

			private const float RowHeight = 24f;

			private const float BoxMargin = 16f;

			private const float BoxPaddingX = 20f;

			private const int MaxRowsPerColumn = 15;

			private const float ColumnGap = 12f;

			private GUIStyle _lineStyle;

			private GUIStyle _blockedLineStyle;

			private GUIStyle _boxStyle;

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

			private readonly Dictionary<string, long> _alertOrder = new Dictionary<string, long>();

			private long _nextAlertOrder;

			private bool _isDragging;

			private Vector2 _dragOffset;

			private Vector2? _lastHudSize;

			private void OnGUI()
			{
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e8: 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_0201: 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)
				if (!ConfigManager.ShowHud || !GameAPI.IsGameActive())
				{
					_activeAlertIds.Clear();
					_alertOrder.Clear();
					_isDragging = false;
					return;
				}
				List<GoodInfo> list = Discovery.Goods.Where((GoodInfo g) => g.IsBelowThreshold).ToList();
				if (list.Count == 0)
				{
					_activeAlertIds.Clear();
					_alertOrder.Clear();
					return;
				}
				RefreshAlertOrdering(list);
				list = (from g in list
					orderby _alertOrder.TryGetValue(g.Id, out var value) ? value : 0 descending, g.DisplayName
					select g).ToList();
				EnsureStyles();
				int num = Mathf.Min(15, list.Count);
				int num2 = ((list.Count > 15) ? (list.Count - 15) : 0);
				List<GoodInfo> goods = list.Take(num).ToList();
				List<GoodInfo> goods2 = ((num2 > 0) ? list.Skip(15).Take(15).ToList() : new List<GoodInfo>());
				float columnWidth = GetColumnWidth(goods);
				float num3 = ((num2 > 0) ? GetColumnWidth(goods2) : 0f);
				float num4 = columnWidth + ((num2 > 0) ? (12f + num3) : 0f);
				float width = Mathf.Min(num4 + 20f, (float)Screen.width - 32f);
				int num5 = Mathf.Max(num, num2);
				float num6 = (float)num5 * 24f;
				int num7 = _boxStyle.padding.top + _boxStyle.padding.bottom;
				float height = num6 + (float)num7;
				Rect hudRect = GetHudRect(width, height);
				GUI.color = new Color(1f, 0.9f, 0.9f, 0.96f);
				GUILayout.BeginArea(hudRect, _boxStyle);
				GUI.color = Color.white;
				if (num2 > 0)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					DrawColumn(goods, columnWidth);
					GUILayout.Space(12f);
					DrawColumn(goods2, num3);
					GUILayout.EndHorizontal();
				}
				else
				{
					DrawColumn(goods, columnWidth);
				}
				GUILayout.EndArea();
				HandleDragging(hudRect);
			}

			private void EnsureStyles()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_005f: 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_0040: Expected O, but got Unknown
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				//IL_0099: Expected O, but got Unknown
				if (_lineStyle == null)
				{
					_lineStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = 16
					};
				}
				if (_blockedLineStyle == null)
				{
					_blockedLineStyle = new GUIStyle(_lineStyle);
				}
				_blockedLineStyle.normal.textColor = new Color(1f, 0.45f, 0.45f, 1f);
				if (_boxStyle == null)
				{
					_boxStyle = new GUIStyle(GUI.skin.box)
					{
						padding = new RectOffset(10, 10, 8, 8)
					};
				}
			}

			private void DrawColumn(IReadOnlyList<GoodInfo> goods, float width)
			{
				GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(width) });
				foreach (GoodInfo good in goods)
				{
					DrawAlertLine(good);
				}
				GUILayout.EndVertical();
			}

			private void RefreshAlertOrdering(IReadOnlyList<GoodInfo> belowThreshold)
			{
				HashSet<string> currentIds = new HashSet<string>(belowThreshold.Select((GoodInfo g) => g.Id));
				foreach (GoodInfo item in belowThreshold)
				{
					if (!_activeAlertIds.Contains(item.Id))
					{
						_activeAlertIds.Add(item.Id);
						_alertOrder[item.Id] = ++_nextAlertOrder;
					}
				}
				List<string> list = _activeAlertIds.Where((string id) => !currentIds.Contains(id)).ToList();
				foreach (string item2 in list)
				{
					_activeAlertIds.Remove(item2);
					_alertOrder.Remove(item2);
				}
			}

			private float GetColumnWidth(IReadOnlyList<GoodInfo> goods)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				float num = 0f;
				foreach (GoodInfo good in goods)
				{
					string text = $"{good.DisplayName}: {good.CurrentAmount}/{good.Threshold}";
					float num2 = _lineStyle.CalcSize(new GUIContent(text)).x + 22.5f + 8f;
					if (num2 > num)
					{
						num = num2;
					}
				}
				return Mathf.Max(180f, num);
			}

			private void DrawAlertLine(GoodInfo good)
			{
				//IL_006e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: 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_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) });
				if ((Object)(object)good.Icon != (Object)null && (Object)(object)good.Icon.texture != (Object)null)
				{
					Rect rect = GUILayoutUtility.GetRect(22.5f, 22.5f, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(22.5f),
						GUILayout.Height(22.5f)
					});
					Rect textureRect = good.Icon.textureRect;
					float num = ((Rect)(ref textureRect)).x / (float)((Texture)good.Icon.texture).width;
					textureRect = good.Icon.textureRect;
					float num2 = ((Rect)(ref textureRect)).y / (float)((Texture)good.Icon.texture).height;
					textureRect = good.Icon.textureRect;
					float num3 = ((Rect)(ref textureRect)).width / (float)((Texture)good.Icon.texture).width;
					textureRect = good.Icon.textureRect;
					Rect val = default(Rect);
					((Rect)(ref val))..ctor(num, num2, num3, ((Rect)(ref textureRect)).height / (float)((Texture)good.Icon.texture).height);
					Color color = GUI.color;
					if (good.IsIngredientBlocked)
					{
						GUI.color = new Color(1f, 0.55f, 0.55f, 1f);
					}
					GUI.DrawTextureWithTexCoords(rect, (Texture)(object)good.Icon.texture, val);
					GUI.color = color;
				}
				else
				{
					GUILayout.Label(string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(22.5f),
						GUILayout.Height(22.5f)
					});
				}
				GUILayout.Label($"{good.DisplayName}: {good.CurrentAmount}/{good.Threshold}", good.IsIngredientBlocked ? _blockedLineStyle : _lineStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
			}

			private Rect GetHudRect(float width, float height)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: 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_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: 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_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: 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)
				Vector2 hudPosition = ConfigManager.HudPosition;
				if (hudPosition.x < 0f || hudPosition.y < 0f)
				{
					_lastHudSize = new Vector2(width, height);
					float num = ((ConfigManager.HudAnchor == ConfigManager.HudHorizontalAnchor.Left) ? 16f : ((float)Screen.width - width - 16f));
					return new Rect(num, (float)Screen.height - height - 16f, width, height);
				}
				if (!_isDragging && _lastHudSize.HasValue)
				{
					Vector2 value = _lastHudSize.Value;
					float num2 = value.x - width;
					float num3 = value.y - height;
					if (!Mathf.Approximately(num2, 0f) || !Mathf.Approximately(num3, 0f))
					{
						float num4 = ((ConfigManager.HudAnchor == ConfigManager.HudHorizontalAnchor.Right) ? (hudPosition.x + num2) : hudPosition.x);
						((Vector2)(ref hudPosition))..ctor(num4, hudPosition.y + num3);
					}
				}
				float num5 = Mathf.Clamp(hudPosition.x, 0f, Mathf.Max(0f, (float)Screen.width - width));
				float num6 = Mathf.Clamp(hudPosition.y, 0f, Mathf.Max(0f, (float)Screen.height - height));
				if (!Mathf.Approximately(num5, ConfigManager.HudPosition.x) || !Mathf.Approximately(num6, ConfigManager.HudPosition.y))
				{
					ConfigManager.HudPosition = new Vector2(num5, num6);
				}
				_lastHudSize = new Vector2(width, height);
				return new Rect(num5, num6, width, height);
			}

			private void HandleDragging(Rect rect)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: 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_009a: Invalid comparison between Unknown and I4
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Invalid comparison between Unknown and I4
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Invalid comparison between Unknown and I4
				if (!ConfigManager.MovableHud)
				{
					_isDragging = false;
					return;
				}
				Event current = Event.current;
				if (current != null)
				{
					if ((int)current.type == 0 && current.button == 0 && ((Rect)(ref rect)).Contains(current.mousePosition))
					{
						_isDragging = true;
						_dragOffset = current.mousePosition - new Vector2(((Rect)(ref rect)).x, ((Rect)(ref rect)).y);
						current.Use();
					}
					else if (_isDragging && (int)current.type == 3)
					{
						Vector2 val = current.mousePosition - _dragOffset;
						float num = Mathf.Clamp(val.x, 0f, Mathf.Max(0f, (float)Screen.width - ((Rect)(ref rect)).width));
						float num2 = Mathf.Clamp(val.y, 0f, Mathf.Max(0f, (float)Screen.height - ((Rect)(ref rect)).height));
						ConfigManager.HudPosition = new Vector2(num, num2);
						current.Use();
					}
					else if (_isDragging && ((int)current.type == 1 || (int)current.rawType == 1))
					{
						_isDragging = false;
						current.Use();
					}
				}
			}
		}

		private static GameObject _hudRoot;

		public static void Initialize()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (!((Object)(object)_hudRoot != (Object)null))
			{
				Plugin.Log("HUD.Initialize()");
				_hudRoot = new GameObject("StockAlertHUD");
				Object.DontDestroyOnLoad((Object)(object)_hudRoot);
				_hudRoot.AddComponent<AlertHudBehaviour>();
			}
		}
	}
}
namespace StockAlert.Infrastructure.Utils
{
	public static class Utils
	{
		public static Texture2D SpriteToTexture(Sprite sprite)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if ((Object)(object)sprite == (Object)null)
			{
				return null;
			}
			Rect textureRect = sprite.textureRect;
			Texture2D val = new Texture2D((int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height);
			Color[] pixels = sprite.texture.GetPixels((int)((Rect)(ref textureRect)).x, (int)((Rect)(ref textureRect)).y, (int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height);
			val.SetPixels(pixels);
			val.Apply();
			return val;
		}
	}
}
namespace StockAlert.Infrastructure.Plugin
{
	[BepInPlugin("StockAlert", "Stock Alert", "1.1.8")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance;

		private Harmony _harmony;

		private bool _gameReadyInitialized;

		private void Awake()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			Instance = this;
			Log("StockAlert loaded");
			ConfigManager.Load();
			_harmony = new Harmony("StockAlert.Harmony");
			_harmony.PatchAll();
			Log("Harmony patches applied");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		public static void Log(string msg)
		{
			Logger.CreateLogSource("Stock Alert").LogInfo((object)msg);
		}

		public void OnGameReady()
		{
			if (_gameReadyInitialized)
			{
				Log("OnGameReady() skipped - already initialized");
				return;
			}
			_gameReadyInitialized = true;
			Log("OnGameReady() fired - initializing mod");
			Discovery.Initialize();
			AutoProductionLimits.Initialize();
			HUD.Initialize();
			StockAlert.UI.Panels.UI.Initialize();
			StockAlert.UI.Panels.UI.Refresh();
			StockAlertRuntime.Initialize();
			AutoProductionLimits.ApplyCurrentTargets();
		}

		public void ResetGameReady()
		{
			if (_gameReadyInitialized)
			{
				_gameReadyInitialized = false;
				Log("Game-ready state reset");
			}
		}
	}
}
namespace StockAlert.Infrastructure.Hooks
{
	[HarmonyPatch]
	internal static class EmbarkationCostRangePatch
	{
		private readonly struct CostRange
		{
			public readonly int Min;

			public readonly int Max;

			public CostRange(int min, int max)
			{
				Min = min;
				Max = max;
			}
		}

		private const string RangeLabelName = "StockAlertCostRangeLabel";

		private static FieldInfo _fiGoodCostText;

		private static FieldInfo _fiRewardCostText;

		[HarmonyPatch(typeof(GoodPickSlot), "SetUp")]
		[HarmonyPostfix]
		private static void GoodPickSlotSetUpPostfix(GoodPickSlot __instance, GoodPickState state)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			if ((object)_fiGoodCostText == null)
			{
				_fiGoodCostText = typeof(GoodPickSlot).GetField("costText", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _fiGoodCostText?.GetValue(__instance);
			TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
			if (val == null)
			{
				return;
			}
			if (!ConfigManager.ShowEmbarkationCostRanges || state == null)
			{
				RemoveRangeLabel(((Component)__instance).transform);
				return;
			}
			CostRange? goodCostRange = GetGoodCostRange(state);
			if (!goodCostRange.HasValue)
			{
				RemoveRangeLabel(((Component)__instance).transform);
			}
			else
			{
				ApplyCostDisplay(((Component)__instance).transform, val, state.cost, goodCostRange.Value.Min, goodCostRange.Value.Max);
			}
		}

		[HarmonyPatch(typeof(RewardPickSlot), "SetUp")]
		[HarmonyPostfix]
		private static void RewardPickSlotSetUpPostfix(RewardPickSlot __instance, ConditionPickState state)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			if ((object)_fiRewardCostText == null)
			{
				_fiRewardCostText = typeof(RewardPickSlot).GetField("costText", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _fiRewardCostText?.GetValue(__instance);
			TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
			if (val == null)
			{
				return;
			}
			if (!ConfigManager.ShowEmbarkationCostRanges || state == null)
			{
				RemoveRangeLabel(((Component)__instance).transform);
				return;
			}
			CostRange? conditionCostRange = GetConditionCostRange(state);
			if (!conditionCostRange.HasValue)
			{
				RemoveRangeLabel(((Component)__instance).transform);
			}
			else
			{
				ApplyCostDisplay(((Component)__instance).transform, val, state.cost, conditionCostRange.Value.Min, conditionCostRange.Value.Max);
			}
		}

		private static void ApplyCostDisplay(Transform slotTransform, TMP_Text currentCostText, int currentCost, int minCost, int maxCost)
		{
			ApplyCurrentCostText(currentCostText, currentCost, minCost, maxCost);
			ApplyRangeText(slotTransform, currentCostText, minCost, maxCost);
		}

		private static void ApplyCurrentCostText(TMP_Text text, int currentCost, int minCost, int maxCost)
		{
			text.alignment = (TextAlignmentOptions)514;
			text.textWrappingMode = (TextWrappingModes)0;
			text.overflowMode = (TextOverflowModes)0;
			text.enableAutoSizing = true;
			text.fontSizeMax = Mathf.Min((text.fontSizeMax > 0f) ? text.fontSizeMax : text.fontSize, text.fontSize);
			text.fontSizeMin = Mathf.Min(8f, text.fontSizeMax);
			text.richText = true;
			text.text = $"<color=#{GetCostColorHex(currentCost, minCost, maxCost)}>{currentCost}</color>";
		}

		private static void ApplyRangeText(Transform slotTransform, TMP_Text template, int minCost, int maxCost)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text orCreateRangeLabel = GetOrCreateRangeLabel(slotTransform, template);
			if (!((Object)(object)orCreateRangeLabel == (Object)null))
			{
				orCreateRangeLabel.alignment = (TextAlignmentOptions)514;
				orCreateRangeLabel.textWrappingMode = (TextWrappingModes)0;
				orCreateRangeLabel.overflowMode = (TextOverflowModes)0;
				orCreateRangeLabel.enableAutoSizing = true;
				orCreateRangeLabel.fontSizeMax = Mathf.Min((template.fontSizeMax > 0f) ? template.fontSizeMax : template.fontSize, template.fontSize);
				orCreateRangeLabel.fontSizeMin = Mathf.Min(8f, orCreateRangeLabel.fontSizeMax);
				orCreateRangeLabel.richText = false;
				((Graphic)orCreateRangeLabel).color = new Color(0.72f, 1f, 0.45f, 1f);
				orCreateRangeLabel.text = $"{minCost}-{maxCost}";
				((Component)orCreateRangeLabel).gameObject.SetActive(true);
			}
		}

		private static TMP_Text GetOrCreateRangeLabel(Transform slotTransform, TMP_Text template)
		{
			//IL_0093: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slotTransform == (Object)null || (Object)(object)template == (Object)null)
			{
				return null;
			}
			Transform val = slotTransform.Find("StockAlertCostRangeLabel");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).GetComponent<TMP_Text>();
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)template).gameObject, slotTransform, false);
			((Object)val2).name = "StockAlertCostRangeLabel";
			val2.SetActive(true);
			TMP_Text component = val2.GetComponent<TMP_Text>();
			RectTransform component2 = val2.GetComponent<RectTransform>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.anchorMin = new Vector2(0f, 1f);
				component2.anchorMax = new Vector2(0f, 1f);
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.sizeDelta = new Vector2(42f, 22f);
				component2.anchoredPosition = new Vector2(12f, -10f);
			}
			return component;
		}

		private static void RemoveRangeLabel(Transform slotTransform)
		{
			if (!((Object)(object)slotTransform == (Object)null))
			{
				Transform val = slotTransform.Find("StockAlertCostRangeLabel");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static string GetCostColorHex(int currentCost, int minCost, int maxCost)
		{
			if (currentCost <= minCost)
			{
				return "7ED957";
			}
			if (currentCost >= maxCost)
			{
				return "FF5A4D";
			}
			return "FFD84D";
		}

		private static CostRange? GetGoodCostRange(GoodPickState state)
		{
			try
			{
				EmbarkGoodMetaRewardModel val = GameAPI.GetSettings()?.metaRewards?.OfType<EmbarkGoodMetaRewardModel>().FirstOrDefault((Func<EmbarkGoodMetaRewardModel, bool>)((EmbarkGoodMetaRewardModel model) => model?.good != null && string.Equals(model.good.Name, state.name, StringComparison.OrdinalIgnoreCase)));
				return ((Object)(object)val != (Object)null) ? new CostRange?(new CostRange(((Vector2Int)(ref val.costRange)).x, ((Vector2Int)(ref val.costRange)).y)) : null;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static CostRange? GetConditionCostRange(ConditionPickState state)
		{
			return GetEmbarkEffectCostRange(state) ?? GetBuildingCostRange(state);
		}

		private static CostRange? GetEmbarkEffectCostRange(ConditionPickState state)
		{
			try
			{
				EmbarkEffectMetaRewardModel val = GameAPI.GetSettings()?.metaRewards?.OfType<EmbarkEffectMetaRewardModel>().FirstOrDefault((Func<EmbarkEffectMetaRewardModel, bool>)((EmbarkEffectMetaRewardModel model) => (Object)(object)model?.effect != (Object)null && string.Equals(((SO)model.effect).Name, state.name, StringComparison.OrdinalIgnoreCase)));
				return ((Object)(object)val != (Object)null) ? new CostRange?(new CostRange(((Vector2Int)(ref val.costRange)).x, ((Vector2Int)(ref val.costRange)).y)) : null;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static CostRange? GetBuildingCostRange(ConditionPickState state)
		{
			try
			{
				Settings settings = GameAPI.GetSettings();
				if ((Object)(object)settings == (Object)null || !settings.ContainsBuilding(state.name))
				{
					return null;
				}
				BuildingModel building = settings.GetBuilding(state.name);
				return ((Object)(object)building != (Object)null) ? new CostRange?(new CostRange(((Vector2Int)(ref building.costRange)).x, ((Vector2Int)(ref building.costRange)).y)) : null;
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(GoodsHUD), "SetUp")]
	internal static class GoodsHudReadyPatch
	{
		private static void Postfix(GoodsHUD __instance)
		{
			StockAlert.Infrastructure.Plugin.Plugin.Log("GoodsHUD.SetUp detected");
			StockAlert.Infrastructure.Plugin.Plugin.Instance?.OnGameReady();
		}
	}
	[HarmonyPatch(typeof(BaseAlertHUDSlot), "SetUp")]
	internal static class IdleBuilderNewsSlotSizingPatch
	{
		private const float VerticalPadding = 22f;

		private static readonly FieldInfo ContentField = AccessTools.Field(typeof(BaseAlertHUDSlot), "content");

		private static readonly FieldInfo ContentTextField = AccessTools.Field(typeof(BaseAlertHUDSlot), "contentText");

		private static readonly Dictionary<int, Vector2> OriginalSlotSizes = new Dictionary<int, Vector2>();

		private static readonly Dictionary<int, Vector2> OriginalContentSizes = new Dictionary<int, Vector2>();

		[HarmonyPostfix]
		private static void ResizeIdleBuilderNewsSlot(BaseAlertHUDSlot __instance)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				object? obj = ContentTextField?.GetValue(__instance);
				TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
				object? obj2 = ContentField?.GetValue(__instance);
				RectTransform val2 = (RectTransform)((obj2 is RectTransform) ? obj2 : null);
				RectTransform rectTransform = ((MB)__instance).RectTransform;
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)rectTransform == (Object)null))
				{
					RememberOriginalSize(rectTransform, OriginalSlotSizes);
					RememberOriginalSize(val2, OriginalContentSizes);
					if (!IsIdleBuilderAlert(val.text))
					{
						RestoreSize(rectTransform, OriginalSlotSizes);
						RestoreSize(val2, OriginalContentSizes);
						val.textWrappingMode = (TextWrappingModes)0;
						return;
					}
					val.textWrappingMode = (TextWrappingModes)1;
					val.overflowMode = (TextOverflowModes)0;
					Vector2 val3 = OriginalSlotSizes[((Object)rectTransform).GetInstanceID()];
					Vector2 val4 = OriginalContentSizes[((Object)val2).GetInstanceID()];
					string text = val.text;
					Rect rect = val.rectTransform.rect;
					float num = val.GetPreferredValues(text, ((Rect)(ref rect)).width, 0f).y + 22f;
					float height = Mathf.Max(val3.y, num);
					float height2 = Mathf.Max(val4.y, num);
					SetHeight(rectTransform, height);
					SetHeight(val2, height2);
				}
			}
			catch (Exception)
			{
			}
		}

		private static bool IsIdleBuilderAlert(string text)
		{
			return !string.IsNullOrWhiteSpace(text) && text.StartsWith("You have idle builders:", StringComparison.Ordinal);
		}

		private static void RememberOriginalSize(RectTransform rect, Dictionary<int, Vector2> sizes)
		{
			//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)
			int instanceID = ((Object)rect).GetInstanceID();
			if (!sizes.ContainsKey(instanceID))
			{
				Rect rect2 = rect.rect;
				sizes[instanceID] = ((Rect)(ref rect2)).size;
			}
		}

		private static void RestoreSize(RectTransform rect, Dictionary<int, Vector2> sizes)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (sizes.TryGetValue(((Object)rect).GetInstanceID(), out var value))
			{
				rect.SetSizeWithCurrentAnchors((Axis)0, value.x);
				rect.SetSizeWithCurrentAnchors((Axis)1, value.y);
			}
		}

		private static void SetHeight(RectTransform rect, float height)
		{
			rect.SetSizeWithCurrentAnchors((Axis)1, height);
		}
	}
	[HarmonyPatch]
	internal static class IngredientsMenuStockPatch
	{
		private static FieldInfo _fiCounter;

		private static FieldInfo _fiSlot;

		private static MethodInfo _miGetAmount;

		[HarmonyPatch(typeof(IngredientsMenuSlot), "SetUp")]
		[HarmonyPostfix]
		private static void IngredientsMenuSlotSetUpPostfix(IngredientsMenuSlot __instance, IngredientState state)
		{
			TryApplyBuildingStockCounter(__instance, state);
		}

		[HarmonyPatch(typeof(IngredientsMenuSlot), "UpdateState")]
		[HarmonyPostfix]
		private static void IngredientsMenuSlotUpdateStatePostfix(IngredientsMenuSlot __instance)
		{
			object? obj = AccessTools.Field(typeof(IngredientsMenuSlot), "state")?.GetValue(__instance);
			IngredientState val = (IngredientState)((obj is IngredientState) ? obj : null);
			if (val != null)
			{
				TryApplyBuildingStockCounter(__instance, val);
			}
		}

		private static void TryApplyBuildingStockCounter(IngredientsMenuSlot menuSlot, IngredientState state)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!ConfigManager.ShowIngredientWheelBuildingStock || (Object)(object)menuSlot == (Object)null || state == null)
			{
				return;
			}
			_ = state.good;
			if (false || !GameAPI.IsGameActive() || string.IsNullOrWhiteSpace(state.good.name))
			{
				return;
			}
			if ((object)_fiSlot == null)
			{
				_fiSlot = typeof(IngredientsMenuSlot).GetField("slot", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj = _fiSlot?.GetValue(menuSlot);
			RangeGoodSlot val = (RangeGoodSlot)((obj is RangeGoodSlot) ? obj : null);
			if (val == null)
			{
				return;
			}
			if ((object)_fiCounter == null)
			{
				_fiCounter = typeof(RangeGoodSlot).GetField("counter", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			object? obj2 = _fiCounter?.GetValue(val);
			TMP_Text val2 = (TMP_Text)((obj2 is TMP_Text) ? obj2 : null);
			if (val2 != null)
			{
				if ((object)_miGetAmount == null)
				{
					_miGetAmount = typeof(IngredientsMenuSlot).GetMethod("GetAmount", BindingFlags.Instance | BindingFlags.NonPublic);
				}
				int num = ((_miGetAmount != null) ? ((int)_miGetAmount.Invoke(menuSlot, null)) : 0);
				int amount = state.good.amount;
				string text = val2.text ?? string.Empty;
				string text2 = text;
				int num2 = text.IndexOf(" (", StringComparison.Ordinal);
				if (num2 >= 0)
				{
					text2 = text.Substring(0, num2);
				}
				int amountInNonWarehouseBuildings = GameAPI.GetAmountInNonWarehouseBuildings(state.good.name);
				if (num < amount && amountInNonWarehouseBuildings > 0)
				{
					val2.text = $"{text2} ({amountInNonWarehouseBuildings})";
				}
				else
				{
					val2.text = text2;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class ItemLocatorClickPatch
	{
		[HarmonyPatch(typeof(GoodSlot), "SetUp")]
		[HarmonyPostfix]
		private static void GoodSlotSetUpPostfix(GoodSlot __instance, Good good)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			TrackedGoodClickTarget.Attach((Component)(object)__instance, good.name);
		}

		[HarmonyPatch(typeof(GoodSlotButton), "OnClick")]
		[HarmonyPrefix]
		private static bool GoodSlotButtonOnClickPrefix(GoodSlotButton __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			Good good = __instance.GetGood();
			if (string.IsNullOrWhiteSpace(good.name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(good.name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(BuildingStorageProductSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool BuildingStorageProductSlotOnClickPrefix(BuildingStorageProductSlot __instance)
		{
			//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			Good value = Traverse.Create((object)__instance).Field("good").GetValue<Good>();
			if (string.IsNullOrWhiteSpace(value.name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(value.name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(IngredientsStorageSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool IngredientsStorageSlotOnClickPrefix(IngredientsStorageSlot __instance)
		{
			//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			Good value = Traverse.Create((object)__instance).Field("good").GetValue<Good>();
			if (string.IsNullOrWhiteSpace(value.name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(value.name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(ReorderableStorageSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool ReorderableStorageSlotOnClickPrefix(ReorderableStorageSlot __instance)
		{
			//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			Good value = Traverse.Create((object)__instance).Field("good").GetValue<Good>();
			if (string.IsNullOrWhiteSpace(value.name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(value.name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(RangeGoodSlot), "SetUp")]
		[HarmonyPostfix]
		private static void RangeGoodSlotSetUpPostfix(RangeGoodSlot __instance, Good good)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			TrackedGoodClickTarget.Attach((Component)(object)__instance, good.name);
		}

		[HarmonyPatch(typeof(GoodsSetSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool GoodsSetSlotOnClickPrefix(GoodsSetSlot __instance)
		{
			//IL_0022: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			Good value = Traverse.Create((object)__instance).Field("current").GetValue<Good>();
			if (string.IsNullOrWhiteSpace(value.name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(value.name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(IngredientSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool IngredientSlotOnClickPrefix(IngredientSlot __instance)
		{
			if (!IsModifierPressed())
			{
				return true;
			}
			object? obj = AccessTools.Method(typeof(IngredientSlot), "GetGood", (Type[])null, (Type[])null)?.Invoke(__instance, null);
			GoodModel val = (GoodModel)((obj is GoodModel) ? obj : null);
			if ((Object)(object)val == (Object)null || string.IsNullOrWhiteSpace(((SO)val).Name))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(((SO)val).Name);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(IngredientsMenuSlot), "OnClick")]
		[HarmonyPrefix]
		private static bool IngredientsMenuSlotOnClickPrefix(IngredientsMenuSlot __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!IsModifierPressed())
			{
				return true;
			}
			IngredientState value = Traverse.Create((object)__instance).Field("state").GetValue<IngredientState>();
			if (value != null)
			{
				_ = value.good;
				if (0 == 0 && !string.IsNullOrWhiteSpace(value.good.name))
				{
					ItemLocatorOverlay.Toggle(value.good.name);
					PlayButtonSound();
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(WorkshopRecipeSlot), "OpenRecipesPopup")]
		[HarmonyPrefix]
		private static bool WorkshopRecipeSlotOpenRecipesPopupPrefix(WorkshopRecipeSlot __instance)
		{
			if (!IsModifierPressed())
			{
				return true;
			}
			WorkshopRecipeModel value = Traverse.Create((object)__instance).Field("model").GetValue<WorkshopRecipeModel>();
			object obj;
			if (value == null)
			{
				obj = null;
			}
			else
			{
				GoodRef producedGood = value.producedGood;
				if (producedGood == null)
				{
					obj = null;
				}
				else
				{
					GoodModel good = producedGood.good;
					obj = ((good != null) ? ((SO)good).Name : null);
				}
			}
			string text = (string)obj;
			if (string.IsNullOrWhiteSpace(text))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(text);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(BlightPostRecipeSlot), "OpenRecipesPopup")]
		[HarmonyPrefix]
		private static bool BlightPostRecipeSlotOpenRecipesPopupPrefix(BlightPostRecipeSlot __instance)
		{
			if (!IsModifierPressed())
			{
				return true;
			}
			WorkshopRecipeModel value = Traverse.Create((object)__instance).Field("model").GetValue<WorkshopRecipeModel>();
			object obj;
			if (value == null)
			{
				obj = null;
			}
			else
			{
				GoodRef producedGood = value.producedGood;
				if (producedGood == null)
				{
					obj = null;
				}
				else
				{
					GoodModel good = producedGood.good;
					obj = ((good != null) ? ((SO)good).Name : null);
				}
			}
			string text = (string)obj;
			if (string.IsNullOrWhiteSpace(text))
			{
				return true;
			}
			ItemLocatorOverlay.Toggle(text);
			PlayButtonSound();
			return false;
		}

		private static bool IsModifierPressed()
		{
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				return ((ButtonControl)current.leftCtrlKey).isPressed || ((ButtonControl)current.rightCtrlKey).isPressed || current.ctrlKey.isPressed;
			}
			return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
		}

		private static void PlayButtonSound()
		{
			try
			{
				object obj = typeof(MB).GetProperty("SoundsManager", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null, null);
				obj?.GetType().GetMethod("PlayButtonSound", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj, null);
			}
			catch (Exception)
			{
			}
		}
	}
	[HarmonyPatch(typeof(WorkshopsService), "SetGlobalLimitFor")]
	internal static class WorkshopsServiceSetGlobalLimitForPatch
	{
		private static void Postfix(string goodModel, int limit)
		{
			StockAlert.Infrastructure.Plugin.Plugin.Log($"Production limit updated: {goodModel} -> {limit}");
			ProductionLimitSync.SyncThresholds();
		}
	}
	[HarmonyPatch(typeof(WorkshopsService), "LoadLimits")]
	internal static class WorkshopsServiceLoadLimitsPatch
	{
		private static void Postfix()
		{
			StockAlert.Infrastructure.Plugin.Plugin.Log("Workshop global limits loaded");
			ProductionLimitSync.SyncThresholds();
		}
	}
	internal static class ProductionLimitSync
	{
		public static void SyncThresholds()
		{
			if (ConfigManager.RefreshGoodsFromProductionLimits(Discovery.Goods))
			{
				StockAlert.UI.Panels.UI.Refresh();
			}
		}
	}
	[HarmonyPatch]
	internal static class TradeRouteProfitPatch
	{
		private static readonly FieldInfo StateField = AccessTools.Field(typeof(TownOfferSlot), "state");

		private static readonly FieldInfo TimeTextField = AccessTools.Field(typeof(TownOfferSlot), "timeText");

		private static readonly PropertyInfo EffectsServiceProperty = AccessTools.Property(typeof(GameMB), "EffectsService");

		private static readonly PropertyInfo TradeServiceProperty = AccessTools.Property(typeof(GameMB), "TradeService");

		private static MethodInfo _getTradeRoutesRewardsMethod;

		private static MethodInfo _getTradeRoutesFuelMethod;

		private static MethodInfo _getValueInCurrencyMethod;

		[HarmonyPatch(typeof(TownOfferSlot), "SetUpTexts")]
		[HarmonyPostfix]
		private static void AddProfitToTravelTime(TownOfferSlot __instance)
		{
			if (!ConfigManager.ShowTradeRouteProfit || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				object? obj = StateField?.GetValue(__instance);
				TownOfferState val = (TownOfferState)((obj is TownOfferState) ? obj : null);
				object? obj2 = TimeTextField?.GetValue(__instance);
				TMP_Text val2 = (TMP_Text)((obj2 is TMP_Text) ? obj2 : null);
				if (val != null && !((Object)(object)val2 == (Object)null) && TryCalculateProfitPerGood(val, out var profitPerGood))
				{
					val2.richText = true;
					val2.text = val2.text + "  <color=" + GetProfitColor(profitPerGood) + ">Profit/good " + FormatProfit(profitPerGood) + "</color>";
				}
			}
			catch (Exception)
			{
			}
		}

		private static bool TryCalculateProfitPerGood(TownOfferState state, out float profitPerGood)
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			profitPerGood = 0f;
			Settings settings = GameAPI.GetSettings();
			TradeRoutesConfig val = settings?.tradeRoutesConfig;
			GoodModel val2 = ((settings != null) ? settings.GetGood(state.good.name) : null);
			GoodModel val3 = settings?.tradeCurrency;
			GoodModel val4 = val?.fuel;
			if ((Object)(object)settings == (Object)null || (Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
			{
				return false;
			}
			if (state.amount <= 0 || state.good.amount <= 0 || state.price < 0 || state.fuel < 0)
			{
				return false;
			}
			int num = state.good.amount * state.amount;
			if (num <= 0)
			{
				return false;
			}
			Good val5 = ApplyTradeRouteRewardEffects(new Good(((SO)val3).Name, state.price));
			Good val6 = ApplyTradeRouteFuelEffects(new Good(((SO)val4).Name, state.fuel));
			float traderSellValueInAmber = GetTraderSellValueInAmber(state.good.name, num);
			float traderSellValueInAmber2 = GetTraderSellValueInAmber(val6.name, val6.amount * state.amount);
			int num2 = val5.amount * state.amount;
			float num3 = (float)num2 - traderSellValueInAmber - traderSellValueInAmber2;
			profitPerGood = num3 / (float)num;
			return true;
		}

		private static float GetTraderSellValueInAmber(string goodName, int amount)
		{
			if (string.IsNullOrWhiteSpace(goodName) || amount <= 0)
			{
				return 0f;
			}
			object obj = TradeServiceProperty?.GetValue(null, null);
			if (obj == null)
			{
				return 0f;
			}
			if ((object)_getValueInCurrencyMethod == null)
			{
				_getValueInCurrencyMethod = obj.GetType().GetMethod("GetValueInCurrency", new Type[2]
				{
					typeof(string),
					typeof(int)
				});
			}
			return (_getValueInCurrencyMethod?.Invoke(obj, new object[2] { goodName, amount }) is float num) ? num : 0f;
		}

		private static Good ApplyTradeRouteRewardEffects(Good reward)
		{
			//IL_001e: 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_008e: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			object obj = EffectsServiceProperty?.GetValue(null, null);
			if (obj == null)
			{
				return reward;
			}
			if ((object)_getTradeRoutesRewardsMethod == null)
			{
				_getTradeRoutesRewardsMethod = obj.GetType().GetMethod("GetTradeRoutesRewards", new Type[1] { typeof(Good) });
			}
			return (_getTradeRoutesRewardsMethod?.Invoke(obj, new object[1] { reward }) is Good val) ? val : reward;
		}

		private static Good ApplyTradeRouteFuelEffects(Good fuel)
		{
			//IL_001e: 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_008e: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			object obj = EffectsServiceProperty?.GetValue(null, null);
			if (obj == null)
			{
				return fuel;
			}
			if ((object)_getTradeRoutesFuelMethod == null)
			{
				_getTradeRoutesFuelMethod = obj.GetType().GetMethod("GetTradeRoutesFuel", new Type[1] { typeof(Good) });
			}
			return (_getTradeRoutesFuelMethod?.Invoke(obj, new object[1] { fuel }) is Good val) ? val : fuel;
		}

		private static string FormatProfit(float profit)
		{
			return (profit > 0f) ? $"+{profit:0.#}" : profit.ToString("0.#");
		}

		private static string GetProfitColor(float profit)
		{
			if (profit > 0f)
			{
				return "#7CFF6B";
			}
			if (profit < 0f)
			{
				return "#FF6B5E";
			}
			return "#FFD95A";
		}
	}
	[HarmonyPatch]
	internal static class WorkerAssignmentQueuePatch
	{
		[HarmonyPatch(typeof(BuildingWorkerSlot), "SetUp")]
		[HarmonyPostfix]
		private static void BuildingWorkerSlotSetUpPostfix(BuildingWorkerSlot __instance)
		{
			QueuedWorkerSlotCompanion.Attach(__instance);
		}

		[HarmonyPatch(typeof(BuildingWorkerSlot), "OnRacePicked")]
		[HarmonyPrefix]
		private static bool BuildingWorkerSlotOnRacePickedPrefix(BuildingWorkerSlot __instance, RaceModel race)
		{
			if (!ConfigManager.EnableQueuedWorkerAssignments || (Object)(object)__instance == (Object)null || (Object)(object)race == (Object)null)
			{
				return true;
			}
			if (!IsQueueModifierPressed())
			{
				return true;
			}
			ProductionBuilding value = Traverse.Create((object)__instance).Field("building").GetValue<ProductionBuilding>();
			WorkplaceModel value2 = Traverse.Create((object)__instance).Field("workplace").GetValue<WorkplaceModel>();
			Actor value3 = Traverse.Create((object)__instance).Field("actor").GetValue<Actor>();
			if ((Object)(object)value == (Object)null || value2 == null)
			{
				return true;
			}
			Villager val = (Villager)(object)((value3 is Villager) ? value3 : null);
			if (val != null && (Object)(object)val.raceModel == (Object)(object)race)
			{
				return false;
			}
			WorkerAssignmentQueue.SetQueuedRace(value, value2, race);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(BuildingWorkerSlot), "TryAssign")]
		[HarmonyPrefix]
		private static bool BuildingWorkerSlotTryAssignPrefix(BuildingWorkerSlot __instance, RaceModel race)
		{
			if (!ConfigManager.EnableQueuedWorkerAssignments || (Object)(object)race == (Object)null || !IsQueueModifierPressed())
			{
				return true;
			}
			ProductionBuilding value = Traverse.Create((object)__instance).Field("building").GetValue<ProductionBuilding>();
			WorkplaceModel value2 = Traverse.Create((object)__instance).Field("workplace").GetValue<WorkplaceModel>();
			if ((Object)(object)value == (Object)null || value2 == null)
			{
				return true;
			}
			WorkerAssignmentQueue.SetQueuedRace(value, value2, race);
			PlayButtonSound();
			return false;
		}

		[HarmonyPatch(typeof(RacesMenuSlot), "UpdateButton")]
		[HarmonyPostfix]
		private static void RacesMenuSlotUpdateButtonPostfix(RacesMenuSlot __instance)
		{
			if (ConfigManager.EnableQueuedWorkerAssignments && !((Object)(object)__instance == (Object)null))
			{
				Button value = Traverse.Create((object)__instance).Field("button").GetValue<Button>();
				if ((Object)(object)value != (Object)null)
				{
					((Selectable)value).interactable = true;
				}
			}
		}

		[HarmonyPatch(typeof(RacesMenuSlot), "SetUp")]
		[HarmonyPostfix]
		private static void RacesMenuSlotSetUpPostfix(RacesMenuSlot __instance)
		{
			IdleBuilderRaceMenuMarker.Attach(__instance);
		}

		[HarmonyPatch(typeof(RacesMenu), "OnClicked")]
		[HarmonyPrefix]
		private static bool RacesMenuOnClickedPrefix(RacesMenu __instance, RacesMenuSlot pick)
		{
			if (!ConfigManager.EnableQueuedWorkerAssignments || (Object)(object)__instance == (Object)null || (Object)(object)pick == (Object)null)
			{
				return true;
			}
			RaceModel race = pick.GetRace();
			if ((Object)(object)race == (Object)null || !IsQueueModifierPressed())
			{
				return true;
			}
			Traverse.Create((object)__instance).Field("lastClick").SetValue((object)Time.unscaledTime);
			Traverse.Create((object)__instance).Field("callback").GetValue<Action<RaceModel>>()?.Invoke(race);
			typeof(RadialMenu).GetMethod("Hide", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(__instance, null);
			return false;
		}

		private static bool IsQueueModifierPressed()
		{
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				return ((ButtonControl)current.leftCtrlKey).isPressed || ((ButtonControl)current.rightCtrlKey).isPressed || current.ctrlKey.isPressed;
			}
			return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
		}

		private static void PlayButtonSound()
		{
			try
			{
				object obj = typeof(MB).GetProperty("SoundsManager", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null, null);
				obj?.GetType().GetMethod("PlayButtonSound", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj, null);
			}
			catch (Exception)
			{
			}
		}
	}
}
namespace StockAlert.Infrastructure.Bootstrap
{
	internal sealed class StockAlertRuntime : MonoBehaviour
	{
		private static StockAlertRuntime _instance;

		private float _nextRefreshTime;

		private float _nextAutoAdjustTime;

		private float _nextBuilderStatusRefreshTime;

		private float _nextWorkerQueueRefreshTime;

		private float _nextItemLocatorRefreshTime;

		private bool _seasonEndingAlertShown;

		private GameDate _seasonEndingAlertDate;

		private bool _wasGameActive;

		public static void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)_instance != (Object)null)
			{
				((Behaviour)_instance).enabled = true;
				return;
			}
			GameObject val = new GameObject("StockAlertRuntime");
			Object.DontDestroyOnLoad((Object)(object)val);
			_instance = val.AddComponent<StockAlertRuntime>();
		}

		private void Awake()
		{
			StockAlert.Infrastructure.Plugin.Plugin.Log("StockAlertRuntime ready");
		}

		private void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut toggleSettingsKey = ConfigManager.ToggleSettingsKey;
			if (((KeyboardShortcut)(ref toggleSettingsKey)).IsDown())
			{
				StockAlert.UI.Panels.UI.Toggle();
			}
			if (!GameAPI.IsGameActive())
			{
				if (_wasGameActive)
				{
					StockAlert.Infrastructure.Plugin.Plugin.Instance?.ResetGameReady();
				}
				_wasGameActive = false;
				BuilderStatusIndicators.Clear();
				IdleBuildersAlert.Clear();
				WorkerAssignmentQueue.ClearAll();
				ItemLocatorOverlay.Clear();
				_seasonEndingAlertShown = false;
				_seasonEndingAlertDate = default(GameDate);
				return;
			}
			_wasGameActive = true;
			UpdateSeasonEndingTradeRoutesAlert();
			if (Time.unscaledTime >= _nextRefreshTime)
			{
				_nextRefreshTime = Time.unscaledTime + 1f;
				Discovery.UpdateStock();
				BuildingAlertIndicators.Refresh();
			}
			if (Time.unscaledTime >= _nextBuilderStatusRefreshTime)
			{
				_nextBuilderStatusRefreshTime = Time.unscaledTime + 0.5f;
				BuilderStatusIndicators.Refresh();
				IdleBuildersAlert.Refresh();
			}
			if (Time.unscaledTime >= _nextWorkerQueueRefreshTime)
			{
				_nextWorkerQueueRefreshTime = Time.unscaledTime + 0.5f;
				if (ConfigManager.EnableQueuedWorkerAssignments)
				{
					WorkerAssignmentQueue.Process();
				}
				else
				{
					WorkerAssignmentQueue.ClearAll();
					QueuedWorkerSlotCompanion.ClearAll();
				}
			}
			if (Time.unscaledTime >= _nextItemLocatorRefreshTime)
			{
				_nextItemLocatorRefreshTime = Time.unscaledTime + 0.5f;
				ItemLocatorOverlay.Refresh();
			}
			if ((ConfigManager.AutoAdjustProductionLimits || ConfigManager.AutoAdjustPurgingFire) && Time.unscaledTime >= _nextAutoAdjustTime)
			{
				_nextAutoAdjustTime = Time.unscaledTime + 2f;
				AutoProductionLimits.ApplyCurrentTargets();
			}
		}

		private void UpdateSeasonEndingTradeRoutesAlert()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!ConfigManager.SeasonEndingTradeRoutesAlert)
			{
				_seasonEndingAlertShown = false;
				_seasonEndingAlertDate = default(GameDate);
				return;
			}
			GameDate currentGameDate = GameAPI.GetCurrentGameDate();
			if (!((object)(GameDate)(ref currentGameDate)).Equals((object?)_seasonEndingAlertDate))
			{
				_seasonEndingAlertDate = currentGameDate;
				_seasonEndingAlertShown = false;
			}
			if (!_seasonEndingAlertShown)
			{
				float timeTillNextSeasonChange = GameAPI.GetTimeTillNextSeasonChange();
				if (!(timeTillNextSeasonChange <= 0f) && !(timeTillNextSeasonChange > 3f))
				{
					GameAPI.PublishNews("Season ending! Check trade routes.", null, (AlertSeverity)1);
					GameAPI.PauseGame();
					_seasonEndingAlertShown = true;
				}
			}
		}
	}
}
namespace StockAlert.Game
{
	internal static class AutoProductionLimits
	{
		private static readonly Dictionary<string, HashSet<string>> ConsumingRacesByGood = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);

		private static bool _initialized;

		public static void Initialize()
		{
			if (!_initialized)
			{
				BuildConsumerMap();
				_initialized = true;
			}
		}

		public static void ApplyCurrentTargets()
		{
			if ((!ConfigManager.AutoAdjustProductionLimits && !ConfigManager.AutoAdjustPurgingFire) || !GameAPI.IsGameActive())
			{
				return;
			}
			Initialize();
			HashSet<string> availableRecipeGoods = GameAPI.GetAvailableRecipeGoods();
			if (availableRecipeGoods.Count == 0)
			{
				return;
			}
			bool flag = false;
			if (ConfigManager.AutoAdjustProductionLimits)
			{
				float autoAdjustMultiplier = ConfigManager.AutoAdjustMultiplier;
				foreach (KeyValuePair<string, HashSet<string>> item in ConsumingRacesByGood)
				{
					if (!availableRecipeGoods.Contains(item.Key))
					{
						continue;
					}
					int num = 0;
					foreach (string item2 in item.Value)
					{
						num += GameAPI.GetAliveVillagerCount(item2);
					}
					int num2 = Mathf.Max(0, Mathf.CeilToInt((float)num * autoAdjustMultiplier));
					int productionLimit = GameAPI.GetProductionLimit(null, item.Key);
					if (productionLimit != num2)
					{
						GameAPI.SetProductionLimit(item.Key, num2);
						Plugin.Log($"Auto-adjusted production limit for {item.Key} => {num2} ({num} consumers x {autoAdjustMultiplier:0.0})");
						flag = true;
					}
				}
			}
			if (ConfigManager.AutoAdjustPurgingFire)
			{
				flag |= ApplyBlightFuelTarget(availableRecipeGoods);
			}
			if (flag)
			{
				GameAPI.RefreshWorkshopLimits();
			}
		}

		private static void BuildConsumerMap()
		{
			ConsumingRacesByGood.Clear();
			Settings settings = GameAPI.GetSettings();
			if (settings?.Races == null)
			{
				return;
			}
			RaceModel[] races = settings.Races;
			foreach (RaceModel val in races)
			{
				if (val?.needs == null || string.IsNullOrWhiteSpace(((SO)val).Name))
				{
					continue;
				}
				NeedModel[] needs = val.needs;
				for (int j = 0; j < needs.Length; j++)
				{
					GoodModel val2 = needs[j]?.referenceGood;
					if (!((Object)(object)val2 == (Object)null) && !string.IsNullOrWhiteSpace(((SO)val2).Name))
					{
						if (!ConsumingRacesByGood.TryGetValue(((SO)val2).Name, out var value))
						{
							value = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
							ConsumingRacesByGood[((SO)val2).Name] = value;
						}
						value.Add(((SO)val).Name);
					}
				}
			}
			Plugin.Log($"AutoProductionLimits: mapped {ConsumingRacesByGood.Count} consumable goods");
		}

		private static bool ApplyBlightFuelTarget(HashSet<string> availableRecipeGoods)
		{
			string blightPostFuelId = GameAPI.GetBlightPostFuelId();
			if (string.IsNullOrWhiteSpace(blightPostFuelId) || !availableRecipeGoods.Contains(blightPostFuelId))
			{
				return false;
			}
			int num = Mathf.Max(0, GameAPI.GetGlobalActiveCysts() + 1);
			int productionLimit = GameAPI.GetProductionLimit(null, blightPostFuelId);
			if (productionLimit == num)
			{
				return false;
			}
			GameAPI.SetProductionLimit(blightPostFuelId, num);
			Plugin.Log($"Auto-adjusted production limit for {blightPostFuelId} => {num} ({num - 1} cysts + 1)");
			return true;
		}
	}
	public static class GameAPI
	{
		private static PropertyInfo _piMbSettings;

		private static PropertyInfo _piStorageService;

		private static PropertyInfo _piWorkshopsService;

		private static PropertyInfo _piGameContentService;

		private static PropertyInfo _piRecipesService;

		private static PropertyInfo _piVillagersService;

		private static PropertyInfo _piBuildingsService;

		private static PropertyInfo _piBlightService;

		private static PropertyInfo _piLocalStorages;

		private static PropertyInfo _piIngredientsStorages;

		private static PropertyInfo _piIsGameActive;

		private static PropertyInfo _piCalendarService;

		private static PropertyInfo _piTimeScaleService;

		private static PropertyInfo _piNewsService;

		private static PropertyInfo _piResourcesService;

		private static PropertyInfo _piDepositsService;

		private static PropertyInfo _piLakesService;

		private static PropertyInfo _piOreService;

		private static PropertyInfo _piGladesService;

		private static MethodInfo _miGetAmount;

		private static MethodInfo _miGetGlobalLimit;

		private static MethodInfo _miSetGlobalLimit;

		private static MethodInfo _miIsBuildingUnlocked;

		private static MethodInfo _miGetRecipesForBuilding;

		private static MethodInfo _miGetAliveRaceAmount;

		private static MethodInfo _miGetGlobalActiveCysts;

		private static MethodInfo _miGetDefaultProfessionAmount;

		private static MethodInfo _miGetDefaultProfessionVillager;

		private static MethodInfo _miSetProfession;

		private static MethodInfo _miGetTimeTillNextSeasonChange;

		private static MethodInfo _miPause;

		private static MethodInfo _miPublishNews;

		private static MethodInfo _miRemoveNews;

		private static MethodInfo _miIsGlade;

		private static PropertyInfo _piWorkshopLimits;

		private static PropertyInfo _piWorkshops;

		private static PropertyInfo _piBlightPosts;

		private static PropertyInfo _piGathererHuts;

		private static PropertyInfo _piCamps;

		private static FieldInfo _fiCurrentNews;

		private static PropertyInfo _piReactiveValue;

		public static Settings GetSettings()
		{
			if (_piMbSettings == null)
			{
				_piMbSettings = typeof(MB).GetProperty("Settings", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			object? obj = _piMbSettings?.GetValue(null, null);
			return (Settings)((obj is Settings) ? obj : null);
		}

		public static int GetStoredAmount(GoodModel model, string fallbackId)
		{
			if ((Object)(object)model == (Object)null && string.IsNullOrWhiteSpace(fallbackId))
			{
				return 0;
			}
			try
			{
				if (_piStorageService == null)
				{
					_piStorageService = typeof(GameMB).GetProperty("StorageService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				object obj = _piStorageService?.GetValue(null, null);
				if (obj == null)
				{
					return 0;
				}
				if (_miGetAmount == null)
				{
					_miGetAmount = obj.GetType().GetMethod("GetAmount", new Type[1] { typeof(string) });
				}
				if (_miGetAmount == null)
				{
					return 0;
				}
				string text = (((Object)(object)model != (Object)null) ? ((SO)model).Name : fallbackId);
				return (int)_miGetAmount.Invoke(obj, new object[1] { text });
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static int GetAmountInNonWarehouseBuildings(string goodId)
		{
			if (string.IsNullOrWhiteSpace(goodId))
			{
				return 0;
			}
			try
			{
				object storageService = GetStorageService();
				if (storageService == null)
				{
					return 0;
				}
				int num = 0;
				if ((object)_piLocalStorages == null)
				{
					_piLocalStorages = storageService.GetType().GetProperty("LocalStorages", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_piLocalStorages?.GetValue(storageService, null) is IDictionary dictionary)
				{
					foreach (DictionaryEntry item in dictionary)
					{
						object? value = item.Value;
						BuildingStorage val = (BuildingStorage)((value is BuildingStorage) ? value : null);
						if (val != null)
						{
							num += val.GetAmount(goodId);
						}
					}
				}
				if ((object)_piIngredientsStorages == null)
				{
					_piIngredientsStorages = storageService.GetType().GetProperty("IngredientsStorages", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_piIngredientsStorages?.GetValue(storageService, null) is IDictionary dictionary2)
				{
					foreach (DictionaryEntry item2 in dictionary2)
					{
						object? value2 = item2.Value;
						BuildingIngredientsStorage val2 = (BuildingIngredientsStorage)((value2 is BuildingIngredientsStorage) ? value2 : null);
						if (val2 != null && val2.goods != null)
						{
							num += val2.goods.GetAmount(goodId);
						}
					}
				}
				return num;
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static bool IsGameActive()
		{
			try
			{
				if (_piIsGameActive == null)
				{
					_piIsGameActive = typeof(GameMB).GetProperty("IsGameActive", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_piIsGameActive == null)
				{
					return false;
				}
				object value = _piIsGameActive.GetValue(null, null);
				bool flag = default(bool);
				int num;
				if (value is bool)
				{
					flag = (bool)value;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static Dictionary<string, int> GetProductionLimitsSnapshot()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			try
			{
				object workshopsService = GetWorkshopsService();
				if (workshopsService == null)
				{
					return dictionary;
				}
				if (_piWorkshopLimits == null)
				{
					_piWorkshopLimits = workshopsService.GetType().GetProperty("Limits", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (!(_piWorkshopLimits?.GetValue(workshopsService, null) is IDictionary dictionary2))
				{
					return dictionary;
				}
				foreach (DictionaryEntry item in dictionary2)
				{
					if (item.Key is string key && item.Value is int value)
					{
						dictionary[key] = value;
					}
				}
			}
			catch (Exception)
			{
			}
			return dictionary;
		}

		public static int GetProductionLimit(GoodModel model, string fallbackId)
		{
			if (string.IsNullOrWhiteSpace(fallbackId))
			{
				return 0;
			}
			try
			{
				object workshopsService = GetWorkshopsService();
				if (workshopsService == null)
				{
					return 0;
				}
				if (_miGetGlobalLimit == null)
				{
					_miGetGlobalLimit = workshopsService.GetType().GetMethod("GetGlobalLimitFor", new Type[1] { typeof(string) });
				}
				if (_miGetGlobalLimit == null)
				{
					return 0;
				}
				return (int)_miGetGlobalLimit.Invoke(workshopsService, new object[1] { fallbackId });
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static void SetProductionLimit(string goodId, int limit)
		{
			if (string.IsNullOrWhiteSpace(goodId))
			{
				return;
			}
			try
			{
				object workshopsService = GetWorkshopsService();
				if (workshopsService != null)
				{
					if (_miSetGlobalLimit == null)
					{
						_miSetGlobalLimit = workshopsService.GetType().GetMethod("SetGlobalLimitFor", new Type[2]
						{
							typeof(string),
							typeof(int)
						});
					}
					_miSetGlobalLimit?.Invoke(workshopsService, new object[2] { goodId, limit });
				}
			}
			catch (Exception)
			{
			}
		}

		public static void RefreshWorkshopLimits()
		{
			try
			{
				object buildingsService = GetBuildingsService();
				if (buildingsService != null)
				{
					RefreshLimitsFromDictionary(buildingsService, "Workshops", ref _piWorkshops);
					RefreshLimitsFromDictionary(buildingsService, "BlightPosts", ref _piBlightPosts);
				}
			}
			catch (Exception)
			{
			}
		}

		public static int GetAliveVillagerCount(string raceId)
		{
			if (string.IsNullOrWhiteSpace(raceId))
			{
				return 0;
			}
			try
			{
				if (_piVillagersService == null)
				{
					_piVillagersService = typeof(GameMB).GetProperty("VillagersService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				object obj = _piVillagersService?.GetValue(null, null);
				if (obj == null)
				{
					return 0;
				}
				if (_miGetAliveRaceAmount == null)
				{
					_miGetAliveRaceAmount = obj.GetType().GetMethod("GetAliveRaceAmount", new Type[1] { typeof(string) });
				}
				if (_miGetAliveRaceAmount == null)
				{
					return 0;
				}
				return (int)_miGetAliveRaceAmount.Invoke(obj, new object[1] { raceId });
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static int GetDefaultProfessionAmount(string raceId)
		{
			if (string.IsNullOrWhiteSpace(raceId))
			{
				return 0;
			}
			try
			{
				object villagersService = GetVillagersService();
				if (villagersService == null)
				{
					return 0;
				}
				if (_miGetDefaultProfessionAmount == null)
				{
					_miGetDefaultProfessionAmount = villagersService.GetType().GetMethod("GetDefaultProfessionAmount", new Type[1] { typeof(string) });
				}
				if (_miGetDefaultProfessionAmount == null)
				{
					return 0;
				}
				return (int)_miGetDefaultProfessionAmount.Invoke(villagersService, new object[1] { raceId });
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static Villager GetDefaultProfessionVillager(string raceId, ProductionBuilding building)
		{
			if (string.IsNullOrWhiteSpace(raceId) || (Object)(object)building == (Object)null)
			{
				return null;
			}
			try
			{
				object villagersService = GetVillagersService();
				if (villagersService == null)
				{
					return null;
				}
				if (_miGetDefaultProfessionVillager == null)
				{
					_miGetDefaultProfessionVillager = villagersService.GetType().GetMethod("GetDefaultProfessionVillager", new Type[2]
					{
						typeof(string),
						typeof(ProductionBuilding)
					});
				}
				object? obj = _miGetDefaultProfessionVillager?.Invoke(villagersService, new object[2] { raceId, building });
				return (Villager)((obj is Villager) ? obj : null);
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static void AssignVillagerToWorkplace(Villager villager, ProductionBuilding building, int workplaceIndex)
		{
			if ((Object)(object)villager == (Object)null || (Object)(object)building == (Object)null || workplaceIndex < 0)
			{
				return;
			}
			try
			{
				object villagersService = GetVillagersService();
				if (villagersService != null)
				{
					if (_miSetProfession == null)
					{
						_miSetProfession = villagersService.GetType().GetMethod("SetProfession", new Type[5]
						{
							typeof(Villager),
							typeof(string),
							typeof(ProductionBuilding),
							typeof(int),
							typeof(bool)
						});
					}
					_miSetProfession?.Invoke(villagersService, new object[5] { villager, building.Profession, building, workplaceIndex, true });
				}
			}
			catch (Exception)
			{
			}
		}

		public static int GetGlobalActiveCysts()
		{
			try
			{
				object blightService = GetBlightService();
				if (blightService == null)
				{
					return 0;
				}
				if (_miGetGlobalActiveCysts == null)
				{
					_miGetGlobalActiveCysts = blightService.GetType().GetMethod("GetGlobalActiveCysts", Type.EmptyTypes);
				}
				if (_miGetGlobalActiveCysts == null)
				{
					return 0;
				}
				return (int)_miGetGlobalActiveCysts.Invoke(blightService, null);
			}
			catch (Exception)
			{
				return 0;
			}
		}

		public static float GetTimeTillNextSeasonChange()
		{
			try
			{
				object calendarService = GetCalendarService();
				if (calendarService == null)
				{
					return float.MaxValue;
				}
				if (_miGetTimeTillNextSeasonChange == null)
				{
					_miGetTimeTillNextSeasonChange = calendarService.GetType().GetMethod("GetTimeTillNextSeasonChange", Type.EmptyTypes);
				}
				if (_miGetTimeTillNextSeasonChange == null)
				{
					return float.MaxValue;
				}
				return (float)_miGetTimeTillNextSeasonChange.Invoke(calendarService, null);
			}
			catch (Exception)
			{
				return float.MaxValue;
			}
		}

		public static GameDate GetCurrentGameDate()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object calendarService = GetCalendarService();
				return (GameDate)(((calendarService?.GetType().GetProperty("GameDate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))?.GetValue(calendarService, null) is GameDate val) ? val : default(GameDate));
			}
			catch (Exception)
			{
				return default(GameDate);
			}
		}

		public static void PauseGame()
		{
			try
			{
				object timeScaleService = GetTimeScaleService();
				if (timeScaleService == null)
				{
					return;
				}
				object obj = timeScaleService.GetType().GetMethod("IsPaused", Type.EmptyTypes)?.Invoke(timeScaleService, null);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) == 0)
				{
					if (_miPause == null)
					{
						_miPause = timeScaleService.GetType().GetMethod("Pause", new Type[1] { typeof(bool) });
					}
					_miPause?.Invoke(timeScaleService, new object[1] { false });
				}
			}
			catch (Exception)
			{
			}
		}

		public static News PublishNews(string content, string description = null, AlertSeverity severity = 1)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(content))
			{
				return null;
			}
			try
			{
				object newsService = GetNewsService();
				if (newsService == null)
				{
					return null;
				}
				HashSet<News> before = new HashSet<News>(GetCurrentNews());
				if (_miPublishNews == null)
				{
					_miPublishNews = newsService.GetType().GetMethod("PublishNews", new Type[5]
					{
						typeof(string),
						typeof(string),
						typeof(AlertSeverity),
						typeof(Sprite),
						typeof(IBroadcaster)
					});
				}
				_miPublishNews?.Invoke(newsService, new object[5] { content, description, severity, null, null });
				return ((IEnumerable<News>)GetCurrentNews()).FirstOrDefault((Func<News, bool>)((News news) => news != null && !before.Contains(news) && news.content == content));
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static void RemoveNews(News news)
		{
			if (news == null)
			{
				return;
			}
			try
			{
				object newsService = GetNewsService();
				if (newsService != null)
				{
					if (_miRemoveNews == null)
					{
						_miRemoveNews = newsService.GetType().GetMethod("RemoveNews", new Type[1] { typeof(News) });
					}
					_miRemoveNews?.Invoke(newsService, new object[1] { news });
				}
			}
			catch (Exception)
			{
			}
		}

		public static List<News> GetCurrentNews()
		{
			try
			{
				object newsService = GetNewsService();
				if (newsService == null)
				{
					return new List<News>();
				}
				if ((object)_fiCurrentNews == null)
				{
					_fiCurrentNews = newsService.GetType().GetField("currentNews", BindingFlags.Instance | BindingFlags.NonPublic);
				}
				object obj = _fiCurrentNews?.GetValue(newsService);
				if (obj == null)
				{
					return new List<News>();
				}
				if ((object)_piReactiveValue == null)
				{
					_piReactiveValue = obj.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				return (_piReactiveValue?.GetValue(obj, null) as List<News>) ?? new List<News>();
			}
			catch (Exception)
			{
				return new List<News>();
			}
		}

		public static string GetBlightPostFuelId()
		{
			try
			{
				Settings settings = GetSettings();
				object obj;
				if (settings == null)
				{
					obj = null;
				}
				else
				{
					BlightConfig blightConfig = settings.blightConfig;
					if (blightConfig == null)
					{
						obj = null;
					}
					else
					{
						GoodRef blightPostFuel = blightConfig.blightPostFuel;
						obj = ((blightPostFuel != null) ? blightPostFuel.Name : null);
					}
				}
				if (obj == null)
				{
					obj = string.Empty;
				}
				return (string)obj;
			}
			catch (Exception)
			{
				return string.Empty;
			}
		}

		public static HashSet<string> GetAvailableRecipeGoods()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				object buildingsService = GetBuildingsService();
				if (buildingsService == null)
				{
					return hashSet;
				}
				AddRecipeGoodsFromDictionary(buildingsService, "Workshops", ref _piWorkshops, hashSet);
				AddRecipeGoodsFromDictionary(buildingsService, "BlightPosts", ref _piBlightPosts, hashSet);
				Settings settings = GetSettings();
				if ((Object)(object)settings != (Object)null)
				{
					AddUnlockedRecipeGoodsFromModels((IEnumerable<BuildingModel>)(object)settings.workshops, hashSet);
					AddUnlockedRecipeGoodsFromModels((IEnumerable<BuildingModel>)(object)settings.blightPosts, hashSet);
				}
			}
			catch (Exception)
			{
			}
			return hashSet;
		}

		private static void AddUnlockedRecipeGoodsFromModels(IEnumerable<BuildingModel> buildingModels, HashSet<string> goods)
		{
			if (buildingModels == null)
			{
				return;
			}
			foreach (BuildingModel buildingModel in buildingModels)
			{
				if (!((Object)(object)buildingModel == (Object)null) && buildingModel.HasAccessTo() && IsBuildingUnlocked(buildingModel))
				{
					AddRecipeGoodsFromModel(buildingModel, goods);
				}
			}
		}

		private static void AddRecipeGoodsFromModel(BuildingModel buildingModel, HashSet<string> goods)
		{
			Settings settings = GetSettings();
			object recipesService = GetRecipesService();
			if ((Object)(object)settings == (Object)null || recipesService == null)
			{
				return;
			}
			if (_miGetRecipesForBuilding == null)
			{
				_miGetRecipesForBuilding = recipesService.GetType().GetMethod("GetRecipesFor", new Type[1] { typeof(string) });
			}
			if (!(_miGetRecipesForBuilding?.Invoke(recipesService, new object[1] { ((SO)buildingModel).Name }) is IEnumerable<string> enumerable))
			{
				return;
			}
			foreach (string item in enumerable)
			{
				if (!string.IsNullOrWhiteSpace(item))
				{
					WorkshopRecipeModel workshopRecipe = settings.GetWorkshopRecipe(item);
					object obj;
					if (workshopRecipe == null)
					{
						obj = null;
					}
					else
					{
						GoodRef producedGood = workshopRecipe.producedGood;
						obj = ((producedGood != null) ? producedGood.Name : null);
					}
					string text = (string)obj;
					if (!string.IsNullOrWhiteSpace(text))
					{
						goods.Add(text);
					}
				}
			}
		}

		private static bool IsBuildingUnlocked(BuildingModel buildingModel)
		{
			object gameContentService = GetGameContentService();
			if (gameContentService == null)
			{
				return false;
			}
			if (_miIsBuildingUnlocked == null)
			{
				_miIsBuildingUnlocked = gameContentService.GetType().GetMethod("IsUnlocked", new Type[1] { typeof(BuildingModel) });
			}
			object obj = _miIsBuildingUnlocked?.Invoke(gameContentService, new object[1] { buildingModel });
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		public static List<IWorkshop> GetRecipeBuildings()
		{
			List<IWorkshop> list = new List<IWorkshop>();
			try
			{
				object buildingsService = GetBuildingsService();
				if (buildingsService == null)
				{
					return list;
				}
				AddWorkshopsFromDictionary(buildingsService, "Workshops", ref _piWorkshops, list);
				AddWorkshopsFromDictionary(buildingsService, "BlightPosts", ref _piBlightPosts, list);
			}
			catch (Exception)
			{
			}
			return list;
		}

		public static List<ProductionBuilding> GetGatheringSourceBuildings()
		{
			List<ProductionBuilding> list = new List<ProductionBuilding>();
			try
			{
				object buildingsService = GetBuildingsService();
				if (buildingsService == null)
				{
					return list;
				}
				AddProductionBuildingsFromDictionary(buildingsService, "GathererHuts", ref _piGathererHuts, list);
				AddProductionBuildingsFromDictionary(buildingsService, "Camps", ref _piCamps, list);
			}
			catch (Exception)
			{
			}
			return list;
		}

		internal static List<TrackedItemLocation> GetTrackedItemLocations(string goodId)
		{
			Dictionary<string, TrackedItemLocation> dictionary = new Dictionary<string, TrackedItemLocation>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(goodId))
			{
				return dictionary.Values.ToList();
			}
			try
			{
				AddBuildingStorageLocations(goodId, dictionary);
				AddIngredientStorageLocations(goodId, dictionary);
				AddRelicLocations(goodId, dictionary);
				AddCarriedGoodDestinations(goodId, dictionary);
				AddNaturalResourceLocations(goodId, dictionary);
				AddDepositLocations(goodId, dictionary);
				AddLakeLocations(goodId, dictionary);
				AddOreLocations(goodId, dictionary);
			}
			catch (Exception)
			{
			}
			return dictionary.Values.ToList();
		}

		private static object GetWorkshopsService()
		{
			if (_piWorkshopsService == null)
			{
				_piWorkshopsService = typeof(GameMB).GetProperty("WorkshopsService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piWorkshopsService?.GetValue(null, null);
		}

		private static object GetGameContentService()
		{
			if (_piGameContentService == null)
			{
				_piGameContentService = typeof(GameMB).GetProperty("GameContentService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piGameContentService?.GetValue(null, null);
		}

		private static object GetRecipesService()
		{
			if (_piRecipesService == null)
			{
				_piRecipesService = typeof(GameMB).GetProperty("RecipesService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piRecipesService?.GetValue(null, null);
		}

		private static object GetStorageService()
		{
			if (_piStorageService == null)
			{
				_piStorageService = typeof(GameMB).GetProperty("StorageService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piStorageService?.GetValue(null, null);
		}

		private static object GetBuildingsService()
		{
			if (_piBuildingsService == null)
			{
				_piBuildingsService = typeof(GameMB).GetProperty("BuildingsService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piBuildingsService?.GetValue(null, null);
		}

		private static object GetVillagersService()
		{
			if (_piVillagersService == null)
			{
				_piVillagersService = typeof(GameMB).GetProperty("VillagersService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piVillagersService?.GetValue(null, null);
		}

		private static object GetBlightService()
		{
			if (_piBlightService == null)
			{
				_piBlightService = typeof(GameMB).GetProperty("BlightService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piBlightService?.GetValue(null, null);
		}

		private static object GetCalendarService()
		{
			if (_piCalendarService == null)
			{
				_piCalendarService = typeof(GameMB).GetProperty("CalendarService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piCalendarService?.GetValue(null, null);
		}

		private static object GetTimeScaleService()
		{
			if (_piTimeScaleService == null)
			{
				_piTimeScaleService = typeof(GameMB).GetProperty("TimeScaleService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piTimeScaleService?.GetValue(null, null);
		}

		private static object GetNewsService()
		{
			if (_piNewsService == null)
			{
				_piNewsService = typeof(GameMB).GetProperty("NewsService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piNewsService?.GetValue(null, null);
		}

		private static object GetResourcesService()
		{
			if (_piResourcesService == null)
			{
				_piResourcesService = typeof(GameMB).GetProperty("ResourcesService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piResourcesService?.GetValue(null, null);
		}

		private static object GetDepositsService()
		{
			if (_piDepositsService == null)
			{
				_piDepositsService = typeof(GameMB).GetProperty("DepositsService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piDepositsService?.GetValue(null, null);
		}

		private static object GetLakesService()
		{
			if (_piLakesService == null)
			{
				_piLakesService = typeof(GameMB).GetProperty("LakesService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piLakesService?.GetValue(null, null);
		}

		private static object GetOreService()
		{
			if (_piOreService == null)
			{
				_piOreService = typeof(GameMB).GetProperty("OreService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piOreService?.GetValue(null, null);
		}

		private static object GetGladesService()
		{
			if (_piGladesService == null)
			{
				_piGladesService = typeof(GameMB).GetProperty("GladesService", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			return _piGladesService?.GetValue(null, null);
		}

		private static void AddRecipeGoodsFromDictionary(object buildingsService, string propertyName, ref PropertyInfo propertyInfo, HashSet<string> goods)
		{
			if ((object)propertyInfo == null)
			{
				propertyInfo = buildingsService.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(propertyInfo?.GetValue(buildingsService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				IWorkshop val = (IWorkshop)((value is IWorkshop) ? value : null);
				if (val == null)
				{
					continue;
				}
				foreach (WorkshopRecipeState item2 in val.Recipes.Where((WorkshopRecipeState r) => r != null && !string.IsNullOrWhiteSpace(r.productName)))
				{
					goods.Add(item2.productName);
				}
			}
		}

		private static void AddWorkshopsFromDictionary(object buildingsService, string propertyName, ref PropertyInfo propertyInfo, List<IWorkshop> workshops)
		{
			if ((object)propertyInfo == null)
			{
				propertyInfo = buildingsService.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(propertyInfo?.GetValue(buildingsService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				IWorkshop val = (IWorkshop)((value is IWorkshop) ? value : null);
				if (val != null)
				{
					workshops.Add(val);
				}
			}
		}

		private static void RefreshLimitsFromDictionary(object buildingsService, string propertyName, ref PropertyInfo propertyInfo)
		{
			if ((object)propertyInfo == null)
			{
				propertyInfo = buildingsService.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(propertyInfo?.GetValue(buildingsService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				(item.Value?.GetType().GetMethod("RefreshLimits", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))?.Invoke(item.Value, null);
			}
		}

		private static void AddProductionBuildingsFromDictionary(object buildingsService, string propertyName, ref PropertyInfo propertyInfo, List<ProductionBuilding> buildings)
		{
			if ((object)propertyInfo == null)
			{
				propertyInfo = buildingsService.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(propertyInfo?.GetValue(buildingsService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				ProductionBuilding val = (ProductionBuilding)((value is ProductionBuilding) ? value : null);
				if (val != null)
				{
					buildings.Add(val);
				}
			}
		}

		private static void AddBuildingStorageLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			object storageService = GetStorageService();
			if (storageService == null)
			{
				return;
			}
			if ((object)_piLocalStorages == null)
			{
				_piLocalStorages = storageService.GetType().GetProperty("LocalStorages", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(_piLocalStorages?.GetValue(storageService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				BuildingStorage val = (BuildingStorage)((value is BuildingStorage) ? value : null);
				if (val != null)
				{
					Building owner = val.Owner;
					int amount = val.GetAmount(goodId);
					if (!((Object)(object)owner == (Object)null) && !(owner is Storage) && amount > 0)
					{
						AddLocation(results, $"building:{owner.Id}", (Object)(object)owner, owner.Center, amount);
					}
				}
			}
		}

		private static void AddIngredientStorageLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			object storageService = GetStorageService();
			if (storageService == null)
			{
				return;
			}
			if ((object)_piIngredientsStorages == null)
			{
				_piIngredientsStorages = storageService.GetType().GetProperty("IngredientsStorages", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (!(_piIngredientsStorages?.GetValue(storageService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				BuildingIngredientsStorage val = (BuildingIngredientsStorage)((value is BuildingIngredientsStorage) ? value : null);
				if (val != null)
				{
					Building owner = val.owner;
					GoodsCollection goods = val.goods;
					int num = ((goods != null) ? goods.GetAmount(goodId) : 0);
					if (!((Object)(object)owner == (Object)null) && !(owner is Storage) && val.goods != null && num > 0)
					{
						AddLocation(results, $"building:{owner.Id}", (Object)(object)owner, owner.Center, num);
					}
				}
			}
		}

		private static void AddRelicLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			object buildingsService = GetBuildingsService();
			if (buildingsService == null || !(buildingsService.GetType().GetProperty("Relics", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(buildingsService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Relic val = (Relic)((value is Relic) ? value : null);
				if (val != null && val.state != null)
				{
					LimitedGoodsCollection relicGoods = val.state.relicGoods;
					int num = ((relicGoods != null) ? ((GoodsCollection)relicGoods).GetAmount(goodId) : 0);
					LockedGoodsCollection rewards = val.state.rewards;
					int num2 = ((rewards != null) ? ((GoodsCollection)rewards).GetAmount(goodId) : 0);
					if (num > 0 || num2 > 0)
					{
						AddLocation(results, $"building:{((Building)val).Id}", (Object)(object)val, ((Building)val).Center, num + num2);
					}
				}
			}
		}

		private static void AddCarriedGoodDestinations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			object villagersService = GetVillagersService();
			object buildingsService = GetBuildingsService();
			if (villagersService == null || buildingsService == null)
			{
				return;
			}
			IDictionary dictionary = villagersService.GetType().GetProperty("Villagers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(villagersService, null) as IDictionary;
			IDictionary dictionary2 = buildingsService.GetType().GetProperty("Buildings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(buildingsService, null) as IDictionary;
			if (dictionary == null || dictionary2 == null)
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Villager val = (Villager)((value is Villager) ? value : null);
				if (val == null || val.state == null || !((ActorState)val.state).isAlive)
				{
					continue;
				}
				int num = 0;
				Good carriedGood = ((ActorState)val.state).carriedGood;
				if (string.Equals(carriedGood.name, goodId, StringComparison.OrdinalIgnoreCase) && carriedGood.amount > 0)
				{
					num = carriedGood.amount;
				}
				else
				{
					Good good = ((ActorState)val.state).servedGoodRequest.good;
					if (string.Equals(good.name, goodId, StringComparison.OrdinalIgnoreCase) && good.amount > 0)
					{
						num = good.amount;
					}
				}
				if (num <= 0)
				{
					continue;
				}
				int toId = ((ActorState)val.state).servedGoodRequest.toId;
				if (toId > 0 && dictionary2.Contains(toId))
				{
					object? obj = dictionary2[toId];
					Building val2 = (Building)((obj is Building) ? obj : null);
					if (val2 != null && !(val2 is Storage))
					{
						AddLocation(results, $"building:{val2.Id}", (Object)(object)val2, val2.Center, num);
					}
				}
			}
		}

		private static void AddNaturalResourceLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
		}

		private static void AddDepositLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00de: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			object depositsService = GetDepositsService();
			if (depositsService == null || !(depositsService.GetType().GetProperty("AvailableDeposits", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(depositsService, null) is IDictionary dictionary) || !dictionary.Contains(goodId) || !(dictionary[goodId] is IEnumerable<ResourceDeposit> enumerable))
			{
				return;
			}
			foreach (ResourceDeposit item in enumerable)
			{
				if (!((Object)(object)item == (Object)null) && item.State.isAvailable && item.State.isActive && item.State.chargesLeft > 0)
				{
					Vector2Int field = item.Field;
					object arg = ((Vector2Int)(ref field)).x;
					field = item.Field;
					AddLocation(results, $"deposit:{arg}:{((Vector2Int)(ref field)).y}", (Object)(object)item, item.Center, 0);
				}
			}
		}

		private static void AddLakeLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			object lakesService = GetLakesService();
			if (lakesService == null || !(lakesService.GetType().GetProperty("AvailableLakes", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(lakesService, null) is IDictionary dictionary) || !dictionary.Contains(goodId) || !(dictionary[goodId] is IEnumerable<Lake> enumerable))
			{
				return;
			}
			foreach (Lake item in enumerable)
			{
				if (!((Object)(object)item == (Object)null) && item.State.isAvailable && item.State.chargesLeft > 0)
				{
					Vector2Int field = item.Field;
					object arg = ((Vector2Int)(ref field)).x;
					field = item.Field;
					AddLocation(results, $"lake:{arg}:{((Vector2Int)(ref field)).y}", (Object)(object)item, item.Center, 0);
				}
			}
		}

		private static void AddOreLocations(string goodId, IDictionary<string, TrackedItemLocation> results)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			object oreService = GetOreService();
			if (oreService == null || !(oreService.GetType().GetProperty("Ore", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(oreService, null) is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Ore val = (Ore)((value is Ore) ? value : null);
				if (val != null && string.Equals(val.GetRefGood(), goodId, StringComparison.OrdinalIgnoreCase) && (val.State.mainCharges?.Sum() ?? 0) + (val.State.extraCharges?.Sum() ?? 0) > 0 && !IsFieldInGlade(val.Field))
				{
					Vector2Int field = val.Field;
					object arg = ((Vector2Int)(ref field)).x;
					field = val.Field;
					AddLocation(results, $"ore:{arg}:{((Vector2Int)(ref field)).y}", (Object)(object)val, val.Center, 0);
				}
			}
		}

		private static bool IsFieldInGlade(Vector2Int field)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object gladesService = GetGladesService();
				if (gladesService == null)
				{
					return false;
				}
				if ((object)_miIsGlade == null)
				{
					_miIsGlade = gladesService.GetType().GetMethod("IsGlade", new Type[1] { typeof(Vector2Int) });
				}
				object obj = _miIsGlade?.Invoke(gladesService, new object[1] { field });
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void AddLocation(IDictionary<string, TrackedItemLocation> results, string key, Object source, Vector3 fallbackPosition, int amount)
		{
			//IL_0071: 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)
			if (!string.IsNullOrWhiteSpace(key) && !(source == (Object)null))
			{
				if (results.TryGetValue(key, out var value) && value != null)
				{
					value.Source = source;
					value.FallbackPosition = fallbackPosition;
					value.Amount += Math.Max(0, amount);
				}
				else
				{
					results[key] = new TrackedItemLocation
					{
						Key = key,
						Source = source,
						FallbackPosition = fallbackPosition,
						Amount = Math.Max(0, amount)
					};
				}
			}
		}
	}
	internal static class WorkerAssignmentQueue
	{
		private readonly struct QueueKey : IEquatable<QueueKey>
		{
			public int BuildingId { get; }

			public int WorkplaceIndex { get; }

			public QueueKey(int buildingId, int workplaceIndex)
			{
				BuildingId = buildingId;
				WorkplaceIndex = workplaceIndex;
			}

			public bool Equals(QueueKey other)
			{
				return BuildingId == other.BuildingId && WorkplaceIndex == other.WorkplaceIndex;
			}

			public override bool Equals(object obj)
			{
				return obj is QueueKey other && Equals(other);
			}

			public override int GetHashCode()
			{
				return (BuildingId * 397) ^ WorkplaceIndex;
			}
		}

		private sealed class QueueEntry
		{
			public QueueKey Key;

			public ProductionBuilding Building;

			public WorkplaceModel Workplace;

			public string RaceId;

			public long Order;
		}

		private static readonly Dictionary<QueueKey, QueueEntry> Entries = new Dictionary<QueueKey, QueueEntry>();

		private static PropertyInfo _piIsRemoved;

		private static PropertyInfo _piReactiveValue;

		private static long _nextOrder;

		public static void SetQueuedRace(ProductionBuilding building, WorkplaceModel workplace, RaceModel race)
		{
			if (!((Object)(object)building == (Object)null) && workplace != null && !((Object)(object)race == (Object)null))
			{
				SetQueuedRace(building, building.GetIndexOf(workplace), workplace, ((SO)race).Name);
			}
		}

		public static void SetQueuedRace(ProductionBuilding building, int workplaceIndex, WorkplaceModel workplace, string raceId)
		{
			if (!((Object)(object)building == (Object)null) && workplaceIndex >= 0 && !string.IsNullOrWhiteSpace(raceId))
			{
				QueueKey key = new QueueKey(((Building)building).Id, workplaceIndex);
				if (!Entries.TryGetValue(key, out var value))
				{
					value = new QueueEntry
					{
						Key = key,
						Building = building,
						Workplace = workplace,
						Order = ++_nextOrder
					};
					Entries[key] = value;
				}
				value.Building = building;
				value.Workplace = workplace ?? value.Workplace;
				value.RaceId = raceId;
				Plugin.Log($"Queued {raceId} for {((Building)building).ModelName} workplace {workplaceIndex}");
			}
		}

		public static void ClearQueuedRace(ProductionBuilding building, WorkplaceModel workplace)
		{
			if (!((Object)(object)building == (Object)null) && workplace != null)
			{
				ClearQueuedRace(building, building.GetIndexOf(workplace));
			}
		}

		public static void ClearQueuedRace(ProductionBuilding building, int workplaceIndex)
		{
			if (!((Object)(object)building == (Object)null) && workplaceIndex >= 0)
			{
				Entries.Remove(new QueueKey(((Building)building).Id, workplaceIndex));
			}
		}

		public static RaceModel GetQueuedRace(ProductionBuilding building, WorkplaceModel workplace)
		{
			if ((Object)(object)building == (Object)null || workplace == null)
			{
				return null;
			}
			return GetQueuedRace(building, building.GetIndexOf(workplace));
		}

		public static RaceModel GetQueuedRace(ProductionBuilding building, int workplaceIndex)
		{
			string raceId = GetQueuedRaceId(building, workplaceIndex);
			if (string.IsNullOrWhiteSpace(raceId))
			{
				return null;
			}
			return GameAPI.GetSettings()?.Races?.FirstOrDefault((Func<RaceModel, bool>)((RaceModel r) => string.Equals((r != null) ? ((SO)r).Name : null, raceId, StringComparison.OrdinalIgnoreCase)));
		}

		public static string GetQueuedRaceId(ProductionBuilding building, int workplaceIndex)
		{
			if ((Object)(object)building == (Object)null || workplaceIndex < 0)
			{
				return null;
			}
			QueueEntry value;
			return Entries.TryGetValue(new QueueKey(((Building)building).Id, workplaceIndex), out value) ? value.RaceId : null;
		}

		public static void ClearAll()
		{
			Entries.Clear();
		}

		public static void Process()
		{
			if (!GameAPI.IsGameActive() || Entries.Count == 0)
			{
				return;
			}
			foreach (QueueEntry item in Entries.Values.OrderBy((QueueEntry e) => e.Order).ToList())
			{
				if (!IsEntryValid(item))
				{
					Entries.Remove(item.Key);
					continue;
				}
				int workplaceIndex = item.Key.WorkplaceIndex;
				if (item.Building.IsWorkplaceFree(workplaceIndex) && GameAPI.GetDefaultProfessionAmount(item.RaceId) > 0)
				{
					Villager defaultProfessionVillager = GameAPI.GetDefaultProfessionVillager(item.RaceId, item.Building);
					if (!((Object)(object)defaultProfessionVillager == (Object)null))
					{
						GameAPI.AssignVillagerToWorkplace(defaultProfessionVillager, item.Building, workplaceIndex);
						Plugin.Log($"Assigned queued {item.RaceId} to {((Building)item.Building).ModelName} workplace {workplaceIndex}");
						Entries.Remove(item.Key);
					}
				}
			}
		}

		private static bool IsEntryValid(QueueEntry entry)
		{
			return entry != null && (Object)(object)entry.Building != (Object)null && !IsBuildingRemoved(entry.Building) && entry.Key.WorkplaceIndex >= 0 && entry.Key.WorkplaceIndex < entry.Building.Workplaces.Length;
		}

		private static bool IsBuildingRemoved(ProductionBuilding building)
		{
			try
			{
				if ((object)_piIsRemoved == null)
				{
					_piIsRemoved = typeof(Building).GetProperty("IsRemoved");
				}
				object obj = _piIsRemoved?.GetValue(building, null);
				if (obj == null)
				{
					return false;
				}
				if ((object)_piReactiveValue == null)
				{
					_piReactiveValue = obj.GetType().GetProperty("Value");
				}
				object obj2 = _piReactiveValue?.GetValue(obj, null);
				bool flag = default(bool);
				int num;
				if (obj2 is bool)
				{
					flag = (bool)obj2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
}
namespace StockAlert.Game.Hooks
{
	public class GameReadyHook : MonoBehaviour
	{
		private void Awake()
		{
			Plugin.Log("GameReadyHook created, persistent, ID=" + ((Object)this).GetInstanceID());
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			Plugin.Log("Scene loaded: " + ((Scene)(ref scene)).name);
			if (((Scene)(ref scene)).name != "Game" && ((Scene)(ref scene)).name != "Gameplay")
			{
				Plugin.Log("Not gameplay scene, ignoring: " + ((Scene)(ref scene)).name);
				return;
			}
			Plugin.Log("Gameplay scene detected, searching for GameMB...");
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				GameMB componentInChildren = val.GetComponentInChildren<GameMB>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Plugin.Log("Found REAL GameMB in gameplay scene");
					((MonoBehaviour)this).StartCoroutine(WaitForGameServices(componentInChildren));
					return;
				}
			}
			Plugin.Log("Gameplay scene loaded but GameMB not found yet.");
		}

		private IEnumerator WaitForGameServices(GameMB game)
		{
			Plugin.Log("Waiting for GameServices...");
			FieldInfo fi = typeof(GameMB).GetField("GameServices", BindingFlags.Instance | BindingFlags.NonPublic);
			while (fi.GetValue(game) == null)
			{
				Plugin.Log("GameServices still null...");
				yield return (object)new WaitForSeconds(0.5f);
			}
			Plugin.Log("GameServices READY — firing callback!");
			Plugin.Instance.OnGameReady();
		}
	}
	internal class StockAlertGameReadyHook : MonoBehaviour
	{
		private void Awake()
		{
			Plugin.Log("StockAlertGameReadyHook created, persistent, ID=" + ((Object)this).GetInstanceID());
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			SceneManager.sceneLoaded += OnSceneLoaded;
			Plugin.Log("Subscribed to sceneLoaded event");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			Plugin.Log($"OnSceneLoaded called on ID={((Object)this).GetInstanceID()} for scene {((Scene)(ref scene)).name}");
			if (((Scene)(ref scene)).name != "Game" && ((Scene)(ref scene)).name != "Gameplay")
			{
				return;
			}
			Plugin.Log("Gameplay scene detected, searching for GameMB...");
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				GameMB componentInChildren = val.GetComponentInChildren<GameMB>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Plugin.Log("Found REAL GameMB in gameplay scene");
					((MonoBehaviour)this).StartCoroutine(WaitForGameServices(componentInChildren));
					return;
				}
			}
			Plugin.Log("Gameplay scene loaded but GameMB not found yet.");
		}

		private IEnumerator WaitForGameServices(GameMB game)
		{
			Plugin.Log("Waiting for GameServices...");
			FieldInfo fi = typeof(GameMB).GetField("GameServices", BindingFlags.Instance | BindingFlags.NonPublic);
			while (fi.GetValue(game) == null)
			{
				Plugin.Log("GameServices still null...");
				yield return (object)new WaitForSeconds(0.5f);
			}
			Plugin.Log("GameServices READY — firing callback!");
			Plugin.Instance.OnGameReady();
		}
	}
}
namespace StockAlert.Game.Discovery
{
	public static class Discovery
	{
		public static List<GoodInfo> Goods { get; } = new List<GoodInfo>();


		public static HashSet<string> BlockedIngredientGoods { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);


		public static void Initialize()
		{
			Plugin.Log("Discovery.Initialize()");
			Goods.Clear();
			Settings settings = GameAPI.GetSettings();
			if ((Object)(object)settings == (Object)null)
			{
				Plugin.Log("Discovery.Initialize(): Settings is null");
				return;
			}
			GoodModel[] goods = settings.Goods;
			if (goods == null || goods.Length == 0)
			{
				Plugin.Log("Discovery.Initialize(): No goods found in Settings");
				return;
			}
			GoodModel[] array = goods;
			foreach (GoodModel val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					GoodInfo goodInfo = new GoodInfo
					{
						Model = val,
						Id = ((SO)val).Name,
						ConfigKey = BuildConfigKey(((SO)val).Name),
						DisplayName = ResolveDisplayName(val),
						Icon = val.icon,
						CurrentAmount = 0
					};
					ConfigManager.EnsureGoodConfig(goodInfo);
					Goods.Add(goodInfo);
				}
			}
			Goods.Sort((GoodInfo left, GoodInfo right) => string.Compare(left.DisplayName, right.DisplayName, StringComparison.OrdinalIgnoreCase));
			ConfigManager.RefreshGoodsFromProductionLimits(Goods);
			UpdateStock();
			Plugin.Log($"Discovery.Initialize(): Loaded {Goods.Count} goods");
		}

		private static string ResolveDisplayName(GoodModel model)
		{
			string text = ((object)model.displayName)?.ToString();
			if (!string.IsNullOrWhiteSpace(text) && text.IndexOf("Missing key", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text;
			}
			if (!string.IsNullOrWhiteSpace(((SO)model).Name))
			{
				return ((SO)model).Name;
			}
			return "Unknown Good";
		}

		private static string BuildConfigKey(string rawId)
		{
			if (string.IsNullOrWhiteSpace(rawId))
			{
				return "UnknownGood";
			}
			StringBuilder stringBuilder = new StringBuilder(rawId.Length);
			foreach (char c in rawId)
			{
				switch (c)
				{
				case '\t':
				case '\n':
				case '"':
				case '\'':
				case '=':
				case '[':
				case '\\':
				case ']':
					stringBuilder.Append('_');
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			return stringBuilder.ToString();
		}

		public static void UpdateStock()
		{
			foreach (GoodInfo good in Goods)
			{
				if (!((Object)(object)good.Model == (Object)null))
				{
					good.CurrentAmount = GameAPI.GetStoredAmount(good.Model, good.Id);
				}
			}
			UpdateIngredientWarnings();
		}

		private static void UpdateIngredientWarnings()
		{
			Settings settings = GameAPI.GetSettings();
			if ((Object)(object)settings == (Object)null)
			{
				ClearIngredientWarnings();
				return;
			}
			BlockedIngredientGoods.Clear();
			List<GoodInfo> list = Goods.Where((GoodInfo g) => g.IsBelowThreshold).ToList();
			if (list.Count == 0)
			{
				ClearIngredientWarnings();
				return;
			}
			Dictionary<string, int> globalAmounts = Goods.ToDictionary<GoodInfo, string, int>((GoodInfo g) => g.Id, (GoodInfo g) => g.CurrentAmount, StringComparer.OrdinalIgnoreCase);
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, bool> dictionary2 = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet = new HashSet<string>(list.Select((GoodInfo g) => g.Id), StringComparer.OrdinalIgnoreCase);
			foreach (IWorkshop recipeBuilding in GameAPI.GetRecipeBuildings())
			{
				if (((recipeBuilding != null) ? recipeBuilding.Recipes : null) == null)
				{
					continue;
				}
				foreach (WorkshopRecipeState recipe in recipeBuilding.Recipes)
				{
					if (recipe == null || !((RecipeState)recipe).active)
					{
						continue;
					}
					WorkshopRecipeModel workshopRecipe = settings.GetWorkshopRecipe(((RecipeState)recipe).model);
					if ((Object)(object)workshopRecipe == (Object)null)
					{
						continue;
					}
					GoodRef producedGood = workshopRecipe.producedGood;
					if (string.IsNullOrWhiteSpace((producedGood != null) ? producedGood.Name : null))
					{
						continue;
					}
					string name = workshopRecipe.producedGood.Name;
					if (!hashSet.Contains(name))
					{
						continue;
					}
					int num = ((RecipeModel)workshopRecipe).grade?.level ?? 0;
					bool flag = CanRecipeContinue(recipeBuilding, workshopRecipe, globalAmounts);
					if (!dictionary.TryGetValue(name, out var value) || num > value)
					{
						dictionary[name] = num;
						dictionary2[name] = flag;
						if (!flag)
						{
							AddMissingIngredientCandidates(recipeBuilding, workshopRecipe, globalAmounts, BlockedIngredientGoods);
						}
					}
					else if (num == value)
					{
						if (flag)
						{
							dictionary2[name] = true;
						}
						else if (!dictionary2[name])
						{
							AddMissingIngredientCandidates(recipeBuilding, workshopRecipe, globalAmounts, BlockedIngredientGoods);
						}
					}
				}
			}
			foreach (GoodInfo good in Goods)
			{
				good.IsIngredientBlocked = good.IsBelowThreshold && dictionary.ContainsKey(good.Id) && dictionary2.TryGetValue(good.Id, out var value2) && !value2;
			}
		}

		private static bool CanRecipeContinue(IWorkshop workshop, WorkshopRecipeModel recipeModel, IReadOnlyDictionary<string, int> globalAmounts)
		{
			if (recipeModel?.requiredGoods == null || recipeModel.requiredGoods.Length == 0)
			{
				return true;
			}
			Dictionary<string, int> dictionary = globalAmounts.ToDictionary<KeyValuePair<string, int>, string, int>((KeyValuePair<string, int> pair) => pair.Key, (KeyValuePair<string, int> pair) => pair.Value, StringComparer.OrdinalIgnoreCase);
			Dictionary<string, int> dictionary2 = ((workshop == null) ? null : workshop.IngredientsStorage?.goods?.goods);
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<string, int> item in dictionary2)
				{
					if (item.Value > 0)
					{
						dictionary[item.Key] = (dictionary.TryGetValue(item.Key, out var value) ? (value + item.Value) : item.Value);
					}
				}
			}
			return CanSatisfyIngredientSets(recipeModel.requiredGoods, 0, dictionary);
		}

		private static bool CanSatisfyIngredientSets(GoodsSet[] ingredientSets, int setIndex, Dictionary<string, int> availableAmounts)
		{
			if (ingredientSets == null || setIndex >= ingredientSets.Length)
			{
				return true;
			}
			GoodsSet val = ingredientSets[setIndex];
			if (val?.goods == null || val.goods.Length == 0)
			{
				return CanSatisfyIngredientSets(ingredientSets, setIndex + 1, availableAmounts);
			}
			GoodRef[] goods = val.goods;
			foreach (GoodRef val2 in goods)
			{
				if ((Object)(object)val2?.good == (Object)null)
				{
					continue;
				}
				string name = ((SO)val2.good).Name;
				int amount = val2.amount;
				if (availableAmounts.TryGetValue(name, out var value) && value >= amount)
				{
					availableAmounts[name] = value - amount;
					if (CanSatisfyIngredientSets(ingredientSets, setIndex + 1, availableAmounts))
					{
						availableAmounts[name] = value;
						return true;
					}
					availableAmounts[name] = value;
				}
			}
			return false;
		}

		private static void AddMissingIngredientCandidates(IWorkshop workshop, WorkshopRecipeModel recipeModel, IReadOnlyDictionary<string, int> globalAmounts, ISet<string> blockedIngredientGoods)
		{
			if (blockedIngredientGoods == null || recipeModel?.requiredGoods == null || recipeModel.requiredGoods.Length == 0)
			{
				return;
			}
			Dictionary<string, int> dictionary = globalAmounts.ToDictionary<KeyValuePair<string, int>, string, int>((KeyValuePair<string, int> pair) => pair.Key, (KeyValuePair<string, int> pair) => pair.Value, StringComparer.OrdinalIgnoreCase);
			Dictionary<string, int> dictionary2 = ((workshop == null) ? null : workshop.IngredientsStorage?.goods?.goods);
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<string, int> item in dictionary2)
				{
					if (item.Value > 0)
					{
						dictionary[item.Key] = (dictionary.TryGetValue(item.Key, out var value) ? (value + item.Value) : item.Value);
					}
				}
			}
			CollectMissingIngredientCandidates(recipeModel.requiredGoods, 0, dictionary, blockedIngredientGoods);
		}

		private static bool CollectMissingIngredientCandidates(GoodsSet[] ingredientSets, int setIndex, Dictionary<string, int> availableAmounts, ISet<string> blockedIngredientGoods)
		{
			if (ingredientSets == null || setIndex >= ingredientSets.Length)
			{
				return true;
			}
			GoodsSet val = ingredientSets[setIndex];
			if (val?.goods == null || val.goods.Length == 0)
			{
				return CollectMissingIngredientCandidates(ingredientSets, setIndex + 1, availableAmounts, blockedIngredientGoods);
			}
			List<GoodRef> list = new List<GoodRef>();
			GoodRef[] goods = val.goods;
			foreach (GoodRef val2 in goods)
			{
				if (!((Object)(object)val2?.good == (Object)null))
				{
					string name = ((SO)val2.good).Name;
					int amount = val2.amount;
					if (availableAmounts.TryGetValue(name, out var value) && value >= amount)
					{
						list.Add(val2);
					}
				}
			}
			if (list.Count == 0)
			{
				GoodRef[] goods2 = val.goods;
				foreach (GoodRef val3 in goods2)
				{
					if (!((Object)(object)val3?.good == (Object)null) && !string.IsNullOrWhiteSpace(((SO)val3.good).Name))
					{
						blockedIngredientGoods.Add(((SO)val3.good).Name);
					}
				}
				return false;
			}
			bool result = false;
			foreach (GoodRef item in list)
			{
				string name2 = ((SO)item.good).Name;
				int num = availableAmounts[name2];
				availableAmounts[name2] = num - item.amount;
				if (CollectMissingIngredientCandidates(ingredientSets, setIndex + 1, availableAmounts, blockedIngredientGoods))
				{
					result = true;
				}
				availableAmounts[name2] = num;
			}
			return result;
		}

		private static void ClearIngredientWarnings()
		{
			BlockedIngredientGoods.Clear();
			foreach (GoodInfo good in Goods)
			{
				good.IsIngredientBlocked = false;
			}
		}
	}
}
namespace StockAlert.Core.Models
{
	public class GoodInfo
	{
		public GoodModel Model;

		public string Id;

		public string ConfigKey;

		public string DisplayName;

		public Sprite Icon;

		public int CurrentAmount;

		public int Threshold;

		public bool Enabled;

		public bool IsIngredientBlocked;

		public bool IsBelowThreshold => Enabled && CurrentAmount < Threshold;
	}
	internal sealed class TrackedItemLocation
	{
		public string Key { get; set; }

		public Object Source { get; set; }

		public Vector3 FallbackPosition { get; set; }

		public int Amount { get; set; }
	}
}
namespace StockAlert.Config
{
	public static class ConfigManager
	{
		public enum HudHorizontalAnchor
		{
			Left,
			Right
		}

		private static ConfigFile _config;

		private static ConfigEntry<KeyboardShortcut> _toggleSettingsKey;

		private static ConfigEntry<bool> _showHud;

		private static ConfigEntry<bool> _movableHud;

		private static ConfigEntry<bool> _showBuildingAlertIndicators;

		private static ConfigEntry<bool> _showBuildingSpecificItemIndicators;

		private static ConfigEntry<float> _buildingShortageIconScale;

		private static ConfigEntry<bool> _showBuilderStatusIcons;

		private static ConfigEntry<bool> _showIdleBuildersAlert;

		private static ConfigEntry<bool> _enableQueuedWorkerAssignments;

		private static ConfigEntry<bool> _showIngredientWheelBuildingStock;

		private static ConfigEntry<bool> _showEmbarkationCostRanges;

		private static ConfigEntry<bool> _showTradeRouteProfit;

		private static ConfigEntry<bool> _seasonEndingTradeRoutesAlert;

		private static ConfigEntry<bool> _autoAdjustProductionLimits;

		private static ConfigEntry<bool> _autoAdjustPurgingFire;

		private static ConfigEntry<float> _autoAdjustMultiplier;

		private static ConfigEntry<HudHorizontalAnchor> _hudAnchor;

		private static ConfigEntry<float> _hudPositionX;

		private static ConfigEntry<float> _hudPositionY;

		public static KeyboardShortcut ToggleSettingsKey
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				Load();
				return _toggleSettingsKey.Value;
			}
		}

		public static bool ShowHud
		{
			get
			{
				Load();
				return _showHud.Value;
			}
			set
			{
				Load();
				_showHud.Value = value;
				_config.Save();
			}
		}

		public static bool MovableHud
		{
			get
			{
				Load();
				return _movableHud.Value;
			}
			set
			{
				Load();
				_movableHud.Value = value;
				_config.Save();
			}
		}

		public static Vector2 HudPosition
		{
			get
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				Load();
				return new Vector2(_hudPositionX.Value, _hudPositionY.Value);
			}
			set
			{
				//IL_000c: 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)
				Load();
				_hudPositionX.Value = value.x;
				_hudPositionY.Value = value.y;
				_config.Save();
			}
		}

		public static HudHorizontalAnchor HudAnchor
		{
			get
			{
				Load();
				return _hudAnchor.Value;
			}
			set
			{
				Load();
				_hudAnchor.Value = value;
				_config.Save();
			}
		}

		public static bool ShowBuildingAlertIndicators
		{
			get
			{
				Load();
				return _showBuildingAlertIndicators.Value;
			}
			set
			{
				Load();
				_showBuildingAlertIndicators.Value = value;
				_config.Save();
			}
		}

		public static bool ShowBuildingSpecificItemIndicators
		{
			get
			{
				Load();
				return _showBuildingSpecificItemIndicators.Value;
			}
			set
			{
				Load();
				_showBuildingSpecificItemIndicators.Value = value;
				_config.Save();
			}
		}

		public static float BuildingShortageIconScale
		{
			get
			{
				Load();
				return NormalizeBuildingShortageIconScale(_buildingShortageIconScale.Value);
			}
			set
			{
				Load();
				_buildingShortageIconScale.Value = NormalizeBuildingShortageIconScale(value);
				_config.Save();
			}
		}

		public static bool ShowBuilderStatusIcons
		{
			get
			{
				Load();
				return _showBuilderStatusIcons.Value;
			}
			set
			{
				Load();
				_showBuilderStatusIcons.Value = value;
				_config.Save();
			}
		}

		public static bool ShowIdleBuildersAlert
		{
			get
			{
				Load();
				return _showIdleBuildersAlert.Value;
			}
			set
			{
				Load();
				_showIdleBuildersAlert.Value = value;
				_config.Save();
			}
		}

		public static bool AutoAdjustProductionLimits
		{
			get
			{
				Load();
				return _autoAdjustProductionLimits.Value;
			}
			set
			{
				Load();
				_autoAdjustProductionLimits.Value = value;
				_config.Save();
			}
		}

		public static bool EnableQueuedWorkerAssignments
		{
			get
			{
				Load();
				return _enableQueuedWorkerAssignments.Value;
			}
			set
			{
				Load();
				_enableQueuedWorkerAssignments.Value = value;
				_config.Save();
			}
		}

		public static bool SeasonEndingTradeRoutesAlert
		{
			get
			{
				Load();
				return _seasonEndingTradeRoutesAlert.Value;
			}
			set
			{
				Load();
				_seasonEndingTradeRoutesAlert.Value = value;
				_config.Save();
			}
		}

		public static bool ShowIngredientWheelBuildingStock
		{
			get
			{
				Load();
				return _showIngredientWheelBuildingStock.Value;
			}
			set
			{
				Load();
				_showIngredientWheelBuildingStock.Value = value;
				_config.Save();
			}
		}

		public static bool ShowEmbarkationCostRanges
		{
			get
			{
				Load();
				return _showEmbarkationCostRanges.Value;
			}
			set
			{
				Load();
				_showEmbarkationCostRanges.Value = value;
				_config.Save();
			}
		}

		public static bool ShowTradeRouteProfit
		{
			get
			{
				Load();
				return _showTradeRouteProfit.Value;
			}
			set
			{
				Load();
				_showTradeRouteProfit.Value = value;
				_config.Save();
			}
		}

		public static float AutoAdjustMultiplier
		{
			get
			{
				Load();
				return NormalizeMultiplier(_autoAdjustMultiplier.Value);
			}
			set
			{
				Load();
				_autoAdjustMultiplier.Value = NormalizeMultiplier(value);
				_config.Save();
			}
		}

		public static bool AutoAdjustPurgingFire
		{
			get
			{
				Load();
				return _autoAdjustPurgingFire.Value;
			}
			set
			{
				Load();
				_autoAdjustPurgingFire.Value = value;
				_config.Save();
			}
		}

		public static void Load()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0046: 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_010d: Expected O, but got Unknown
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Expected O, but got Unknown
			if (_config == null)
			{
				_config = new ConfigFile(Paths.ConfigPath + "\\StockAlert.cfg", true);
				_toggleSettingsKey = _config.Bind<KeyboardShortcut>("General", "ToggleSettingsKey", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "Key used to show or hide the Stock Alert settings window.");
				_showHud = _config.Bind<bool>("HUD", "ShowHUD", true, "Show or hide the Stock Alert HUD.");
				_movableHud = _config.Bind<bool>("HUD", "MovableHUD", false, "Allow dragging the Stock Alert HUD.");
				_showBuildingAlertIndicators = _config.Bind<bool>("HUD", "ShowBuildingAlertIndicators", true, "Show red and yellow worker markers over recipe buildings related to current shortages.");
				_showBuildingSpecificItemIndicators = _config.Bind<bool>("HUD", "ShowBuildingSpecificItemIndicators", true, "Show shortage product icons next to building shortage indicators.");
				_buildingShortageIconScale = _config.Bind<float>("HUD", "BuildingShortageIconScale", 0.9f, new ConfigDescription("Scale of shortage product icons next to building shortage indicators. Range: 0.2 to 2.0.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 2f), Array.Empty<object>()));
				_showBuilderStatusIcons = _config.Bind<bool>("HUD", "ShowBuilderStatusIcons", false, "Show idle and working icons over free builder villagers.");
				_showIdleBuildersAlert = _config.Bind<bool>("HUD", "ShowIdleBuildersAlert", false, "Show a persistent alert while you have idle builders.");
				_enableQueuedWorkerAssignments = _config.Bind<bool>("HUD", "EnableQueuedWorkerAssignments", false, "Allow queuing a race for a worker slot so it auto-fills when a matching free villager becomes available.");
				_showIngredientWheelBuildingStock = _config.Bind<bool>("HUD", "ShowIngredientWheelBuildingStock", false, "Show how much of each ingredient is currently sitting in non-warehouse building storage in the ingredient selection wheel.");
				_showEmbarkationCostRanges = _config.Bind<bool>("HUD", "ShowEmbarkationCostRanges", false, "Show embarkation bonus costs as current cost over maximum possible cost.");
				_showTradeRouteProfit = _config.Bind<bool>("HUD", "ShowTradeRouteProfit", false, "Show estimated profit on trade route offers.");
				_seasonEndingTradeRoutesAlert = _config.Bind<bool>("HUD", "SeasonEndingTradeRoutesAlert", false, "Pause 3 seconds before season end and show a reminder to check trade routes.");
				_autoAdjustProductionLimits = _config.Bind<bool>("Automation", "AutoAdjustProductionLimits", false, "Automatically adjust global production limits for consumer goods based on the number of villagers that can consume each good.");
				_autoAdjustPurgingFire = _config.Bind<bool>("Automation", "AutoAdjustPurgingFire", false, "Automatically set Purging Fire in blight posts to active cysts plus one.");
				_autoAdjustMultiplier = _config.Bind<float>("Automation", "ProductionLimitMultiplier", 2f, new ConfigDescription("Multiplier applied per consuming villager when auto-adjusting production limits. Range: 1.0 to 9.0.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 9f), Array.Empty<object>()));
				_hudAnchor = _config.Bind<HudHorizontalAnchor>("HUD", "HudAnchor", HudHorizontalAnchor.Right, "Horizontal anchor for the Stock Alert HUD. The HUD always stays anchored to the bottom.");
				_hudPositionX = _config.Bind<float>("HUD", "PositionX", -1f, "Saved X position for the Stock Alert HUD. Negative uses the configured bottom anchor.");
				_hudPositionY = _config.Bind<float>("HUD", "PositionY", -1f, "Saved Y position for the Stock Alert HUD. Negative uses the configured bottom anchor.");
			}
		}

		public static void EnsureGoodConfig(GoodInfo g)
		{
			Load();
			ApplyProductionLimit(g);
		}

		public static bool RefreshGoodsFromProductionLimits(IEnumerable<GoodInfo> goods)
		{
			bool flag = false;
			foreach (GoodInfo good in goods)
			{
				flag |= ApplyProductionLimit(good);
			}
			return flag;
		}

		public static bool RefreshGoodFromProductionLimit(GoodInfo good)
		{
			return ApplyProductionLimit(good);
		}

		private static bool ApplyProductionLimit(GoodInfo g)
		{
			int threshold = g.Threshold;
			int productionLimit = GameAPI.GetProductionLimit(g.Model, g.Id);
			g.Threshold = Mathf.Max(0, productionLimit);
			g.Enabled = g.Threshold > 0;
			if (threshold != g.Threshold)
			{
				Plugin.Log($"Synced threshold for {g.Id} => {g.Threshold}");
				return true;
			}
			return false;
		}

		private static float NormalizeMultiplier(float value)
		{
			return Mathf.Clamp(Mathf.Round(value * 10f) / 10f, 1f, 9f);
		}

		private static float NormalizeBuildingShortageIconScale(float value)
		{
			return Mathf.Clamp(Mathf.Round(value * 100f) / 100f, 0.2f, 2f);
		}
	}
}