using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FeastPlanner.Config;
using FeastPlanner.Core;
using FeastPlanner.Runtime;
using FeastPlanner.UI;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("FeastPlanner")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3d86f14e8a42c9e6f2d9b8523fed2e3759fd3cf6")]
[assembly: AssemblyProduct("FeastPlanner")]
[assembly: AssemblyTitle("FeastPlanner")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FeastPlanner
{
	[BepInPlugin("com.valheimmodlab.feastplanner", "Feast Planner", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[DefaultExecutionOrder(-900)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.valheimmodlab.feastplanner";

		public const string PluginName = "Feast Planner";

		public const string PluginVersion = "1.0.0";

		private FeastPlannerConfig? _config;

		private FeastPlannerController? _controller;

		private FeastPlannerShell? _shell;

		private ManualLogSource? _log;

		private void Awake()
		{
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			_log = ((BaseUnityPlugin)this).Logger;
			_config = FeastPlannerConfig.Bind(((BaseUnityPlugin)this).Config);
			FoodTierTable tierTable = VanillaFoodTierTable.CreateDefault();
			JsonSavedMealStore savedMealStore = new JsonSavedMealStore(Path.Combine(Paths.ConfigPath, "FeastPlanner", "custom-meals-v1.json"));
			_controller = new FeastPlannerController(new ValheimFoodLoader(tierTable), new ValheimInventoryReader(), new ValheimContainerReader(new ContainerInventoryScanner(new ContainerScanRules(_config.ContainerScanRadius.Value, _config.ContainerScanMaxContainers.Value, _config.ContainerScanCooldownSeconds.Value))), new ValheimKnowledgeReader(), new ValheimActiveFoodReader(), new FeastRecommendationEngine(tierTable), tierTable, savedMealStore);
			_shell = new FeastPlannerShell(((BaseUnityPlugin)this).Logger, (PlannerRole role, TargetBiome biome) => _controller.BuildViewModel(role, biome), delegate(PlannerViewMode mode)
			{
				_controller.SetMode(mode);
			}, delegate(string mealId)
			{
				_controller.SelectSavedMeal(mealId);
			}, delegate
			{
				_controller.DeleteSelectedMeal();
			}, delegate(string name)
			{
				_controller.RenameSelectedMeal(name);
			}, delegate(int slotIndex, string foodPrefabName, PlannerRole role, TargetBiome biome)
			{
				_controller.AssignFoodToSlot(slotIndex, foodPrefabName, role, biome);
			}, delegate(string? savedMealId, string name, IReadOnlyList<string> foodPrefabNames, PlannerRole role, TargetBiome biome)
			{
				_controller.SaveCustomMealDraft(savedMealId, name, foodPrefabNames, role, biome);
			});
			_shell.Register();
			((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("{0} {1} loaded. Press {2} to open the planner.", "Feast Planner", "1.0.0", _config.TogglePlanner.Value));
		}

		private void OnDestroy()
		{
			_shell?.Dispose();
		}

		private void Update()
		{
			//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)
			if (_config == null)
			{
				return;
			}
			KeyboardShortcut value = _config.TogglePlanner.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				try
				{
					_controller?.RefreshCatalog();
				}
				catch (Exception arg)
				{
					ManualLogSource? log = _log;
					if (log != null)
					{
						log.LogError((object)$"Failed to refresh Feast Planner catalog: {arg}");
					}
				}
				try
				{
					_shell?.Toggle();
				}
				catch (Exception arg2)
				{
					ManualLogSource? log2 = _log;
					if (log2 != null)
					{
						log2.LogError((object)$"Failed to toggle Feast Planner shell: {arg2}");
					}
				}
			}
			FeastPlannerShell? shell = _shell;
			if (shell != null && shell.IsOpen && Input.GetKeyDown((KeyCode)27))
			{
				_shell.Close();
			}
			_shell?.UpdateInputBlock();
		}
	}
}
namespace FeastPlanner.UI
{
	public sealed class CustomEditDraft
	{
		public string? SavedMealId { get; }

		public string Name { get; }

		public IReadOnlyList<string> Slots { get; }

		public IReadOnlyList<string> FoodPrefabNames => new ReadOnlyCollection<string>(Slots.Where((string slot) => !string.IsNullOrWhiteSpace(slot)).ToList());

		public bool HasUnsavedChanges { get; }

		public bool RequiresDiscardConfirmation => HasUnsavedChanges;

		public string DiscardText
		{
			get
			{
				if (!RequiresDiscardConfirmation)
				{
					return string.Empty;
				}
				return "Discard changes?";
			}
		}

		private CustomEditDraft(string? savedMealId, string name, IEnumerable<string> slots, bool hasUnsavedChanges)
		{
			SavedMealId = savedMealId;
			Name = SavedMealLibrary.CleanName(name);
			Slots = new ReadOnlyCollection<string>(NormalizeSlots(slots).ToList());
			HasUnsavedChanges = hasUnsavedChanges;
		}

		public static CustomEditDraft New(string name)
		{
			return new CustomEditDraft(null, name, Array.Empty<string>(), hasUnsavedChanges: false);
		}

		public static CustomEditDraft FromSavedMeal(SavedMeal meal)
		{
			return new CustomEditDraft(meal.Id, meal.Name, meal.FoodPrefabNames, hasUnsavedChanges: false);
		}

		public static CustomEditDraft FromValues(string? savedMealId, string name, IEnumerable<string> foodPrefabNames)
		{
			return new CustomEditDraft(savedMealId, name, foodPrefabNames, hasUnsavedChanges: false);
		}

		public CustomEditDraft WithName(string name)
		{
			return new CustomEditDraft(SavedMealId, name, Slots, hasUnsavedChanges: true);
		}

		public CustomEditDraft WithSlot(int slotIndex, string foodPrefabName)
		{
			if (slotIndex < 0 || slotIndex >= 3)
			{
				return this;
			}
			List<string> list = Slots.ToList();
			list[slotIndex] = (foodPrefabName ?? string.Empty).Trim();
			return new CustomEditDraft(SavedMealId, Name, list, hasUnsavedChanges: true);
		}

		public CustomEditDraft ClearDraft()
		{
			return new CustomEditDraft(SavedMealId, Name, Array.Empty<string>(), hasUnsavedChanges: true);
		}

		public CustomEditDraft MarkSaved(string savedMealId)
		{
			return new CustomEditDraft(savedMealId, Name, Slots, hasUnsavedChanges: false);
		}

		private static IEnumerable<string> NormalizeSlots(IEnumerable<string> slots)
		{
			List<string> list = (from slot in (slots ?? Array.Empty<string>()).Take(3)
				select slot?.Trim() ?? string.Empty).ToList();
			while (list.Count < 3)
			{
				list.Add(string.Empty);
			}
			return list;
		}
	}
	public sealed class CustomFoodPickerProjection
	{
		public IReadOnlyList<FoodPickerRow> Rows { get; }

		public FoodPickerRow? PreviewRow { get; }

		public int PageIndex { get; }

		public int PageCount { get; }

		public bool HasPreviousPage => PageIndex > 0;

		public bool HasNextPage => PageIndex + 1 < PageCount;

		public string PageText => $"Page {PageIndex + 1}/{PageCount}";

		private CustomFoodPickerProjection(IReadOnlyList<FoodPickerRow> rows, FoodPickerRow? previewRow, int pageIndex, int pageCount)
		{
			Rows = rows;
			PreviewRow = previewRow;
			PageIndex = pageIndex;
			PageCount = pageCount;
		}

		public static CustomFoodPickerProjection From(IEnumerable<FoodDefinition> visibleFoods, string searchText, FoodPickerCategory category, TargetBiome? biomeFilter, int pageIndex, int pageSize, string? previewPrefabName = null)
		{
			int num = Math.Max(1, pageSize);
			List<FoodDefinition> list = SavedMealFoodPicker.Filter(visibleFoods, searchText, biomeFilter, category).ToList();
			int num2 = Math.Max(1, (int)Math.Ceiling((double)list.Count / (double)num));
			int num3 = Math.Max(0, Math.Min(pageIndex, num2 - 1));
			List<FoodDefinition> source = list.Skip(num3 * num).Take(num).ToList();
			FoodDefinition previewFood = source.FirstOrDefault((FoodDefinition food) => string.Equals(food.PrefabName, previewPrefabName, StringComparison.OrdinalIgnoreCase)) ?? source.FirstOrDefault();
			List<FoodPickerRow> list2 = source.Select((FoodDefinition food) => FoodPickerRow.From(food, previewFood != null && string.Equals(food.PrefabName, previewFood.PrefabName, StringComparison.OrdinalIgnoreCase))).ToList();
			return new CustomFoodPickerProjection(previewRow: list2.FirstOrDefault((FoodPickerRow row) => row.IsPreviewed), rows: new ReadOnlyCollection<FoodPickerRow>(list2), pageIndex: num3, pageCount: num2);
		}
	}
	public sealed class FoodPickerRow
	{
		private sealed class PickerIngredientPreviewBuilder
		{
			public string PrefabName { get; }

			public string DisplayName { get; }

			public Sprite? Icon { get; }

			public int Amount { get; set; }

			public PickerIngredientPreviewBuilder(string prefabName, string displayName, Sprite? icon)
			{
				PrefabName = prefabName;
				DisplayName = displayName;
				Icon = icon;
			}

			public PickerIngredientPreview ToPreview()
			{
				return new PickerIngredientPreview(PrefabName, DisplayName, Amount, Icon);
			}
		}

		public string PrefabName { get; }

		public string DisplayName { get; }

		public string DisplayText { get; }

		public string StatsText { get; }

		public string HealingText { get; }

		public string DurationText { get; }

		public string InlineStatsText { get; }

		public IReadOnlyList<PickerIngredientPreview> Ingredients { get; }

		public IReadOnlyList<string> IngredientTexts => Ingredients.Select((PickerIngredientPreview ingredient) => ingredient.DisplayText).ToList();

		public bool IsPreviewed { get; }

		public Sprite? Icon { get; }

		private FoodPickerRow(string prefabName, string displayName, string displayText, string statsText, string healingText, string durationText, string inlineStatsText, IReadOnlyList<PickerIngredientPreview> ingredients, bool isPreviewed, Sprite? icon)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			DisplayText = displayText;
			StatsText = statsText;
			HealingText = healingText;
			DurationText = durationText;
			InlineStatsText = inlineStatsText;
			Ingredients = ingredients;
			IsPreviewed = isPreviewed;
			Icon = icon;
		}

		public static FoodPickerRow From(FoodDefinition food, bool isPreviewed = false)
		{
			return new FoodPickerRow(food.PrefabName, food.DisplayName, TruncateText(food.DisplayName, 30), $"H{food.Stats.Health:0} S{food.Stats.Stamina:0} E{food.Stats.Eitr:0}", $"HP/s {food.Stats.Healing:0.#}", FormatDuration(food.Stats.Duration), $"H{food.Stats.Health:0} S{food.Stats.Stamina:0} E{food.Stats.Eitr:0} HP/s {food.Stats.Healing:0.#} {FormatDuration(food.Stats.Duration)}", FlattenIngredients(food.Ingredients), isPreviewed, food.Icon);
		}

		private static IReadOnlyList<PickerIngredientPreview> FlattenIngredients(IReadOnlyList<FoodIngredient> ingredients)
		{
			Dictionary<string, PickerIngredientPreviewBuilder> flattened = new Dictionary<string, PickerIngredientPreviewBuilder>(StringComparer.OrdinalIgnoreCase);
			List<PickerIngredientPreviewBuilder> list = new List<PickerIngredientPreviewBuilder>();
			foreach (FoodIngredient ingredient in ingredients)
			{
				AddFlattenedIngredient(flattened, list, ingredient, ingredient.Amount);
			}
			return list.Select((PickerIngredientPreviewBuilder value) => value.ToPreview()).ToList();
		}

		private static void AddFlattenedIngredient(Dictionary<string, PickerIngredientPreviewBuilder> flattened, List<PickerIngredientPreviewBuilder> ordered, FoodIngredient ingredient, int requiredAmount)
		{
			if (ingredient.HasRecipe)
			{
				int num = (int)Math.Ceiling((double)requiredAmount / (double)ingredient.OutputAmount);
				{
					foreach (FoodIngredient recipeIngredient in ingredient.RecipeIngredients)
					{
						AddFlattenedIngredient(flattened, ordered, recipeIngredient, recipeIngredient.Amount * num);
					}
					return;
				}
			}
			if (!flattened.TryGetValue(ingredient.PrefabName, out PickerIngredientPreviewBuilder value))
			{
				value = new PickerIngredientPreviewBuilder(ingredient.PrefabName, ingredient.DisplayName, ingredient.Icon);
				ordered.Add(value);
			}
			value.Amount += requiredAmount;
			flattened[ingredient.PrefabName] = value;
		}

		private static string FormatDuration(float durationSeconds)
		{
			int num = Math.Max(0, (int)Math.Round(durationSeconds / 60f));
			return $"{num}m";
		}

		private static string TruncateText(string value, int maxCharacters)
		{
			if (value.Length <= maxCharacters)
			{
				return value;
			}
			if (maxCharacters > 3)
			{
				return value.Substring(0, maxCharacters - 3) + "...";
			}
			return value.Substring(0, maxCharacters);
		}
	}
	public sealed class PickerIngredientPreview
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public int Amount { get; }

		public Sprite? Icon { get; }

		public string DisplayText => $"{DisplayName} x{Amount:0}";

		public PickerIngredientPreview(string prefabName, string displayName, int amount, Sprite? icon)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Amount = Math.Max(0, amount);
			Icon = icon;
		}
	}
	public sealed class CustomPlanProjection
	{
		private const int MaxRows = 8;

		public IReadOnlyList<CustomPlanRow> Rows { get; }

		private CustomPlanProjection(IEnumerable<CustomPlanRow> rows)
		{
			Rows = new ReadOnlyCollection<CustomPlanRow>(rows.Take(8).ToList());
		}

		public static CustomPlanProjection From(FeastPlannerViewModel model, string activeTargetName, string? pendingDeleteSavedMealId)
		{
			Dictionary<string, FoodDefinition> visibleByPrefab = model.VisibleFoods.GroupBy<FoodDefinition, string>((FoodDefinition food) => food.PrefabName, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, FoodDefinition>, string, FoodDefinition>((IGrouping<string, FoodDefinition> group) => group.Key, (IGrouping<string, FoodDefinition> group) => group.First(), StringComparer.OrdinalIgnoreCase);
			return new CustomPlanProjection(model.SavedMeals.Select((SavedMeal meal) => CustomPlanRow.From(meal, visibleByPrefab, string.Equals(meal.Id, model.SelectedSavedMealId, StringComparison.OrdinalIgnoreCase), string.Equals(meal.Name, activeTargetName, StringComparison.OrdinalIgnoreCase), string.Equals(meal.Id, pendingDeleteSavedMealId, StringComparison.OrdinalIgnoreCase))));
		}
	}
	public sealed class CustomPlanRow
	{
		public string Id { get; }

		public string Name { get; }

		public IReadOnlyList<FoodDefinition> Foods { get; }

		public FoodStats Totals { get; }

		public string FoodsText { get; }

		public string StatsText { get; }

		public string DurationText { get; }

		public string ReadinessText { get; }

		public bool IsSelected { get; }

		public bool IsActive { get; }

		public bool IsDeletePending { get; }

		private CustomPlanRow(string id, string name, IReadOnlyList<FoodDefinition> foods, FoodStats totals, string foodsText, string statsText, string durationText, string readinessText, bool isSelected, bool isActive, bool isDeletePending)
		{
			Id = id;
			Name = name;
			Foods = foods;
			Totals = totals;
			FoodsText = foodsText;
			StatsText = statsText;
			DurationText = durationText;
			ReadinessText = readinessText;
			IsSelected = isSelected;
			IsActive = isActive;
			IsDeletePending = isDeletePending;
		}

		public static CustomPlanRow From(SavedMeal meal, IReadOnlyDictionary<string, FoodDefinition> visibleByPrefab, bool isSelected, bool isActive, bool isDeletePending)
		{
			List<FoodDefinition> list = new List<FoodDefinition>();
			List<string> list2 = new List<string>();
			int num = 0;
			foreach (string foodPrefabName in meal.FoodPrefabNames)
			{
				if (visibleByPrefab.TryGetValue(foodPrefabName, out FoodDefinition value))
				{
					list.Add(value);
					list2.Add(value.DisplayName);
				}
				else
				{
					num++;
					list2.Add("Hidden saved food");
				}
			}
			FoodStats foodStats = Total(list);
			string readinessText = ((list.Count == 0) ? "Unavailable" : ((num > 0) ? "Warnings" : "Saved"));
			return new CustomPlanRow(meal.Id, meal.Name, new ReadOnlyCollection<FoodDefinition>(list), foodStats, string.Join(", ", list2), FormatStats(foodStats), FormatDuration(foodStats.Duration), readinessText, isSelected, isActive, isDeletePending);
		}

		private static FoodStats Total(IEnumerable<FoodDefinition> foods)
		{
			List<FoodDefinition> list = foods.ToList();
			return new FoodStats(list.Sum((FoodDefinition food) => food.Stats.Health), list.Sum((FoodDefinition food) => food.Stats.Stamina), list.Sum((FoodDefinition food) => food.Stats.Eitr), list.Sum((FoodDefinition food) => food.Stats.Healing), (list.Count == 0) ? 0f : list.Min((FoodDefinition food) => food.Stats.Duration));
		}

		private static string FormatStats(FoodStats stats)
		{
			return $"H {stats.Health:0}  S {stats.Stamina:0}  E {stats.Eitr:0}";
		}

		private static string FormatDuration(float seconds)
		{
			if (!(seconds <= 0f))
			{
				return $"{Math.Round(seconds / 60f):0}m";
			}
			return "0m";
		}
	}
	public sealed class FeastPlannerShell : IDisposable
	{
		private const float PanelWidth = 1260f;

		private const float PanelHeight = 640f;

		private const float HeaderHeight = 74f;

		private const float ActiveStripHeight = 64f;

		private const float FooterHeight = 58f;

		private const float Gutter = 18f;

		private const float LeftColumnRatio = 0.48f;

		private const float BodyPanelHeightBonus = 36f;

		private const float BodyPanelYOffset = 0f;

		private const int RecommendedRowCount = 8;

		private const int CustomRowCount = 8;

		private const int MaxCustomEditIngredientChips = 3;

		private readonly ManualLogSource _log;

		private readonly Func<PlannerRole, TargetBiome, FeastPlannerViewModel> _buildViewModel;

		private readonly Action<PlannerViewMode> _setPlannerMode;

		private readonly Action<string> _selectSavedMeal;

		private readonly Action _deleteSavedMeal;

		private readonly Action<string> _renameSavedMeal;

		private readonly Action<int, string, PlannerRole, TargetBiome> _assignFoodToSlot;

		private readonly Action<string?, string, IReadOnlyList<string>, PlannerRole, TargetBiome> _saveCustomMealDraft;

		private GameObject? _root;

		private Text? _activeTargetLabelText;

		private Text? _activeTargetText;

		private Text? _activeTargetHealthValueText;

		private Text? _activeTargetStaminaValueText;

		private Text? _activeTargetEitrValueText;

		private Text? _activeTargetDurationText;

		private Text? _activeTargetStatusText;

		private GameObject? _roleControlRoot;

		private GameObject? _biomeControlRoot;

		private GameObject? _recommendedTabButton;

		private GameObject? _customTabButton;

		private Text? _roleControlText;

		private Text? _biomeControlText;

		private GameObject? _roleDropdownRoot;

		private GameObject? _biomeDropdownRoot;

		private GameObject? _cookableToggleRoot;

		private Text? _cookableToggleText;

		private Text? _setActiveText;

		private Text? _clearActiveText;

		private GameObject? _deleteCustomButton;

		private Text? _deleteCustomText;

		private GameObject? _editCustomButton;

		private GameObject? _newCustomButton;

		private GameObject? _saveCustomButton;

		private GameObject? _clearDraftButton;

		private GameObject? _discardButton;

		private Text? _discardText;

		private Text? _detailsTitleText;

		private Text? _totalStatsText;

		private Text? _detailsDurationText;

		private Text? _ingredientSummaryText;

		private Text? _detailsHealthText;

		private Text? _detailsStaminaText;

		private Text? _detailsEitrText;

		private Text? _detailsHealthValueText;

		private Text? _detailsStaminaValueText;

		private Text? _detailsEitrValueText;

		private readonly Text?[] _foodDetailTexts = (Text?[])(object)new Text[3];

		private readonly Text?[] _ingredientDetailTexts = (Text?[])(object)new Text[6];

		private readonly Text?[] _rowNameTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _rowStatsTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _rowDurationTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _rowStatusTexts = (Text?[])(object)new Text[8];

		private readonly GameObject?[] _rowButtons = (GameObject?[])(object)new GameObject[8];

		private readonly Image?[,] _rowFoodIcons = new Image[8, 3];

		private readonly Text?[] _customRowNameTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _customRowStatsTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _customRowDurationTexts = (Text?[])(object)new Text[8];

		private readonly Text?[] _customRowStatusTexts = (Text?[])(object)new Text[8];

		private readonly Image?[,] _customRowFoodIcons = new Image[8, 3];

		private readonly Text?[] _slotButtonTexts = (Text?[])(object)new Text[3];

		private readonly Text?[] _slotPrimaryTexts = (Text?[])(object)new Text[3];

		private readonly Text?[] _slotStatsTexts = (Text?[])(object)new Text[3];

		private readonly Image?[] _slotFoodIcons = (Image?[])(object)new Image[3];

		private readonly Image?[] _customEditSlotShades = (Image?[])(object)new Image[3];

		private readonly Image?[,] _slotIngredientIcons = new Image[3, 3];

		private readonly Text?[,] _slotIngredientTexts = new Text[3, 3];

		private readonly Text?[] _pickerRowTexts = (Text?[])(object)new Text[5];

		private readonly Image?[] _pickerRowIcons = (Image?[])(object)new Image[5];

		private readonly GameObject?[] _pickerRowButtons = (GameObject?[])(object)new GameObject[5];

		private readonly Image?[] _foodDetailIcons = (Image?[])(object)new Image[3];

		private readonly Image?[] _foodDetailCardShades = (Image?[])(object)new Image[3];

		private readonly Image?[] _ingredientDetailIcons = (Image?[])(object)new Image[6];

		private readonly Image?[] _activeTargetFoodIcons = (Image?[])(object)new Image[3];

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

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

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

		private GameObject? _pickerMenuRoot;

		private InputField? _customNameInput;

		private InputField? _pickerSearchInput;

		private Text? _pickerCategoryText;

		private Text? _pickerBiomeText;

		private Text? _pickerDetailTitleText;

		private Text? _pickerDetailStatsText;

		private Image? _pickerDetailIcon;

		private GameObject? _addPickerFoodButton;

		private GameObject? _pickerCategoryDropdownRoot;

		private GameObject? _pickerBiomeDropdownRoot;

		private Text? _pickerPageText;

		private readonly Image?[] _pickerIngredientIcons = (Image?[])(object)new Image[6];

		private readonly Text?[] _pickerIngredientTexts = (Text?[])(object)new Text[6];

		private RecommendedPlanProjection? _projection;

		private CustomPlanProjection? _customProjection;

		private CustomFoodPickerProjection? _pickerProjection;

		private FeastPlannerViewModel? _latestModel;

		private CustomEditDraft? _editDraft;

		private RecommendedPlanRow? _selectedRow;

		private CustomPlanRow? _selectedCustomRow;

		private int? _selectedCustomFoodIndex;

		private MealCraftability _currentCraftability = MealCraftability.Empty;

		private string _activeTargetName = string.Empty;

		private string? _pendingDeleteSavedMealId;

		private int? _editingSlotIndex;

		private string? _pickerPreviewPrefabName;

		private int _pickerPageIndex;

		private int _lastDetailsFoodCount;

		private PlannerRole _selectedRole = PlannerRole.Balanced;

		private TargetBiome _selectedBiome;

		private PlannerViewMode _selectedMode;

		private FoodPickerCategory _pickerCategory;

		private TargetBiome? _pickerBiomeFilter;

		private bool _discardPending;

		private bool _isCustomEditing;

		private bool _cookableOnly;

		private bool _openRequested;

		private bool _registered;

		public bool IsOpen
		{
			get
			{
				if (RootExists())
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		public FeastPlannerShell(ManualLogSource log, Func<PlannerRole, TargetBiome, FeastPlannerViewModel> buildViewModel, Action<PlannerViewMode>? setPlannerMode = null, Action<string>? selectSavedMeal = null, Action? deleteSavedMeal = null, Action<string>? renameSavedMeal = null, Action<int, string, PlannerRole, TargetBiome>? assignFoodToSlot = null, Action<string?, string, IReadOnlyList<string>, PlannerRole, TargetBiome>? saveCustomMealDraft = null)
		{
			_log = log;
			_buildViewModel = buildViewModel;
			_setPlannerMode = setPlannerMode ?? ((Action<PlannerViewMode>)delegate
			{
			});
			_selectSavedMeal = selectSavedMeal ?? ((Action<string>)delegate
			{
			});
			_deleteSavedMeal = deleteSavedMeal ?? ((Action)delegate
			{
			});
			_renameSavedMeal = renameSavedMeal ?? ((Action<string>)delegate
			{
			});
			_assignFoodToSlot = assignFoodToSlot ?? ((Action<int, string, PlannerRole, TargetBiome>)delegate
			{
			});
			_saveCustomMealDraft = saveCustomMealDraft ?? ((Action<string, string, IReadOnlyList<string>, PlannerRole, TargetBiome>)delegate
			{
			});
		}

		public void Register()
		{
			if (!_registered)
			{
				GUIManager.OnCustomGUIAvailable += CreateOnGuiAvailable;
				_registered = true;
			}
		}

		public void Toggle()
		{
			SetOpen(!IsOpen);
		}

		public void Close()
		{
			SetOpen(open: false);
		}

		public void SetOpen(bool open)
		{
			_openRequested = open;
			if (!open)
			{
				UpdateInputBlock();
				if (RootExists())
				{
					_root.SetActive(false);
				}
				else
				{
					ForgetRoot();
				}
				return;
			}
			if (!CanShowPanel())
			{
				_openRequested = false;
				if (RootExists())
				{
					_root.SetActive(false);
				}
				else
				{
					ForgetRoot();
				}
				_log.LogDebug((object)"Feast Planner shell open ignored because Valheim HUD/player state is not ready.");
				return;
			}
			if (!RootExists())
			{
				ForgetRoot();
				CreateOnGuiAvailable();
			}
			if (RootExists())
			{
				_root.SetActive(true);
				RefreshRecommendedRows();
			}
		}

		public void Dispose()
		{
			UpdateInputBlock();
			if (_registered)
			{
				GUIManager.OnCustomGUIAvailable -= CreateOnGuiAvailable;
				_registered = false;
			}
			if (RootExists())
			{
				Object.Destroy((Object)(object)_root);
			}
			ForgetRoot();
		}

		private static bool CanShowPanel()
		{
			if (GUIManager.CustomGUIFront != null && Player.m_localPlayer != null)
			{
				return Hud.instance != null;
			}
			return false;
		}

		private void CreateOnGuiAvailable()
		{
			try
			{
				if (_openRequested && !RootExists() && GUIManager.CustomGUIFront != null)
				{
					ForgetRoot();
					Create(GUIManager.CustomGUIFront.transform);
				}
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Failed to create Feast Planner shell: {arg}");
			}
		}

		private void Create(Transform parent)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: 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_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			_root = instance.CreateWoodpanel(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 1260f, 640f, false);
			((Object)_root).name = "FeastPlanner_V06Shell";
			CreateShade(_root.transform, "FeastPlanner_RootShade", Vector2.zero, 1224f, 604f, new Color(0.08f, 0.05f, 0.03f, 0.26f));
			CreateHeader();
			CreateRegion("FeastPlanner_ActiveStrip", new Vector2(0f, 218f), 1224f, 64f);
			CreateShade(_root.transform, "FeastPlanner_ActiveIdentityTray", new Vector2(-480f, 218f), 214f, 44f, ActiveTraySurface());
			CreateShade(_root.transform, "FeastPlanner_ActiveFoodTray", new Vector2(-268f, 218f), 132f, 44f, ActiveTraySurface());
			CreateShade(_root.transform, "FeastPlanner_ActiveStatsTray", new Vector2(28f, 218f), 350f, 44f, ActiveTraySurface());
			for (int i = 0; i < 2; i++)
			{
				CreateShade(_root.transform, $"FeastPlanner_ActiveStatDivider_{i + 1}", new Vector2(-24f + (float)i * 118f, 218f), 2f, 32f, SummaryRuleSurface());
			}
			CreateShade(_root.transform, "FeastPlanner_ActiveStatusBadge", new Vector2(474f, 218f), 168f, 44f, ActiveBadgeSurface());
			_activeTargetLabelText = CreateLabel("Active", new Vector2(-548f, 229f), 82f, 18f, 12, instance.ValheimBeige, (TextAnchor)3);
			_activeTargetText = CreateLabel("none", new Vector2(-468f, 210f), 180f, 30f, 18, instance.ValheimYellow, (TextAnchor)3);
			for (int j = 0; j < _activeTargetFoodIcons.Length; j++)
			{
				_activeTargetFoodIcons[j] = CreateIconSlot(_root.transform, new Vector2(-304f + (float)j * 36f, 218f), 28f);
			}
			CreateLabel("Health", new Vector2(-122f, 231f), 74f, 16f, 11, new Color(1f, 0.34f, 0.3f, 0.92f), (TextAnchor)4);
			CreateLabel("Stamina", new Vector2(-4f, 231f), 86f, 16f, 11, new Color(1f, 0.68f, 0.12f, 0.92f), (TextAnchor)4);
			CreateLabel("Eitr", new Vector2(114f, 231f), 74f, 16f, 11, new Color(0.36f, 0.64f, 1f, 0.92f), (TextAnchor)4);
			_activeTargetHealthValueText = CreateLabel("", new Vector2(-122f, 210f), 74f, 26f, 20, new Color(1f, 0.34f, 0.3f, 1f), (TextAnchor)4);
			_activeTargetStaminaValueText = CreateLabel("", new Vector2(-4f, 210f), 86f, 26f, 20, new Color(1f, 0.68f, 0.12f, 1f), (TextAnchor)4);
			_activeTargetEitrValueText = CreateLabel("", new Vector2(114f, 210f), 74f, 26f, 20, new Color(0.36f, 0.64f, 1f, 1f), (TextAnchor)4);
			_activeTargetDurationText = CreateLabel("", new Vector2(474f, 225f), 146f, 22f, 20, instance.ValheimBeige, (TextAnchor)4);
			_activeTargetStatusText = CreateLabel("", new Vector2(474f, 205f), 146f, 20f, 13, instance.ValheimYellow, (TextAnchor)4);
			float num = 408f;
			float num2 = 168f - num / 2f + 0f;
			float num3 = 1206f * 0.48f;
			float num4 = 1206f - num3;
			float num5 = -612f + num3 / 2f;
			float num6 = num5 + num3 / 2f + 18f + num4 / 2f;
			GameObject val = CreateRegion("FeastPlanner_LeftColumn", new Vector2(num5, num2), num3, num);
			GameObject val2 = CreateRegion("FeastPlanner_RightDetails", new Vector2(num6, num2), num4, num);
			GameObject val3 = CreateRegion("FeastPlanner_FooterActions", new Vector2(0f, -273f), 1224f, 58f);
			CreateRecommendedControls(val.transform, num3, num);
			CreateRecommendedRows(val.transform, num3, num);
			CreateCustomRows(val.transform, num3, num);
			CreateRecommendedDetails(val2.transform, num4, num);
			CreateCustomEditMode(val2.transform, num4, num);
			CreateFoodPickerMenu();
			CreateFooterActions(val3.transform);
			_root.SetActive(false);
		}

		private void CreateHeader()
		{
			//IL_0020: 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_005e: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			CreateShade(_root.transform, "FeastPlanner_HeaderRule", new Vector2(0f, 256f), 1168f, 2f, new Color(0.46f, 0.3f, 0.13f, 0.45f));
			CreateLabel("Feast Planner", new Vector2(-392f, 282f), 360f, 44f, 32, instance.ValheimBeige, (TextAnchor)3);
			_recommendedTabButton = CreateButton("Recommended", new Vector2(-72f, 282f), 190f, 42f, SelectRecommendedTab);
			_customTabButton = CreateButton("Custom", new Vector2(140f, 282f), 170f, 42f, SelectCustomTab);
			CreateLabel("Inv + Nearby", new Vector2(444f, 282f), 210f, 36f, 20, instance.ValheimBeige, (TextAnchor)5);
			CreateButton("X", new Vector2(588f, 282f), 44f, 44f, Close);
		}

		private void CreateRecommendedControls(Transform parent, float width, float height)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			float width2 = width / 2f - 24f;
			float num = 0f - width / 4f;
			float num2 = width / 4f;
			float num3 = height / 2f - 34f;
			_roleControlRoot = CreateButton("Role: Balanced", parent, new Vector2(num, num3), width2, 34f, ToggleRoleDropdown);
			_roleControlText = _roleControlRoot.GetComponentInChildren<Text>();
			_biomeControlRoot = CreateButton("Biome: Meadows", parent, new Vector2(num2, num3), width2, 34f, ToggleBiomeDropdown);
			_biomeControlText = _biomeControlRoot.GetComponentInChildren<Text>();
			_roleDropdownRoot = CreateRoleDropdown(parent, new Vector2(num, num3 - 126f), width2);
			_biomeDropdownRoot = CreateBiomeDropdown(parent, new Vector2(num2, num3 - 126f), width2);
		}

		private GameObject CreateRoleDropdown(Transform parent, Vector2 position, float width)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			PlannerRole[] array = new PlannerRole[7]
			{
				PlannerRole.Balanced,
				PlannerRole.BossFight,
				PlannerRole.ExploreGather,
				PlannerRole.BuildFarm,
				PlannerRole.MineHaul,
				PlannerRole.MagicEitr,
				PlannerRole.BestAvailable
			};
			GameObject val = CreateDropdownRoot(parent, "FeastPlanner_RoleDropdown", position, width, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				PlannerRole role = array[i];
				CreateButton(Display(role), val.transform, DropdownOptionPosition(i, array.Length), width - 18f, 26f, delegate
				{
					SelectPlannerRole(role);
				});
			}
			val.SetActive(false);
			return val;
		}

		private GameObject CreateBiomeDropdown(Transform parent, Vector2 position, float width)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			TargetBiome[] array = new TargetBiome[7]
			{
				TargetBiome.Meadows,
				TargetBiome.BlackForest,
				TargetBiome.Swamp,
				TargetBiome.Mountain,
				TargetBiome.Plains,
				TargetBiome.Mistlands,
				TargetBiome.Ashlands
			};
			GameObject val = CreateDropdownRoot(parent, "FeastPlanner_BiomeDropdown", position, width, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				TargetBiome biome = array[i];
				CreateButton(Display(biome), val.transform, DropdownOptionPosition(i, array.Length), width - 18f, 26f, delegate
				{
					SelectTargetBiome(biome);
				});
			}
			val.SetActive(false);
			return val;
		}

		private GameObject CreatePickerCategoryDropdown(Transform parent, Vector2 position, float width)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			FoodPickerCategory[] array = new FoodPickerCategory[5]
			{
				FoodPickerCategory.All,
				FoodPickerCategory.HealthHeavy,
				FoodPickerCategory.StaminaHeavy,
				FoodPickerCategory.Eitr,
				FoodPickerCategory.BalancedUtility
			};
			GameObject val = CreateDropdownRoot(parent, "FeastPlanner_PickerCategoryDropdown", position, width, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				FoodPickerCategory category = array[i];
				CreateButton(Display(category), val.transform, DropdownOptionPosition(i, array.Length), width - 18f, 26f, delegate
				{
					SelectPickerCategory(category);
				});
			}
			val.SetActive(false);
			return val;
		}

		private GameObject CreatePickerBiomeDropdown(Transform parent, Vector2 position, float width)
		{
			//IL_0069: 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)
			TargetBiome?[] array = new TargetBiome?[8]
			{
				null,
				TargetBiome.Meadows,
				TargetBiome.BlackForest,
				TargetBiome.Swamp,
				TargetBiome.Mountain,
				TargetBiome.Plains,
				TargetBiome.Mistlands,
				TargetBiome.Ashlands
			};
			GameObject val = CreateDropdownRoot(parent, "FeastPlanner_PickerBiomeDropdown", position, width, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				TargetBiome? biome = array[i];
				CreateButton(biome.HasValue ? Display(biome.Value) : "Any Biome", val.transform, DropdownOptionPosition(i, array.Length), width - 18f, 26f, delegate
				{
					SelectPickerBiome(biome);
				});
			}
			val.SetActive(false);
			return val;
		}

		private void CreateRecommendedRows(Transform parent, float width, float height)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			_cookableToggleRoot = CreateButton("Cookable Now: Off", parent, new Vector2(0f, height / 2f - 78f), width - 32f, 36f, ToggleCookableOnly);
			_cookableToggleText = _cookableToggleRoot.GetComponentInChildren<Text>();
			float num = 72f;
			float num2 = 14f;
			float num3 = width - 32f;
			float num4 = 96f;
			float num5 = 58f;
			float num6 = 128f;
			float num7 = 46f;
			float num8 = 10f;
			float num9 = 14f;
			float num10 = num3 - num4 - num5 - num6 - num7 - num8 * 4f - num9 * 2f;
			float num11 = 0f - num3 / 2f + num9 + num7 / 2f;
			float num12 = num11 + num7 / 2f + num8 + num10 / 2f;
			float num13 = num12 + num10 / 2f + num8 + num6 / 2f;
			float num14 = num13 + num6 / 2f + num8 + num5 / 2f;
			float num15 = num3 / 2f - num9 - num4 / 2f;
			float num16 = height / 2f - 142f;
			for (int i = 0; i < 8; i++)
			{
				float num17 = num16 - (float)i * (num + num2);
				int index = i;
				GameObject val = CreateButton("", parent, new Vector2(0f, num17), num3, num, delegate
				{
					SelectVisibleRow(index);
				});
				((Object)val).name = $"FeastPlanner_RecommendedRow_{i + 1}";
				_rowButtons[i] = val;
				val.GetComponentInChildren<Text>().text = string.Empty;
				for (int num18 = 0; num18 < 1; num18++)
				{
					_rowFoodIcons[i, num18] = CreateIconSlot(val.transform, new Vector2(num11, 0f), 38f);
				}
				_rowNameTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num12, 0f), num10, num, 15, GUIManager.Instance.ValheimBeige, (TextAnchor)3);
				_rowStatsTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num13, 0f), num6, num, 13, GUIManager.Instance.ValheimBeige, (TextAnchor)4);
				_rowDurationTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num14, 0f), num5, num, 13, GUIManager.Instance.ValheimBeige, (TextAnchor)4);
				_rowStatusTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num15, 0f), num4, num, 13, GUIManager.Instance.ValheimYellow, (TextAnchor)5);
			}
		}

		private void CreateCustomRows(Transform parent, float width, float height)
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			float height2 = 32f;
			float num = width - 32f;
			float num2 = 82f;
			float num3 = 46f;
			float num4 = 116f;
			float num5 = 88f;
			float num6 = 6f;
			float num7 = 10f;
			float num8 = num - num2 - num3 - num4 - num5 - num6 * 4f - num7 * 2f;
			float num9 = 0f - num / 2f + num7 + num5 / 2f;
			float num10 = num9 + num5 / 2f + num6 + num8 / 2f;
			float num11 = num10 + num8 / 2f + num6 + num4 / 2f;
			float num12 = num11 + num4 / 2f + num6 + num3 / 2f;
			float num13 = num / 2f - num7 - num2 / 2f;
			for (int i = 0; i < 8; i++)
			{
				GameObject val = _rowButtons[i];
				if (val != null)
				{
					for (int j = 0; j < 3; j++)
					{
						_customRowFoodIcons[i, j] = CreateIconSlot(val.transform, new Vector2(num9 - 28f + (float)j * 28f, 0f), 24f);
					}
					_customRowNameTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num10, 0f), num8, height2, 14, GUIManager.Instance.ValheimBeige, (TextAnchor)3);
					_customRowStatsTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num11, 0f), num4, height2, 13, GUIManager.Instance.ValheimBeige, (TextAnchor)4);
					_customRowDurationTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num12, 0f), num3, height2, 13, GUIManager.Instance.ValheimBeige, (TextAnchor)4);
					_customRowStatusTexts[i] = CreateChildLabel(val.transform, "", new Vector2(num13, 0f), num2, height2, 13, GUIManager.Instance.ValheimYellow, (TextAnchor)5);
				}
			}
		}

		private void CreateRecommendedDetails(Transform parent, float width, float height)
		{
			//IL_004a: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			float num = width - 42f;
			float num2 = 0f - num / 2f;
			float num3 = height / 2f - 20f;
			float num4 = num3 - 42f;
			float num5 = num3 - 154f;
			float num6 = num3 - 284f;
			CreateDetailsRowShade(parent, "FeastPlanner_DetailsSummaryRow", new Vector2(0f, num4), num, 98f);
			CreateDetailsAccentShade(parent, "FeastPlanner_DetailsSummaryHeaderStrip", new Vector2(num2 + 124f, num4 + 28f), 190f, 28f, SummaryHeaderSurface());
			CreateDetailsAccentShade(parent, "FeastPlanner_DetailsSummaryRule", new Vector2(0f, num4 + 6f), num - 44f, 2f, SummaryRuleSurface());
			for (int i = 0; i < 2; i++)
			{
				CreateDetailsAccentShade(parent, $"FeastPlanner_DetailsSummaryStatDivider_{i + 1}", new Vector2(num2 + 142f + (float)i * 118f, num4 - 23f), 2f, 42f, SummaryRuleSurface());
			}
			CreateDetailsAccentShade(parent, "FeastPlanner_DetailsDurationBadge", new Vector2(num / 2f - 94f, num4 - 22f), 112f, 44f, SummaryBadgeSurface());
			float num7 = (num - 30f) / 3f;
			for (int j = 0; j < _foodDetailTexts.Length; j++)
			{
				float num8 = num2 + num7 / 2f + (float)j * (num7 + 15f);
				_foodDetailCardShades[j] = CreateDetailsRowShade(parent, $"FeastPlanner_DetailsFoodCard_{j + 1}", new Vector2(num8, num5), num7, 112f);
				AddFoodDetailCardClickHandler(_foodDetailCardShades[j], j);
			}
			CreateDetailsRowShade(parent, "FeastPlanner_DetailsIngredientsRow", new Vector2(0f, num6), num, 132f);
			_detailsTitleText = CreateChildLabel(parent, "Select a plan", new Vector2(num2 + 124f, num4 + 28f), 168f, 24f, 17, instance.ValheimBeige, (TextAnchor)3);
			_totalStatsText = CreateChildLabel(parent, "H 0  S 0  E 0", new Vector2(num2 + 96f, num4 - 32f), 1f, 1f, 1, new Color(1f, 1f, 1f, 0f), (TextAnchor)3);
			_detailsHealthText = CreateChildLabel(parent, "Health", new Vector2(num2 + 80f, num4 - 8f), 92f, 20f, 13, new Color(1f, 0.34f, 0.3f, 0.92f), (TextAnchor)4);
			_detailsStaminaText = CreateChildLabel(parent, "Stamina", new Vector2(num2 + 198f, num4 - 8f), 104f, 20f, 13, new Color(1f, 0.68f, 0.12f, 0.92f), (TextAnchor)4);
			_detailsEitrText = CreateChildLabel(parent, "Eitr", new Vector2(num2 + 316f, num4 - 8f), 92f, 20f, 13, new Color(0.36f, 0.64f, 1f, 0.92f), (TextAnchor)4);
			_detailsHealthValueText = CreateChildLabel(parent, "0", new Vector2(num2 + 80f, num4 - 32f), 92f, 32f, 27, new Color(1f, 0.34f, 0.3f, 1f), (TextAnchor)4);
			_detailsStaminaValueText = CreateChildLabel(parent, "0", new Vector2(num2 + 198f, num4 - 32f), 104f, 32f, 27, new Color(1f, 0.68f, 0.12f, 1f), (TextAnchor)4);
			_detailsEitrValueText = CreateChildLabel(parent, "0", new Vector2(num2 + 316f, num4 - 32f), 92f, 32f, 27, new Color(0.36f, 0.64f, 1f, 1f), (TextAnchor)4);
			_detailsDurationText = CreateChildLabel(parent, "0m", new Vector2(num / 2f - 94f, num4 - 22f), 96f, 40f, 25, instance.ValheimBeige, (TextAnchor)4);
			for (int k = 0; k < _foodDetailTexts.Length; k++)
			{
				float num9 = num2 + num7 / 2f + (float)k * (num7 + 15f);
				_foodDetailIcons[k] = CreateIconSlot(parent, new Vector2(num9, num5 + 28f), 34f);
				_foodDetailTexts[k] = CreateChildLabel(parent, "", new Vector2(num9, num5 - 22f), num7 - 20f, 66f, 13, instance.ValheimBeige, (TextAnchor)1);
				SetRaycastTarget((Graphic?)(object)_foodDetailIcons[k], raycastTarget: false);
				SetRaycastTarget((Graphic?)(object)_foodDetailTexts[k], raycastTarget: false);
				TrackDetailsControl((Component?)(object)_foodDetailIcons[k]);
			}
			_ingredientSummaryText = CreateChildLabel(parent, "Ingredients: none selected", new Vector2(num2 + 160f, num6 + 44f), 286f, 26f, 15, instance.ValheimBeige, (TextAnchor)3);
			float num10 = (num - 44f) / 2f;
			float num11 = num10 - 68f;
			for (int l = 0; l < _ingredientDetailTexts.Length; l++)
			{
				int num12 = l % 2;
				int num13 = l / 2;
				float num14 = num2 + 18f + (float)num12 * num10;
				float num15 = num6 + 16f - (float)num13 * 31f;
				float num16 = num14 + 42f + num11 / 2f;
				_ingredientDetailIcons[l] = CreateIconSlot(parent, new Vector2(num14 + 16f, num15), 22f);
				_ingredientDetailTexts[l] = CreateChildLabel(parent, "", new Vector2(num16, num15), num11, 26f, 13, instance.ValheimBeige, (TextAnchor)3);
				TrackDetailsControl((Component?)(object)_ingredientDetailIcons[l]);
			}
			TrackDetailsControl((Component?)(object)_detailsTitleText);
			TrackDetailsControl((Component?)(object)_totalStatsText);
			TrackDetailsControl((Component?)(object)_detailsDurationText);
			TrackDetailsControl((Component?)(object)_detailsHealthText);
			TrackDetailsControl((Component?)(object)_detailsStaminaText);
			TrackDetailsControl((Component?)(object)_detailsEitrText);
			TrackDetailsControl((Component?)(object)_detailsHealthValueText);
			TrackDetailsControl((Component?)(object)_detailsStaminaValueText);
			TrackDetailsControl((Component?)(object)_detailsEitrValueText);
			TrackDetailsControl((Component?)(object)_ingredientSummaryText);
			Text[] foodDetailTexts = _foodDetailTexts;
			foreach (Text component in foodDetailTexts)
			{
				TrackDetailsControl((Component?)(object)component);
			}
			foodDetailTexts = _ingredientDetailTexts;
			foreach (Text component2 in foodDetailTexts)
			{
				TrackDetailsControl((Component?)(object)component2);
			}
		}

		private void CreateCustomEditMode(Transform parent, float width, float height)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_0152: 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_01ee: 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_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			float num = width - 42f;
			float num2 = height / 2f - 40f;
			Image val = CreateShade(parent, "FeastPlanner_CustomEditNameHeaderShade", new Vector2(0f, num2), num, 48f, SummaryHeaderSurface());
			_customEditControls.Add(((Component)val).gameObject);
			Text val2 = CreateChildLabel(parent, "Plan Name", new Vector2(0f - num / 2f + 68f, num2), 118f, 28f, 14, instance.ValheimBeige, (TextAnchor)3);
			_customEditControls.Add(((Component)val2).gameObject);
			_customNameInput = CreateInputField(parent, "Custom meal", new Vector2(92f, num2), num - 184f, 34f);
			((UnityEvent<string>)(object)_customNameInput.onEndEdit).AddListener((UnityAction<string>)delegate(string value)
			{
				RenameCustomDraft(value);
			});
			_customEditControls.Add(((Component)_customNameInput).gameObject);
			for (int num3 = 0; num3 < _slotButtonTexts.Length; num3++)
			{
				int slotIndex = num3;
				float num4 = num2 - 72f - (float)num3 * 86f;
				_customEditSlotShades[num3] = CreateShade(parent, $"FeastPlanner_CustomEditSlotShade_{num3 + 1}", new Vector2(0f, num4), num, 74f, PanelRowSurface());
				_customEditControls.Add(((Component)_customEditSlotShades[num3]).gameObject);
				GameObject val3 = CreateButton(string.Empty, parent, new Vector2(0f, num4), num - 18f, 66f, delegate
				{
					OpenFoodPicker(slotIndex);
				});
				_slotButtonTexts[num3] = val3.GetComponentInChildren<Text>();
				SetRowText(_slotButtonTexts[num3], string.Empty);
				_slotFoodIcons[num3] = CreateIconSlot(val3.transform, new Vector2(0f - num / 2f + 30f, 9f), 34f);
				Text val4 = CreateChildLabel(val3.transform, $"Slot {num3 + 1}", new Vector2(-212f, 14f), 70f, 20f, 12, instance.ValheimYellow, (TextAnchor)3);
				_customEditControls.Add(((Component)val4).gameObject);
				_slotPrimaryTexts[num3] = CreateChildLabel(val3.transform, "Choose food", new Vector2(-82f, 14f), 212f, 24f, 17, instance.ValheimOrange, (TextAnchor)3);
				_slotStatsTexts[num3] = CreateChildLabel(val3.transform, string.Empty, new Vector2(148f, 14f), 260f, 22f, 14, instance.ValheimBeige, (TextAnchor)3);
				for (int num5 = 0; num5 < 3; num5++)
				{
					CreateSlotIngredientChip(val3.transform, slotIndex, num5, new Vector2(0f - num / 2f + 88f + (float)num5 * 126f, -17f));
				}
				_customEditControls.Add(val3);
			}
			Image val5 = CreateShade(parent, "FeastPlanner_CustomEditActionBand", new Vector2(0f, num2 - 338f), num, 52f, PanelRegionSurface());
			_customEditControls.Add(((Component)val5).gameObject);
			_saveCustomButton = CreateButton("Save", parent, new Vector2(0f - num / 2f + 86f, num2 - 338f), 138f, 36f, SaveCustomDraft);
			_clearDraftButton = CreateButton("Clear Draft", parent, new Vector2(0f - num / 2f + 254f, num2 - 338f), 154f, 36f, ClearCustomDraft);
			_discardButton = CreateButton("Cancel", parent, new Vector2(0f - num / 2f + 424f, num2 - 338f), 128f, 36f, ConfirmDiscard);
			_discardText = _discardButton.GetComponentInChildren<Text>();
			_customEditControls.Add(_saveCustomButton);
			_customEditControls.Add(_clearDraftButton);
			_customEditControls.Add(_discardButton);
			SetEditControlsActive(active: false);
		}

		private void CreateSlotIngredientChip(Transform parent, int slotIndex, int chipIndex, Vector2 position)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			Image val = CreateShade(parent, $"FeastPlanner_CustomEditIngredientChip_{slotIndex + 1}_{chipIndex + 1}", position, 112f, 28f, ActiveTraySurface());
			_customEditControls.Add(((Component)val).gameObject);
			_slotIngredientIcons[slotIndex, chipIndex] = CreateIconSlot(parent, new Vector2(position.x - 38f, position.y), 22f);
			_slotIngredientTexts[slotIndex, chipIndex] = CreateChildLabel(parent, string.Empty, new Vector2(position.x + 8f, position.y), 76f, 20f, 11, GUIManager.Instance.ValheimBeige, (TextAnchor)3);
		}

		private void CreateFoodPickerMenu()
		{
			//IL_001b: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: 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_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			_pickerMenuRoot = GUIManager.Instance.CreateWoodpanel(_root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -18f), 760f, 460f, false);
			((Object)_pickerMenuRoot).name = "FeastPlanner_FoodPickerMenu";
			GUIManager instance = GUIManager.Instance;
			CreateShade(_pickerMenuRoot.transform, "FeastPlanner_FoodPickerBackdropShade", new Vector2(0f, -8f), 704f, 390f, new Color(0.035f, 0.024f, 0.016f, 0.16f));
			CreateChildLabel(_pickerMenuRoot.transform, "Choose Food", new Vector2(-243f, 190f), 220f, 34f, 22, instance.ValheimBeige, (TextAnchor)3);
			CreateButton("X", _pickerMenuRoot.transform, new Vector2(338f, 190f), 42f, 36f, CloseFoodPicker);
			Text val = CreateChildLabel(_pickerMenuRoot.transform, "Search", new Vector2(-306f, 145f), 76f, 28f, 15, instance.ValheimBeige, (TextAnchor)3);
			_pickerControls.Add(((Component)val).gameObject);
			_pickerSearchInput = CreateInputField(_pickerMenuRoot.transform, "", new Vector2(34f, 145f), 560f, 34f);
			((UnityEvent<string>)(object)_pickerSearchInput.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				RefreshFoodPicker();
			});
			_pickerControls.Add(((Component)_pickerSearchInput).gameObject);
			_pickerCategoryText = CreateButton("All", _pickerMenuRoot.transform, new Vector2(-278f, 98f), 150f, 32f, TogglePickerCategoryDropdown).GetComponentInChildren<Text>();
			_pickerControls.Add(((Component)((Component)_pickerCategoryText).transform.parent).gameObject);
			_pickerBiomeText = CreateButton("Any Biome", _pickerMenuRoot.transform, new Vector2(-106f, 98f), 170f, 32f, TogglePickerBiomeDropdown).GetComponentInChildren<Text>();
			_pickerControls.Add(((Component)((Component)_pickerBiomeText).transform.parent).gameObject);
			_pickerCategoryDropdownRoot = CreatePickerCategoryDropdown(_pickerMenuRoot.transform, new Vector2(-278f, 2f), 150f);
			_pickerBiomeDropdownRoot = CreatePickerBiomeDropdown(_pickerMenuRoot.transform, new Vector2(-106f, -42f), 170f);
			for (int num = 0; num < _pickerRowTexts.Length; num++)
			{
				int index = num;
				GameObject val2 = CreateButton("", _pickerMenuRoot.transform, new Vector2(-207f, 50f - (float)num * 50f), 292f, 40f, delegate
				{
					PreviewFood(index);
				});
				_pickerRowButtons[num] = val2;
				_pickerRowTexts[num] = val2.GetComponentInChildren<Text>();
				_pickerRowIcons[num] = CreateIconSlot(val2.transform, new Vector2(-122f, 0f), 24f);
				_pickerControls.Add(val2);
			}
			_pickerDetailIcon = CreateIconSlot(_pickerMenuRoot.transform, new Vector2(156f, 78f), 62f);
			_pickerControls.Add(((Component)_pickerDetailIcon).gameObject);
			_pickerDetailTitleText = CreateChildLabel(_pickerMenuRoot.transform, "Select a food", new Vector2(156f, 22f), 332f, 34f, 20, instance.ValheimBeige, (TextAnchor)4);
			_pickerControls.Add(((Component)_pickerDetailTitleText).gameObject);
			_pickerDetailStatsText = CreateChildLabel(_pickerMenuRoot.transform, "", new Vector2(156f, -20f), 332f, 28f, 15, instance.ValheimYellow, (TextAnchor)4);
			_pickerControls.Add(((Component)_pickerDetailStatsText).gameObject);
			for (int num2 = 0; num2 < _pickerIngredientIcons.Length; num2++)
			{
				int num3 = num2 % 3;
				int num4 = num2 / 3;
				CreatePickerIngredientChip(_pickerMenuRoot.transform, num2, new Vector2(36f + (float)num3 * 120f, -86f - (float)num4 * 30f));
			}
			_addPickerFoodButton = CreateButton("Add Food", _pickerMenuRoot.transform, new Vector2(156f, -140f), 148f, 36f, AddPreviewedFood);
			_pickerControls.Add(_addPickerFoodButton);
			GameObject item = CreateButton("Prev", _pickerMenuRoot.transform, new Vector2(-278f, -190f), 104f, 32f, PreviousPickerPage);
			_pickerControls.Add(item);
			_pickerPageText = CreateChildLabel(_pickerMenuRoot.transform, "Page 1/1", new Vector2(0f, -190f), 160f, 28f, 14, instance.ValheimBeige, (TextAnchor)4);
			_pickerControls.Add(((Component)_pickerPageText).gameObject);
			GameObject item2 = CreateButton("Next", _pickerMenuRoot.transform, new Vector2(278f, -190f), 104f, 32f, NextPickerPage);
			_pickerControls.Add(item2);
			SetPickerControlsActive(active: false);
		}

		private void CreatePickerIngredientChip(Transform parent, int chipIndex, Vector2 position)
		{
			//IL_0008: 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_0038: 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_004a: 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)
			_pickerIngredientIcons[chipIndex] = CreateIconSlot(parent, new Vector2(position.x - 36f, position.y), 24f);
			_pickerIngredientTexts[chipIndex] = CreateChildLabel(parent, string.Empty, new Vector2(position.x + 24f, position.y), 86f, 24f, 12, GUIManager.Instance.ValheimBeige, (TextAnchor)3);
			_pickerControls.Add(((Component)_pickerIngredientIcons[chipIndex]).gameObject);
			_pickerControls.Add(((Component)_pickerIngredientTexts[chipIndex]).gameObject);
		}

		private void CreateFooterActions(Transform parent)
		{
			//IL_0012: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			_setActiveText = CreateButton("Set Active", parent, new Vector2(-465f, 0f), 180f, 38f, SetSelectedActive).GetComponentInChildren<Text>();
			_clearActiveText = CreateButton("Clear", parent, new Vector2(-270f, 0f), 130f, 38f, ClearSelectedActive).GetComponentInChildren<Text>();
			_deleteCustomButton = CreateButton("Delete", parent, new Vector2(-120f, 0f), 130f, 38f, DeleteSelectedCustomPlan);
			_deleteCustomText = _deleteCustomButton.GetComponentInChildren<Text>();
			_editCustomButton = CreateButton("Edit", parent, new Vector2(30f, 0f), 110f, 38f, BeginCustomEdit);
			_newCustomButton = CreateButton("New", parent, new Vector2(155f, 0f), 100f, 38f, BeginNewCustomDraft);
		}

		private GameObject CreateRegion(string name, Vector2 position, float width, float height)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateWoodpanel(_root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, height, false);
			((Object)obj).name = name;
			CreateShade(obj.transform, name + "_Shade", Vector2.zero, width - 16f, height - 16f, PanelRegionSurface());
			return obj;
		}

		private GameObject CreateDropdownRoot(Transform parent, string name, Vector2 position, float width, int optionCount)
		{
			//IL_0020: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			float num = 18f + (float)optionCount * 30f;
			GameObject obj = GUIManager.Instance.CreateWoodpanel(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, num, false);
			((Object)obj).name = name;
			CreateShade(obj.transform, name + "_Shade", Vector2.zero, width - 12f, num - 12f, new Color(0.03f, 0.02f, 0.01f, 0.58f));
			return obj;
		}

		private Image CreateDetailsRowShade(Transform parent, string name, Vector2 position, float width, float height)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Image val = CreateShade(parent, name, position, width - 18f, height, PanelRowSurface());
			TrackDetailsControl((Component?)(object)val);
			return val;
		}

		private Image CreateDetailsAccentShade(Transform parent, string name, Vector2 position, float width, float height, Color color)
		{
			//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)
			Image val = CreateShade(parent, name, position, width, height, color);
			TrackDetailsControl((Component?)(object)val);
			return val;
		}

		private static Vector2 DropdownOptionPosition(int index, int optionCount)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)(optionCount - 1) * 30f / 2f;
			return new Vector2(0f, num - (float)index * 30f);
		}

		private static Image CreateShade(Transform parent, string name, Vector2 position, float width, float height, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(width, height);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = false;
			val.transform.SetAsFirstSibling();
			return component2;
		}

		private static Image CreateIconSlot(Transform parent, Vector2 position, float size)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_005d: 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_007d: 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)
			GameObject val = new GameObject("FeastPlanner_IconSlot", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(size, size);
			Image component2 = val.GetComponent<Image>();
			component2.type = (Type)1;
			component2.preserveAspect = true;
			((Graphic)component2).raycastTarget = false;
			SetIconSprite(component2, null);
			return component2;
		}

		private static void SetIconSprite(Image? image, Sprite? sprite)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (image != null)
			{
				image.sprite = sprite;
				((Graphic)image).color = (Color)((sprite == null) ? new Color(1f, 1f, 1f, 0f) : Color.white);
			}
		}

		private Text CreateLabel(string text, Vector2 position, float width, float height, int fontSize, Color color, TextAnchor alignment)
		{
			//IL_001b: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			Text component = GUIManager.Instance.CreateText(text, _root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerifBold, fontSize, color, false, Color.black, width, height, false).GetComponent<Text>();
			component.alignment = alignment;
			SetLongContentTextOptions(component);
			return component;
		}

		private Text CreateChildLabel(Transform parent, string text, Vector2 position, float width, float height, int fontSize, Color color, TextAnchor alignment)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Text component = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerifBold, fontSize, color, false, Color.black, width, height, false).GetComponent<Text>();
			component.alignment = alignment;
			SetLongContentTextOptions(component);
			return component;
		}

		private static void SetLongContentTextOptions(Text label)
		{
			label.horizontalOverflow = (HorizontalWrapMode)1;
			label.verticalOverflow = (VerticalWrapMode)0;
		}

		private GameObject CreateButton(string text, Vector2 position, float width, float height, Action onClick)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return CreateButton(text, _root.transform, position, width, height, onClick);
		}

		private GameObject CreateButton(string text, Transform parent, Vector2 position, float width, float height, Action onClick)
		{
			//IL_001f: 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_0033: 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_007e: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateButton(text, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, height);
			((Object)obj).name = "FeastPlanner_" + text.Replace(" ", string.Empty) + "Button";
			((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				onClick();
			});
			SetButtonTint(obj, ButtonSurface());
			AddButtonFrame(obj, width, height);
			return obj;
		}

		private static void AddButtonFrame(GameObject buttonObject, float width, float height)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			Image component = buttonObject.GetComponent<Image>();
			if (component != null)
			{
				component.type = (Type)1;
			}
			CreateButtonFrameShade(buttonObject.transform, ((Object)buttonObject).name + "_StoneInset", Vector2.zero, Vector2.one, new Vector2(4f, 4f), new Vector2(-4f, -4f), ButtonInsetSurface());
			CreateButtonFrameShade(buttonObject.transform, ((Object)buttonObject).name + "_TopRule", new Vector2(0f, 1f), Vector2.one, new Vector2(7f, -6f), new Vector2(-7f, -4f), ButtonTopRuleSurface());
			CreateButtonFrameShade(buttonObject.transform, ((Object)buttonObject).name + "_BottomShadow", Vector2.zero, new Vector2(1f, 0f), new Vector2(7f, 4f), new Vector2(-7f, 7f), ButtonBottomShadowSurface());
			CreateButtonFrameShade(buttonObject.transform, ((Object)buttonObject).name + "_LeftRule", Vector2.zero, new Vector2(0f, 1f), new Vector2(4f, 6f), new Vector2(6f, -6f), ButtonSideRuleSurface());
			CreateButtonFrameShade(buttonObject.transform, ((Object)buttonObject).name + "_RightRule", new Vector2(1f, 0f), Vector2.one, new Vector2(-6f, 6f), new Vector2(-4f, -6f), ButtonSideRuleSurface());
		}

		private static Image CreateButtonFrameShade(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_003b: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = false;
			val.transform.SetAsFirstSibling();
			return component2;
		}

		private void AddFoodDetailCardClickHandler(Image? shade, int index)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			if (shade != null)
			{
				((Graphic)shade).raycastTarget = true;
				Button obj = ((Component)shade).gameObject.GetComponent<Button>() ?? ((Component)shade).gameObject.AddComponent<Button>();
				((Selectable)obj).transition = (Transition)0;
				((Selectable)obj).targetGraphic = (Graphic)(object)shade;
				((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
				{
					ToggleCustomFoodFilter(index);
				});
			}
		}

		private InputField CreateInputField(Transform parent, string text, Vector2 position, float width, float height)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0056: 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_0080: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FeastPlanner_InputField", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(InputField)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(width, height);
			((Graphic)val.GetComponent<Image>()).color = ButtonSurface();
			Text component2 = GUIManager.Instance.CreateText(text, val.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, GUIManager.Instance.AveriaSerifBold, 15, GUIManager.Instance.ValheimBeige, false, Color.black, width - 16f, height - 8f, false).GetComponent<Text>();
			component2.alignment = (TextAnchor)3;
			InputField component3 = val.GetComponent<InputField>();
			component3.textComponent = component2;
			component3.text = text;
			return component3;
		}

		private void ToggleCookableOnly()
		{
			if (_selectedMode != PlannerViewMode.Custom)
			{
				_cookableOnly = !_cookableOnly;
				_pendingDeleteSavedMealId = null;
				RefreshProjectionOnly();
			}
		}

		private void ToggleRoleDropdown()
		{
			if (_selectedMode == PlannerViewMode.Recommended)
			{
				bool num = _roleDropdownRoot != null && !_roleDropdownRoot.activeSelf;
				HideRecommendedDropdowns();
				if (num)
				{
					OpenDropdown(_roleDropdownRoot);
				}
			}
		}

		private void ToggleBiomeDropdown()
		{
			if (_selectedMode == PlannerViewMode.Recommended)
			{
				bool num = _biomeDropdownRoot != null && !_biomeDropdownRoot.activeSelf;
				HideRecommendedDropdowns();
				if (num)
				{
					OpenDropdown(_biomeDropdownRoot);
				}
			}
		}

		private void SelectPlannerRole(PlannerRole role)
		{
			_selectedRole = role;
			_selectedRow = null;
			_pendingDeleteSavedMealId = null;
			HideRecommendedDropdowns();
			RefreshRecommendedRows();
		}

		private void SelectTargetBiome(TargetBiome biome)
		{
			_selectedBiome = biome;
			_selectedRow = null;
			_pendingDeleteSavedMealId = null;
			HideRecommendedDropdowns();
			RefreshRecommendedRows();
		}

		private void HideRecommendedDropdowns()
		{
			GameObject? roleDropdownRoot = _roleDropdownRoot;
			if (roleDropdownRoot != null)
			{
				roleDropdownRoot.SetActive(false);
			}
			GameObject? biomeDropdownRoot = _biomeDropdownRoot;
			if (biomeDropdownRoot != null)
			{
				biomeDropdownRoot.SetActive(false);
			}
		}

		private static void OpenDropdown(GameObject? dropdown)
		{
			if (dropdown != null)
			{
				dropdown.SetActive(true);
				dropdown.transform.SetAsLastSibling();
			}
		}

		private void SelectRecommendedTab()
		{
			ExitCustomEdit();
			HideRecommendedDropdowns();
			_selectedMode = PlannerViewMode.Recommended;
			_pendingDeleteSavedMealId = null;
			_selectedCustomFoodIndex = null;
			SetPlannerMode(PlannerViewMode.Recommended);
			RefreshProjectionOnly();
		}

		private void SelectCustomTab()
		{
			if (_selectedMode != PlannerViewMode.Custom)
			{
				ExitCustomEdit();
			}
			_selectedMode = PlannerViewMode.Custom;
			HideRecommendedDropdowns();
			_pendingDeleteSavedMealId = null;
			_selectedCustomFoodIndex = null;
			SetPlannerMode(PlannerViewMode.Custom);
			RefreshProjectionOnly();
		}

		private void SetPlannerMode(PlannerViewMode mode)
		{
			_setPlannerMode(mode);
		}

		private void SelectVisibleRow(int index)
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				SelectSavedMeal(index);
			}
			else
			{
				SelectRow(index);
			}
		}

		private void SelectRow(int index)
		{
			if (_projection != null && index >= 0 && index < _projection.Rows.Count)
			{
				_selectedRow = _projection.Rows[index];
				_pendingDeleteSavedMealId = null;
				RefreshProjectionOnly();
			}
		}

		private void SelectSavedMeal(int index)
		{
			if (!TryPromptDiscard() && _customProjection != null && index >= 0 && index < _customProjection.Rows.Count)
			{
				_selectedCustomRow = _customProjection.Rows[index];
				_pendingDeleteSavedMealId = null;
				_selectedCustomFoodIndex = null;
				_selectSavedMeal(_selectedCustomRow.Id);
				SetPlannerMode(PlannerViewMode.Custom);
				RefreshRecommendedRows();
			}
		}

		private void ToggleCustomFoodFilter(int index)
		{
			if (_selectedMode == PlannerViewMode.Custom && !_isCustomEditing && _selectedCustomRow != null && index >= 0 && index < _selectedCustomRow.Foods.Count)
			{
				_selectedCustomFoodIndex = ((_selectedCustomFoodIndex == index) ? ((int?)null) : new int?(index));
				RefreshProjectionOnly();
			}
		}

		private void SetSelectedActive()
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				if (_selectedCustomRow != null)
				{
					_activeTargetName = _selectedCustomRow.Name;
					_pendingDeleteSavedMealId = null;
					RefreshProjectionOnly();
				}
			}
			else if (_selectedRow != null)
			{
				_activeTargetName = _selectedRow.Name;
				RefreshProjectionOnly();
			}
		}

		private void ClearSelectedActive()
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				ClearCustomActiveTarget();
				return;
			}
			string text = _selectedRow?.Name;
			if (text != null && string.Equals(text, _activeTargetName, StringComparison.OrdinalIgnoreCase))
			{
				_activeTargetName = string.Empty;
				_pendingDeleteSavedMealId = null;
				RefreshProjectionOnly();
			}
		}

		private void ClearCustomActiveTarget()
		{
			if (!string.IsNullOrWhiteSpace(_activeTargetName))
			{
				_activeTargetName = string.Empty;
				_pendingDeleteSavedMealId = null;
				RefreshProjectionOnly();
			}
		}

		private void DeleteSelectedCustomPlan()
		{
			if (_isCustomEditing)
			{
				ConfirmDiscard();
			}
			else if (_selectedMode == PlannerViewMode.Custom && _selectedCustomRow != null)
			{
				if (!string.Equals(_pendingDeleteSavedMealId, _selectedCustomRow.Id, StringComparison.OrdinalIgnoreCase))
				{
					_pendingDeleteSavedMealId = _selectedCustomRow.Id;
					RefreshProjectionOnly();
					return;
				}
				DeleteSavedMeal();
				_pendingDeleteSavedMealId = null;
				_selectedCustomRow = null;
				RefreshRecommendedRows();
			}
		}

		private void DeleteSavedMeal()
		{
			_deleteSavedMeal();
		}

		private void BeginCustomEdit()
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				_editDraft = ((_selectedCustomRow == null) ? CustomEditDraft.New($"Custom {(_customProjection?.Rows.Count ?? 0) + 1}") : CustomEditDraft.FromValues(_selectedCustomRow.Id, _selectedCustomRow.Name, _selectedCustomRow.Foods.Select((FoodDefinition food) => food.PrefabName)));
				_isCustomEditing = true;
				_discardPending = false;
				_editingSlotIndex = null;
				SyncDraftInputs();
				RefreshProjectionOnly();
			}
		}

		private void BeginNewCustomDraft()
		{
			if (_selectedMode != PlannerViewMode.Custom)
			{
				SelectCustomTab();
			}
			if (!TryPromptDiscard())
			{
				_editDraft = CustomEditDraft.New($"Custom {(_customProjection?.Rows.Count ?? 0) + 1}");
				_isCustomEditing = true;
				_discardPending = false;
				_editingSlotIndex = null;
				SyncDraftInputs();
				RefreshProjectionOnly();
			}
		}

		private void RenameCustomDraft(string name)
		{
			if (_editDraft != null)
			{
				_editDraft = _editDraft.WithName(name);
				_discardPending = false;
				RefreshProjectionOnly();
			}
		}

		private void OpenFoodPicker(int slotIndex)
		{
			if (_editDraft == null)
			{
				BeginCustomEdit();
			}
			_editingSlotIndex = slotIndex;
			_pickerPreviewPrefabName = _editDraft?.Slots[slotIndex];
			_pickerPageIndex = 0;
			HidePickerDropdowns();
			if (_pickerSearchInput != null)
			{
				_pickerSearchInput.text = string.Empty;
			}
			RefreshFoodPicker();
			RefreshProjectionOnly();
		}

		private void PreviewFood(int rowIndex)
		{
			if (_editDraft != null)
			{
				int? editingSlotIndex = _editingSlotIndex;
				if (editingSlotIndex.HasValue && _pickerProjection != null && rowIndex >= 0 && rowIndex < _pickerProjection.Rows.Count)
				{
					FoodPickerRow foodPickerRow = _pickerProjection.Rows[rowIndex];
					_pickerPreviewPrefabName = foodPickerRow.PrefabName;
					RefreshFoodPicker();
				}
			}
		}

		private void AddPreviewedFood()
		{
			if (_editDraft == null)
			{
				return;
			}
			int? editingSlotIndex = _editingSlotIndex;
			if (editingSlotIndex.HasValue)
			{
				FoodPickerRow foodPickerRow = _pickerProjection?.PreviewRow;
				if (foodPickerRow != null)
				{
					_editDraft = _editDraft.WithSlot(_editingSlotIndex.Value, foodPickerRow.PrefabName);
					_pickerPreviewPrefabName = foodPickerRow.PrefabName;
					_discardPending = false;
					CloseFoodPicker();
					RefreshProjectionOnly();
				}
			}
		}

		private void TogglePickerCategoryDropdown()
		{
			bool num = _pickerCategoryDropdownRoot != null && !_pickerCategoryDropdownRoot.activeSelf;
			HidePickerDropdowns();
			if (num)
			{
				OpenDropdown(_pickerCategoryDropdownRoot);
			}
		}

		private void TogglePickerBiomeDropdown()
		{
			bool num = _pickerBiomeDropdownRoot != null && !_pickerBiomeDropdownRoot.activeSelf;
			HidePickerDropdowns();
			if (num)
			{
				OpenDropdown(_pickerBiomeDropdownRoot);
			}
		}

		private void SelectPickerCategory(FoodPickerCategory category)
		{
			_pickerCategory = category;
			_pickerPageIndex = 0;
			HidePickerDropdowns();
			RefreshFoodPicker();
		}

		private void SelectPickerBiome(TargetBiome? biome)
		{
			_pickerBiomeFilter = biome;
			_pickerPageIndex = 0;
			HidePickerDropdowns();
			RefreshFoodPicker();
		}

		private void HidePickerDropdowns()
		{
			GameObject? pickerCategoryDropdownRoot = _pickerCategoryDropdownRoot;
			if (pickerCategoryDropdownRoot != null)
			{
				pickerCategoryDropdownRoot.SetActive(false);
			}
			GameObject? pickerBiomeDropdownRoot = _pickerBiomeDropdownRoot;
			if (pickerBiomeDropdownRoot != null)
			{
				pickerBiomeDropdownRoot.SetActive(false);
			}
		}

		private void PreviousPickerPage()
		{
			_pickerPageIndex = Math.Max(0, _pickerPageIndex - 1);
			RefreshFoodPicker();
		}

		private void NextPickerPage()
		{
			_pickerPageIndex++;
			RefreshFoodPicker();
		}

		private void ClearCustomDraft()
		{
			if (_editDraft != null)
			{
				_editDraft = _editDraft.ClearDraft();
				_discardPending = false;
				SyncDraftInputs();
				RefreshProjectionOnly();
			}
		}

		private void SaveCustomDraft()
		{
			if (_editDraft != null)
			{
				_saveCustomMealDraft(_editDraft.SavedMealId, _editDraft.Name, _editDraft.FoodPrefabNames, _selectedRole, _selectedBiome);
				_editDraft = _editDraft.MarkSaved(_editDraft.SavedMealId ?? string.Empty);
				_isCustomEditing = false;
				_editingSlotIndex = null;
				_discardPending = false;
				CloseFoodPicker();
				RefreshRecommendedRows();
			}
		}

		private void ConfirmDiscard()
		{
			CustomEditDraft? editDraft = _editDraft;
			if (editDraft != null && editDraft.HasUnsavedChanges && !_discardPending)
			{
				_discardPending = true;
				RefreshProjectionOnly();
				return;
			}
			_editDraft = null;
			_isCustomEditing = false;
			_editingSlotIndex = null;
			_discardPending = false;
			CloseFoodPicker();
			RefreshProjectionOnly();
		}

		private void ExitCustomEdit()
		{
			_editDraft = null;
			_isCustomEditing = false;
			_editingSlotIndex = null;
			_discardPending = false;
			CloseFoodPicker();
		}

		private void CloseFoodPicker()
		{
			_editingSlotIndex = null;
			_pickerPreviewPrefabName = null;
			HidePickerDropdowns();
			SetPickerControlsActive(active: false);
		}

		private bool TryPromptDiscard()
		{
			if (_isCustomEditing)
			{
				CustomEditDraft? editDraft = _editDraft;
				if (editDraft != null && editDraft.HasUnsavedChanges)
				{
					_discardPending = true;
					RefreshProjectionOnly();
					return true;
				}
			}
			return false;
		}

		private void RefreshRecommendedRows()
		{
			RefreshDataAndProjection();
		}

		private void RefreshDataAndProjection()
		{
			if (!RootExists() || _rowNameTexts[0] == null)
			{
				return;
			}
			try
			{
				FeastPlannerViewModel model = _buildViewModel(_selectedRole, _selectedBiome);
				ApplyModelProjection(model, syncModeFromModel: true);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Failed to refresh Feast Planner recommended rows: {arg}");
			}
		}

		private void RefreshProjectionOnly()
		{
			if (!RootExists() || _rowNameTexts[0] == null)
			{
				return;
			}
			if (_latestModel == null)
			{
				RefreshDataAndProjection();
				return;
			}
			try
			{
				ApplyModelProjection(_latestModel, syncModeFromModel: false);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Failed to refresh Feast Planner projected rows: {arg}");
			}
		}

		private void ApplyModelProjection(FeastPlannerViewModel model, bool syncModeFromModel)
		{
			_latestModel = model;
			_selectedRole = model.SelectedRole;
			_selectedBiome = model.SelectedBiome;
			if (syncModeFromModel)
			{
				_selectedMode = model.SelectedMode;
			}
			_currentCraftability = model.Craftability;
			_projection = RecommendedPlanProjection.From(model, _cookableOnly, _activeTargetName);
			_customProjection = CustomPlanProjection.From(model, _activeTargetName, _pendingDeleteSavedMealId);
			_selectedRow = ((_selectedRow != null && _projection.Rows.Any((RecommendedPlanRow row) => row.Name == _selectedRow.Name && row.RowLabel == _selectedRow.RowLabel)) ? _projection.Rows.First((RecommendedPlanRow row) => row.Name == _selectedRow.Name && row.RowLabel == _selectedRow.RowLabel) : _projection.Rows.FirstOrDefault());
			_selectedCustomRow = ((_selectedCustomRow != null && _customProjection.Rows.Any((CustomPlanRow row) => row.Id == _selectedCustomRow.Id)) ? _customProjection.Rows.First((CustomPlanRow row) => row.Id == _selectedCustomRow.Id) : (_customProjection.Rows.FirstOrDefault((CustomPlanRow row) => row.IsSelected) ?? _customProjection.Rows.FirstOrDefault()));
			if (_selectedCustomFoodIndex.HasValue && (_selectedCustomRow == null || _selectedCustomFoodIndex.Value >= _selectedCustomRow.Foods.Count))
			{
				_selectedCustomFoodIndex = null;
			}
			ApplyProjection();
			RefreshFoodPicker();
		}

		private void ApplyProjection()
		{
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			if (_projection == null)
			{
				return;
			}
			if (_activeTargetText != null)
			{
				_activeTargetText.text = _projection.ActiveTargetText;
			}
			if (_cookableToggleText != null)
			{
				_cookableToggleText.text = ((_selectedMode == PlannerViewMode.Custom) ? "Saved Plans" : (_cookableOnly ? "Cookable Now: On" : "Cookable Now: Off"));
			}
			ApplyListHeaderLayout();
			if (_roleControlText != null)
			{
				_roleControlText.text = "Role: " + Display(_selectedRole);
			}
			if (_biomeControlText != null)
			{
				_biomeControlText.text = "Biome: " + Display(_selectedBiome);
			}
			SetRecommendedControlsVisible(_selectedMode == PlannerViewMode.Recommended);
			ApplyTabStyles();
			if (_setActiveText != null)
			{
				string text = ((_selectedMode != PlannerViewMode.Custom) ? _selectedRow?.Name : _selectedCustomRow?.Name);
				_setActiveText.text = ((text == null) ? "Set Active" : "Set Active");
			}
			ApplyDetailsProjection((_selectedMode == PlannerViewMode.Custom) ? RecommendedDetailsProjection.From(ToRecommendedRow(_selectedCustomRow), _currentCraftability, _activeTargetName, ingredientsExpanded: false, _selectedCustomFoodIndex) : RecommendedDetailsProjection.From(_selectedRow, _currentCraftability, _activeTargetName));
			ApplyActiveTargetProjection((_selectedMode == PlannerViewMode.Custom) ? ActiveTargetProjection.From(ToRecommendedRow(_customProjection?.Rows.FirstOrDefault((CustomPlanRow row) => row.Name == _activeTargetName)), _activeTargetName) : ActiveTargetProjection.From(_projection.Rows.FirstOrDefault((RecommendedPlanRow row) => row.Name == _activeTargetName), _activeTargetName));
			for (int num = 0; num < 8; num++)
			{
				if (_rowNameTexts[num] == null || _rowStatsTexts[num] == null || _rowDurationTexts[num] == null || _rowStatusTexts[num] == null)
				{
					continue;
				}
				if (num >= _projection.Rows.Count)
				{
					ClearRecommendedRow(num);
					continue;
				}
				RecommendedPlanRow recommendedPlanRow = _projection.Rows[num];
				if (_selectedMode == PlannerViewMode.Recommended)
				{
					ApplyRecommendedRowLayout(_rowButtons[num], num);
					ShowRecommendedRow(num);
					bool flag = recommendedPlanRow == _selectedRow;
					SetButtonTint(_rowButtons[num], flag ? AccentSurface() : ButtonSurface());
					string marker = (flag ? "> " : "  ");
					SetRowText(_rowNameTexts[num], FormatRowName(marker, num + 1, recommendedPlanRow.RowLabel));
					SetRowText(_rowStatsTexts[num], FormatCompactStats(recommendedPlanRow.Totals));
					SetRowText(_rowDurationTexts[num], recommendedPlanRow.DurationText);
					SetRowText(_rowStatusTexts[num], recommendedPlanRow.AvailabilityText);
					ApplyIconCluster(_rowFoodIcons, num, recommendedPlanRow.Foods);
				}
				else
				{
					ClearRecommendedRow(num);
				}
			}
			ApplyCustomRows();
			ApplyCustomEditMode();
		}

		private void SetRecommendedControlsVisible(bool visible)
		{
			GameObject? roleControlRoot = _roleControlRoot;
			if (roleControlRoot != null)
			{
				roleControlRoot.SetActive(visible);
			}
			GameObject? biomeControlRoot = _biomeControlRoot;
			if (biomeControlRoot != null)
			{
				biomeControlRoot.SetActive(visible);
			}
			if (!visible)
			{
				HideRecommendedDropdowns();
			}
		}

		private void ApplyTabStyles()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			SetButtonTint(_recommendedTabButton, (_selectedMode == PlannerViewMode.Recommended) ? AccentSurface() : ButtonSurface());
			SetButtonTint(_customTabButton, (_selectedMode == PlannerViewMode.Custom) ? AccentSurface() : ButtonSurface());
		}

		private void ApplyDetailsProjection(RecommendedDetailsProjection details)
		{
			SetRowText(_detailsTitleText, details.TitleText);
			SetRowText(_totalStatsText, details.TotalStatsText);
			SetRowText(_detailsDurationText, details.DurationText);
			SetRowText(_ingredientSummaryText, details.IngredientSummaryText);
			SetRowText(_detailsHealthValueText, ExtractStatValue(details.TotalStatsText, "H"));
			SetRowText(_detailsStaminaValueText, ExtractStatValue(details.TotalStatsText, "S"));
			SetRowText(_detailsEitrValueText, ExtractStatValue(details.TotalStatsText, "E"));
			_lastDetailsFoodCount = details.Foods.Count;
			ApplySelectedFoodDetailLayout(details.Foods.Count == 1);
			ApplyFoodDetailCardSelection(details.SelectedFoodIndex);
			if (_clearActiveText != null)
			{
				_clearActiveText.text = (details.CanClearActive ? "Clear Active" : "Clear");
			}
			Text? deleteCustomText;
			object text;
			if (_deleteCustomText != null)
			{
				deleteCustomText = _deleteCustomText;
				if (_selectedMode == PlannerViewMode.Custom)
				{
					CustomPlanRow? selectedCustomRow = _selectedCustomRow;
					if (selectedCustomRow != null && selectedCustomRow.IsDeletePending)
					{
						text = "Confirm Delete";
						goto IL_0124;
					}
				}
				text = "Delete";
				goto IL_0124;
			}
			goto IL_0129;
			IL_0124:
			deleteCustomText.text = (string)text;
			goto IL_0129;
			IL_0129:
			if (_deleteCustomButton != null)
			{
				_deleteCustomButton.SetActive(_selectedMode == PlannerViewMode.Custom);
			}
			for (int i = 0; i < _foodDetailTexts.Length; i++)
			{
				if (i >= details.Foods.Count)
				{
					SetRowText(_foodDetailTexts[i], string.Empty);
					SetIconSprite(_foodDetailIcons[i], null);
					continue;
				}
				RecommendedFoodDetails recommendedFoodDetails = details.Foods[i];
				SetRowText(_foodDetailTexts[i], TruncateText(recommendedFoodDetails.Name, 18) + "\n" + recommendedFoodDetails.StatsText + "\n" + recommendedFoodDetails.ReadinessText);
				SetIconSprite(_foodDetailIcons[i], recommendedFoodDetails.Icon);
			}
			for (int j = 0; j < _ingredientDetailTexts.Length; j++)
			{
				if (j >= details.IngredientLines.Count)
				{
					SetRowText(_ingredientDetailTexts[j], string.Empty);
					SetIconSprite(_ingredientDetailIcons[j], null);
					continue;
				}
				SetRowText(_ingredientDetailTexts[j], details.IngredientLines[j]);
				if (IsIngredientOverflowLine(details.IngredientLines[j]) || j >= details.Ingredients.Count)
				{
					SetIconSprite(_ingredientDetailIcons[j], null);
				}
				else
				{
					SetIconSprite(_ingredientDetailIcons[j], details.Ingredients[j].Icon);
				}
			}
		}

		private static bool IsIngredientOverflowLine(string line)
		{
			return line.StartsWith("+", StringComparison.Ordinal);
		}

		private void ApplySelectedFoodDetailLayout(bool selectedFoodOnly)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			if (_foodDetailCardShades[0] == null)
			{
				return;
			}
			RectTransform component = ((Component)((Component)_foodDetailCardShades[0]).transform.parent).GetComponent<RectTransform>();
			float num = ((component == null) ? 585f : component.sizeDelta.x);
			float num2 = ((component == null) ? 368f : component.sizeDelta.y);
			float num3 = num - 42f;
			float num4 = 0f - num3 / 2f;
			float num5 = num2 / 2f - 20f - 154f;
			float num6 = (num3 - 30f) / 3f;
			if (selectedFoodOnly)
			{
				SetDetailsControlActive((Graphic?)(object)_foodDetailCardShades[0], active: true);
				SetDetailsRect((Graphic?)(object)_foodDetailCardShades[0], new Vector2(0f, num5), num3 - 18f, 112f);
				SetDetailsControlActive((Graphic?)(object)_foodDetailIcons[0], active: true);
				SetDetailsControlActive((Graphic?)(object)_foodDetailTexts[0], active: true);
				SetDetailsRect((Graphic?)(object)_foodDetailIcons[0], new Vector2(0f, num5 + 30f), 46f, 46f);
				SetDetailsRect((Graphic?)(object)_foodDetailTexts[0], new Vector2(0f, num5 - 28f), num3 - 54f, 64f);
				if (_foodDetailTexts[0] != null)
				{
					_foodDetailTexts[0].alignment = (TextAnchor)4;
				}
				for (int i = 1; i < _foodDetailCardShades.Length; i++)
				{
					SetDetailsControlActive((Graphic?)(object)_foodDetailCardShades[i], active: false);
					SetDetailsControlActive((Graphic?)(object)_foodDetailIcons[i], active: false);
					SetDetailsControlActive((Graphic?)(object)_foodDetailTexts[i], active: false);
				}
				return;
			}
			for (int j = 0; j < _foodDetailCardShades.Length; j++)
			{
				float num7 = num4 + num6 / 2f + (float)j * (num6 + 15f);
				SetDetailsControlActive((Graphic?)(object)_foodDetailCardShades[j], active: true);
				SetDetailsControlActive((Graphic?)(object)_foodDetailIcons[j], active: true);
				SetDetailsControlActive((Graphic?)(object)_foodDetailTexts[j], active: true);
				SetDetailsRect((Graphic?)(object)_foodDetailCardShades[j], new Vector2(num7, num5), num6 - 18f, 112f);
				SetDetailsRect((Graphic?)(object)_foodDetailIcons[j], new Vector2(num7, num5 + 28f), 34f, 34f);
				SetDetailsRect((Graphic?)(object)_foodDetailTexts[j], new Vector2(num7, num5 - 22f), num6 - 20f, 66f);
				if (_foodDetailTexts[j] != null)
				{
					_foodDetailTexts[j].alignment = (TextAnchor)1;
				}
			}
		}

		private void ApplyFoodDetailCardSelection(int? selectedFoodIndex)
		{
			//IL_0035: 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)
			for (int i = 0; i < _foodDetailCardShades.Length; i++)
			{
				if (_foodDetailCardShades[i] != null)
				{
					((Graphic)_foodDetailCardShades[i]).color = ((selectedFoodIndex == i) ? AccentSurface() : PanelRowSurface());
				}
			}
		}

		private static void SetDetailsControlActive(Graphic? graphic, bool active)
		{
			if (graphic != null)
			{
				((Component)graphic).gameObject.SetActive(active);
			}
		}

		private static void SetRaycastTarget(Graphic? graphic, bool raycastTarget)
		{
			if (graphic != null)
			{
				graphic.raycastTarget = raycastTarget;
			}
		}

		private static void SetDetailsRect(Graphic? graphic, Vector2 position, float width, float height)
		{
			//IL_0010: 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)
			if (graphic != null)
			{
				RectTransform component = ((Component)graphic).GetComponent<RectTransform>();
				if (component != null)
				{
					component.anchoredPosition = position;
					component.sizeDelta = new Vector2(width, height);
				}
			}
		}

		private void ApplyActiveTargetProjection(ActiveTargetProjection activeTarget)
		{
			SetRowText(_activeTargetLabelText, "Active");
			SetRowText(_activeTargetText, activeTarget.NameText);
			SetRowText(_activeTargetHealthValueText, activeTarget.HealthText);
			SetRowText(_activeTargetStaminaValueText, activeTarget.StaminaText);
			SetRowText(_activeTargetEitrValueText, activeTarget.EitrText);
			SetRowText(_activeTargetDurationText, activeTarget.DurationText);
			SetRowText(_activeTargetStatusText, activeTarget.ReadinessText);
			for (int i = 0; i < _activeTargetFoodIcons.Length; i++)
			{
				if (i < activeTarget.Foods.Count)
				{
					FoodDefinition foodDefinition = activeTarget.Foods[i];
					SetIconSprite(_activeTargetFoodIcons[i], foodDefinition.Icon);
				}
				else
				{
					SetIconSprite(_activeTargetFoodIcons[i], null);
				}
			}
		}

		private void ApplyCustomRows()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (_customProjection == null)
			{
				return;
			}
			for (int i = 0; i < 8; i++)
			{
				if (_customRowNameTexts[i] != null && _customRowStatsTexts[i] != null && _customRowDurationTexts[i] != null && _customRowStatusTexts[i] != null)
				{
					if (_selectedMode != PlannerViewMode.Custom || i >= _customProjection.Rows.Count)
					{
						ClearCustomRow(i);
						continue;
					}
					CustomPlanRow customPlanRow = _customProjection.Rows[i];
					ApplyCustomRowLayout(_rowButtons[i], i);
					ShowCustomRow(i);
					SetButtonTint(_rowButtons[i], customPlanRow.IsSelected ? AccentSurface() : ButtonSurface());
					string marker = (customPlanRow.IsSelected ? "> " : (customPlanRow.IsActive ? "* " : "  "));
					SetRowText(_customRowNameTexts[i], FormatRowName(marker, i + 1, customPlanRow.Name));
					SetRowText(_customRowStatsTexts[i], FormatCompactStats(customPlanRow.Totals));
					SetRowText(_customRowDurationTexts[i], customPlanRow.DurationText);
					SetRowText(_customRowStatusTexts[i], customPlanRow.IsDeletePending ? "Confirm" : customPlanRow.ReadinessText);
					ApplyIconCluster(_customRowFoodIcons, i, customPlanRow.Foods);
				}
			}
		}

		private void ApplyCustomEditMode()
		{
			bool flag = _selectedMode == PlannerViewMode.Custom && _isCustomEditing && _editDraft != null;
			SetDetailsControlsActive(!flag);
			if (!flag)
			{
				ApplySelectedFoodDetailLayout(_lastDetailsFoodCount == 1);
			}
			SetEditControlsActive(flag);
			int pickerControlsActive;
			if (flag)
			{
				int? editingSlotIndex = _editingSlotIndex;
				pickerControlsActive = (editingSlotIndex.HasValue ? 1 : 0);
			}
			else
			{
				pickerControlsActive = 0;
			}
			SetPickerControlsActive((byte)pickerControlsActive != 0);
			if (_editCustomButton != null)
			{
				_editCustomButton.SetActive(_selectedMode == PlannerViewMode.Custom && !_isCustomEditing);
			}
			if (_newCustomButton != null)
			{
				_newCustomButton.SetActive(_selectedMode == PlannerViewMode.Custom && !_isCustomEditing);
			}
			if (_saveCustomButton != null)
			{
				_saveCustomButton.SetActive(flag);
			}
			if (_clearDraftButton != null)
			{
				_clearDraftButton.SetActive(flag);
			}
			if (_discardButton != null)
			{
				_discardButton.SetActive(flag);
			}
			if (_discardText != null)
			{
				_discardText.text = (_discardPending ? "Confirm Cancel" : "Cancel");
			}
			if (flag && _editDraft != null)
			{
				SyncDraftInputs();
				for (int i = 0; i < _slotButtonTexts.Length; i++)
				{
					string text = _editDraft.Slots[i];
					FoodDefinition foodDefinition = FindVisibleFood(text);
					SetRowText(_slotButtonTexts[i], string.Empty);
					SetRowText(_slotPrimaryTexts[i], FormatSlotPrimaryText(i, text, foodDefinition));
					SetRowText(_slotStatsTexts[i], FormatSlotStatsText(foodDefinition));
					SetIconSprite(_slotFoodIcons[i], foodDefinition?.Icon);
					ApplySlotIngredientChips(i, foodDefinition);
					SetEditSlotShadeTint(i, !string.IsNullOrWhiteSpace(text));
				}
			}
		}

		private void RefreshFoodPicker()
		{
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			if (_latestModel == null)
			{
				return;
			}
			int? editingSlotIndex = _editingSlotIndex;
			if (!editingSlotIndex.HasValue)
			{
				return;
			}
			IReadOnlyList<FoodDefinition> visibleFoods = _latestModel.VisibleFoods;
			InputField? pickerSearchInput = _pickerSearchInput;
			_pickerProjection = CustomFoodPickerProjection.From(visibleFoods, ((pickerSearchInput != null) ? pickerSearchInput.text : null) ?? string.Empty, _pickerCategory, _pickerBiomeFilter, _pickerPageIndex, _pickerRowTexts.Length, _pickerPreviewPrefabName);
			_pickerPageIndex = _pickerProjection.PageIndex;
			_pickerPreviewPrefabName = _pickerProjection.PreviewRow?.PrefabName;
			SetRowText(_pickerCategoryText, Display(_pickerCategory));
			SetRowText(_pickerBiomeText, _pickerBiomeFilter.HasValue ? Display(_pickerBiomeFilter.Value) : "Any Biome");
			SetRowText(_pickerPageText, _pickerProjection.PageText);
			FoodPickerRow previewRow = _pickerProjection.PreviewRow;
			SetIconSprite(_pickerDetailIcon, previewRow?.Icon);
			SetRowText(_pickerDetailTitleText, (previewRow == null) ? "No foods match" : previewRow.DisplayText);
			SetRowText(_pickerDetailStatsText, (previewRow == null) ? "No matching foods" : previewRow.InlineStatsText);
			ApplyPickerIngredientChips(previewRow);
			for (int i = 0; i < _pickerRowTexts.Length; i++)
			{
				if (i >= _pickerProjection.Rows.Count)
				{
					SetRowText(_pickerRowTexts[i], string.Empty);
					SetIconSprite(_pickerRowIcons[i], null);
					if (_pickerRowButtons[i] != null)
					{
						_pickerRowButtons[i].SetActive(false);
					}
					continue;
				}
				FoodPickerRow foodPickerRow = _pickerProjection.Rows[i];
				if (_pickerRowButtons[i] != null)
				{
					_pickerRowButtons[i].SetActive(true);
				}
				SetButtonTint(_pickerRowButtons[i], foodPickerRow.IsPreviewed ? AccentSurface() : ButtonSurface());
				SetIconSprite(_pickerRowIcons[i], foodPickerRow.Icon);
				SetRowText(_pickerRowTexts[i], foodPickerRow.DisplayText);
			}
		}

		private void ApplyPickerIngredientChips(FoodPickerRow? previewRow)
		{
			for (int i = 0; i < _pickerIngredientIcons.Length; i++)
			{
				SetIconSprite(_pickerIngredientIcons[i], null);
				SetRowText(_pickerIngredientTexts[i], string.Empty);
			}
			if (previewRow == null)
			{
				return;
			}
			int num = 0;
			foreach (PickerIngredientPreview item in previewRow.Ingredients.Take(_pickerIngredientIcons.Length))
			{
				int num2 = num++;
				SetIconSprite(_pickerIngredientIcons[num2], item.Icon);
				SetRowText(_pickerIngredientTexts[num2], TruncateText(item.DisplayText, 18));
			}
		}

		private void SetEditSlotShadeTint(int index, bool filled)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 0 && index < _customEditSlotShades.Length && _customEditSlotShades[index] != null)
			{
				((Graphic)_customEditSlotShades[index]).color = (filled ? AccentSurface() : PanelRowSurface());
			}
		}

		private void ApplySlotIngredientChips(int slotIndex, FoodDefinition? food)
		{
			for (int i = 0; i < 3; i++)
			{
				SetIconSprite(_slotIngredientIcons[slotIndex, i], null);
				SetRowText(_slotIngredientTexts[slotIndex, i], string.Empty);
			}
			if (food == null)
			{
				return;
			}
			int num = 0;
			foreach (FoodIngredient item in food.Ingredients.Take(3))
			{
				int num2 = num++;
				SetIconSprite(_slotIngredientIcons[slotIndex, num2], item.Icon);
				SetRowText(_slotIngredientTexts[slotIndex, num2], FormatSlotIngredientText(item));
			}
		}

		private void SyncDraftInputs()
		{
			if (_editDraft != null && _customNameInput != null && !string.Equals(_customNameInput.text, _editDraft.Name, StringComparison.Ordinal))
			{
				_customNameInput.text = _editDraft.Name;
			}
		}

		private void SetEditControlsActive(bool active)
		{
			foreach (GameObject customEditControl in _customEditControls)
			{
				customEditControl.SetActive(active);
			}
		}

		private void TrackDetailsControl(Component? component, bool useParent = false)
		{
			if (component != null)
			{
				_detailsControls.Add(useParent ? ((Component)component.transform.parent).gameObject : component.gameObject);
			}
		}

		private void SetDetailsControlsActive(bool active)
		{
			foreach (GameObject detailsControl in _detailsControls)
			{
				detailsControl.SetActive(active);
			}
		}

		private void SetPickerControlsActive(bool active)
		{
			if (_pickerMenuRoot != null)
			{
				_pickerMenuRoot.SetActive(active);
			}
			foreach (GameObject pickerControl in _pickerControls)
			{
				pickerControl.SetActive(active);
			}
		}

		public void UpdateInputBlock(bool forceOff = false)
		{
			GUIManager.BlockInput(!forceOff && IsOpen && ((_customNameInput != null && _customNameInput.isFocused) || (_pickerSearchInput != null && _pickerSearchInput.isFocused)));
		}

		private void ClearRecommendedRow(int index)
		{
			SetRowText(_rowNameTexts[index], string.Empty);
			SetRowText(_rowStatsTexts[index], string.Empty);
			SetRowText(_rowDurationTexts[index], string.Empty);
			SetRowText(_rowStatusTexts[index], string.Empty);
			ApplyIconCluster(_rowFoodIcons, index, Array.Empty<FoodDefinition>());
			HideRecommendedRow(index);
		}

		private void ShowRecommendedRow(int index)
		{
			if (_selectedMode == PlannerViewMode.Recommended)
			{
				GameObject? obj = _rowButtons[index];
				if (obj != null)
				{
					obj.SetActive(true);
				}
			}
		}

		private void HideRecommendedRow(int index)
		{
			if (_selectedMode == PlannerViewMode.Recommended)
			{
				GameObject? obj = _rowButtons[index];
				if (obj != null)
				{
					obj.SetActive(false);
				}
			}
		}

		private void ShowCustomRow(int index)
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				GameObject? obj = _rowButtons[index];
				if (obj != null)
				{
					obj.SetActive(true);
				}
			}
		}

		private void HideCustomRow(int index)
		{
			if (_selectedMode == PlannerViewMode.Custom)
			{
				GameObject? obj = _rowButtons[index];
				if (obj != null)
				{
					obj.SetActive(false);
				}
			}
		}

		private static void ApplyRecommendedRowLayout(GameObject? row, int index)
		{
			float num = 408f / 2f - 142f;
			ApplyRowLayout(row, 72f, num - (float)index * 86f);
		}

		private static void ApplyCustomRowLayout(GameObject? row, int index)
		{
			float num = 408f / 2f - 92f;
			ApplyRowLayout(row, 32f, num - (float)index * 37f);
		}

		private void ApplyListHeaderLayout()
		{
			//IL_0047: 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 (_cookableToggleRoot != null)
			{
				RectTransform component = _cookableToggleRoot.GetComponent<RectTransform>();
				if (component != null)
				{
					float num = 408f;
					float num2 = ((_selectedMode == PlannerViewMode.Custom) ? (num / 2f - 46f) : (num / 2f - 78f));
					component.anchoredPosition = new Vector2(component.anchoredPosition.x, num2);
				}
			}
		}

		private static void ApplyRowLayout(GameObject? row, float height, float y)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (row != null)
			{
				RectTransform component = row.GetComponent<RectTransform>();
				if (component != null)
				{
					component.sizeDelta = new Vector2(component.sizeDelta.x, height);
					component.anchoredPosition = new Vector2(0f, y);
				}
			}
		}

		private void ClearCustomRow(int index)
		{
			SetRowText(_customRowNameTexts[index], string.Empty);
			SetRowText(_customRowStatsTexts[index], string.Empty);
			SetRowText(_customRowDurationTexts[index], string.Empty);
			SetRowText(_customRowStatusTexts[index], string.Empty);
			ApplyIconCluster(_customRowFoodIcons, index, Array.Empty<FoodDefinition>());
			HideCustomRow(index);
		}

		private static void ApplyIconCluster(Image?[,] icons, int rowIndex, IReadOnlyList<FoodDefinition> foods)
		{
			for (int i = 0; i < 3; i++)
			{
				if (i < foods.Count)
				{
					FoodDefinition foodDefinition = foods[i];
					SetIconSprite(icons[rowIndex, i], foodDefinition.Icon);
				}
				else
				{
					SetIconSprite(icons[rowIndex, i], null);
				}
			}
		}

		private FoodDefinition? FindVisibleFood(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName) || _latestModel == null)
			{
				return null;
			}
			return _latestModel.VisibleFoods.FirstOrDefault((FoodDefinition food) => string.Equals(food.PrefabName, prefabName, StringComparison.OrdinalIgnoreCase));
		}

		private static string FormatSlotPrimaryText(int slotIndex, string prefabName, FoodDefinition? food)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return "Choose food";
			}
			if (food == null)
			{
				return $"Slot {slotIndex + 1}: Hidden saved food";
			}
			return TruncateText(food.DisplayName, 24);
		}

		private static string FormatSlotStatsText(FoodDefinition? food)
		{
			if (food != null)
			{
				return $"{FormatCompactStats(food.Stats)}  HP/s {food.Stats.Healing:0.#}";
			}
			return string.Empty;
		}

		private static string FormatSlotIngredientText(FoodIngredient ingredient)
		{
			return $"{TruncateText(ingredient.DisplayName, 12)} x{ingredient.Amount:0}";
		}

		private static RecommendedPlanRow? ToRecommendedRow(CustomPlanRow? row)
		{
			if (row != null)
			{
				return RecommendedPlanRow.FromMeal(row.Name, row.Foods, MealCraftability.Empty);
			}
			return null;
		}

		private static void SetRowText(Text? label, string value)
		{
			if (label != null)
			{
				label.text = value;
			}
		}

		private static void SetButtonTint(GameObject? buttonObject, Color color)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (buttonObject != null)
			{
				Image component = buttonObject.GetComponent<Image>();
				if (component != null)
				{
					((Graphic)component).color = color;
				}
			}
		}

		private static Color ButtonSurface()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return PanelRowSurface();
		}

		private static Color ButtonInsetSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.12f, 0.105f, 0.09f, 0.24f);
		}

		private static Color ButtonTopRuleSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.52f, 0.38f, 0.22f, 0.34f);
		}

		private static Color ButtonBottomShadowSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.015f, 0.011f, 0.008f, 0.52f);
		}

		private static Color ButtonSideRuleSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.34f, 0.24f, 0.14f, 0.22f);
		}

		private static Color AccentSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.2f, 0.12f, 0.045f, 0.58f);
		}

		private static Color PanelRegionSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.035f, 0.024f, 0.016f, 0.34f);
		}

		private static Color PanelRowSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.025f, 0.018f, 0.012f, 0.58f);
		}

		private static Color ActiveTraySurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.055f, 0.035f, 0.018f, 0.42f);
		}

		private static Color ActiveBadgeSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.16f, 0.09f, 0.035f, 0.4f);
		}

		private static Color SummaryHeaderSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.18f, 0.105f, 0.04f, 0.34f);
		}

		private static Color SummaryBadgeSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.13f, 0.075f, 0.03f, 0.42f);
		}

		private static Color SummaryRuleSurface()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.46f, 0.3f, 0.13f, 0.42f);
		}

		private static string ExtractStatValue(string statsText, string label)
		{
			string[] array = (statsText ?? string.Empty).Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length - 1; i++)
			{
				if (string.Equals(array[i], label, StringComparison.OrdinalIgnoreCase))
				{
					return array[i + 1];
				}
			}
			return "0";
		}

		private static string FormatRowName(string marker, int ordinal, string name)
		{
			return $"{marker}{ordinal}. {TruncateText(name, 20)}";
		}

		private static string FormatCompactStats(FoodStats stats)
		{
			return $"H{stats.Health:0} S{stats.Stamina:0} E{stats.Eitr:0}";
		}

		private static string Display(PlannerRole role)
		{
			return role switch
			{
				PlannerRole.BossFight => "Boss Fight", 
				PlannerRole.ExploreGather => "Explore", 
				PlannerRole.BuildFarm => "Build", 
				PlannerRole.MineHaul => "Mine", 
				PlannerRole.MagicEitr => "Magic", 
				PlannerRole.BestAvailable => "Best", 
				_ => "Balanced", 
			};
		}

		private static string Display(FoodPickerCategory category)
		{
			return category switch
			{
				FoodPickerCategory.HealthHeavy => "Health", 
				FoodPickerCategory.StaminaHeavy => "Stamina", 
				FoodPickerCategory.Eitr => "Eitr", 
				FoodPickerCategory.BalancedUtility => "Balanced", 
				_ => "All", 
			};
		}

		private static string Display(TargetBiome biome)
		{
			if (biome == TargetBiome.BlackForest)
			{
				return "Black Forest";
			}
			return biome.ToString();
		}

		private static string TruncateText(string value, int maxCharacters)
		{
			if (value.Length <= maxCharacters)
			{
				return value;
			}
			if (maxCharacters > 3)
			{
				return value.Substring(0, maxCharacters - 3) + "...";
			}
			return value.Substring(0, maxCharacters);
		}

		private bool RootExists()
		{
			return (Object)(object)_root != (Object)null;
		}

		private void ForgetRoot()
		{
			_root = null;
		}
	}
	public sealed class RecommendedDetailsProjection
	{
		private const int VisibleIngredientRows = 6;

		private const int VisibleIngredientRowsWithOverflow = 5;

		public string TitleText { get; }

		public string TotalStatsText { get; }

		public string DurationText { get; }

		public IReadOnlyList<RecommendedFoodDetails> Foods { get; }

		public string AvailabilityText { get; }

		public string IngredientSummaryText { get; }

		public string MissingIngredientPreviewText { get; }

		public IReadOnlyList<IngredientProgress> Ingredients { get; }

		public IReadOnlyList<string> IngredientLines { get; }

		public int? SelectedFoodIndex { get; }

		public bool AreIngredientsExpanded { get; }

		public string SourceStatusText { get; }

		public bool CanClearActive { get; }

		public static RecommendedDetailsProjection Empty { get; } = new RecommendedDetailsProjection("Select a plan", "H 0  S 0  E 0", "0m", Array.Empty<RecommendedFoodDetails>(), "Availability: Select a plan", "Ingredients: collapsed, none selected", string.Empty, Array.Empty<IngredientProgress>(), Array.Empty<string>(), null, areIngredientsExpanded: false, string.Empty, canClearActive: false);

		private RecommendedDetailsProjection(string titleText, string totalStatsText, string durationText, IReadOnlyList<RecommendedFoodDetails> foods, string availabilityText, string ingredientSummaryText, string missingIngredientPreviewText, IReadOnlyList<IngredientProgress> ingredients, IReadOnlyList<string> ingredientLines, int? selectedFoodIndex, bool areIngredientsExpanded, string sourceStatusText, bool canClearActive)
		{
			TitleText = titleText;
			TotalStatsText = totalStatsText;
			DurationText = durationText;
			Foods = foods;
			AvailabilityText = availabilityText;
			IngredientSummaryText = ingredientSummaryText;
			MissingIngredientPreviewText = missingIngredientPreviewText;
			Ingredients = ingredients;
			IngredientLines = ingredientLines;
			SelectedFoodIndex = selectedFoodIndex;
			AreIngredientsExpanded = areIngredientsExpanded;
			SourceStatusText = sourceStatusText;
			CanClearActive = canClearActive;
		}

		public static RecommendedDetailsProjection From(RecommendedPlanRow? row, MealCraftability craftability, string activeTargetName, bool ingredientsExpanded = false, int? selectedFoodIndex = null)
		{
			if (row == null)
			{
				return Empty;
			}
			List<RecommendedFoodDetails> list = row.Foods.Select((FoodDefinition food) => RecommendedFoodDetails.From(food, craftability.ForFood(food.PrefabName))).ToList();
			int? selectedFoodIndex2 = NormalizeSelectedFoodIndex(row, selectedFoodIndex);
			List<IngredientProgress> list2 = SelectedIngredients(row, craftability, selectedFoodIndex2).SelectMany(FlattenDisplayIngredients).ToList();
			List<IngredientProgress> list3 = list2.Where((IngredientProgress ingredient) => ingredient.Missing > 0).ToList();
			string availabilityText = FormatSelectedAvailability(row, craftability, selectedFoodIndex2, list3);
			string ingredientSummaryText = ((list3.Count == 0) ? "Ingredients: ready" : $"Ingredients: {list3.Count} missing");
			List<string> list4 = FormatIngredientLines(list2, ingredientsExpanded);
			return new RecommendedDetailsProjection(row.Name, FormatStats(row.PlanTotals), row.PlanDurationText, new ReadOnlyCollection<RecommendedFoodDetails>(list), availabilityText, ingredientSummaryText, string.Empty, new ReadOnlyCollection<IngredientProgress>(list2.ToList()), new ReadOnlyCollection<string>(list4), selectedFoodIndex2, ingredientsExpanded, craftability.ScanStatusText, string.Equals(row.Name, activeTargetName, StringComparison.OrdinalIgnoreCase));
		}

		private static int? NormalizeSelectedFoodIndex(RecommendedPlanRow row, int? selectedFoodIndex)
		{
			if (!selectedFoodIndex.HasValue || selectedFoodIndex.Value < 0 || selectedFoodIndex.Value >= row.Foods.Count)
			{
				return null;
			}
			return selectedFoodIndex;
		}

		private static IReadOnlyList<IngredientProgress> SelectedIngredients(RecommendedPlanRow row, MealCraftability craftability, int? selectedFoodIndex)
		{
			IEnumerable<FoodDefinition> source;
			if (!selectedFoodIndex.HasValue)
			{
				IEnumerable<FoodDefinition> foods = row.Foods;
				source = foods;
			}
			else
			{
				source = row.Foods.Skip(selectedFoodIndex.Value).Take(1);
			}
			return (from food in source
				select craftability.ForFood(food.PrefabName) into foodCraftability
				where foodCraftability != null
				select foodCraftability).SelectMany((FoodCraftability foodCraftability) => foodCraftability.Ingredients).ToList();
		}

		private static IEnumerable<IngredientProgress> FlattenDisplayIngredients(IngredientProgress ingredient)
		{
			if (ingredient.Children.Count == 0)
			{
				yield return ingredient;
				yield break;
			}
			if (ingredient.Available >= ingredient.Required && !string.IsNullOrWhiteSpace(ingredient.SourceBreakdown))
			{
				yield return ingredient;
				yield break;
			}
			foreach (IngredientProgress item in ingredient.Children.SelectMany(FlattenDisplayIngredients))
			{
				yield return item;
			}
		}

		private static List<string> FormatIngredientLines(IReadOnlyList<IngredientProgress> ingredients, bool ingredientsExpanded)
		{
			if (ingredientsExpanded || ingredients.Count <= 6)
			{
				return ingredients.Select(FormatIngredientPreview).ToList();
			}
			int num = ingredients.Count - 5;
			List<string> list = ingredients.Take(5).Select(FormatIngredientPreview).ToList();
			list.Add($"+{num} more ingredients");
			return list;
		}

		private static string FormatSelectedAvailability(RecommendedPlanRow row, MealCraftability craftability, int? selectedFoodIndex, IReadOnlyList<IngredientProgress> missing)
		{
			if (selectedFoodIndex.HasValue)
			{
				FoodDefinition foodDefinition = row.Foods[selectedFoodIndex.Value];
				FoodCraftability foodCraftability = craftability.ForFood(foodDefinition.PrefabName);
				if (foodCraftability != null && (foodCraftability.AvailableFoodCount > 0 || (foodCraftability.IsCraftableByRecipe && foodCraftability.FoodUnitsCraftable > 0)))
				{
					return "Availability: Ready";
				}
				if (missing.Count <= 0)
				{
					return "Availability: Missing";
				}
				return $"Availability: Missing {missing.Count}";
			}
			if (row.IsReady)
			{
				return "Availability: Ready";
			}
			if (missing.Count > 0)
			{
				return $"Availability: Missing {missing.Count}";
			}
			return "Availability: " + row.AvailabilityText;
		}

		private static string FormatIngredientPreview(IngredientProgress ingredient)
		{
			string text = (string.IsNullOrWhiteSpace(ingredient.SourceBreakdown) ? string.Empty : (" (" + ingredient.SourceBreakdown + ")"));
			return $"{ingredient.DisplayName} {ingredient.Available}/{ingredient.Required}{text}";
		}

		private static string FormatStats(FoodStats stats)
		{
			return $"H {stats.Health:0}  S {stats.Stamina:0}  E {stats.Eitr:0}";
		}
	}
	public sealed class RecommendedFoodDetails
	{
		public string Name { get; }

		public string StatsText { get; }

		public string ReadinessText { get; }

		public Sprite? Icon { get; }

		private RecommendedFoodDetails(string name, string statsText, string readinessText, Sprite? icon)
		{
			Name = name;
			StatsText = statsText;
			ReadinessText = readinessText;
			Icon = icon;
		}

		public static RecommendedFoodDetails From(FoodDefinition food, FoodCraftability? craftability)
		{
			return new RecommendedFoodDetails(food.DisplayName, $"H {food.Stats.Health:0}  S {food.Stats.Stamina:0}  E {food.Stats.Eitr:0}", FormatReadiness(food, craftability), food.Icon);
		}

		private static string FormatReadiness(FoodDefinition food, FoodCraftability? craftability)
		{
			if (craftability == null)
			{
				return "Missing";
			}
			if (craftability.AvailableFoodCount > 0)
			{
				return FormatAvailableFood(craftability.AvailableFoodCount, craftability.AvailableFoodSourceText);
			}
			if (!food.HasRecipe)
			{
				return "Missing";
			}
			if (craftability.IsCraftableByRecipe && craftability.FoodUnitsCraftable > 0)
			{
				return $"Ready x{craftability.FoodUnitsCraftable}";
			}
			int num = craftability.Ingredients.Count((IngredientProgress ingredient) => ingredient.Missing > 0);
			if (num <= 0)
			{
				return "Missing";
			}
			return $"Missing {num}";
		}

		private static string FormatAvailableFood(int count, string sourceText)
		{
			if (string.IsNullOrWhiteSpace(sourceText))
			{
				return $"Available x{count}";
			}
			if (string.Equals(sourceText, $"nearby x{count}", StringComparison.OrdinalIgnoreCase))
			{
				return $"Available x{count} nearby";
			}
			if (string.Equals(sourceText, $"inventory x{count}", StringComparison.OrdinalIgnoreCase))
			{
				return $"Available x{count} inventory";
			}
			return $"Available x{count} ({sourceText})";
		}
	}
	public sealed class RecommendedPlanProjection
	{
		private const int MaxRows = 8;

		public IReadOnlyList<RecommendedPlanRow> Rows { get; }

		public string ActiveTargetText { get; }

		private RecommendedPlanProjection(IEnumerable<RecommendedPlanRow> rows, string activeTargetText)
		{
			Rows = new ReadOnlyCollection<RecommendedPlanRow>(rows.Take(8).ToList());
			ActiveTargetText = (string.IsNullOrWhiteSpace(activeTargetText) ? "Active:" : ("Active: " + activeTargetText));
		}

		public static RecommendedPlanProjection From(FeastPlannerViewModel model, bool cookableOnly, string activeTargetName)
		{
			return new RecommendedPlanProjection(BuildMealRows(model, cookableOnly), activeTargetName);
		}

		private static IReadOnlyList<RecommendedPlanRow> BuildMealRows(FeastPlannerViewModel model, bool cookableOnly)
		{
			if (cookableOnly)
			{
				return BuildCookableNowRows(model);
			}
			List<FoodDefinition> list = RankFoods(model.VisibleFoods.Where((FoodDefinition food) => food.Tier <= model.SelectedBiome), model.SelectedRole, model.ActiveFoods).ToList();
			if (list.Count == 0)
			{
				list = RankFoods(model.Recommendation.Foods, model.SelectedRole, model.ActiveFoods).ToList();
			}
			return BuildPlanFoodRows("Best Plan", list.Take(3).ToList(), model.Craftability);
		}

		private static IReadOnlyList<RecommendedPlanRow> BuildCookableNowRows(FeastPlannerViewModel model)
		{
			List<FoodDefinition> foods = RankFoods(model.VisibleFoods.Where((FoodDefinition food) => food.Tier <= model.SelectedBiome && IsReadyFood(food, model.Craftability)), model.SelectedRole, model.ActiveFoods).Take(3).ToList();
			return BuildPlanFoodRows("Cookable Now", foods, model.Craftability);
		}

		private static IReadOnlyList<RecommendedPlanRow> BuildPlanFoodRows(string planName, IReadOnlyList<FoodDefinition> foods, MealCraftability craftability)
		{
			return (from food in foods.Take(3)
				select RecommendedPlanRow.FromFoodRow(planName, food, foods, craftability)).ToList();
		}

		private static IEnumerable<FoodDefinition> RankFoods(IEnumerable<FoodDefinition> foods, PlannerRole role, ActiveFoodState activeFoods)
		{
			return (from food in foods
				orderby (int)food.Tier descending, Score(food, role, activeFoods) descending, food.Stats.Total descending, food.Stats.Duration descending
				select food).ThenBy<FoodDefinition, string>((FoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase);
		}

		private static bool IsReadyFood(FoodDefinition food, MealCraftability craftability)
		{
			FoodCraftability foodCraftability = craftability.ForFood(food.PrefabName);
			if (foodCraftability != null)
			{
				if (foodCraftability.AvailableFoodCount <= 0)
				{
					if (foodCraftability.IsCraftableByRecipe)
					{
						return foodCraftability.FoodUnitsCraftable > 0;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static float Score(FoodDefinition food, PlannerRole role, ActiveFoodState activeFoods)
		{
			FoodStats stats = food.Stats;
			float num = (activeFoods.Contains(food.PrefabName) ? 2f : 0f);
			float num2 = stats.Duration / 600f;
			return role switch
			{
				PlannerRole.BossFight => stats.Health * 2.2f + stats.Stamina * 0.8f + stats.Healing * 30f + num2, 
				PlannerRole.ExploreGather => stats.Stamina * 2.1f + stats.Health * 0.8f + num2 * 4f, 
				PlannerRole.BuildFarm => stats.Stamina * 1.9f + num2 * 4f + Math.Min(stats.Health, 45f) * 0.5f, 
				PlannerRole.MineHaul => stats.Stamina * 1.4f + stats.Health * 1.3f + num2 * 3f, 
				PlannerRole.MagicEitr => stats.Eitr * 3f + stats.Health * 0.8f + num2 * 2f, 
				PlannerRole.Balanced => stats.Health + stats.Stamina + stats.Eitr * 1.2f + num2 * 2f, 
				PlannerRole.BestAvailable => stats.Total + stats.Healing * 20f + num2 * 2f, 
				_ => stats.Total, 
			} - num;
		}
	}
	public sealed class RecommendedPlanRow
	{
		public string Name { get; }

		public string RowLabel { get; }

		public IReadOnlyList<FoodDefinition> Foods { get; }

		public IReadOnlyList<FoodDefinition> PlanFoods { get; }

		public FoodStats Totals { get; }

		public FoodStats PlanTotals { get; }

		public string FoodsText { get; }

		public string StatsText { get; }

		public string DurationText { get; }

		public string PlanDurationText { get; }

		public string AvailabilityText { get; }

		public string PlanAvailabilityText { get; }

		public bool IsReady { get; }

		public bool PlanIsReady { get; }

		private RecommendedPlanRow(string name, IReadOnlyList<FoodDefinition> foods, FoodStats totals, string foodsText, string statsText, string durationText, string availabilityText, bool isReady, string rowLabel)
		{
			Name = name;
			RowLabel = rowLabel;
			Foods = foods;
			PlanFoods = foods;
			Totals = totals;
			PlanTotals = totals;
			FoodsText = foodsText;
			StatsText = statsText;
			DurationText = durationText;
			PlanDurationText = durationText;
			AvailabilityText = availabilityText;
			PlanAvailabilityText = availabilityText;
			IsReady = isReady;
			PlanIsReady = isReady;
		}

		private RecommendedPlanRow(string name, IReadOnlyList<FoodDefinition> foods, IReadOnlyList<FoodDefinition> planFoods, FoodStats totals, FoodStats planTotals, string foodsText, string statsText, string durationText, string planDurationText, string availabilityText, string planAvailabilityText, bool isReady, bool planIsReady, string rowLabel)
		{
			Name = name;
			RowLabel = rowLabel;
			Foods = foods;
			PlanFoods = planFoods;
			Totals = totals;
			PlanTotals = planTotals;
			FoodsText = foodsText;
			StatsText = statsText;
			DurationText = durationText;
			PlanDurationText = planDurationText;
			AvailabilityText = availabilityText;
			PlanAvailabilityText = planAvailabilityText;
			IsReady = isReady;
			PlanIsReady = planIsReady;
		}

		public static RecommendedPlanRow FromMeal(string name, IReadOnlyList<FoodDefinition> foods, MealCraftability craftability, string? rowLabel = null)
		{
			FoodStats foodStats = Total(foods);
			List<FoodCraftability> list = (from food in foods
				select craftability.ForFood(food.PrefabName) into row
				where row != null
				select row).ToList();
			bool flag = foods.Count > 0 && list.Count == foods.Count && list.All((FoodCraftability row) => row.AvailableFoodCount > 0 || (row.IsCraftableByRecipe && row.FoodUnitsCraftable > 0));
			return new RecommendedPlanRow(name, new ReadOnlyCollection<FoodDefinition>(foods.ToList()), foodStats, string.Join(", ", foods.Select((FoodDefinition food) => food.DisplayName)), FormatStats(foodStats), FormatDuration(foodStats.Duration), flag ? "Ready" : AvailabilityForMeal(foods, craftability), flag, rowLabel ?? name);
		}

		public static RecommendedPlanRow FromFoodRow(string planName, FoodDefinition food, IReadOnlyList<FoodDefinition> planFoods, MealCraftability craftability)
		{
			FoodStats foodStats = Total(planFoods);
			List<FoodCraftability> list = (from planFood in planFoods
				select craftability.ForFood(planFood.PrefabName) into row
				where row != null
				select row).ToList();
			bool flag = planFoods.Count > 0 && list.Count == planFoods.Count && list.All((FoodCraftability row) => row.AvailableFoodCount > 0 || (row.IsCraftableByRecipe && row.FoodUnitsCraftable > 0));
			FoodCraftability foodCraftability = craftability.ForFood(food.PrefabName);
			bool flag2 = foodCraftability != null && (foodCraftability.AvailableFoodCount > 0 || (foodCraftability.IsCraftableByRecipe && foodCraftability.FoodUnitsCraftable > 0));
			return new RecommendedPlanRow(planName, new ReadOnlyCollection<FoodDefinition>(new FoodDefinition[1] { food }), new ReadOnlyCollection<FoodDefinition>(planFoods.ToList()), food.Stats, foodStats, food.DisplayName, FormatStats(food.Stats), FormatDuration(food.Stats.Duration), FormatDuration(foodStats.Duration), flag2 ? "Ready" : AvailabilityForFood(food, foodCraftability), flag ? "Ready" : AvailabilityForMeal(planFoods, craftability), flag2, flag, food.DisplayName);
		}

		public static RecommendedPlanRow FromFood(FoodDefinition food, MealCraftability craftability)
		{
			FoodCraftability foodCraftability = craftability.ForFood(food.PrefabName);
			bool flag = foodCraftability != null && (foodCraftability.AvailableFoodCount > 0 || (foodCraftability.IsCraftableByRecipe && foodCraftability.FoodUnitsCraftable > 0));
			return new RecommendedPlanRow(food.DisplayName, new ReadOnlyCollection<FoodDefinition>(new FoodDefinition[1] { food }), food.Stats, food.DisplayName, FormatStats(food.Stats), FormatDuration(food.Stats.Duration), flag ? "Ready" : "Missing", flag, food.DisplayName);
		}

		private static string AvailabilityForFood(FoodDefinition food, FoodCraftability? craftability)
		{
			if (craftability == null)
			{
				return "Missing";
			}
			int num = craftability.Ingredients.Count((IngredientProgress ingredient) => ingredient.Missing > 0);
			if (num > 0)
			{
				return $"Missing {num}";
			}
			if (!food.HasRecipe)
			{
				return "Missing";
			}
			return "Uncertain";
		}

		private static string AvailabilityForMeal(IReadOnlyList<FoodDefinition> foods, MealCraftability craftability)
		{
			if (foods.Count == 0)
			{
				return "No foods";
			}
			if (craftability.MissingIngredients.Count > 0)
			{
				return $"Missing {craftability.MissingIngredients.Count}";
			}
			if (!craftability.HasNonRecipeFoods)
			{
				return "Uncertain";
			}
			return "Missing";
		}

		private static FoodStats Total(IEnumerable<FoodDefinition> foods)
		{
			List<FoodDefinition> list = foods.ToList();
			return new FoodStats(list.Sum((FoodDefinition food) => food.Stats.Health), list.Sum((FoodDefinition food) => food.Stats.Stamina), list.Sum((FoodDefinition food) => food.Stats.Eitr), list.Sum((FoodDefinition food) => food.Stats.Healing), (list.Count == 0) ? 0f : list.Min((FoodDefinition food) => food.Stats.Duration));
		}

		private static string FormatStats(FoodStats stats)
		{
			return $"H {stats.Health:0}  S {stats.Stamina:0}  E {stats.Eitr:0}";
		}

		private static string FormatDuration(float seconds)
		{
			if (!(seconds <= 0f))
			{
				return $"{Math.Round(seconds / 60f):0}m";
			}
			return "0m";
		}
	}
	public sealed class ActiveTargetProjection
	{
		public bool HasActiveTarget { get; }

		public string TitleText { get; }

		public string NameText { get; }

		public string StatsText { get; }

		public string HealthText { get; }

		public string StaminaText { get; }

		public string EitrText { get; }

		public string DurationText { get; }

		public string ReadinessText { get; }

		public IReadOnlyList<FoodDefinition> Foods { get; }

		public static ActiveTargetProjection Empty { get; } = new ActiveTargetProjection(hasActiveTarget: false, "Active: none", "none", string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, Array.Empty<FoodDefinition>());

		private ActiveTargetProjection(bool hasActiveTarget, string titleText, string nameText, string statsText, string healthText, string staminaText, string eitrText, string durationText, string readinessText, IReadOnlyList<FoodDefinition> foods)
		{
			HasActiveTarget = hasActiveTarget;
			TitleText = titleText;
			NameText = nameText;
			StatsText = statsText;
			HealthText = healthText;
			StaminaText = staminaText;
			EitrText = eitrText;
			DurationText = durationText;
			ReadinessText = readinessText;
			Foods = new ReadOnlyCollection<FoodDefinition>(foods.ToList());
		}

		public static ActiveTargetProjection From(RecommendedPlanRow? row, string activeTargetName)
		{
			if (row == null || string.IsNullOrWhiteSpace(activeTargetName) || !string.Equals(row.Name, activeTargetName, StringComparison.OrdinalIgnoreCase))
			{
				return Empty;
			}
			return new ActiveTargetProjection(hasActiveTarget: true, "Active: " + row.Name, row.Name, $"H{row.PlanTotals.Health:0} S{row.PlanTotals.Stamina:0} E{row.PlanTotals.Eitr:0}", $"{row.PlanTotals.Health:0}", $"{row.PlanTotals.Stamina:0}", $"{row.PlanTotals.Eitr:0}", row.PlanDurationText, row.PlanAvailabilityText, row.PlanFoods);
		}
	}
}
namespace FeastPlanner.Runtime
{
	public sealed class ContainerScanRules
	{
		public float Radius { get; }

		public int MaxContainers { get; }

		public float CooldownSeconds { get; }

		public ContainerScanRules(float radius = 20f, int maxContainers = 32, float cooldownSeconds = 3f)
		{
			Radius = Math.Max(1f, radius);
			MaxContainers = Math.Max(1, maxContainers);
			CooldownSeconds = Math.Max(0f, cooldownSeconds);
		}
	}
	public interface IContainerScanPlayer
	{
		float X { get; }

		float Y { get; }

		float Z { get; }
	}
	public interface IScannableContainer
	{
		string Name { get; }

		float X { get; }

		float Y { get; }

		float Z { get; }

		bool IsInUse { get; }

		bool IsPrivate { get; }

		bool IsOwner { get; }

		bool HasAccess(IContainerScanPlayer player);

		IEnumerable<InventoryStack> ReadStacks();
	}
	public sealed class ContainerScanResult
	{
		public InventorySnapshot Items { get; }

		public ContainerScanReport Report { get; }

		public ContainerScanResult(InventorySnapshot items, ContainerScanReport report)
		{
			Items = items;
			Report = report;
		}
	}
	public sealed class ContainerInventoryScanner
	{
		private readonly ContainerScanRules _rules;

		private ContainerScanResult? _lastResult;

		private float _lastScanSeconds = float.NegativeInfinity;

		public ContainerInventoryScanner(ContainerScanRules rules)
		{
			_rules = rules;
		}

		public bool TryReadCached(float nowSeconds, out ContainerScanResult result)
		{
			if (_lastResult != null && nowSeconds - _lastScanSeconds < _rules.CooldownSeconds)
			{
				result = CreateCooldownResult(nowSeconds);
				return true;
			}
			result = new ContainerScanResult(InventorySnapshot.Empty, ContainerScanReport.NotScanned);
			return false;
		}

		public ContainerScanResult Scan(IContainerScanPlayer? player, IEnumerable<IScannableContainer> containers, float nowSeconds)
		{
			if (TryReadCached(nowSeconds, out ContainerScanResult result))
			{
				return result;
			}
			if (player == null)
			{
				return new ContainerScanResult(InventorySnapshot.Empty, ContainerScanReport.NotScanned);
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			bool capped = false;
			List<InventoryStack> list = new List<InventoryStack>();
			foreach (IScannableContainer container in containers)
			{
				if (Distance(player, container) > _rules.Radius)
				{
					num5++;
					continue;
				}
				if (container.IsInUse)
				{
					num2++;
					continue;
				}
				if (container.IsPrivate && !container.IsOwner)
				{
					num3++;
					continue;
				}
				try
				{
					if (!container.HasAccess(player))
					{
						num4++;
						continue;
					}
				}
				catch
				{
					num4++;
					continue;
				}
				if (num >= _rules.MaxContainers)
				{
					capped = true;
					break;
				}
				list.AddRange(container.ReadStacks());
				num++;
			}
			int skippedContainers = num2 + num3 + num4 + num5;
			ContainerScanResult result2 = (_lastResult = new ContainerScanResult(InventorySnapshot.FromStacks(list), new ContainerScanReport(enabled: true, isCooldown: false, num, skippedContainers, num2, num3, num4, num5, capped, 0)));
			_lastScanSeconds = nowSeconds;
			return result2;
		}

		private ContainerScanResult CreateCooldownResult(float nowSeconds)
		{
			int secondsSinceScan = Math.Max(0, (int)Math.Floor(nowSeconds - _lastScanSeconds));
			return new ContainerScanResult(_lastResult.Items, new ContainerScanReport(enabled: true, isCooldown: true, _lastResult.Report.ScannedContainers, _lastResult.Report.SkippedContainers, _lastResult.Report.SkippedInUse, _lastResult.Report.SkippedPrivate, _lastResult.Report.SkippedWardedOrNoAccess, _lastResult.Report.SkippedTooFar, _lastResult.Report.Capped, secondsSinceScan));
		}

		private static float Distance(IContainerScanPlayer player, IScannableContainer container)
		{
			float num = player.X - container.X;
			float num2 = player.Y - container.Y;
			float num3 = player.Z - container.Z;
			return (float)Math.Sqrt(num * num + num2 * num2 + num3 * num3);
		}
	}
	public sealed class FeastPlannerController
	{
		private readonly ValheimFoodLoader _foodLoader;

		private readonly ValheimInventoryReader _inventoryReader;

		private readonly ValheimContainerReader _containerReader;

		private readonly ValheimKnowledgeReader _knowledgeReader;

		private readonly ValheimActiveFoodReader _activeFoodReader;

		private readonly FeastRecommendationEngine _engine;

		private readonly FoodTierTable _tierTable;

		private readonly JsonSavedMealStore? _savedMealStore;

		private IReadOnlyList<FoodDefinition> _catalog = new List<FoodDefinition>();

		private SavedMealLibrary _savedMeals = SavedMealLibrary.Empty();

		private PlannerViewMode _mode;

		private string? _selectedSavedMealId;

		private string _savedMealStatus = string.Empty;

		private bool _catalogLoaded;

		private SavedMeal? SelectedMeal => _savedMeals.Meals.FirstOrDefault((SavedMeal meal) => meal.Id == _selectedSavedMealId);

		public FeastPlannerController(ValheimFoodLoader foodLoader, ValheimInventoryReader inventoryReader, ValheimContainerReader containerReader, ValheimKnowledgeReader knowledgeReader, ValheimActiveFoodReader activeFoodReader, FeastRecommendationEngine engine, FoodTierTable tierTable, JsonSavedMealStore? savedMealStore = null)
		{
			_foodLoader = foodLoader;
			_inventoryReader = inventoryReader;
			_containerReader = containerReader;
			_knowledgeReader = knowledgeReader;
			_activeFoodReader = activeFoodReader;
			_engine = engine;
			_tierTable = tierTable;
			_savedMealStore = savedMealStore;
			if (_savedMealStore != null)
			{
				SavedMealStoreResult savedMealStoreResult = _savedMealStore.Load();
				_savedMeals = savedMealStoreResult.Library;
				_savedMealStatus = savedMealStoreResult.Status;
				_selectedSavedMealId = _savedMeals.Meals.FirstOrDefault()?.Id;
			}
		}

		public FeastPlannerViewModel BuildViewModel(PlannerRole role, TargetBiome biome)
		{
			Player localPlayer = Player.m_localPlayer;
			EnsureCatalogLoaded();
			InventorySnapshot inventory = _inventoryReader.Read(localPlayer);
			ContainerScanResult containerScanResult = _containerReader.Read(localPlayer);
			SourceInventorySnapshot sourceInventorySnapshot = SourceInventorySnapshot.Create(inventory, containerScanResult.Items, containerScanResult.Report);
			PlayerFoodKnowledge knowledge = _knowledgeReader.Read(localPlayer, _catalog);
			List<FoodDefinition> visibleFoods = DiscoveryFilter.FilterVisibleFoods(_catalog, knowledge, sourceInventorySnapshot.Combined).ToList();
			ActiveFoodState activeFoods = _activeFoodReader.Read(localPlayer);
			FeastRecommendation feastRecommendation = _engine.Recommend(role, biome, visibleFoods, sourceInventorySnapshot.Combined, activeFoods);
			SavedMealValidationResult savedMealValidation = null;
			if (_mode == PlannerViewMode.Custom && SelectedMeal != null)
			{
				SavedMealPlannerResult savedMealPlannerResult = SavedMealPlanner.BuildCustomRecommendation(SelectedMeal, _catalog, visibleFoods, biome, _tierTable);
				feastRecommendation = savedMealPlannerResult.Recommendation;
				savedMealValidation = savedMealPlannerResult.Validation;
			}
			MealCraftability craftability = CraftabilityCalculator.CalculateMeal(feastRecommendation.Foods, sourceInventorySnapshot);
			return new FeastPlannerViewModel(role, biome, feastRecommendation, activeFoods, craftability, _mode, _savedMeals.Meals, _selectedSavedMealId, visibleFoods, savedMealValidation, _savedMealStatus);
		}

		public void RefreshCatalog()
		{
			_catalog = _foodLoader.Load();
			_catalogLoaded = ObjectDB.instance != null;
		}

		public void SetMode(PlannerViewMode mode)
		{
			_mode = mode;
			if (_mode == PlannerViewMode.Custom && _selectedSavedMealId == null)
			{
				_selectedSavedMealId = _savedMeals.Meals.FirstOrDefault()?.Id;
			}
		}

		public void SelectSavedMeal(string mealId)
		{
			if (!_savedMeals.TryFind(mealId, out SavedMeal meal) || meal == null)
			{
				_savedMealStatus = "Saved meal not found.";
				return;
			}
			_selectedSavedMealId = meal.Id;
			_mode = PlannerViewMode.Custom;
			_savedMealStatus = "Selected " + meal.Name + ".";
		}

		public void SaveRecommendedMeal(PlannerRole role, TargetBiome biome)
		{
			List<string> foodPrefabNames = BuildRecommendedModel(role, biome).Recommendation.Foods.Select((FoodDefinition food) => food.PrefabName).ToList();
			if (!_savedMeals.TryCreate($"Custom {_savedMeals.Meals.Count + 1}", foodPrefabNames, DateTimeOffset.UtcNow, out SavedMeal meal, out string error))
			{
				_savedMealStatus = error;
				return;
			}
			_selectedSavedMealId = meal.Id;
			_mode = PlannerViewMode.Custom;
			SaveLibrary("Saved " + meal.Name + ".");
		}

		public void RenameSelectedMeal(string name)
		{
			SavedMeal selectedMeal = SelectedMeal;
			if (selectedMeal == null)
			{
				_savedMealStatus = "No saved meal selected.";
				return;
			}
			_savedMeals.Rename(selectedMeal.Id, name, DateTimeOffset.UtcNow);
			SaveLibrary("Renamed saved meal.");
		}

		public void SaveCustomMealDraft(string? savedMealId, string name, IEnumerable<string> foodPrefabNames, PlannerRole role, TargetBiome biome)
		{
			FeastPlannerViewModel feastPlannerViewModel = BuildRecommendedModel(role, biome);
			HashSet<string> visiblePrefabNames = new HashSet<string>(feastPlannerViewModel.VisibleFoods.Select((FoodDefinition food) => food.PrefabName), StringComparer.OrdinalIgnoreCase);
			List<string> list = (from food in SavedMealLibrary.CleanFoodNames(foodPrefabNames)
				where visiblePrefabNames.Contains(food)
				select food).Take(3).ToList();
			SavedMeal meal2;
			string error2;
			if (list.Count == 0)
			{
				_savedMealStatus = "Choose at least one eligible food.";
			}
			else if (savedMealId == null)
			{
				if (!_savedMeals.TryCreate(name, list, DateTimeOffset.UtcNow, out SavedMeal meal, out string error))
				{
					_savedMealStatus = error;
					return;
				}
				_selectedSavedMealId = meal.Id;
				_mode = PlannerViewMode.Custom;
				SaveLibrary("Saved " + meal.Name + ".");
			}
			else if (!_savedMeals.TryFind(savedMealId, out meal2) || meal2 == null)
			{
				_savedMealStatus = "Saved meal not found.";
			}
			else if (!_savedMeals.Rename(meal2.Id, name, DateTimeOffset.UtcNow))
			{
				_savedMealStatus = "Saved meal not found.";
			}
			else if (!_savedMeals.UpdateFoods(meal2.Id, list, DateTimeOffset.UtcNow, out error2))
			{
				_savedMealStatus = error2;
			}
			else
			{
				SaveLibrary("Saved custom meal.");
			}
		}

		public void DeleteSelectedMeal()
		{
			SavedMeal selectedMeal = SelectedMeal;
			if (selectedMeal == null)
			{
				_savedMealStatus = "No saved meal selected.";
				return;
			}
			_savedMeals.Delete(selectedMeal.Id);
			_selectedSavedMealId = _savedMeals.Meals.FirstOrDefault()?.Id;
			SaveLibrary("Deleted saved meal.");
		}

		public void AssignFoodToSlot(int slotIndex, string foodPrefabName, PlannerRole role, TargetBiome biome)
		{
			SavedMeal selectedMeal = SelectedMeal;
			if (selectedMeal == null)
			{
				SaveRecommendedMeal(role, biome);
				selectedMeal = SelectedMeal;
				if (selectedMeal == null)
				{
					return;
				}
			}
			string error;
			if (!BuildRecommendedModel(role, biome).VisibleFoods.Any((FoodDefinition food) => string.Equals(food.PrefabName, foodPrefabName, StringComparison.OrdinalIgnoreCase)))
			{
				_savedMealStatus = "Food is not eligible.";
			}
			else if (_savedMeals.UpdateFoodSlot(selectedMeal.Id, slotIndex, foodPrefabName, DateTimeOffset.UtcNow, out error))
			{
				SaveLibrary("Updated saved meal.");
			}
			else
			{
				_savedMealStatus = error;
			}
		}

		private void EnsureCatalogLoaded()
		{
			if (!_catalogLoaded)
			{
				RefreshCatalog();
			}
		}

		private FeastPlannerViewModel BuildRecommendedModel(PlannerRole role, TargetBiome biome)
		{
			PlannerViewMode mode = _mode;
			_mode = PlannerViewMode.Recommended;
			FeastPlannerViewModel result = BuildViewModel(role, biome);
			_mode = mode;
			return result;
		}

		private void SaveLibrary(string successStatus)
		{
			if (_savedMealStore == null)
			{
				_savedMealStatus = successStatus;
				return;
			}
			SavedMealStoreResult savedMealStoreResult = _savedMealStore.Save(_savedMeals);
			_savedMealStatus = (savedMealStoreResult.Success ? successStatus : savedMealStoreResult.Status);
		}
	}
	public sealed class SavedMealStoreResult
	{
		public SavedMealLibrary Library { get; }

		public bool Success { get; }

		public string Status { get; }

		public SavedMealStoreResult(SavedMealLibrary library, bool success, string status)
		{
			Library = library;
			Success = success;
			Status = status;
		}
	}
	public sealed class JsonSavedMealStore
	{
		[DataContract]
		private sealed class SavedMealFile
		{
			[DataMember(Name = "schemaVersion", Order = 0)]
			public int SchemaVersion { get; set; }

			[DataMember(Name = "meals", Order = 1)]
			public List<SavedMealRecord>? Meals { get; set; }
		}

		[DataContract]
		private sealed class SavedMealRecord
		{
			[DataMember(Name = "id", Order = 0)]
			public string? Id { get; set; }

			[DataMember(Name = "name", Order = 1)]
			public string? Name { get; set; }

			[DataMember(Name = "foodPrefabNames", Order = 2)]
			public List<string>? FoodPrefabNames { get; set; }

			[DataMember(Name = "createdUtc", Order = 3)]
			public string? CreatedUtc { get; set; }

			[DataMember(Name = "updatedUtc", Order = 4)]
			public string? UpdatedUtc { get; set; }
		}

		public const int CurrentSchemaVersion = 1;

		private readonly string _path;

		public string Path => _path;

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

		public SavedMealStoreResult Load()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(_path))
			{
				return new SavedMealStoreResult(SavedMealLibrary.Empty(), success: true, "No saved meals yet.");
			}
			try
			{
				using FileStream fileStream = File.OpenRead(_path);
				SavedMealFile savedMealFile = (SavedMealFile)((XmlObjectSerializer)new DataContractJsonSerializer(typeof(SavedMealFile))).ReadObject((Stream)fileStream);
				if (savedMealFile == null || savedMealFile.SchemaVersion != 1)
				{
					return new SavedMealStoreResult(SavedMealLibrary.Empty(), success: false, "Saved meal file uses an unsupported format.");
				}
				List<SavedMeal> list = (savedMealFile.Meals ?? new List<SavedMealRecord>()).Select((SavedMealRecord record) => new SavedMeal(record.Id ?? Guid.NewGuid().ToString("N"), record.Name ?? "Custom meal", record.FoodPrefabNames ?? new List<string>(), ParseDate(record.CreatedUtc), ParseDate(record.UpdatedUtc))).ToList();
				return new SavedMealStoreResult(SavedMealLibrary.FromMeals(list), success: true, $"Loaded {list.Count} saved meals.");
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is SerializationException || ex is ArgumentException)
			{
				return new SavedMealStoreResult(SavedMealLibrary.Empty(), success: false, "Saved meal file could not be read.");
			}
		}

		public SavedMealStoreResult Save(SavedMealLibrary library)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string directoryName = System.IO.Path.GetDirectoryName(_path);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				SavedMealFile savedMealFile = new SavedMealFile
				{
					SchemaVersion = 1,
					Meals = library.Meals.Select((SavedMeal meal) => new SavedMealRecord
					{
						Id = meal.Id,
						Name = meal.Name,
						FoodPrefabNames = meal.FoodPrefabNames.ToList(),
						CreatedUtc = FormatDate(meal.CreatedUtc),
						UpdatedUtc = FormatDate(meal.UpdatedUtc)
					}).ToList()
				};
				string text = _path + ".tmp";
				using (FileStream fileStream = File.Create(text))
				{
					((XmlObjectSerializer)new DataContractJsonSerializer(typeof(SavedMealFile))).WriteObject((Stream)fileStream, (object)savedMealFile);
				}
				if (File.Exists(_path))
				{
					File.Delete(_path);
				}
				File.Move(text, _path);
				return new SavedMealStoreResult(library, success: true, $"Saved {library.Meals.Count} saved meals.");
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is SerializationException)
			{
				return new SavedMealStoreResult(library, success: false, "Saved meals could not be written.");
			}
		}

		private static DateTimeOffset ParseDate(string? value)
		{
			if (!DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var result))
			{
				return DateTimeOffset.UtcNow;
			}
			return result;
		}

		private static string FormatDate(DateTimeOffset value)
		{
			return value.UtcDateTime.ToString("O", CultureInfo.InvariantCulture);
		}
	}
	public sealed class RawFoodItem
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public float Health { get; }

		public float Stamina { get; }

		public float Eitr { get; }

		public float Healing { get; }

		public float Duration { get; }

		public string? RecipeName { get; }

		public bool IsDrink { get; }

		public IReadOnlyList<FoodIngredient> Ingredients { get; }

		public string? MaterialName { get; }

		public Sprite? Icon { get; }

		public int RecipeOutputAmount { get; }

		public RawFoodItem(string prefabName, string displayName, float health, float stamina, float eitr, float healing, float duration, string? recipeName, bool isDrink, IEnumerable<FoodIngredient>? ingredients = null, string? materialName = null, Sprite? icon = null, int recipeOutputAmount = 1)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			Healing = healing;
			Duration = duration;
			RecipeName = recipeName;
			IsDrink = isDrink;
			Ingredients = new ReadOnlyCollection<FoodIngredient>((ingredients ?? Enumerable.Empty<FoodIngredient>()).ToList());
			MaterialName = materialName;
			Icon = icon;
			RecipeOutputAmount = ((recipeOutputAmount <= 0) ? 1 : recipeOutputAmount);
		}
	}
	public static class RuntimeFoodCatalogBuilder
	{
		public static IEnumerable<FoodDefinition> Build(IEnumerable<RawFoodItem> rawItems, FoodTierTable tierTable)
		{
			foreach (RawFoodItem rawItem in rawItems)
			{
				FoodStats stats = new FoodStats(rawItem.Health, rawItem.Stamina, rawItem.Eitr, rawItem.Healing, rawItem.Duration);
				if (FoodEligibility.HasFoodValue(stats) && (!rawItem.IsDrink || !(rawItem.Health <= 0f) || !(rawItem.Stamina <= 0f) || !(rawItem.Eitr <= 0f)))
				{
					IReadOnlyList<FoodIngredient> readOnlyList;
					if (rawItem.Ingredients.Count != 0)
					{
						readOnlyList = rawItem.Ingredients;
					}
					else
					{
						IReadOnlyList<FoodIngredient> readOnlyList2 = FallbackConversionIngredients(rawItem).ToList();
						readOnlyList = readOnlyList2;
					}
					IReadOnlyList<FoodIngredient> ingredients = readOnlyList;
					yield return new FoodDefinition(rawItem.PrefabName, rawItem.DisplayName, stats, rawItem.RecipeName, tierTable.GetTier(rawItem.PrefabName) ?? TargetBiome.Ashlands, rawItem.IsDrink, ingredients, rawItem.MaterialName, rawItem.Icon, rawItem.RecipeOutputAmount);
				}
			}
		}

		private static IEnumerable<FoodIngredient> FallbackConversionIngredients(RawFoodItem item)
		{
			string text = Normalize(item.PrefabName);
			string text2 = Normalize(item.DisplayName);
			bool flag = ((text == "cookedmeat" || text == "cookedboarmeat") ? true : false);
			if (flag || text2.Contains("cookedboarmeat"))
			{
				yield return new FoodIngredient("RawMeat", "Boar meat", 1);
				yield break;
			}
			if (text == "cookeddeermeat" || text2.Contains("cookeddeermeat"))
			{
				yield return new FoodIngredient("DeerMeat", "Deer meat", 1);
				yield break;
			}
			flag = ((text == "necktailgrilled" || text == "grillednecktail") ? true : false);
			if (flag || text2.Contains("grillednecktail"))
			{
				yield return new FoodIngredient("NeckTail", "Neck tail", 1);
			}
		}

		private static string Normalize(string value)
		{
			return new string(value.Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray());
		}
	}
	public sealed class ValheimActiveFoodReader
	{
		public ActiveFoodState Read(Player? player)
		{
			List<Food> list = ((player != null) ? player.GetFoods() : null);
			if (list == null)
			{
				return ActiveFoodState.Empty;
			}
			List<ActiveFood> list2 = new List<ActiveFood>();
			foreach (Food item in list)
			{
				SharedData val = item.m_item?.m_shared;
				string displayName = ((val != null) ? Localize(val.m_name) : item.m_name);
				float time = item.m_time;
				list2.Add(new ActiveFood(item.m_name, displayName, item.m_health, item.m_stamina, item.m_eitr, time, item.CanEatAgain()));
			}
			return ActiveFoodState.FromFoods(list2);
		}

		private static string Localize(string value)
		{
			if (Localization.instance == null)
			{
				return value;
			}
			return Localization.instance.Localize(value);
		}
	}
	public sealed class ValheimContainerReader
	{
		private sealed class ValheimContainerScanPlayer : IContainerScanPlayer
		{
			private readonly Player _player;

			public float X => ((Component)_player).transform.position.x;

			public float Y => ((Component)_player).transform.position.y;

			public float Z => ((Component)_player).transform.position.z;

			public ValheimContainerScanPlayer(Player player)
			{
				_player = player;
			}
		}

		private sealed class ValheimScannableContainer : IScannableContainer
		{
			private readonly Container _container;

			public string Name => _container.m_name;

			public float X => ((Component)_container).transform.position.x;

			public float Y => ((Component)_container).transform.position.y;

			public float Z => ((Component)_container).transform.position.z;

			public bool IsInUse => _container.IsInUse();

			public bool IsPrivate => (int)_container.m_privacy != 2;

			public bool IsOwner => _container.IsOwner();

			public ValheimScannableContainer(Container container)
			{
				_container = container;
			}

			public bool HasAccess(IContainerScanPlayer player)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (_container.m_checkGuardStone && !PrivateArea.CheckAccess(((Component)_container).transform.position, 0f, false, true))
				{
					return false;
				}
				return true;
			}

			public IEnumerable<InventoryStack> ReadStacks()
			{
				Inventory inventory = _container.GetInventory();
				if (inventory == null)
				{
					return Enumerable.Empty<InventoryStack>();
				}
				return (from item in inventory.GetAllItems()
					where item?.m_dropPrefab != null && item.m_stack > 0
					select new InventoryStack(((Object)item.m_dropPrefab).name, item.m_stack)).ToList();
			}
		}

		private readonly ContainerInventoryScanner _scanner;

		public ValheimContainerReader(ContainerInventoryScanner scanner)
		{
			_scanner = scanner;
		}

		public ContainerScanResult Read(Player? player)
		{
			if (_scanner.TryReadCached(Time.time, out ContainerScanResult result))
			{
				return result;
			}
			ValheimContainerScanPlayer player2 = ((player == null) ? null : new ValheimContainerScanPlayer(player));
			IEnumerable<ValheimScannableContainer> containers = from container in Object.FindObjectsByType<Container>((FindObjectsSortMode)0)
				where container != null
				select new ValheimScannableContainer(container);
			return _scanner.Scan(player2, containers, Time.time);
		}
	}
	public sealed class ValheimFoodLoader
	{
		private sealed class RecipeFoodMetadata
		{
			public string? RecipeName { get; }

			public IReadOnlyList<FoodIngredient> Ingredients { get; }

			public int OutputAmount { get; }

			public RecipeFoodMetadata(string? recipeName, IReadOnlyList<FoodIngredient> ingredients, int outputAmount)
			{
				RecipeName = recipeName;
				Ingredients = ingredients;
				OutputAmount = ((outputAmount <= 0) ? 1 : outputAmount);
			}
		}

		private sealed class CookingConversionMetadata
		{
			public ItemDrop From { get; }

			public ItemDrop To { get; }

			public CookingConversionMetadata(ItemDrop from, ItemDrop to)
			{
				From = from;
				To = to;
			}
		}

		private readonly FoodTierTable _tierTable;

		public ValheimFoodLoader(FoodTierTable tierTable)
		{
			_tierTable = tierTable;
		}

		public IReadOnlyList<FoodDefinition> Load()
		{
			if (ObjectDB.instance?.m_items == null)
			{
				return new List<FoodDefinition>();
			}
			return RuntimeFoodCatalogBuilder.Build(ReadRawItems(BuildCookingConversionIndex()), _tierTable).ToList();
		}

		private IEnumerable<RawFoodItem> ReadRawItems(IReadOnlyDictionary<string, CookingConversionMetadata> conversionIndex)
		{
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (item == null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (component != null)
				{
					SharedData val = component.m_itemData?.m_shared;
					if (val != null)
					{
						RecipeFoodMetadata recipeFoodMetadata = FindRecipe(component, conversionIndex);
						yield return new RawFoodItem(((Object)item).name, Localize(val.m_name), val.m_food, val.m_foodStamina, val.m_foodEitr, val.m_foodRegen, val.m_foodBurnTime, recipeFoodMetadata?.RecipeName, val.m_isDrink, recipeFoodMetadata?.Ingredients, val.m_name, FirstIcon(val), recipeFoodMetadata?.OutputAmount ?? 1);
					}
				}
			}
		}

		private static RecipeFoodMetadata? FindRecipe(ItemDrop drop, IReadOnlyDictionary<string, CookingConversionMetadata> conversionIndex, int depth = 0)
		{
			if (depth > 4)
			{
				return null;
			}
			if (ObjectDB.instance?.m_recipes != null)
			{
				foreach (Recipe recipe in ObjectDB.instance.m_recipes)
				{
					if (recipe?.m_item?.m_itemData?.m_shared != null && (((Object)recipe.m_item).name == ((Object)drop).name || recipe.m_item.m_itemData.m_shared.m_name == drop.m_itemData.m_shared.m_name))
					{
						return new RecipeFoodMetadata(recipe.m_item.m_itemData.m_shared.m_name, ReadIngredients(recipe, conversionIndex, depth + 1), recipe.m_amount);
					}
				}
			}
			return FindCookingConversion(drop, conversionIndex, depth);
		}

		private static Dictionary<string, CookingConversionMetadata> BuildCookingConversionIndex()
		{
			Dictionary<string, CookingConversionMetadata> dictionary = new Dictionary<string, CookingConversionMetadata>(StringComparer.OrdinalIgnoreCase);
			CookingStation[] array = Resources.FindObjectsOfTypeAll<CookingStation>() ?? Array.Empty<CookingStation>();
			foreach (CookingStation val in array)
			{
				if (val?.m_conversion == null)
				{
					continue;
				}
				foreach (ItemConversion item in val.m_conversion)
				{
					ItemDrop val2 = item?.m_from;
					ItemDrop val3 = item?.m_to;
					if (val2?.m_itemData?.m_shared != null && val3?.m_itemData?.m_shared != null)
					{
						CookingConversionMetadata value = new CookingConversionMetadata(val2, val3);
						dictionary[((Object)val3).name] = value;
						dictionary[val3.m_itemData.m_shared.m_name] = value;
					}
				}
			}
			return dictionary;
		}

		private static RecipeFoodMetadata? FindCookingConversion(ItemDrop drop, IReadOnlyDictionary<string, CookingConversionMetadata> conversionIndex, int depth)
		{
			if (!conversionIndex.TryGetValue(((Object)drop).name, out CookingConversionMetadata value) && !conversionIndex.TryGetValue(drop.m_itemData.m_shared.m_name, out value))
			{
				return null;
			}
			ItemDrop obj = value.From;
			_ = value.To;
			SharedData shared = obj.m_itemData.m_shared;
			RecipeFoodMetadata recipeFoodMetadata = FindRecipe(obj, conversionIndex, depth + 1);
			FoodIngredient foodIngredient = new FoodIngredient(((Object)obj).name, Localize(shared.m_name), 1, FirstIcon(shared), recipeFoodMetadata?.Ingredients, recipeFoodMetadata?.OutputAmount ?? 1);
			return new RecipeFoodMetadata(null, new FoodIngredient[1] { foodIngredient }, 1);
		}

		private static IReadOnlyList<FoodIngredient> ReadIngredients(Recipe recipe, IReadOnlyDictionary<string, CookingConversionMetadata> conversionIndex, int depth)
		{
			List<FoodIngredient> list = new List<FoodIngredient>();
			if (recipe.m_resources == null)
			{
				return list;
			}
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (val != null)
				{
					ItemDrop resItem = val.m_resItem;
					SharedData val2 = resItem?.m_itemData?.m_shared;
					if (resItem != null && val2 != null)
					{
						RecipeFoodMetadata recipeFoodMetadata = FindRecipe(resItem, conversionIndex, depth);
						list.Add(new FoodIngredient(((Object)resItem).name, Localize(val2.m_name), val.GetAmount(1), FirstIcon(val2), recipeFoodMetadata?.Ingredients, recipeFoodMetadata?.OutputAmount ?? 1));
					}
				}
			}
			return list;
		}

		private static Sprite? FirstIcon(SharedData shared)
		{
			Sprite[] icons = shared.m_icons;
			if (icons == null || icons.Length <= 0)
			{
				return null;
			}
			return shared.m_icons[0];
		}

		private static string Localize(string value)
		{
			if (Localization.instance == null)
			{
				return value;
			}
			return Localization.instance.Localize(value);
		}
	}
	public sealed class ValheimInventoryReader
	{
		public InventorySnapshot Read(Player? player)
		{
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			if (val == null)
			{
				return InventorySnapshot.Empty;
			}
			List<InventoryStack> list = new List<InventoryStack>();
			foreach (ItemData allItem in val.GetAllItems())
			{
				string prefabName = (((Object)(object)allItem.m_dropPrefab != (Object)null) ? ((Object)allItem.m_dropPrefab).name : allItem.m_shared.m_name);
				list.Add(new InventoryStack(prefabName, allItem.m_stack));
			}
			return InventorySnapshot.FromStacks(list);
		}
	}
	public sealed class ValheimKnowledgeReader
	{
		public PlayerFoodKnowledge Read(Player? player, IEnumerable<FoodDefinition> foods)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			if (player == null)
			{
				return new PlayerFoodKnowledge(list, list2);
			}
			foreach (FoodDefinition food in foods)
			{
				if (food.RecipeName != null && player.IsRecipeKnown(food.RecipeName))
				{
					list.Add(food.RecipeName);
				}
				string materialName = food.MaterialName ?? food.PrefabName;
				AddKnownMaterial(player, list2, materialName);
				foreach (FoodIngredient ingredient in food.Ingredients)
				{
					AddKnownMaterial(player, list2, ingredient.PrefabName);
				}
			}
			return new PlayerFoodKnowledge(list, list2);
		}

		private static void AddKnownMaterial(Player player, List<string> materials, string materialName)
		{
			foreach (string item in MaterialKnowledgeKeys.Candidates(materialName))
			{
				if (player.IsMaterialKnown(item) || player.IsKnownMaterial(item))
				{
					materials.Add(materialName);
					materials.Add(item);
					break;
				}
			}
		}
	}
}
namespace FeastPlanner.Core
{
	public sealed class ActiveFood
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public float Health { get; }

		public float Stamina { get; }

		public float Eitr { get; }

		public float RemainingSeconds { get; }

		public bool CanEatAgain { get; }

		public string RemainingText
		{
			get
			{
				int num = Math.Max(0, (int)Math.Round(RemainingSeconds));
				return $"{num / 60}:{num % 60:00}";
			}
		}

		public ActiveFood(string prefabName, string displayName, float health, float stamina, float eitr, float remainingSeconds, bool canEatAgain)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			RemainingSeconds = remainingSeconds;
			CanEatAgain = canEatAgain;
		}
	}
	public sealed class ActiveFoodState
	{
		public static ActiveFoodState Empty { get; } = new ActiveFoodState(Array.Empty<ActiveFood>());

		public IReadOnlyList<ActiveFood> Foods { get; }

		private ActiveFoodState(IReadOnlyList<ActiveFood> foods)
		{
			Foods = new ReadOnlyCollection<ActiveFood>(foods.ToList());
		}

		public static ActiveFoodState FromFoods(IEnumerable<ActiveFood> foods)
		{
			return new ActiveFoodState(foods.ToList());
		}

		public bool Contains(string prefabName)
		{
			return Foods.Any((ActiveFood food) => string.Equals(food.PrefabName, prefabName, StringComparison.OrdinalIgnoreCase));
		}
	}
	public sealed class IngredientProgress
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public int Required { get; }

		public int Available { get; }

		public int Missing { get; }

		public Sprite? Icon { get; }

		public IReadOnlyList<IngredientProgress> Children { get; }

		public string SourceBreakdown { get; }

		public string ProgressText
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(SourceBreakdown))
				{
					return $"{Available}/{Required} {DisplayName} ({SourceBreakdown})";
				}
				return $"{Available}/{Required} {DisplayName}";
			}
		}

		public IngredientProgress(string prefabName, string displayName, int required, int available, Sprite? icon = null, IEnumerable<IngredientProgress>? children = null, string? sourceBreakdown = null)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Required = Math.Max(0, required);
			Available = Math.Max(0, available);
			Missing = Math.Max(0, Required - Available);
			Icon = icon;
			Children = new ReadOnlyCollection<IngredientProgress>((children ?? Enumerable.Empty<IngredientProgress>()).ToList());
			SourceBreakdown = sourceBreakdown ?? string.Empty;
		}
	}
	public sealed class FoodCraftability
	{
		public FoodDefinition Food { get; }

		public bool IsCraftableByRecipe { get; }

		public int CraftOperationsPossible { get; }

		public int FoodUnitsCraftable { get; }

		public int AvailableFoodCount { get; }

		public string AvailableFoodSourceText { get; }

		public IReadOnlyList<IngredientProgress> Ingredients { get; }

		public FoodCraftability(FoodDefinition food, bool isCraftableByRecipe, int craftOperationsPossible, int foodUnitsCraftable, IEnumerable<IngredientProgress> ingredients, int availableFoodCount = 0, string availableFoodSourceText = "")
		{
			Food = food;
			IsCraftableByRecipe = isCraftableByRecipe;
			CraftOperationsPossible = Math.Max(0, craftOperationsPossible);
			FoodUnitsCraftable = Math.Max(0, foodUnitsCraftable);
			Ingredients = new ReadOnlyCollection<IngredientProgress>(ingredients.ToList());
			AvailableFoodCount = Math.Max(0, availableFoodCount);
			AvailableFoodSourceText = availableFoodSourceText ?? string.Empty;
		}
	}
	public sealed class MealCraftability
	{
		public static MealCraftability Empty { get; } = new MealCraftability(Enumerable.Empty<FoodCraftability>(), Enumerable.Empty<IngredientProgress>(), hasNonRecipeFoods: false);

		public IReadOnlyList<FoodCraftability> Foods { get; }

		public IReadOnlyList<IngredientProgress> MissingIngredients { get; }

		public bool HasNonRecipeFoods { get; }

		public string ScanStatusText { get; }

		public bool IsMealCraftable
		{
			get
			{
				if (MissingIngredients.Count == 0)
				{
					return Foods.Any((FoodCraftability food) => food.IsCraftableByRecipe);
				}
				return false;
			}
		}

		public MealCraftability(IEnumerable<FoodCraftability> foods, IEnumerable<IngredientProgress> missingIngredients, bool hasNonRecipeFoods, string scanStatusText = "")
		{
			Foods = new ReadOnlyCollection<FoodCraftability>(foods.ToList());
			MissingIngredients = new ReadOnlyCollection<IngredientProgress>(missingIngredients.ToList());
			HasNonRecipeFoods = hasNonRecipeFoods;
			ScanStatusText = scanStatusText;
		}

		public FoodCraftability? ForFood(string prefabName)
		{
			return Foods.FirstOrDefault((FoodCraftability food) => string.Equals(food.Food.PrefabName, prefabName, StringComparison.OrdinalIgnoreCase));
		}
	}
	public static class CraftabilityCalculator
	{
		private sealed class AggregatedRequirement
		{
			public string PrefabName { get; }

			public string DisplayName { get; }

			public Sprite? Icon { get; }

			public int Required { get; set; }

			public AggregatedRequirement(string prefabName, string displayName, Sprite? icon)
			{
				PrefabName = prefabName;
				DisplayName = displayName;
				Icon = icon;
			}
		}

		public static MealCraftability CalculateMeal(IEnumerable<FoodDefinition> foods, InventorySnapshot inventory)
		{
			return CalculateMeal(foods, SourceInventorySnapshot.InventoryOnly(inventory));
		}

		public static MealCraftability CalculateMeal(IEnumerable<FoodDefinition> foods, SourceInventorySnapshot inventory)
		{
			List<FoodCraftability> list = foods.Select((FoodDefinition food) => CalculateFood(food, inventory)).ToList();
			IReadOnlyList<IngredientProgress> missingIngredients = CalculateMealMissing(list, inventory);
			return new MealCraftability(list, missingIngredients, list.Any((FoodCraftability food) => !food.IsCraftableByRecipe), inventory.ScanReport.StatusText);
		}

		private static FoodCraftability CalculateFood(FoodDefinition food, SourceInventorySnapshot inventory)
		{
			int num = inventory.Combined.Count(food.PrefabName);
			string availableFoodSourceText = ((num > 0) ? inventory.FormatSourceBreakdown(food.PrefabName) : string.Empty);
			if (!food.HasRecipe || food.Ingredients.Count == 0)
			{
				return new FoodCraftability(food, isCraftableByRecipe: false, 0, 0, Enumerable.Empty<IngredientProgress>(), num, availableFoodSourceText);
			}
			List<IngredientProgress> list = food.Ingredients.Select((FoodIngredient ingredient) => CalculateIngredient(ingredient, ingredient.Amount, inventory)).ToList();
			int num2 = ((list.Count != 0) ? list.Min((IngredientProgress ingredient) => (ingredient.Required > 0) ? (ingredient.Available / ingredient.Required) : 0) : 0);
			return new FoodCraftability(food, isCraftableByRecipe: true, num2, num2 * food.RecipeOutputAmount, list, num, availableFoodSourceText);
		}

		private static IngredientProgress CalculateIngredient(FoodIngredient ingredient, int required, SourceInventorySnapshot inventory)
		{
			int num = inventory.Combined.Count(ingredient.PrefabName);
			if (!ingredient.HasRecipe)
			{
				return new IngredientProgress(ingredient.PrefabName, ingredient.DisplayName, required, num, ingredient.Icon, null, inventory.FormatSourceBreakdown(ingredient.PrefabName));
			}
			int num2 = Math.Max(0, required - num);
			int operationsNeeded = ((num2 != 0) ? ((int)Math.Ceiling((double)num2 / (double)ingredient.OutputAmount)) : 0);
			List<IngredientProgress> list = ingredient.RecipeIngredients.Select((FoodIngredient child) => CalculateIngredient(child, child.Amount * operationsNeeded, inventory)).ToList();
			int val = ((list.Count != 0) ? list.Min((IngredientProgress child) => (child.Required > 0) ? (child.Available / child.Required * operationsNeeded) : operationsNeeded) : 0);
			int num3 = ((operationsNeeded != 0) ? Math.Min(operationsNeeded, val) : 0);
			int available = num + num3 * ingredient.OutputAmount;
			return new IngredientProgress(ingredient.PrefabName, ingredient.DisplayName, required, available, ingredient.Icon, list, inventory.FormatSourceBreakdown(ingredient.PrefabName));
		}

		private static IReadOnlyList<IngredientProgress> CalculateMealMissing(IEnumerable<FoodCraftability> foods, SourceInventorySnapshot inventory)
		{
			Dictionary<string, AggregatedRequirement> dictionary = new Dictionary<string, AggregatedRequirement>(StringComparer.OrdinalIgnoreCase);
			foreach (FoodCraftability item in foods.Where((FoodCraftability food) => food.IsCraftableByRecipe))
			{
				int num = Math.Max(1, (int)Math.Ceiling(1.0 / (double)Math.Max(1, item.Food.RecipeOutputAmount)));
				foreach (FoodIngredient ingredient in item.Food.Ingredients)
				{
					AddLeafRequirements(dictionary, ingredient, ingredient.Amount * num, inventory);
				}
			}
			return (from requirement in dictionary.Values
				select new IngredientProgress(requirement.PrefabName, requirement.DisplayName, requirement.Required, inventory.Combined.Count(requirement.PrefabName), requirement.Icon, null, inventory.FormatSourceBreakdown(requirement.PrefabName)) into ingredient
				where ingredient.Missing > 0
				select ingredient).OrderBy<IngredientProgress, string>((IngredientProgress ingredient) => ingredient.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
		}

		private static void AddLeafRequirements(Dictionary<string, AggregatedRequirement> requirements, FoodIngredient ingredient, int required, SourceInventorySnapshot inventory)
		{
			if (ingredient.HasRecipe)
			{
				int num = Math.Max(0, required - inventory.Combined.Count(ingredient.PrefabName));
				if (num <= 0)
				{
					return;
				}
				int num2 = (int)Math.Ceiling((double)num / (double)ingredient.OutputAmount);
				{
					foreach (FoodIngredient recipeIngredient in ingredient.RecipeIngredients)
					{
						AddLeafRequirements(requirements, recipeIngredient, recipeIngredient.Amount * num2, inventory);
					}
					return;
				}
			}
			if (!requirements.TryGetValue(ingredient.PrefabName, out AggregatedRequirement value))
			{
				value = new AggregatedRequirement(ingredient.PrefabName, ingredient.DisplayName, ingredient.Icon);
			}
			value.Required += required;
			requirements[ingredient.PrefabName] = value;
		}
	}
	public sealed class PlayerFoodKnowledge
	{
		private readonly HashSet<string> _knownRecipes;

		private readonly HashSet<string> _knownMaterials;

		public PlayerFoodKnowledge(IEnumerable<string> knownRecipes, IEnumerable<string> knownMaterials)
		{
			_knownRecipes = new HashSet<string>(knownRecipes.Where((string value) => !string.IsNullOrWhiteSpace(value)), StringComparer.OrdinalIgnoreCase);
			_knownMaterials = new HashSet<string>(knownMaterials.Where((string value) => !string.IsNullOrWhiteSpace(value)), StringComparer.OrdinalIgnoreCase);
		}

		public bool KnowsRecipe(string recipeName)
		{
			return _knownRecipes.Contains(recipeName);
		}

		public bool KnowsMaterial(string prefabName)
		{
			return MaterialKnowledgeKeys.Candidates(prefabName).Any(_knownMaterials.Contains);
		}
	}
	public static class MaterialKnowledgeKeys
	{
		public static IEnumerable<string> Candidates(string materialName)
		{
			if (string.IsNullOrWhiteSpace(materialName))
			{
				yield break;
			}
			yield return materialName;
			foreach (string item in VanillaAliases(materialName))
			{
				yield return item;
			}
		}

		private static IEnumerable<string> VanillaAliases(string materialName)
		{
			switch (Normalize(materialName))
			{
			case "rawmeat":
			case "boarmeat":
				yield return "$item_boarmeat";
				yield return "BoarMeat";
				break;
			case "deermeat":
				yield return "$item_deermeat";
				break;
			case "necktail":
				yield return "$item_necktail";
				break;
			}
		}

		private static string Normalize(string value)
		{
			return new string(value.Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray());
		}
	}
	public static class DiscoveryFilter
	{
		public static IEnumerable<FoodDefinition> FilterVisibleFoods(IEnumerable<FoodDefinition> foods, PlayerFoodKnowledge knowledge, InventorySnapshot inventory)
		{
			foreach (FoodDefinition food in foods)
			{
				if (food.HasRecipe)
				{
					if (food.RecipeName != null && knowledge.KnowsRecipe(food.RecipeName))
					{
						yield return food;
					}
					else if (food.RecipeName == null && knowledge.KnowsMaterial(food.MaterialName ?? food.PrefabName))
					{
						yield return food;
					}
					else if (food.RecipeName == null && HasKnownConversionSource(food, knowledge, inventory))
					{
						yield return food;
					}
				}
				else if (knowledge.KnowsMaterial(food.MaterialName ?? food.PrefabName) || inventory.Contains(food.PrefabName))
				{
					yield return food;
				}
			}
		}

		private static bool HasKnownConversionSource(FoodDefinition food, PlayerFoodKnowledge knowledge, InventorySnapshot inventory)
		{
			if (food.Ingredients.Count > 0)
			{
				return food.Ingredients.All((FoodIngredient ingredient) => knowledge.KnowsMaterial(ingredient.PrefabName) || inventory.Contains(ingredient.PrefabName));
			}
			return false;
		}
	}
	public enum PlannerRole
	{
		BossFight,
		ExploreGather,
		BuildFarm,
		MineHaul,
		MagicEitr,
		Balanced,
		BestAvailable
	}
	public enum TargetBiome
	{
		Meadows,
		BlackForest,
		Swamp,
		Mountain,
		Plains,
		Mistlands,
		Ashlands
	}
	public enum PlannerViewMode
	{
		Recommended,
		Custom
	}
	public sealed class FeastPlannerViewModel
	{
		public PlannerRole SelectedRole { get; }

		public TargetBiome SelectedBiome { get; }

		public FeastRecommendation Recommendation { get; }

		public ActiveFoodState ActiveFoods { get; }

		public MealCraftability Craftability { get; }

		public PlannerViewMode SelectedMode { get; }

		public IReadOnlyList<SavedMeal> SavedMeals { get; }

		public string? SelectedSavedMealId { get; }

		public IReadOnlyList<FoodDefinition> VisibleFoods { get; }

		public SavedMealValidationResult? SavedMealValidation { get; }

		public string SavedMealStatus { get; }

		public IReadOnlyList<FoodDefinition> Foods => Recommendation.Foods;

		public FeastPlannerViewModel(PlannerRole selectedRole, TargetBiome selectedBiome, FeastRecommendation recommendation, ActiveFoodState activeFoods, MealCraftability craftability, PlannerViewMode selectedMode = PlannerViewMode.Recommended, IReadOnlyList<SavedMeal>? savedMeals = null, string? selectedSavedMealId = null, IReadOnlyList<FoodDefinition>? visibleFoods = null, SavedMealValidationResult? savedMealValidation = null, string savedMealStatus = "")
		{
			SelectedRole = selectedRole;
			SelectedBiome = selectedBiome;
			Recommendation = recommendation;
			ActiveFoods = activeFoods;
			Craftability = craftability;
			SelectedMode = selectedMode;
			SavedMeals = savedMeals ?? Array.Empty<SavedMeal>();
			SelectedSavedMealId = selectedSavedMealId;
			VisibleFoods = visibleFoods ?? Array.Empty<FoodDefinition>();
			SavedMealValidation = savedMealValidation;
			SavedMealStatus = savedMealStatus;
		}
	}
	public sealed class FeastRecommendation
	{
		public IReadOnlyList<FoodDefinition> Foods { get; }

		public FoodStats Totals { get; }

		public string Explanation { get; }

		public FeastRecommendation(IReadOnlyList<FoodDefinition> foods, FoodStats totals, string explanation)
		{
			Foods = new ReadOnlyCollection<FoodDefinition>(foods.ToList());
			Totals = totals;
			Explanation = explanation;
		}
	}
	public sealed class FeastRecommendationEngine
	{
		private readonly FoodTierTable _tierTable;

		public FeastRecommendationEngine(FoodTierTable tierTable)
		{
			_tierTable = tierTable;
		}

		public FeastRecommendation Recommend(PlannerRole role, TargetBiome targetBiome, IEnumerable<FoodDefinition> visibleFoods, InventorySnapshot inventory, ActiveFoodState activeFoods)
		{
			List<FoodDefinition> list = Rank(visibleFoods.Where((FoodDefinition food) => _tierTable.IsAllowedForTarget(food.PrefabName, targetBiome) && food.Tier <= targetBiome).ToList(), role, activeFoods).Take(3).ToList();
			return new FeastRecommendation(list, Total(list), Explain(role, targetBiome, list.Count));
		}

		private static IEnumerable<FoodDefinition> Rank(IEnumerable<FoodDefinition> foods, PlannerRole role, ActiveFoodState activeFoods)
		{
			return (from food in foods
				orderby (int)food.Tier descending, Score(food, role, activeFoods) descending, food.Stats.Total descending, food.Stats.Duration descending
				select food).ThenBy<FoodDefinition, string>((FoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase);
		}

		private static float Score(FoodDefinition food, PlannerRole role, ActiveFoodState activeFoods)
		{
			FoodStats stats = food.Stats;
			float num = (activeFoods.Contains(food.PrefabName) ? 2f : 0f);
			float num2 = stats.Duration / 600f;
			return role switch
			{
				PlannerRole.BossFight => stats.Health * 2.2f + stats.Stamina * 0.8f + stats.Healing * 30f + num2, 
				PlannerRole.ExploreGather => stats.Stamina * 2.1f + stats.Health * 0.8f + num2 * 4f, 
				PlannerRole.BuildFarm => stats.Stamina * 1.9f + num2 * 4f + Math.Min(stats.Health, 45f) * 0.5f, 
				PlannerRole.MineHaul => stats.Stamina * 1.4f + stats.Health * 1.3f + num2 * 3f, 
				PlannerRole.MagicEitr => stats.Eitr * 3f + stats.Health * 0.8f + num2 * 2f, 
				PlannerRole.Balanced => stats.Health + stats.Stamina + stats.Eitr * 1.2f + num2 * 2f, 
				PlannerRole.BestAvailable => stats.Total + stats.Healing * 20f + num2 * 2f, 
				_ => stats.Total, 
			} - num;
		}

		private static FoodStats Total(IEnumerable<FoodDefinition> foods)
		{
			List<FoodDefinition> list = foods.ToList();
			return new FoodStats(list.Sum((FoodDefinition food) => food.Stats.Health), list.Sum((FoodDefinition food) => food.Stats.Stamina), list.Sum((FoodDefinition food) => food.Stats.Eitr), list.Sum((FoodDefinition food) => food.Stats.Healing), (list.Count == 0) ? 0f : list.Min((FoodDefinition food) => food.Stats.Duration));
		}

		private static string Explain(PlannerRole role, TargetBiome targetBiome, int count)
		{
			string text = count switch
			{
				0 => "No eligible foods found.", 
				1 => "Only 1 eligible food found.", 
				2 => "Only 2 eligible foods found.", 
				_ => "Recommended 3 eligible foods.", 
			};
			return text + " Ranked for " + Display(role) + " and " + Display(targetBiome) + " target biome.";
		}

		private static string Display(PlannerRole role)
		{
			return role switch
			{
				PlannerRole.BossFight => "Boss Fight", 
				PlannerRole.ExploreGather => "Explore / Gather", 
				PlannerRole.BuildFarm => "Build / Farm", 
				PlannerRole.MineHaul => "Mine / Haul", 
				PlannerRole.MagicEitr => "Magic / Eitr", 
				PlannerRole.BestAvailable => "Best Available", 
				_ => "Balanced", 
			};
		}

		private static string Display(TargetBiome biome)
		{
			if (biome == TargetBiome.BlackForest)
			{
				return "Black Forest";
			}
			return biome.ToString();
		}
	}
	public sealed record FoodStats(float Health, float Stamina, float Eitr, float Healing, float Duration)
	{
		public float Total => Health + Stamina + Eitr;
	}
	public sealed record FoodIngredient(string PrefabName, string DisplayName, int Amount, Sprite? Icon = null, IReadOnlyList<FoodIngredient>? Ingredients = null, int RecipeOutputAmount = 1)
	{
		public IReadOnlyList<FoodIngredient> RecipeIngredients => Ingredients ?? Array.Empty<FoodIngredient>();

		public bool HasRecipe => RecipeIngredients.Count > 0;

		public int OutputAmount
		{
			get
			{
				if (RecipeOutputAmount > 0)
				{
					return RecipeOutputAmount;
				}
				return 1;
			}
		}
	}
	public sealed class FoodDefinition
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public FoodStats Stats { get; }

		public string? RecipeName { get; }

		public TargetBiome Tier { get; }

		public bool IsDrink { get; }

		public IReadOnlyList<FoodIngredient> Ingredients { get; }

		public string? MaterialName { get; }

		public Sprite? Icon { get; }

		public int RecipeOutputAmount { get; }

		public bool HasRecipe
		{
			get
			{
				if (string.IsNullOrWhiteSpace(RecipeName))
				{
					return Ingredients.Count > 0;
				}
				return true;
			}
		}

		public FoodDefinition(string prefabName, string displayName, FoodStats stats, string? recipeName, TargetBiome tier, bool isDrink, IEnumerable<FoodIngredient>? ingredients = null, string? materialName = null, Sprite? icon = null, int recipeOutputAmount = 1)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Stats = stats;
			RecipeName = recipeName;
			Tier = tier;
			IsDrink = isDrink;
			Ingredients = new ReadOnlyCollection<FoodIngredient>((ingredients ?? Enumerable.Empty<FoodIngredient>()).ToList());
			MaterialName = materialName;
			Icon = icon;
			RecipeOutputAmount = ((recipeOutputAmount <= 0) ? 1 : recipeOutputAmount);
		}
	}
	public static class FoodEligibility
	{
		public static bool HasFoodValue(FoodStats stats)
		{
			if (!(stats.Health > 0f) && !(stats.Stamina > 0f) && !(stats.Eitr > 0f) && !(stats.Healing > 0f))
			{
				return stats.Duration > 0f;
			}
			return true;
		}
	}
	public sealed class FoodTierTable
	{
		private readonly Dictionary<string, TargetBiome> _tiers;

		public FoodTierTable(IReadOnlyDictionary<string, TargetBiome> tiers)
		{
			_tiers = new Dictionary<string, TargetBiome>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, TargetBiome> tier in tiers)
			{
				_tiers[tier.Key] = tier.Value;
			}
		}

		public TargetBiome? GetTier(string prefabName)
		{
			if (!_tiers.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		public bool IsAllowedForTarget(string prefabName, TargetBiome targetBiome)
		{
			TargetBiome? tier = GetTier(prefabName);
			if (tier.HasValue)
			{
				return tier.Value <= targetBiome;
			}
			return true;
		}
	}
	public static class VanillaFoodTierTable
	{
		public static FoodTierTable CreateDefault()
		{
			return new FoodTierTable(new Dictionary<string, TargetBiome>(StringComparer.OrdinalIgnoreCase)
			{
				["Raspberry"] = TargetBiome.Meadows,
				["Blueberries"] = TargetBiome.BlackForest,
				["Mushroom"] = TargetBiome.Meadows,
				["Honey"] = TargetBiome.Meadows,
				["CookedMeat"] = TargetBiome.Meadows,
				["CookedBoarMeat"] = TargetBiome.Meadows,
				["CookedDeerMeat"] = TargetBiome.Meadows,
				["GrilledNeckTail"] = TargetBiome.Meadows,
				["NeckTailGrilled"] = TargetBiome.Meadows,
				["DeerStew"] = TargetBiome.BlackForest,
				["MincedMeatSauce"] = TargetBiome.BlackForest,
				["QueensJam"] = TargetBiome.BlackForest,
				["CarrotSoup"] = TargetBiome.BlackForest,
				["TurnipStew"] = TargetBiome.Swamp,
				["Sausages"] = TargetBiome.Swamp,
				["BlackSoup"] = TargetBiome.Swamp,
				["SerpentStew"] = TargetBiome.Swamp,
				["WolfJerky"] = TargetBiome.Mountain,
				["WolfMeatSkewer"] = TargetBiome.Mountain,
				["Eyescream"] = TargetBiome.Mountain,
				["OnionSoup"] = TargetBiome.Mountain,
				["LoxPie"] = TargetBiome.Plains,
				["FishWraps"] = TargetBiome.Plains,
				["BloodPudding"] = TargetBiome.Plains,
				["Bread"] = TargetBiome.Plains,
				["Salad"] = TargetBiome.Mistlands,
				["MushroomOmelette"] = TargetBiome.Mistlands,
				["SeekerAspic"] = TargetBiome.Mistlands,
				["YggdrasilPorridge"] = TargetBiome.Mistlands,
				["FierySvinstew"] = TargetBiome.Ashlands,
				["MashedMeat"] = TargetBiome.Ashlands,
				["PiquantPie"] = TargetBiome.Ashlands,
				["RoastedCrustPie"] = TargetBiome.Ashlands
			});
		}
	}
	public sealed record InventoryStack(string PrefabName, int Count);
	public sealed class InventorySnapshot
	{
		private readonly Dictionary<string, int> _counts;

		public static InventorySnapshot Empty { get; } = new InventorySnapshot(new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase));

		public IReadOnlyList<InventoryStack> Stacks => new ReadOnlyCollection<InventoryStack>(_counts.Select<KeyValuePair<string, int>, InventoryStack>((KeyValuePair<string, int> pair) => new InventoryStack(pair.Key, pair.Value)).ToList());

		private InventorySnapshot(Dictionary<string, int> counts)
		{
			_counts = counts;
		}

		public static InventorySnapshot FromCounts(IReadOnlyDictionary<string, int> counts)
		{
			Dictionary<string, int> counts2 = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, int> count in counts)
			{
				Add(counts2, count.Key, count.Value);
			}
			return new InventorySnapshot(counts2);
		}

		public static InventorySnapshot FromStacks(IEnumerable<InventoryStack> stacks)
		{
			Dictionary<string, int> counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (InventoryStack stack in stacks)
			{
				Add(counts, stack.PrefabName, stack.Count);
			}
			return new InventorySnapshot(counts);
		}

		public int Count(string prefabName)
		{
			if (!_counts.TryGetValue(prefabName, out var value))
			{
				return 0;
			}
			return value;
		}

		public bool Contains(string prefabName)
		{
			return Count(prefabName) > 0;
		}

		private static void Add(Dictionary<string, int> counts, string prefabName, int count)
		{
			if (!string.IsNullOrWhiteSpace(prefabName) && count > 0)
			{
				counts[prefabName] = (counts.TryGetValue(prefabName, out var value) ? (value + count) : count);
			}
		}
	}
	public sealed class SourceInventorySnapshot
	{
		public InventorySnapshot Inventory { get; }

		public InventorySnapshot NearbyContainers { get; }

		public InventorySnapshot Combined { get; }

		public ContainerScanReport ScanReport { get; }

		private SourceInventorySnapshot(InventorySnapshot inventory, InventorySnapshot nearbyContainers, InventorySnapshot combined, ContainerScanReport scanReport)
		{
			Inventory = inventory;
			NearbyContainers = nearbyContainers;
			Combined = combined;
			ScanReport = scanReport;
		}

		public static SourceInventorySnapshot InventoryOnly(InventorySnapshot inventory)
		{
			return Create(inventory, InventorySnapshot.Empty, ContainerScanReport.NotScanned);
		}

		public static SourceInventorySnapshot Create(InventorySnapshot inventory, InventorySnapshot nearbyContainers, ContainerScanReport scanReport)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (InventoryStack stack in inventory.Stacks)
			{
				dictionary[stack.PrefabName] = stack.Count;
			}
			foreach (InventoryStack stack2 in nearbyContainers.Stacks)
			{
				dictionary[stack2.PrefabName] = (dictionary.TryGetValue(stack2.PrefabName, out var value) ? (value + stack2.Count) : stack2.Count);
			}
			return new SourceInventorySnapshot(inventory, nearbyContainers, InventorySnapshot.FromCounts(dictionary), scanReport);
		}

		public string FormatSourceBreakdown(string prefabName)
		{
			int num = Inventory.Count(prefabName);
			int num2 = NearbyContainers.Count(prefabName);
			if (num > 0 && num2 > 0)
			{
				return $"{num} inv + {num2} nearby";
			}
			if (num2 > 0)
			{
				return $"nearby x{num2}";
			}
			if (num > 0)
			{
				return $"inventory x{num}";
			}
			return "missing";
		}
	}
	public sealed class ContainerScanReport
	{
		public static ContainerScanReport NotScanned { get; } = new ContainerScanReport(enabled: false, isCooldown: false, 0, 0, 0, 0, 0, 0, capped: false, 0);

		public bool Enabled { get; }

		public bool IsCooldown { get; }

		public int ScannedContainers { get; }

		public int SkippedContainers { get; }

		public int SkippedInUse { get; }

		public int SkippedPrivate { get; }

		public int SkippedWardedOrNoAccess { get; }

		public int SkippedTooFar { get; }

		public bool Capped { get; }

		public int SecondsSinceScan { get; }

		public string StatusText
		{
			get
			{
				if (!Enabled)
				{
					return "Nearby: not scanned";
				}
				string text = $"Nearby: {ScannedContainers} containers scanned, {SkippedContainers} skipped";
				if (Capped)
				{
					text += ", partial";
				}
				return text + (IsCooldown ? $", cooldown {SecondsSinceScan}s ago" : $", refreshed {SecondsSinceScan}s ago");
			}
		}

		public ContainerScanReport(bool enabled, bool isCooldown, int scannedContainers, int skippedContainers, int skippedInUse, int skippedPrivate, int skippedWardedOrNoAccess, int skippedTooFar, bool capped, int secondsSinceScan)
		{
			Enabled = enabled;
			IsCooldown = isCooldown;
			ScannedContainers = Math.Max(0, scannedContainers);
			SkippedContainers = Math.Max(0, skippedContainers);
			SkippedInUse = Math.Max(0, skippedInUse);
			SkippedPrivate = Math.Max(0, skippedPrivate);
			SkippedWardedOrNoAccess = Math.Max(0, skippedWardedOrNoAccess);
			SkippedTooFar = Math.Max(0, skippedTooFar);
			Capped = capped;
			SecondsSinceScan = Math.Max(0, secondsSinceScan);
		}

		public static ContainerScanReport Completed(int scanned, int skipped, bool capped, int secondsSinceScan)
		{
			return new ContainerScanReport(enabled: true, isCooldown: false, scanned, skipped, 0, 0, 0, 0, capped, secondsSinceScan);
		}
	}
	public sealed class SavedMeal
	{
		public string Id { get; }

		public string Name { get; }

		public IReadOnlyList<string> FoodPrefabNames { get; }

		public DateTimeOffset CreatedUtc { get; }

		public DateTimeOffset UpdatedUtc { get; }

		public SavedMeal(string id, string name, IEnumerable<string> foodPrefabNames, DateTimeOffset createdUtc, DateTimeOffset updatedUtc)
		{
			Id = (string.IsNullOrWhiteSpace(id) ? Guid.NewGuid().ToString("N") : id);
			Name = SavedMealLibrary.CleanName(name);
			FoodPrefabNames = new ReadOnlyCollection<string>(SavedMealLibrary.CleanFoodNames(foodPrefabNames).ToList());
			CreatedUtc = createdUtc;
			UpdatedUtc = updatedUtc;
		}

		public SavedMeal WithName(string name, DateTimeOffset updatedUtc)
		{
			return new SavedMeal(Id, name, FoodPrefabNames, CreatedUtc, updatedUtc);
		}

		public SavedMeal WithFoods(IEnumerable<string> foodPrefabNames, DateTimeOffset updatedUtc)
		{
			return new SavedMeal(Id, Name, foodPrefabNames, CreatedUtc, updatedUtc);
		}
	}
	public sealed class SavedMealLibrary
	{
		public const int DefaultMaxMeals = 24;

		public const int MaxFoodsPerMeal = 3;

		public const int MaxMealNameLength = 32;

		private readonly List<SavedMeal> _meals;

		private readonly int _maxMeals;

		public IReadOnlyList<SavedMeal> Meals => new ReadOnlyCollection<SavedMeal>(_meals);

		private SavedMealLibrary(IEnumerable<SavedMeal> meals, int maxMeals)
		{
			_maxMeals = Math.Max(1, maxMeals);
			_meals = meals.Take(_maxMeals).ToList();
		}

		public static SavedMealLibrary Empty(int maxMeals = 24)
		{
			return new SavedMealLibrary(Array.Empty<SavedMeal>(), maxMeals);
		}

		public static SavedMealLibrary FromMeals(IEnumerable<SavedMeal> meals, int maxMeals = 24)
		{
			return new SavedMealLibrary(meals, maxMeals);
		}

		public SavedMeal Create(string name, IEnumerable<string> foodPrefabNames, DateTimeOffset nowUtc)
		{
			if (!TryCreate(name, foodPrefabNames, nowUtc, out SavedMeal meal, out string error))
			{
				throw new InvalidOperationException(error);
			}
			return meal;
		}

		public bool TryCreate(string name, IEnumerable<string> foodPrefabNames, DateTimeOffset nowUtc, out SavedMeal meal, out string error)
		{
			meal = new SavedMeal(Guid.NewGuid().ToString("N"), CleanName(name), foodPrefabNames, nowUtc, nowUtc);
			error = string.Empty;
			IReadOnlyList<string> foodPrefabNames2 = meal.FoodPrefabNames;
			if (_meals.Count >= _maxMeals)
			{
				error = "Saved meal limit reached.";
				return false;
			}
			if (foodPrefabNames2.Count == 0)
			{
				error = "Choose at least one food.";
				return false;
			}
			if (foodPrefabNames2.Count > 3)
			{
				error = "Saved meals can include up to three foods.";
				return false;
			}
			_meals.Add(meal);
			return true;
		}

		public bool Rename(string id, string name, DateTimeOffset nowUtc)
		{
			int num = _meals.FindIndex((SavedMeal meal) => meal.Id == id);
			if (num < 0)
			{
				return false;
			}
			_meals[num] = _meals[num].WithName(name, nowUtc);
			return true;
		}

		public bool TryFind(string id, out SavedMeal? meal)
		{
			meal = _meals.FirstOrDefault((SavedMeal candidate) => candidate.Id == id);
			return meal != null;
		}

		public bool UpdateFoodSlot(string id, int slotIndex, string foodPrefabName, DateTimeOffset nowUtc, out string error)
		{
			error = string.Empty;
			if (slotIndex < 0 || slotIndex >= 3)
			{
				error = "Saved meals can include up to three foods.";
				return false;
			}
			int num = _meals.FindIndex((SavedMeal meal) => meal.Id == id);
			if (num < 0)
			{
				error = "Saved meal not found.";
				return false;
			}
			string text = (foodPrefabName ?? string.Empty).Trim();
			if (text.Length == 0)
			{
				error = "Choose a food.";
				return false;
			}
			List<string> list = _meals[num].FoodPrefabNames.Take(3).ToList();
			while (list.Count <= slotIndex)
			{
				list.Add(string.Empty);
			}
			list[slotIndex] = text;
			list = list.Where((string item) => !string.IsNullOrWhiteSpace(item)).ToList();
			_meals[num] = _meals[num].WithFoods(list, nowUtc);
			return true;
		}

		public bool UpdateFoods(string id, IEnumerable<string> foodPrefabNames, DateTimeOffset nowUtc, out string error)
		{
			error = string.Empty;
			List<string> list = CleanFoodNames(foodPrefabNames).ToList();
			if (list.Count == 0)
			{
				error = "Choose at least one food.";
				return false;
			}
			if (list.Count > 3)
			{
				error = "Saved meals can include up to three foods.";
				return false;
			}
			int num = _meals.FindIndex((SavedMeal meal) => meal.Id == id);
			if (num < 0)
			{
				error = "Saved meal not found.";
				return false;
			}
			_meals[num] = _meals[num].WithFoods(list, nowUtc);
			return true;
		}

		public bool Delete(string id)
		{
			return _meals.RemoveAll((SavedMeal meal) => meal.Id == id) > 0;
		}

		public static string CleanName(string name)
		{
			string text = new string((name ?? string.Empty).Select((char character) => (!char.IsControl(character)) ? character : ' ').ToArray());
			text = string.Join(" ", text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
			if (text.Length == 0)
			{
				text = "Custom meal";
			}
			if (text.Length > 32)
			{
				return text.Substring(0, 32).TrimEnd(Array.Empty<char>());
			}
			return text;
		}

		public static IEnumerable<string> CleanFoodNames(IEnumerable<string> foodPrefabNames)
		{
			return from food in foodPrefabNames ?? Array.Empty<string>()
				select food?.Trim() ?? string.Empty into food
				where food.Length > 0
				select food;
		}
	}
	public enum SavedMealEntryStatus
	{
		Valid,
		Hidden,
		Missing,
		Duplicate
	}
	public sealed class SavedMealEntryValidation
	{
		public string PrefabName { get; }

		public string DisplayName { get; }

		public SavedMealEntryStatus Status { get; }

		public SavedMealEntryValidation(string prefabName, string displayName, SavedMealEntryStatus status)
		{
			PrefabName = prefabName;
			DisplayName = displayName;
			Status = status;
		}
	}
	public sealed class SavedMealValidationResult
	{
		public SavedMeal Meal { get; }

		public IReadOnlyList<FoodDefinition> ValidFoods { get; }

		public IReadOnlyList<SavedMealEntryValidation> Entries { get; }

		public bool HasWarnings => Entries.Any((SavedMealEntryValidation entry) => entry.Status != SavedMealEntryStatus.Valid);

		public SavedMealValidationResult(SavedMeal meal, IReadOnlyList<FoodDefinition> validFoods, IReadOnlyList<SavedMealEntryValidation> entries)
		{
			Meal = meal;
			ValidFoods = new ReadOnlyCollection<FoodDefinition>(validFoods.ToList());
			Entries = new ReadOnlyCollection<SavedMealEntryValidation>(entries.ToList());
		}
	}
	public sealed class SavedMealPlannerResult
	{
		public FeastRecommendation Recommendation { get; }

		public SavedMealValidationResult Validation { get; }

		public SavedMealPlannerResult(FeastRecommendation recommendation, SavedMealValidationResult validation)
		{
			Recommendation = recommendation;
			Validation = validation;
		}
	}
	public static class SavedMealPlanner
	{
		public static SavedMealPlannerResult BuildCustomRecommendation(SavedMeal meal, IEnumerable<FoodDefinition> catalog, IEnumerable<FoodDefinition> visibleFoods, TargetBiome targetBiome, FoodTierTable tierTable)
		{
			SavedMealValidationResult savedMealValidationResult = SavedMealValidator.Validate(meal, catalog, visibleFoods, targetBiome, tierTable);
			return new SavedMealPlannerResult(new FeastRecommendation(savedMealValidationResult.ValidFoods, Total(savedMealValidationResult.ValidFoods), Explain(meal, savedMealValidationResult)), savedMealValidationResult);
		}

		private static FoodStats Total(IEnumerable<FoodDefinition> foods)
		{
			List<FoodDefinition> list = foods.ToList();
			return new FoodStats(list.Sum((FoodDefinition food) => food.Stats.Health), list.Sum((FoodDefinition food) => food.Stats.Stamina), list.Sum((FoodDefinition food) => food.Stats.Eitr), list.Sum((FoodDefinition food) => food.Stats.Healing), (list.Count == 0) ? 0f : list.Min((FoodDefinition food) => food.Stats.Duration));
		}

		private static string Explain(SavedMeal meal, SavedMealValidationResult validation)
		{
			int num = validation.Entries.Count((SavedMealEntryValidation entry) => entry.Status != SavedMealEntryStatus.Valid);
			string text = ((num == 0) ? $"{validation.ValidFoods.Count} saved foods ready." : $"{num} saved foods skipped.");
			return "Saved meal: " + meal.Name + ". " + text;
		}
	}
	public static class SavedMealFoodPicker
	{
		public static IEnumerable<FoodDefinition> Filter(IEnumerable<FoodDefinition> visibleFoods, string searchText, TargetBiome? biomeFilter = null, FoodPickerCategory category = FoodPickerCategory.All)
		{
			string query = (searchText ?? string.Empty).Trim();
			return (from food in visibleFoods
				where query.Length == 0 || food.DisplayName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 || food.PrefabName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0
				where !biomeFilter.HasValue || food.Tier == biomeFilter.Value
				where MatchesCategory(food, category)
				select food).OrderBy<FoodDefinition, string>((FoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase).ThenBy<FoodDefinition, string>((FoodDefinition food) => food.PrefabName, StringComparer.OrdinalIgnoreCase);
		}

		private static bool MatchesCategory(FoodDefinition food, FoodPickerCategory category)
		{
			return category switch
			{
				FoodPickerCategory.HealthHeavy => food.Stats.Health > food.Stats.Stamina && food.Stats.Health >= food.Stats.Eitr, 
				FoodPickerCategory.StaminaHeavy => food.Stats.Stamina > food.Stats.Health && food.Stats.Stamina >= food.Stats.Eitr, 
				FoodPickerCategory.Eitr => food.Stats.Eitr > 0f, 
				FoodPickerCategory.BalancedUtility => food.Stats.Eitr <= 0f && Math.Abs(food.Stats.Health - food.Stats.Stamina) <= 15f, 
				_ => true, 
			};
		}
	}
	public enum FoodPickerCategory
	{
		All,
		HealthHeavy,
		StaminaHeavy,
		Eitr,
		BalancedUtility
	}
	public static class SavedMealValidator
	{
		public static SavedMealValidationResult Validate(SavedMeal meal, IEnumerable<FoodDefinition> catalog, IEnumerable<FoodDefinition> visibleFoods, TargetBiome targetBiome, FoodTierTable tierTable)
		{
			Dictionary<string, FoodDefinition> dictionary = catalog.GroupBy<FoodDefinition, string>((FoodDefinition food) => food.PrefabName, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, FoodDefinition>, string, FoodDefinition>((IGrouping<string, FoodDefinition> group) => group.Key, (IGrouping<string, FoodDefinition> group) => group.First(), StringComparer.OrdinalIgnoreCase);
			Dictionary<string, FoodDefinition> dictionary2 = visibleFoods.GroupBy<FoodDefinition, string>((FoodDefinition food) => food.PrefabName, StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, FoodDefinition>, string, FoodDefinition>((IGrouping<string, FoodDefinition> group) => group.Key, (IGrouping<string, FoodDefinition> group) => group.First(), StringComparer.OrdinalIgnoreCase);
			List<FoodDefinition> list = new List<FoodDefinition>();
			List<SavedMealEntryValidation> list2 = new List<SavedMealEntryValidation>();
			foreach (string foodPrefabName in meal.FoodPrefabNames)
			{
				if (!dictionary.TryGetValue(foodPrefabName, out var value))
				{
					list2.Add(new SavedMealEntryValidation(foodPrefabName, foodPrefabName, SavedMealEntryStatus.Missing));
					continue;
				}
				if (!dictionary2.TryGetValue(foodPrefabName, out var value2))
				{
					list2.Add(new SavedMealEntryValidation(foodPrefabName, SafeHiddenName(value), SavedMealEntryStatus.Hidden));
					continue;
				}
				list.Add(value2);
				list2.Add(new SavedMealEntryValidation(foodPrefabName, value2.DisplayName, SavedMealEntryStatus.Valid));
			}
			return new SavedMealValidationResult(meal, list, list2);
		}

		private static string SafeHiddenName(FoodDefinition food)
		{
			if (!string.IsNullOrWhiteSpace(food.RecipeName))
			{
				return "Hidden saved food";
			}
			return food.DisplayName;
		}
	}
}
namespace FeastPlanner.Config
{
	public sealed class FeastPlannerConfig
	{
		private static readonly KeyboardShortcut DefaultTogglePlanner = new KeyboardShortcut((KeyCode)112, (KeyCode[])(object)new KeyCode[1] { (KeyCode)307 });

		public ConfigEntry<KeyboardShortcut> TogglePlanner { get; }

		public ConfigEntry<float> ContainerScanRadius { get; }

		public ConfigEntry<float> ContainerScanCooldownSeconds { get; }

		public ConfigEntry<int> ContainerScanMaxContainers { get; }

		private FeastPlannerConfig(ConfigEntry<KeyboardShortcut> togglePlanner, ConfigEntry<float> containerScanRadius, ConfigEntry<float> containerScanCooldownSeconds, ConfigEntry<int> containerScanMaxContainers)
		{
			TogglePlanner = togglePlanner;
			ContainerScanRadius = containerScanRadius;
			ContainerScanCooldownSeconds = containerScanCooldownSeconds;
			ContainerScanMaxContainers = containerScanMaxContainers;
		}

		public static FeastPlannerConfig Bind(ConfigFile config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyboardShortcut> val = config.Bind<KeyboardShortcut>("Input", "TogglePlanner", DefaultTogglePlanner, "Toggles the Feast Planner panel.");
			if (((object)val.Value/*cast due to .constrained prefix*/).ToString() == "F7")
			{
				val.Value = DefaultTogglePlanner;
			}
			ConfigEntry<float> containerScanRadius = config.Bind<float>("Containers", "ContainerScanRadius", 20f, "Nearby container scan radius in meters.");
			ConfigEntry<float> containerScanCooldownSeconds = config.Bind<float>("Containers", "ContainerScanCooldownSeconds", 3f, "Seconds between nearby container scans.");
			ConfigEntry<int> containerScanMaxContainers = config.Bind<int>("Containers", "ContainerScanMaxContainers", 32, "Maximum nearby containers included per scan.");
			return new FeastPlannerConfig(val, containerScanRadius, containerScanCooldownSeconds, containerScanMaxContainers);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}