using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using HarmonyLib;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SeriousWikibook")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SeriousWikibook")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ad8ce1b6-0bdb-406a-88db-cff7f8221c83")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SeriousWikiBook;

[BepInPlugin("serious.outward.wikibook", "Serious Wiki Book", "1.21.11")]
public class WikiBookPlugin : BaseUnityPlugin
{
	public static readonly int[] WikiBookItemIDs = new int[2] { 5100500, 5100510 };

	private const int CleanWaterItemID = 5600000;

	private static readonly HashSet<int> s_equalBuySellItemIDs = new HashSet<int> { 6200040, 6200070, 6200090, 6200100, 6200110, 6200130, 6200170 };

	private static readonly HashSet<string> s_equalBuySellItemNames = new HashSet<string>(StringComparer.Ordinal) { "butchersamethyst", "tinyaquamarine", "largeemerald", "smallsapphire", "mediumruby", "hackmanite", "tourmaline" };

	private static readonly HashSet<int> s_unsellableItemIDs = new HashSet<int> { 6200010 };

	private static readonly HashSet<string> s_unsellableItemNames = new HashSet<string>(StringComparer.Ordinal) { "tsarstone" };

	internal static int OpenActionID = -1;

	internal static WikiBookPlugin Instance;

	private GameObject m_wikiWindow;

	private InventoryMenu m_inventoryMenu;

	private CharacterUI m_characterUI;

	private bool m_wikiOpen;

	private CanvasGroup m_inventoryCanvasGroup;

	private float m_originalInventoryAlpha;

	private bool m_originalInventoryInteractable;

	private bool m_originalInventoryBlocksRaycasts;

	private InputField m_searchField;

	private RectTransform m_entryListContent;

	private ScrollRect m_entryListScrollRect;

	private Scrollbar m_entryListScrollbar;

	private RectTransform m_articleContent;

	private ScrollRect m_articleScrollRect;

	private Text m_articleTitle;

	private Text m_articleCategory;

	private GameObject m_lastSelectedWikiObject;

	private Button m_activeLeftSourceButton;

	private Coroutine m_focusCoroutine;

	private readonly List<List<Button>> m_articleButtonRows = new List<List<Button>>();

	private WikiCategory m_currentCategory = WikiCategory.None;

	private WikiViewState m_currentViewState = WikiViewState.CategoryOverview;

	private readonly List<WikiItemData> m_items = new List<WikiItemData>();

	private readonly List<WikiRecipeData> m_cookingRecipes = new List<WikiRecipeData>();

	private readonly List<WikiRecipeData> m_alchemyRecipes = new List<WikiRecipeData>();

	private readonly List<WikiRecipeData> m_craftingRecipes = new List<WikiRecipeData>();

	private readonly List<WikiEnchantmentData> m_enchantments = new List<WikiEnchantmentData>();

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

	private readonly List<Item> m_allGameItemPrefabs = new List<Item>();

	private readonly List<Recipe> m_allGameRecipes = new List<Recipe>();

	private readonly List<EnchantmentRecipe> m_allGameEnchantmentRecipes = new List<EnchantmentRecipe>();

	private readonly List<Enchantment> m_allGameEnchantments = new List<Enchantment>();

	private readonly Dictionary<int, List<Recipe>> m_gameRecipesByResultItemId = new Dictionary<int, List<Recipe>>();

	private readonly Dictionary<int, List<WikiRecipeData>> m_recipesByResultItemId = new Dictionary<int, List<WikiRecipeData>>();

	private readonly Dictionary<int, List<WikiRecipeData>> m_recipesUsingItemId = new Dictionary<int, List<WikiRecipeData>>();

	private readonly Dictionary<int, List<WikiRecipeData>> m_decraftRecipesUsingItemId = new Dictionary<int, List<WikiRecipeData>>();

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

	private readonly Dictionary<int, List<EnchantmentRecipe>> m_enchantmentRecipesByResultId = new Dictionary<int, List<EnchantmentRecipe>>();

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

	private readonly Dictionary<int, List<EnchantmentRecipe>> m_compatibleEnchantmentsByItemId = new Dictionary<int, List<EnchantmentRecipe>>();

	private readonly Dictionary<int, List<Item>> m_compatibleItemsByEnchantmentResultId = new Dictionary<int, List<Item>>();

	private WikiLocalizationData m_localizationData;

	private WikiCraftingOverrideFile m_craftingOverrideFile;

	private WikiLegacyUpgradeFile m_legacyUpgradeFile;

	private readonly Dictionary<int, List<WikiLegacyUpgradeData>> m_legacyUpgradesBySourceItemId = new Dictionary<int, List<WikiLegacyUpgradeData>>();

	private readonly Dictionary<int, List<WikiLegacyUpgradeData>> m_legacyUpgradesByResultItemId = new Dictionary<int, List<WikiLegacyUpgradeData>>();

	private readonly HashSet<string> m_favorites = new HashSet<string>(StringComparer.Ordinal);

	private readonly Dictionary<Button, Button> m_leftMainToStar = new Dictionary<Button, Button>();

	private readonly Dictionary<Button, Button> m_leftStarToMain = new Dictionary<Button, Button>();

	private readonly HashSet<string> m_loggedUnsupportedEffectTypes = new HashSet<string>(StringComparer.Ordinal);

	private string m_favoritesFilePath;

	private int m_lastBackHandledFrame = -1;

	private bool m_gameDataCacheBuilt;

	private Texture2D m_wikiBackgroundTexture;

	private Sprite m_wikiBackgroundSprite;

	private Sprite m_backgroundSprite;

	private Sprite m_buttonSprite;

	private Color m_buttonColor = Color.white;

	private Type m_buttonImageType = (Type)0;

	private Material m_buttonMaterial;

	private Transition m_buttonTransition = (Transition)1;

	private ColorBlock m_buttonColors;

	private SpriteState m_buttonSpriteState;

	private Font m_buttonFont;

	private FontStyle m_buttonFontStyle = (FontStyle)0;

	private Color m_buttonTextColor = Color.white;

	private int m_buttonFontSize = 20;

	private TextAnchor m_buttonTextAlignment = (TextAnchor)4;

	private Sprite m_separatorSprite;

	private Color m_separatorColor = Color.white;

	private Font m_outwardFont;

	private static readonly Dictionary<string, string> s_englishUiText = new Dictionary<string, string>(StringComparer.Ordinal);

	internal bool IsWikiOpen => m_wikiOpen;

	internal bool IsSearchFieldFocused
	{
		get
		{
			if (!m_wikiOpen || (Object)(object)m_searchField == (Object)null)
			{
				return false;
			}
			if (m_searchField.isFocused)
			{
				return true;
			}
			EventSystem current = EventSystem.current;
			return (Object)(object)current != (Object)null && (Object)(object)current.currentSelectedGameObject == (Object)(object)((Component)m_searchField).gameObject;
		}
	}

	internal static bool UseEnglishUi
	{
		get
		{
			try
			{
				LocalizationManager instance = LocalizationManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				string text = instance.CurrentLanguage ?? "";
				return text.StartsWith("en", StringComparison.OrdinalIgnoreCase) || text.IndexOf("english", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			catch
			{
				return false;
			}
		}
	}

	internal static bool IsWikiBookItem(int itemId)
	{
		return Extensions.Contains(WikiBookItemIDs, itemId);
	}

	internal static string L(string german, string english)
	{
		return UseEnglishUi ? english : german;
	}

	internal static string GetOpenActionText()
	{
		return L("Öffnen", "Open");
	}

	internal static string LocalizeUiText(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return text ?? "";
		}
		if (TryGetJsonExactTranslation(text, out var translated))
		{
			return translated;
		}
		if (!UseEnglishUi)
		{
			return text;
		}
		if (s_englishUiText.TryGetValue(text, out translated))
		{
			return translated;
		}
		if (text.StartsWith("<b>", StringComparison.Ordinal) && text.EndsWith("</b>", StringComparison.Ordinal) && text.Length >= 7)
		{
			return "<b>" + LocalizeUiText(text.Substring(3, text.Length - 7)) + "</b>";
		}
		if (text.StartsWith("• ", StringComparison.Ordinal))
		{
			return "• " + LocalizeUiText(text.Substring(2));
		}
		if (text.StartsWith("← Zurück zu ", StringComparison.Ordinal))
		{
			return "← Back to " + text.Substring("← Zurück zu ".Length);
		}
		if (text.StartsWith("Gültige Items für ", StringComparison.Ordinal))
		{
			return "Valid items for " + text.Substring("Gültige Items für ".Length);
		}
		if (text.StartsWith("Kategorie: ", StringComparison.Ordinal))
		{
			return "Category: " + LocalizeUiText(text.Substring("Kategorie: ".Length));
		}
		if (text.StartsWith("[Verzauberung] ", StringComparison.Ordinal))
		{
			return "[Enchantment] " + text.Substring("[Verzauberung] ".Length);
		}
		if (text.StartsWith("[Kochrezepte] ", StringComparison.Ordinal))
		{
			return "[Cooking] " + text.Substring("[Kochrezepte] ".Length);
		}
		if (text.StartsWith("[Alchemie] ", StringComparison.Ordinal))
		{
			return "[Alchemy] " + text.Substring("[Alchemie] ".Length);
		}
		if (text.StartsWith("[Handwerk] ", StringComparison.Ordinal))
		{
			return "[Crafting] " + text.Substring("[Handwerk] ".Length);
		}
		if (text.StartsWith("Verzauberung ", StringComparison.Ordinal))
		{
			return "Enchantment " + text.Substring("Verzauberung ".Length);
		}
		if (text.StartsWith("Gewährt: ", StringComparison.Ordinal))
		{
			return "Grants: " + LocalizeEnglishUnits(text.Substring("Gewährt: ".Length));
		}
		if (text.StartsWith("Aufbau von „", StringComparison.Ordinal))
		{
			return "Buildup of “" + text.Substring("Aufbau von „".Length).Replace("“", "”");
		}
		if (text.StartsWith("Entfernt: ", StringComparison.Ordinal))
		{
			return "Removes: " + text.Substring("Entfernt: ".Length);
		}
		if (text.StartsWith("Entfernt Statuseffekte mit „", StringComparison.Ordinal))
		{
			return text.Replace("Entfernt Statuseffekte mit „", "Removes status effects containing “").Replace("“ im Namen", "” in their name");
		}
		if (text.StartsWith("Entfernt Statuseffekte vom Typ: ", StringComparison.Ordinal))
		{
			return "Removes status effects of type: " + text.Substring("Entfernt Statuseffekte vom Typ: ".Length);
		}
		if (text.StartsWith("Verzauberungsort: ", StringComparison.Ordinal))
		{
			return "Enchanting Location: " + LocalizeUiText(text.Substring("Verzauberungsort: ".Length));
		}
		if (text.StartsWith("Ausbau: ", StringComparison.Ordinal))
		{
			return "Upgrade: " + LocalizeUiText(text.Substring("Ausbau: ".Length));
		}
		if (text.EndsWith(" Treffer gefunden.", StringComparison.Ordinal))
		{
			return text.Substring(0, text.Length - " Treffer gefunden.".Length) + " results found.";
		}
		if (text.StartsWith("Es werden maximal ", StringComparison.Ordinal) && text.EndsWith(" Treffer angezeigt.", StringComparison.Ordinal))
		{
			string text2 = text.Substring("Es werden maximal ".Length, text.Length - "Es werden maximal ".Length - " Treffer angezeigt.".Length);
			return "A maximum of " + text2 + " results is shown.";
		}
		int num = text.IndexOf(':');
		if (num > 0)
		{
			string text3 = text.Substring(0, num);
			string text4 = TranslateDynamicLabel(text3);
			if (!string.Equals(text3, text4, StringComparison.Ordinal))
			{
				string text5 = text.Substring(num + 1);
				string text6 = (text5.StartsWith(" ", StringComparison.Ordinal) ? " " : "");
				string text7 = text5.TrimStart(Array.Empty<char>());
				return text4 + ":" + text6 + LocalizeUiText(text7);
			}
		}
		return LocalizeEnglishUnits(ApplyEnglishPhraseReplacements(text));
	}

	private static string TranslateDynamicLabel(string label)
	{
		if (string.IsNullOrEmpty(label))
		{
			return label ?? "";
		}
		if (TryGetJsonExactTranslation(label, out var translated))
		{
			return translated;
		}
		if (s_englishUiText.TryGetValue(label, out translated))
		{
			return translated;
		}
		if (string.Equals(label, "Kapazität", StringComparison.Ordinal))
		{
			return "Capacity";
		}
		if (label.EndsWith("-Resistenz", StringComparison.Ordinal))
		{
			string text = label.Substring(0, label.Length - "-Resistenz".Length);
			return LocalizeUiText(text) + " Resistance";
		}
		if (label.EndsWith("-Schadensmodifikator", StringComparison.Ordinal))
		{
			string text2 = label.Substring(0, label.Length - "-Schadensmodifikator".Length);
			return LocalizeUiText(text2) + " Damage Modifier";
		}
		if (label.EndsWith("-Bonusschaden", StringComparison.Ordinal))
		{
			string text3 = label.Substring(0, label.Length - "-Bonusschaden".Length);
			return LocalizeUiText(text3) + " Bonus Damage";
		}
		if (label.StartsWith("Aufbau von „", StringComparison.Ordinal))
		{
			return "Buildup of “" + label.Substring("Aufbau von „".Length);
		}
		return label;
	}

	private static bool TryGetJsonExactTranslation(string text, out string translated)
	{
		translated = null;
		WikiBookPlugin instance = Instance;
		WikiLocalizationData wikiLocalizationData = (((Object)(object)instance == (Object)null) ? null : instance.m_localizationData);
		if (wikiLocalizationData == null || wikiLocalizationData.exact == null || string.IsNullOrEmpty(text))
		{
			return false;
		}
		if (!wikiLocalizationData.exact.TryGetValue(text, out var value) || value == null)
		{
			return false;
		}
		translated = (UseEnglishUi ? value.en : value.de);
		if (string.IsNullOrWhiteSpace(translated))
		{
			translated = (UseEnglishUi ? value.de : value.en);
		}
		return !string.IsNullOrWhiteSpace(translated);
	}

	private static string LocalizeDataKey(string key, string germanFallback, string englishFallback)
	{
		WikiBookPlugin instance = Instance;
		WikiLocalizationData wikiLocalizationData = (((Object)(object)instance == (Object)null) ? null : instance.m_localizationData);
		if (wikiLocalizationData != null && wikiLocalizationData.sourceTypeKeys != null && !string.IsNullOrWhiteSpace(key) && wikiLocalizationData.sourceTypeKeys.TryGetValue(key, out var value) && value != null)
		{
			string text = (UseEnglishUi ? value.en : value.de);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = (UseEnglishUi ? value.de : value.en);
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
		}
		return L(germanFallback, englishFallback);
	}

	private static string ApplyJsonReplacementRules(string text, IEnumerable<WikiReplacementRule> rules)
	{
		if (string.IsNullOrEmpty(text) || rules == null)
		{
			return text ?? "";
		}
		List<WikiReplacementRule> list = (from rule in rules
			where rule != null && !string.IsNullOrEmpty(rule.de)
			orderby rule.de.Length descending
			select rule).ToList();
		if (list.Count == 0)
		{
			return text;
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length + 32);
		int num = 0;
		while (num < text.Length)
		{
			WikiReplacementRule wikiReplacementRule = null;
			foreach (WikiReplacementRule item in list)
			{
				if (num + item.de.Length > text.Length || string.CompareOrdinal(text, num, item.de, 0, item.de.Length) != 0)
				{
					continue;
				}
				wikiReplacementRule = item;
				break;
			}
			if (wikiReplacementRule == null)
			{
				stringBuilder.Append(text[num]);
				num++;
			}
			else
			{
				string text2 = (UseEnglishUi ? wikiReplacementRule.en : wikiReplacementRule.de);
				stringBuilder.Append(text2 ?? "");
				num += wikiReplacementRule.de.Length;
			}
		}
		return stringBuilder.ToString();
	}

	private static string ApplyEnglishPhraseReplacements(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return text ?? "";
		}
		WikiBookPlugin instance = Instance;
		return ApplyJsonReplacementRules(text, (((Object)(object)instance == (Object)null) ? null : instance.m_localizationData)?.phraseReplacements);
	}

	private static string LocalizeEnglishUnits(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return text ?? "";
		}
		WikiBookPlugin instance = Instance;
		text = ApplyJsonReplacementRules(text, (((Object)(object)instance == (Object)null) ? null : instance.m_localizationData)?.unitReplacements);
		return ApplyEnglishPhraseReplacements(text);
	}

	internal bool ShouldBlockInventoryHide(InventoryMenu menu)
	{
		if (!m_wikiOpen || !IsSearchFieldFocused)
		{
			return false;
		}
		return (Object)(object)m_inventoryMenu == (Object)null || (Object)(object)menu == (Object)(object)m_inventoryMenu;
	}

	internal bool ShouldHandleCharacterUICancel(CharacterUI characterUI)
	{
		if (!m_wikiOpen)
		{
			return false;
		}
		return (Object)(object)m_characterUI == (Object)null || (Object)(object)characterUI == (Object)(object)m_characterUI;
	}

	internal bool ShouldBlockCharacterUIInput(CharacterUI characterUI)
	{
		if (!m_wikiOpen)
		{
			return false;
		}
		if (!IsSearchFieldFocused)
		{
			return false;
		}
		return (Object)(object)m_characterUI == (Object)null || (Object)(object)characterUI == (Object)(object)m_characterUI;
	}

	private void Awake()
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"WikiBook 1.21.11 wird geladen...");
		new Harmony("serious.outward.wikibook").PatchAll();
		LoadWikiBackground();
		LoadWikiData();
		LoadFavorites();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"WikiBook 1.21.11 wurde geladen.");
	}

	private void Update()
	{
		if (!m_wikiOpen)
		{
			return;
		}
		SyncSearchFieldWithCharacterUI();
		EventSystem current = EventSystem.current;
		if ((Object)(object)current == (Object)null || (Object)(object)current.currentSelectedGameObject == (Object)null)
		{
			return;
		}
		GameObject currentSelectedGameObject = current.currentSelectedGameObject;
		if (!((Object)(object)currentSelectedGameObject == (Object)(object)m_lastSelectedWikiObject))
		{
			m_lastSelectedWikiObject = currentSelectedGameObject;
			if ((Object)(object)m_entryListContent != (Object)null && currentSelectedGameObject.transform.IsChildOf((Transform)(object)m_entryListContent))
			{
				EnsureListElementVisible(currentSelectedGameObject.GetComponent<RectTransform>());
			}
			if ((Object)(object)m_articleContent != (Object)null && currentSelectedGameObject.transform.IsChildOf((Transform)(object)m_articleContent))
			{
				EnsureArticleElementVisible(currentSelectedGameObject.GetComponent<RectTransform>());
			}
		}
	}

	private void SyncSearchFieldWithCharacterUI()
	{
		if (m_wikiOpen && !((Object)(object)m_searchField == (Object)null) && m_searchField.isFocused && !((Object)(object)m_characterUI == (Object)null))
		{
			GameObject gameObject = ((Component)m_searchField).gameObject;
			if ((Object)(object)m_characterUI.CurrentSelectedGameObject != (Object)(object)gameObject || (Object)(object)m_characterUI.EventSystemCurrentSelectedGo != (Object)(object)gameObject)
			{
				m_characterUI.SetSelectedGameObject(gameObject);
			}
		}
	}

	private void LoadWikiBackground()
	{
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Expected O, but got Unknown
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (string.IsNullOrEmpty(directoryName))
			{
				return;
			}
			string text = Path.Combine(directoryName, "WikiBG.png");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Suche Wiki-Hintergrund: " + text));
			if (!File.Exists(text))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"WikiBG.png wurde nicht gefunden.");
				return;
			}
			byte[] array = File.ReadAllBytes(text);
			if (array != null && array.Length != 0)
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)5, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					Object.Destroy((Object)(object)val);
					((BaseUnityPlugin)this).Logger.LogWarning((object)"WikiBG.png konnte nicht geladen werden.");
					return;
				}
				((Object)val).name = "SeriousWikiBackgroundTexture";
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				m_wikiBackgroundTexture = val;
				m_wikiBackgroundSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)m_wikiBackgroundSprite).name = "SeriousWikiBackgroundSprite";
				((BaseUnityPlugin)this).Logger.LogInfo((object)("WikiBG.png erfolgreich geladen: " + ((Texture)val).width + "x" + ((Texture)val).height));
			}
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Laden von WikiBG.png:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	internal void OpenWiki()
	{
		if (m_wikiOpen)
		{
			return;
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Versuche eigenständiges Wiki zu öffnen...");
		if (m_items.Count == 0 && m_cookingRecipes.Count == 0 && m_alchemyRecipes.Count == 0 && m_craftingRecipes.Count == 0 && m_enchantments.Count == 0)
		{
			LoadWikiData();
		}
		BuildGameDataCache();
		m_inventoryMenu = Object.FindObjectOfType<InventoryMenu>();
		if ((Object)(object)m_inventoryMenu == (Object)null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Kein InventoryMenu gefunden.");
			return;
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("InventoryMenu gefunden: " + ((Object)((Component)m_inventoryMenu).gameObject).name));
		m_characterUI = ((Component)m_inventoryMenu).GetComponentInParent<CharacterUI>();
		if ((Object)(object)m_characterUI == (Object)null)
		{
			m_characterUI = Object.FindObjectOfType<CharacterUI>();
		}
		if ((Object)(object)m_characterUI != (Object)null)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("CharacterUI gefunden. RewiredID=" + m_characterUI.RewiredID));
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Kein CharacterUI gefunden. Die native InputField-Sperre kann dann nicht greifen.");
		}
		ExtractOutwardStyles();
		Canvas componentInParent = ((Component)m_inventoryMenu).GetComponentInParent<Canvas>();
		if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent.rootCanvas == (Object)null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Kein Root-Canvas gefunden.");
			return;
		}
		BuildWikiWindow(((Component)componentInParent.rootCanvas).transform);
		if (!((Object)(object)m_wikiWindow == (Object)null))
		{
			m_inventoryCanvasGroup = ((Component)m_inventoryMenu).GetComponent<CanvasGroup>();
			if ((Object)(object)m_inventoryCanvasGroup != (Object)null)
			{
				m_originalInventoryAlpha = m_inventoryCanvasGroup.alpha;
				m_originalInventoryInteractable = m_inventoryCanvasGroup.interactable;
				m_originalInventoryBlocksRaycasts = m_inventoryCanvasGroup.blocksRaycasts;
				m_inventoryCanvasGroup.alpha = 0f;
				m_inventoryCanvasGroup.interactable = false;
				m_inventoryCanvasGroup.blocksRaycasts = false;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Inventar wurde für das Wiki unsichtbar gemacht.");
			}
			m_wikiWindow.SetActive(true);
			m_wikiWindow.transform.SetAsLastSibling();
			m_wikiOpen = true;
			m_lastSelectedWikiObject = null;
			ShowCategoryOverview();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Wiki wurde geöffnet.");
		}
	}

	private void BuildGameDataCache()
	{
		if (!m_gameDataCacheBuilt)
		{
			m_allGameItemPrefabs.Clear();
			m_allGameRecipes.Clear();
			m_allGameEnchantmentRecipes.Clear();
			m_allGameEnchantments.Clear();
			m_gameRecipesByResultItemId.Clear();
			m_recipesByResultItemId.Clear();
			m_recipesUsingItemId.Clear();
			m_decraftRecipesUsingItemId.Clear();
			m_enchantmentRecipesByRecipeId.Clear();
			m_enchantmentRecipesByResultId.Clear();
			m_enchantmentsByPresetId.Clear();
			m_compatibleEnchantmentsByItemId.Clear();
			m_compatibleItemsByEnchantmentResultId.Clear();
			m_legacyUpgradesBySourceItemId.Clear();
			m_legacyUpgradesByResultItemId.Clear();
			bool flag = TryLoadItemPrefabsFromPrivateDictionary();
			bool flag2 = TryLoadRecipesFromPrivateDictionary();
			bool flag3 = TryLoadEnchantmentRecipesFromRecipeManager();
			bool flag4 = TryLoadEnchantmentPrefabsFromPrivateDictionary();
			if (!flag || !flag2)
			{
				TryLoadGameDataFromAssetBundles(!flag, !flag2);
			}
			TryLoadEnchantmentDataFromAssetBundles(!flag4, !flag3);
			ResolveLegacyUpgradeRuntimeData();
			BuildGameRecipeLookups();
			BuildRecipeRelationshipLookups();
			BuildEnchantmentLookups();
			BindWikiEnchantmentsToRuntime();
			BuildEnchantmentCompatibilityLookups();
			m_gameDataCacheBuilt = true;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Outward-Spieldaten gecacht.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Echte Item-Prefabs: " + m_allGameItemPrefabs.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Echte Rezepte: " + m_allGameRecipes.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Echte Verzauberungsrezepte: " + m_allGameEnchantmentRecipes.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Echte Verzauberungen: " + m_allGameEnchantments.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Item->Herstellung Beziehungen: " + m_recipesByResultItemId.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Item->Verwendet-in Beziehungen: " + m_recipesUsingItemId.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Item->Verzauberungen Beziehungen: " + m_compatibleEnchantmentsByItemId.Count));
		}
	}

	private void ResolveLegacyUpgradeRuntimeData()
	{
		m_legacyUpgradesBySourceItemId.Clear();
		m_legacyUpgradesByResultItemId.Clear();
		if (m_legacyUpgradeFile == null || m_legacyUpgradeFile.upgrades == null)
		{
			return;
		}
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		foreach (WikiLegacyUpgradeData upgrade in m_legacyUpgradeFile.upgrades)
		{
			if (upgrade == null)
			{
				continue;
			}
			bool flag = upgrade.resolveMissingIdsFromRuntimeName || (m_legacyUpgradeFile.indexPolicy != null && (m_legacyUpgradeFile.indexPolicy.resolveZeroIdsFromRuntimeItemNames || m_legacyUpgradeFile.indexPolicy.resolveFromAliases));
			int sourceItemId = upgrade.sourceItemId;
			int resultItemId = upgrade.resultItemId;
			if (flag)
			{
				upgrade.sourceItemId = ResolveLegacyRuntimeItemId(upgrade, source: true);
				upgrade.resultItemId = ResolveLegacyRuntimeItemId(upgrade, source: false);
			}
			if ((sourceItemId <= 0 && upgrade.sourceItemId > 0) || (resultItemId <= 0 && upgrade.resultItemId > 0))
			{
				num4++;
			}
			bool flag2 = upgrade.includeSourceInItemIndex || upgrade.includeSourceInGlobalSearch || (m_legacyUpgradeFile.indexPolicy != null && (m_legacyUpgradeFile.indexPolicy.includeAllSourceItemsInItems || m_legacyUpgradeFile.indexPolicy.includeAllSourceItemsInGlobalSearch));
			bool flag3 = upgrade.includeResultInItemIndex || upgrade.includeResultInGlobalSearch || (m_legacyUpgradeFile.indexPolicy != null && (m_legacyUpgradeFile.indexPolicy.includeAllResultItemsInItems || m_legacyUpgradeFile.indexPolicy.includeAllResultItemsInGlobalSearch));
			if (upgrade.sourceItemId > 0)
			{
				num++;
				if (flag2)
				{
					EnsureWikiItemEntry(upgrade.sourceItemId, GetLegacyPreferredName(upgrade, source: true), "ADDED FROM LEGACY UPGRADES");
				}
				AddToLookup(m_legacyUpgradesBySourceItemId, upgrade.sourceItemId, upgrade);
			}
			if (upgrade.resultItemId > 0)
			{
				num2++;
				WikiItemData wikiItemData = (flag3 ? EnsureWikiItemEntry(upgrade.resultItemId, GetLegacyPreferredName(upgrade, source: false), "ADDED FROM LEGACY UPGRADES") : GetItemByGameId(upgrade.resultItemId));
				if (wikiItemData != null && string.IsNullOrWhiteSpace(wikiItemData.sourceTypeKey))
				{
					wikiItemData.sourceTypeKey = ((!string.IsNullOrWhiteSpace(upgrade.sourceTypeKey)) ? upgrade.sourceTypeKey : m_legacyUpgradeFile.sourceTypeKey);
				}
				AddToLookup(m_legacyUpgradesByResultItemId, upgrade.resultItemId, upgrade);
			}
			if (upgrade.sourceItemId <= 0 || upgrade.resultItemId <= 0)
			{
				num3++;
			}
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("Legacy-Upgrades aufgelöst: Quellen=" + num + ", Ergebnisse=" + num2 + ", per Alias ergänzt=" + num4 + ", unvollständig=" + num3));
		if (m_legacyUpgradeFile.validation != null && m_legacyUpgradeFile.validation.expectedUpgradeCount > 0 && m_legacyUpgradeFile.validation.expectedUpgradeCount != m_legacyUpgradeFile.upgrades.Count)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Legacy-Upgrades: Erwartet=" + m_legacyUpgradeFile.validation.expectedUpgradeCount + ", geladen=" + m_legacyUpgradeFile.upgrades.Count));
		}
	}

	private int ResolveLegacyRuntimeItemId(WikiLegacyUpgradeData upgrade, bool source)
	{
		if (upgrade == null)
		{
			return 0;
		}
		int num = (source ? upgrade.sourceItemId : upgrade.resultItemId);
		List<string> requestedNames = GetLegacyLookupNames(upgrade, source).ToList();
		Item cachedGameItemPrefab = GetCachedGameItemPrefab(num);
		bool flag = string.Equals(upgrade.idStatus, "verified", StringComparison.OrdinalIgnoreCase) || (m_legacyUpgradeFile != null && m_legacyUpgradeFile.indexPolicy != null && m_legacyUpgradeFile.indexPolicy.preferVerifiedItemIds);
		if ((Object)(object)cachedGameItemPrefab != (Object)null)
		{
			if (flag || LegacyRuntimeItemMatchesNames(cachedGameItemPrefab, requestedNames))
			{
				return num;
			}
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Legacy-ID passt nicht zum Namen und wird neu aufgelöst: " + num + " | " + GetLegacyPreferredName(upgrade, source)));
		}
		string context = (source ? ("Quelle: " + GetLegacyPreferredName(upgrade, source: true)) : ("Ergebnis: " + GetLegacyPreferredName(upgrade, source: false)));
		return ResolveRuntimeItemIdByNames(requestedNames, context);
	}

	private IEnumerable<string> GetLegacyLookupNames(WikiLegacyUpgradeData upgrade, bool source)
	{
		if (upgrade == null)
		{
			yield break;
		}
		string fallbackName = (source ? upgrade.sourceFallbackName : upgrade.resultFallbackName);
		string wikiName = (source ? upgrade.sourceWikiName : upgrade.resultWikiName);
		List<string> aliases = (source ? upgrade.sourceAliases : upgrade.resultAliases);
		if (!string.IsNullOrWhiteSpace(fallbackName))
		{
			yield return fallbackName;
		}
		if (!string.IsNullOrWhiteSpace(wikiName))
		{
			yield return wikiName;
		}
		if (aliases == null)
		{
			yield break;
		}
		foreach (string alias in aliases)
		{
			if (!string.IsNullOrWhiteSpace(alias))
			{
				yield return alias;
			}
		}
	}

	private string GetLegacyPreferredName(WikiLegacyUpgradeData upgrade, bool source)
	{
		if (upgrade == null)
		{
			return "";
		}
		string text = (source ? upgrade.sourceFallbackName : upgrade.resultFallbackName);
		if (!string.IsNullOrWhiteSpace(text))
		{
			return text;
		}
		string text2 = (source ? upgrade.sourceWikiName : upgrade.resultWikiName);
		if (!string.IsNullOrWhiteSpace(text2))
		{
			return text2;
		}
		List<string> list = (source ? upgrade.sourceAliases : upgrade.resultAliases);
		if (list != null)
		{
			string text3 = list.FirstOrDefault((string x) => !string.IsNullOrWhiteSpace(x));
			if (!string.IsNullOrWhiteSpace(text3))
			{
				return text3;
			}
		}
		return "";
	}

	private bool LegacyRuntimeItemMatchesNames(Item item, IEnumerable<string> requestedNames)
	{
		if ((Object)(object)item == (Object)null || requestedNames == null)
		{
			return false;
		}
		HashSet<string> hashSet = new HashSet<string>(from x in requestedNames.Where((string x) => !string.IsNullOrWhiteSpace(x)).Select(NormalizeLegacyItemName)
			where !string.IsNullOrWhiteSpace(x)
			select x, StringComparer.Ordinal);
		if (hashSet.Count == 0)
		{
			return true;
		}
		foreach (string runtimeItemNameAlias in GetRuntimeItemNameAliases(item))
		{
			string text = NormalizeLegacyItemName(runtimeItemNameAlias);
			if (hashSet.Contains(text))
			{
				return true;
			}
			foreach (string item2 in hashSet)
			{
				if (text.EndsWith(item2, StringComparison.Ordinal))
				{
					return true;
				}
			}
		}
		return false;
	}

	private int ResolveRuntimeItemIdByNames(IEnumerable<string> requestedNames, string context)
	{
		if (requestedNames == null)
		{
			return 0;
		}
		List<string> list = (from x in requestedNames.Where((string x) => !string.IsNullOrWhiteSpace(x)).Select(NormalizeLegacyItemName)
			where !string.IsNullOrWhiteSpace(x)
			select x).Distinct<string>(StringComparer.Ordinal).ToList();
		if (list.Count == 0)
		{
			return 0;
		}
		int num = 0;
		List<Item> list2 = new List<Item>();
		foreach (Item allGameItemPrefab in m_allGameItemPrefabs)
		{
			if (!IsPlayerFacingWikiItem(allGameItemPrefab))
			{
				continue;
			}
			int num2 = 0;
			foreach (string runtimeItemNameAlias in GetRuntimeItemNameAliases(allGameItemPrefab))
			{
				string text = NormalizeLegacyItemName(runtimeItemNameAlias);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				foreach (string item in list)
				{
					if (text == item)
					{
						num2 = Math.Max(num2, 1000);
					}
					else if (text.EndsWith(item, StringComparison.Ordinal) || item.EndsWith(text, StringComparison.Ordinal))
					{
						num2 = Math.Max(num2, 950);
					}
					else if (item.Length >= 7 && text.Length >= 7 && (text.Contains(item) || item.Contains(text)))
					{
						num2 = Math.Max(num2, 700);
					}
				}
			}
			if (num2 > 0)
			{
				if (num2 > num)
				{
					num = num2;
					list2.Clear();
					list2.Add(allGameItemPrefab);
				}
				else if (num2 == num)
				{
					list2.Add(allGameItemPrefab);
				}
			}
		}
		List<Item> list3 = (from item in list2
			where (Object)(object)item != (Object)null
			group item by item.ItemID into @group
			select @group.First()).ToList();
		if (num >= 700 && list3.Count == 1)
		{
			return list3[0].ItemID;
		}
		if (list3.Count > 1)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Legacy-Itemname ist mehrdeutig: " + context + " | Treffer=" + list3.Count + " | Namen=" + string.Join(", ", requestedNames.ToArray())));
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Legacy-Item nicht aufgelöst: " + context + " | Namen=" + string.Join(", ", requestedNames.ToArray())));
		}
		return 0;
	}

	private int ResolveRuntimeItemIdByName(string requestedName)
	{
		return ResolveRuntimeItemIdByNames(new string[1] { requestedName }, requestedName);
	}

	private string NormalizeLegacyItemName(string value)
	{
		string text = NormalizeLookupText(value);
		if (string.IsNullOrWhiteSpace(text))
		{
			return "";
		}
		int i;
		for (i = 0; i < text.Length && char.IsDigit(text[i]); i++)
		{
		}
		if (i > 0 && i < text.Length)
		{
			text = text.Substring(i);
		}
		return text.Replace("sabre", "saber").Replace("helmet", "helm");
	}

	private Item GetCachedGameItemPrefab(int gameItemId)
	{
		if (gameItemId <= 0)
		{
			return null;
		}
		return ((IEnumerable<Item>)m_allGameItemPrefabs).FirstOrDefault((Func<Item, bool>)((Item item) => (Object)(object)item != (Object)null && item.ItemID == gameItemId));
	}

	private IEnumerable<string> GetRuntimeItemNameAliases(Item item)
	{
		if (!((Object)(object)item == (Object)null))
		{
			string displayName = GetGameItemDisplayName(item);
			if (!string.IsNullOrWhiteSpace(displayName))
			{
				yield return displayName;
			}
			if (!string.IsNullOrWhiteSpace(((Object)item).name))
			{
				yield return ((Object)item).name;
			}
			string reflectedName = GetStringMember(item, "Name", "EDITOR_Name", "EditorName", "ItemName", "PrefabName", "LocalizationKey", "LocalizationID");
			if (!string.IsNullOrWhiteSpace(reflectedName))
			{
				yield return reflectedName;
			}
		}
	}

	private bool TryLoadItemPrefabsFromPrivateDictionary()
	{
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(ResourcesPrefabManager), "ITEM_PREFABS");
			if (fieldInfo == null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"ITEM_PREFABS-Feld wurde nicht gefunden.");
				return false;
			}
			if (!(fieldInfo.GetValue(null) is IDictionary dictionary))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"ITEM_PREFABS konnte nicht als IDictionary gelesen werden.");
				return false;
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Item val = (Item)((value is Item) ? value : null);
				if (!((Object)(object)val == (Object)null) && val.ItemID > 0 && hashSet.Add(val.ItemID))
				{
					m_allGameItemPrefabs.Add(val);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("ITEM_PREFABS per Reflection gelesen: " + m_allGameItemPrefabs.Count));
			return m_allGameItemPrefabs.Count > 0;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Lesen von ITEM_PREFABS:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return false;
		}
	}

	private bool TryLoadRecipesFromPrivateDictionary()
	{
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(RecipeManager), "m_recipes");
			if (fieldInfo == null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"RecipeManager.m_recipes wurde nicht gefunden.");
				return false;
			}
			if (!(fieldInfo.GetValue(RecipeManager.Instance) is IDictionary dictionary))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"RecipeManager.m_recipes konnte nicht als IDictionary gelesen werden.");
				return false;
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Recipe val = (Recipe)((value is Recipe) ? value : null);
				if (!((Object)(object)val == (Object)null) && (val.RecipeID == 0 || hashSet.Add(val.RecipeID)))
				{
					m_allGameRecipes.Add(val);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("RecipeManager.m_recipes per Reflection gelesen: " + m_allGameRecipes.Count));
			return m_allGameRecipes.Count > 0;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Lesen von RecipeManager.m_recipes:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return false;
		}
	}

	private void TryLoadGameDataFromAssetBundles(bool loadItems, bool loadRecipes)
	{
		try
		{
			HashSet<int> hashSet = new HashSet<int>(m_allGameItemPrefabs.Select((Item x) => x.ItemID));
			HashSet<int> hashSet2 = new HashSet<int>(from x in m_allGameRecipes
				where (Object)(object)x != (Object)null
				select x.RecipeID);
			DictionaryExt<string, List<Object>> objectAssetsPerBundle = ResourcesPrefabManager.ObjectAssetsPerBundle;
			if (objectAssetsPerBundle == null)
			{
				return;
			}
			foreach (string key in objectAssetsPerBundle.Keys)
			{
				List<Object> list = objectAssetsPerBundle[key];
				if (list == null)
				{
					continue;
				}
				foreach (Object item in list)
				{
					if (item == (Object)null)
					{
						continue;
					}
					if (loadItems)
					{
						GameObject val = (GameObject)(object)((item is GameObject) ? item : null);
						if ((Object)(object)val != (Object)null)
						{
							Item component = val.GetComponent<Item>();
							if ((Object)(object)component != (Object)null && component.ItemID > 0 && hashSet.Add(component.ItemID))
							{
								m_allGameItemPrefabs.Add(component);
							}
						}
					}
					if (loadRecipes)
					{
						Recipe val2 = (Recipe)(object)((item is Recipe) ? item : null);
						if ((Object)(object)val2 != (Object)null && (val2.RecipeID == 0 || hashSet2.Add(val2.RecipeID)))
						{
							m_allGameRecipes.Add(val2);
						}
					}
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Fallback-Asset-Suche abgeschlossen.");
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fallback-Asset-Suche fehlgeschlagen:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	private bool TryLoadEnchantmentRecipesFromRecipeManager()
	{
		try
		{
			RecipeManager instance = RecipeManager.Instance;
			if (instance == null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"RecipeManager.Instance ist null. EnchantmentRecipe-Fallback wird benutzt.");
				return false;
			}
			MethodInfo method = typeof(RecipeManager).GetMethod("GetEnchantmentRecipes", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method == null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"RecipeManager.GetEnchantmentRecipes() wurde nicht gefunden. AssetBundle-Fallback wird benutzt.");
				return false;
			}
			object obj = method.Invoke(instance, null);
			if (!(obj is IEnumerable enumerable))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"GetEnchantmentRecipes() lieferte keine auflistbare Sammlung.");
				return false;
			}
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (object item2 in enumerable)
			{
				EnchantmentRecipe val = (EnchantmentRecipe)((item2 is EnchantmentRecipe) ? item2 : null);
				if ((Object)(object)val == (Object)null && item2 is DictionaryEntry)
				{
					object? value = ((DictionaryEntry)item2).Value;
					val = (EnchantmentRecipe)((value is EnchantmentRecipe) ? value : null);
				}
				if ((Object)(object)val == (Object)null && item2 != null)
				{
					try
					{
						PropertyInfo property = item2.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property != null)
						{
							object? value2 = property.GetValue(item2, null);
							val = (EnchantmentRecipe)((value2 is EnchantmentRecipe) ? value2 : null);
						}
					}
					catch
					{
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (val.RecipeID < 0)
					{
						val.InitID();
					}
				}
				catch
				{
				}
				int recipeID = val.RecipeID;
				string item = ((Object)val).name ?? "";
				if ((recipeID > 0 && hashSet.Add(recipeID)) || (recipeID <= 0 && hashSet2.Add(item)))
				{
					m_allGameEnchantmentRecipes.Add(val);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("EnchantmentRecipes aus RecipeManager geladen: " + m_allGameEnchantmentRecipes.Count));
			return m_allGameEnchantmentRecipes.Count > 0;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Laden der EnchantmentRecipes aus RecipeManager:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return false;
		}
	}

	private bool TryLoadEnchantmentPrefabsFromPrivateDictionary()
	{
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(ResourcesPrefabManager), "ENCHANTMENT_PREFABS");
			if (fieldInfo == null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"ENCHANTMENT_PREFABS-Feld wurde nicht gefunden. AssetBundle-Fallback wird benutzt.");
				return false;
			}
			if (!(fieldInfo.GetValue(null) is IDictionary dictionary))
			{
				return false;
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (DictionaryEntry item in dictionary)
			{
				object? value = item.Value;
				Enchantment val = (Enchantment)((value is Enchantment) ? value : null);
				if ((Object)(object)val == (Object)null)
				{
					object? value2 = item.Value;
					GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val = val2.GetComponent<Enchantment>();
					}
				}
				if (!((Object)(object)val == (Object)null))
				{
					int intMember = GetIntMember(val, "PresetID");
					if (intMember > 0 && hashSet.Add(intMember))
					{
						m_allGameEnchantments.Add(val);
					}
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("ENCHANTMENT_PREFABS per Reflection gelesen: " + m_allGameEnchantments.Count));
			return m_allGameEnchantments.Count > 0;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("ENCHANTMENT_PREFABS konnten nicht gelesen werden: " + ex.Message));
			return false;
		}
	}

	private void TryLoadEnchantmentDataFromAssetBundles(bool loadEnchantments, bool loadRecipes)
	{
		try
		{
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<int> hashSet3 = new HashSet<int>(from x in m_allGameEnchantments
				select GetIntMember(x, "PresetID") into x
				where x > 0
				select x);
			DictionaryExt<string, List<Object>> objectAssetsPerBundle = ResourcesPrefabManager.ObjectAssetsPerBundle;
			if (objectAssetsPerBundle == null)
			{
				return;
			}
			foreach (string key in objectAssetsPerBundle.Keys)
			{
				List<Object> list = objectAssetsPerBundle[key];
				if (list == null)
				{
					continue;
				}
				foreach (Object item2 in list)
				{
					if (item2 == (Object)null)
					{
						continue;
					}
					if (loadRecipes)
					{
						EnchantmentRecipe val = (EnchantmentRecipe)(object)((item2 is EnchantmentRecipe) ? item2 : null);
						if ((Object)(object)val != (Object)null)
						{
							try
							{
								if (val.RecipeID < 0)
								{
									val.InitID();
								}
							}
							catch
							{
							}
							int recipeID = val.RecipeID;
							string item = ((Object)val).name ?? "";
							if ((recipeID > 0 && hashSet.Add(recipeID)) || (recipeID <= 0 && hashSet2.Add(item)))
							{
								m_allGameEnchantmentRecipes.Add(val);
							}
						}
					}
					if (!loadEnchantments)
					{
						continue;
					}
					GameObject val2 = (GameObject)(object)((item2 is GameObject) ? item2 : null);
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					Enchantment component = val2.GetComponent<Enchantment>();
					if (!((Object)(object)component == (Object)null))
					{
						int intMember = GetIntMember(component, "PresetID");
						if (intMember > 0 && hashSet3.Add(intMember))
						{
							m_allGameEnchantments.Add(component);
						}
					}
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Enchantment-Asset-Suche abgeschlossen.");
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Enchantment-Asset-Suche fehlgeschlagen:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	private void BuildGameRecipeLookups()
	{
		m_gameRecipesByResultItemId.Clear();
		foreach (Recipe allGameRecipe in m_allGameRecipes)
		{
			if ((Object)(object)allGameRecipe == (Object)null || allGameRecipe.Results == null)
			{
				continue;
			}
			ItemReferenceQuantity[] results = allGameRecipe.Results;
			foreach (ItemReferenceQuantity val in results)
			{
				if (val.ItemID > 0)
				{
					AddToLookup(m_gameRecipesByResultItemId, val.ItemID, allGameRecipe);
				}
			}
		}
	}

	private IEnumerable<WikiRecipeData> GetAllWikiRecipes()
	{
		foreach (WikiRecipeData cookingRecipe in m_cookingRecipes)
		{
			yield return cookingRecipe;
		}
		foreach (WikiRecipeData alchemyRecipe in m_alchemyRecipes)
		{
			yield return alchemyRecipe;
		}
		foreach (WikiRecipeData craftingRecipe in m_craftingRecipes)
		{
			yield return craftingRecipe;
		}
	}

	private WikiCategory GetWikiCategoryForRecipe(WikiRecipeData recipe)
	{
		if (recipe == null)
		{
			return WikiCategory.Crafting;
		}
		if (m_cookingRecipes.Contains(recipe))
		{
			return WikiCategory.Cooking;
		}
		if (m_alchemyRecipes.Contains(recipe))
		{
			return WikiCategory.Alchemy;
		}
		if (m_craftingRecipes.Contains(recipe))
		{
			return WikiCategory.Crafting;
		}
		string text = (recipe.category ?? "").ToLowerInvariant();
		if (text.Contains("koch") || text.Contains("cook"))
		{
			return WikiCategory.Cooking;
		}
		if (text.Contains("alchem"))
		{
			return WikiCategory.Alchemy;
		}
		return WikiCategory.Crafting;
	}

	private bool RecipeMatchesWikiCategory(Recipe gameRecipe, WikiCategory category)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)gameRecipe == (Object)null)
		{
			return false;
		}
		string text = ((object)gameRecipe.CraftingStationType/*cast due to .constrained prefix*/).ToString().ToLowerInvariant();
		return category switch
		{
			WikiCategory.Cooking => text.Contains("cook"), 
			WikiCategory.Alchemy => text.Contains("alchem"), 
			WikiCategory.Crafting => !text.Contains("cook") && !text.Contains("alchem"), 
			_ => true, 
		};
	}

	private void BuildRecipeRelationshipLookups()
	{
		m_recipesByResultItemId.Clear();
		m_recipesUsingItemId.Clear();
		m_decraftRecipesUsingItemId.Clear();
		foreach (WikiRecipeData allWikiRecipe in GetAllWikiRecipes())
		{
			if (allWikiRecipe == null)
			{
				continue;
			}
			Recipe val = FindGameRecipe(allWikiRecipe);
			bool flag = IsDecraftRecipe(allWikiRecipe, val);
			if (!flag)
			{
				bool flag2 = false;
				if (allWikiRecipe.gameResultItemId > 0)
				{
					AddToLookup(m_recipesByResultItemId, allWikiRecipe.gameResultItemId, allWikiRecipe);
					flag2 = true;
				}
				if (allWikiRecipe.results != null)
				{
					foreach (WikiItemReference result in allWikiRecipe.results)
					{
						if (result != null && result.gameItemId > 0)
						{
							AddToLookup(m_recipesByResultItemId, result.gameItemId, allWikiRecipe);
							flag2 = true;
						}
					}
				}
				if (!flag2 && (Object)(object)val != (Object)null && val.Results != null && val.Results.Length != 0 && val.Results[0].ItemID > 0)
				{
					AddToLookup(m_recipesByResultItemId, val.Results[0].ItemID, allWikiRecipe);
				}
			}
			List<WikiItemReference> effectiveRecipeIngredients = GetEffectiveRecipeIngredients(allWikiRecipe, val);
			List<RecipeIngredient> list = ResolveRuntimeIngredients(allWikiRecipe, val, effectiveRecipeIngredients);
			for (int i = 0; i < effectiveRecipeIngredients.Count; i++)
			{
				WikiItemReference wikiItemReference = effectiveRecipeIngredients[i];
				if (wikiItemReference == null)
				{
					continue;
				}
				if (wikiItemReference.gameItemId > 0)
				{
					if (flag)
					{
						AddToLookup(m_decraftRecipesUsingItemId, wikiItemReference.gameItemId, allWikiRecipe);
					}
					else
					{
						AddToLookup(m_recipesUsingItemId, wikiItemReference.gameItemId, allWikiRecipe);
					}
					continue;
				}
				RecipeIngredient val2 = ((i < list.Count) ? list[i] : null);
				if (val2 == null)
				{
					continue;
				}
				List<Item> matchingItemsForRecipeIngredient = GetMatchingItemsForRecipeIngredient(val2, allWikiRecipe, val);
				foreach (Item item in matchingItemsForRecipeIngredient)
				{
					if (!((Object)(object)item == (Object)null) && item.ItemID > 0)
					{
						if (flag)
						{
							AddToLookup(m_decraftRecipesUsingItemId, item.ItemID, allWikiRecipe);
						}
						else
						{
							AddToLookup(m_recipesUsingItemId, item.ItemID, allWikiRecipe);
						}
					}
				}
			}
		}
		SortRecipeLookup(m_recipesByResultItemId);
		SortRecipeLookup(m_recipesUsingItemId);
		SortRecipeLookup(m_decraftRecipesUsingItemId);
	}

	private bool IsDecraftRecipe(WikiRecipeData wikiRecipe, Recipe gameRecipe)
	{
		string text = string.Join(" ", (wikiRecipe == null) ? "" : wikiRecipe.wikiId, (wikiRecipe == null) ? "" : wikiRecipe.fallbackName, (wikiRecipe == null) ? "" : wikiRecipe.category, (wikiRecipe == null) ? "" : wikiRecipe.station, ((Object)(object)gameRecipe == (Object)null) ? "" : gameRecipe.EDITOR_Name, ((Object)(object)gameRecipe == (Object)null) ? "" : gameRecipe.Name).ToLowerInvariant();
		return text.Contains("decraft") || text.Contains("deconstruct") || text.Contains("dismantle") || text.Contains("salvage") || text.Contains("zerleg");
	}

	private void BuildEnchantmentLookups()
	{
		m_enchantmentRecipesByRecipeId.Clear();
		m_enchantmentRecipesByResultId.Clear();
		m_enchantmentsByPresetId.Clear();
		foreach (EnchantmentRecipe allGameEnchantmentRecipe in m_allGameEnchantmentRecipes)
		{
			if (!((Object)(object)allGameEnchantmentRecipe == (Object)null))
			{
				if (allGameEnchantmentRecipe.RecipeID > 0 && !m_enchantmentRecipesByRecipeId.ContainsKey(allGameEnchantmentRecipe.RecipeID))
				{
					m_enchantmentRecipesByRecipeId.Add(allGameEnchantmentRecipe.RecipeID, allGameEnchantmentRecipe);
				}
				if (allGameEnchantmentRecipe.ResultID > 0)
				{
					AddToLookup(m_enchantmentRecipesByResultId, allGameEnchantmentRecipe.ResultID, allGameEnchantmentRecipe);
				}
			}
		}
		foreach (Enchantment allGameEnchantment in m_allGameEnchantments)
		{
			if (!((Object)(object)allGameEnchantment == (Object)null))
			{
				int intMember = GetIntMember(allGameEnchantment, "PresetID");
				if (intMember > 0 && !m_enchantmentsByPresetId.ContainsKey(intMember))
				{
					m_enchantmentsByPresetId.Add(intMember, allGameEnchantment);
				}
			}
		}
	}

	private void BindWikiEnchantmentsToRuntime()
	{
		int num = 0;
		foreach (WikiEnchantmentData enchantment in m_enchantments)
		{
			if (enchantment != null && enchantment.gameEnchantmentId <= 0)
			{
				EnchantmentRecipe val = FindRuntimeEnchantmentRecipeByName(enchantment);
				if (!((Object)(object)val == (Object)null))
				{
					enchantment.gameRecipeId = val.RecipeID;
					enchantment.gameEnchantmentId = val.ResultID;
					num++;
				}
			}
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("Wiki-Verzauberungen an Runtime gebunden: " + num + "/" + m_enchantments.Count));
	}

	private EnchantmentRecipe FindRuntimeEnchantmentRecipeByName(WikiEnchantmentData data)
	{
		if (data == null)
		{
			return null;
		}
		List<string> list = new List<string>();
		AddNormalizedLookupTarget(list, data.fallbackName);
		AddNormalizedLookupTarget(list, data.wikiId);
		if (list.Count == 0)
		{
			return null;
		}
		EnchantmentRecipe val = null;
		int num = 0;
		foreach (EnchantmentRecipe allGameEnchantmentRecipe in m_allGameEnchantmentRecipes)
		{
			if ((Object)(object)allGameEnchantmentRecipe == (Object)null)
			{
				continue;
			}
			Enchantment gameEnchantmentByPresetId = GetGameEnchantmentByPresetId(allGameEnchantmentRecipe.ResultID);
			List<string> list2 = new List<string>();
			if ((Object)(object)gameEnchantmentByPresetId != (Object)null)
			{
				AddNormalizedLookupTarget(list2, gameEnchantmentByPresetId.Name);
				AddNormalizedLookupTarget(list2, ((Object)gameEnchantmentByPresetId).name);
			}
			AddNormalizedLookupTarget(list2, ((Object)allGameEnchantmentRecipe).name);
			int num2 = 0;
			foreach (string item in list)
			{
				foreach (string item2 in list2)
				{
					if (item2 == item)
					{
						num2 = Math.Max(num2, 100);
					}
					else if (item2.EndsWith(item, StringComparison.Ordinal) || item.EndsWith(item2, StringComparison.Ordinal))
					{
						num2 = Math.Max(num2, 90);
					}
					else if (item2.Contains(item) || item.Contains(item2))
					{
						num2 = Math.Max(num2, 70);
					}
				}
			}
			if (num2 > num)
			{
				num = num2;
				val = allGameEnchantmentRecipe;
			}
		}
		return (num >= 70) ? val : null;
	}

	private void AddNormalizedLookupTarget(List<string> targetList, string value)
	{
		string text = NormalizeLookupText(value);
		if (string.IsNullOrWhiteSpace(text))
		{
			return;
		}
		if (!targetList.Contains(text))
		{
			targetList.Add(text);
		}
		int i;
		for (i = 0; i < text.Length && char.IsDigit(text[i]); i++)
		{
		}
		if (i > 0 && i < text.Length)
		{
			string item = text.Substring(i);
			if (!targetList.Contains(item))
			{
				targetList.Add(item);
			}
		}
	}

	private string NormalizeLookupText(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "";
		}
		char[] value2 = value.ToLowerInvariant().Where(char.IsLetterOrDigit).ToArray();
		return new string(value2);
	}

	private string GetLogicalEnchantmentKey(EnchantmentRecipe recipe)
	{
		if ((Object)(object)recipe == (Object)null)
		{
			return "";
		}
		Enchantment gameEnchantmentByPresetId = GetGameEnchantmentByPresetId(recipe.ResultID);
		string value = "";
		if ((Object)(object)gameEnchantmentByPresetId != (Object)null)
		{
			try
			{
				value = gameEnchantmentByPresetId.Name;
			}
			catch
			{
			}
			if (string.IsNullOrWhiteSpace(value))
			{
				value = ((Object)gameEnchantmentByPresetId).name;
			}
		}
		if (string.IsNullOrWhiteSpace(value))
		{
			value = ((Object)recipe).name;
		}
		return NormalizeLogicalEnchantmentName(value);
	}

	private string GetLogicalEnchantmentKey(WikiEnchantmentData data)
	{
		if (data == null)
		{
			return "";
		}
		EnchantmentRecipe val = FindGameEnchantmentRecipe(data);
		if ((Object)(object)val != (Object)null)
		{
			return GetLogicalEnchantmentKey(val);
		}
		string value = ((!string.IsNullOrWhiteSpace(data.fallbackName)) ? data.fallbackName : data.wikiId);
		return NormalizeLogicalEnchantmentName(value);
	}

	private string NormalizeLogicalEnchantmentName(string value)
	{
		string text = NormalizeLookupText(value);
		if (string.IsNullOrWhiteSpace(text))
		{
			return "";
		}
		int i;
		for (i = 0; i < text.Length && char.IsDigit(text[i]); i++)
		{
		}
		if (i > 0 && i < text.Length)
		{
			text = text.Substring(i);
		}
		string[] array = new string[16]
		{
			"bodyarmor", "bodyarmour", "brustpanzer", "brustrüstung", "brustruestung", "chestarmor", "chest", "torso", "helmet", "helm",
			"head", "boots", "boot", "stiefel", "feet", "foot"
		};
		bool flag;
		do
		{
			flag = false;
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (text.Length > text2.Length && text.EndsWith(text2, StringComparison.Ordinal))
				{
					text = text.Substring(0, text.Length - text2.Length);
					flag = true;
					break;
				}
			}
		}
		while (flag && text.Length > 0);
		return text;
	}

	private void BuildEnchantmentCompatibilityLookups()
	{
		m_compatibleEnchantmentsByItemId.Clear();
		m_compatibleItemsByEnchantmentResultId.Clear();
		foreach (EnchantmentRecipe allGameEnchantmentRecipe in m_allGameEnchantmentRecipes)
		{
			if ((Object)(object)allGameEnchantmentRecipe == (Object)null || allGameEnchantmentRecipe.ResultID <= 0)
			{
				continue;
			}
			foreach (Item allGameItemPrefab in m_allGameItemPrefabs)
			{
				if (IsPlayerFacingWikiItem(allGameItemPrefab))
				{
					bool flag = false;
					try
					{
						flag = ((EquipmentData)(ref allGameEnchantmentRecipe.CompatibleEquipments)).Match(allGameItemPrefab);
					}
					catch
					{
					}
					if (flag)
					{
						AddToLookup(m_compatibleEnchantmentsByItemId, allGameItemPrefab.ItemID, allGameEnchantmentRecipe);
						AddToLookup(m_compatibleItemsByEnchantmentResultId, allGameEnchantmentRecipe.ResultID, allGameItemPrefab);
					}
				}
			}
		}
		foreach (KeyValuePair<int, List<EnchantmentRecipe>> item in m_compatibleEnchantmentsByItemId)
		{
			item.Value.Sort((EnchantmentRecipe a, EnchantmentRecipe b) => string.Compare(GetEnchantmentDisplayName(GetOrCreateWikiEnchantmentData(a)), GetEnchantmentDisplayName(GetOrCreateWikiEnchantmentData(b)), StringComparison.CurrentCultureIgnoreCase));
		}
		foreach (KeyValuePair<int, List<Item>> item2 in m_compatibleItemsByEnchantmentResultId)
		{
			item2.Value.Sort((Item a, Item b) => string.Compare(GetGameItemDisplayName(a), GetGameItemDisplayName(b), StringComparison.CurrentCultureIgnoreCase));
		}
	}

	private static void AddToLookup<TKey, TValue>(Dictionary<TKey, List<TValue>> lookup, TKey key, TValue value)
	{
		if (!lookup.TryGetValue(key, out var value2))
		{
			value2 = new List<TValue>();
			lookup.Add(key, value2);
		}
		if (!value2.Contains(value))
		{
			value2.Add(value);
		}
	}

	private void SortRecipeLookup(Dictionary<int, List<WikiRecipeData>> lookup)
	{
		foreach (KeyValuePair<int, List<WikiRecipeData>> item in lookup)
		{
			item.Value.Sort((WikiRecipeData a, WikiRecipeData b) => string.Compare(GetRecipeDisplayName(a), GetRecipeDisplayName(b), StringComparison.CurrentCultureIgnoreCase));
		}
	}

	private void LoadWikiData()
	{
		try
		{
			m_items.Clear();
			m_cookingRecipes.Clear();
			m_alchemyRecipes.Clear();
			m_craftingRecipes.Clear();
			m_enchantments.Clear();
			m_itemsByGameId.Clear();
			m_legacyUpgradesBySourceItemId.Clear();
			m_legacyUpgradesByResultItemId.Clear();
			m_gameDataCacheBuilt = false;
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (string.IsNullOrEmpty(directoryName))
			{
				return;
			}
			string text = Path.Combine(directoryName, "WikiData");
			if (!Directory.Exists(text))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("WikiData-Ordner existiert nicht: " + text));
				return;
			}
			m_localizationData = LoadLocalizationFile(Path.Combine(text, "localization.json"));
			m_items.AddRange(LoadItemFile(Path.Combine(text, "items.json")));
			m_cookingRecipes.AddRange(LoadRecipeFile(Path.Combine(text, "cooking.json")));
			m_alchemyRecipes.AddRange(LoadRecipeFile(Path.Combine(text, "alchemy.json")));
			m_craftingRecipes.AddRange(LoadRecipeFile(Path.Combine(text, "crafting.json")));
			m_enchantments.AddRange(LoadEnchantmentFile(Path.Combine(text, "enchantments.json")));
			m_craftingOverrideFile = LoadCraftingOverrideFile(Path.Combine(text, "crafting_overrides.json"));
			ApplyCraftingOverrides(m_craftingOverrideFile);
			foreach (WikiItemData item in m_items)
			{
				if (item != null && item.gameItemId > 0 && !m_itemsByGameId.ContainsKey(item.gameItemId))
				{
					m_itemsByGameId.Add(item.gameItemId, item);
				}
			}
			List<WikiItemSourceData> list = LoadItemSourceFile(Path.Combine(text, "item_sources.json"));
			MergeItemSources(list);
			m_legacyUpgradeFile = LoadLegacyUpgradeFile(Path.Combine(text, "legacy_upgrades.json"));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"WikiData erfolgreich geladen.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Items: " + m_items.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Kochrezepte: " + m_cookingRecipes.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Alchemie: " + m_alchemyRecipes.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Handwerk: " + m_craftingRecipes.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Verzauberungen: " + m_enchantments.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Item-Quellen: " + list.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Crafting-Overrides: " + ((m_craftingOverrideFile != null && m_craftingOverrideFile.overrides != null) ? m_craftingOverrideFile.overrides.Count : 0)));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Legacy-Upgrades geladen: " + ((m_legacyUpgradeFile != null && m_legacyUpgradeFile.upgrades != null) ? m_legacyUpgradeFile.upgrades.Count : 0)));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Laden der WikiData:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	private WikiLocalizationData LoadLocalizationFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("localization.json wurde nicht gefunden: " + filePath));
			return null;
		}
		try
		{
			WikiLocalizationData wikiLocalizationData = JsonConvert.DeserializeObject<WikiLocalizationData>(File.ReadAllText(filePath));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Lokalisierung geladen: " + ((wikiLocalizationData != null && wikiLocalizationData.exact != null) ? wikiLocalizationData.exact.Count : 0) + " exakte Texte"));
			return wikiLocalizationData;
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden von localization.json: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return null;
		}
	}

	private WikiCraftingOverrideFile LoadCraftingOverrideFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("crafting_overrides.json wurde nicht gefunden: " + filePath));
			return null;
		}
		try
		{
			return JsonConvert.DeserializeObject<WikiCraftingOverrideFile>(File.ReadAllText(filePath));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden von crafting_overrides.json: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return null;
		}
	}

	private void ApplyCraftingOverrides(WikiCraftingOverrideFile file)
	{
		if (file == null || file.overrides == null)
		{
			return;
		}
		foreach (WikiRecipeData replacement in file.overrides)
		{
			if (replacement != null)
			{
				m_craftingRecipes.RemoveAll((WikiRecipeData existing) => CraftingRecipeMatchesOverride(existing, replacement));
				if (string.IsNullOrWhiteSpace(replacement.category))
				{
					replacement.category = "Handwerk";
				}
				m_craftingRecipes.Add(replacement);
			}
		}
	}

	private bool CraftingRecipeMatchesOverride(WikiRecipeData existing, WikiRecipeData replacement)
	{
		if (existing == null || replacement == null)
		{
			return false;
		}
		if (!string.IsNullOrWhiteSpace(existing.wikiId) && !string.IsNullOrWhiteSpace(replacement.wikiId) && string.Equals(existing.wikiId, replacement.wikiId, StringComparison.OrdinalIgnoreCase))
		{
			return true;
		}
		if (existing.gameResultItemId > 0 && replacement.gameResultItemId > 0 && existing.gameResultItemId == replacement.gameResultItemId)
		{
			return true;
		}
		if (!string.IsNullOrWhiteSpace(existing.fallbackName) && !string.IsNullOrWhiteSpace(replacement.fallbackName) && NormalizeLookupText(existing.fallbackName) == NormalizeLookupText(replacement.fallbackName))
		{
			return true;
		}
		return false;
	}

	private WikiLegacyUpgradeFile LoadLegacyUpgradeFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("legacy_upgrades.json wurde nicht gefunden: " + filePath));
			return null;
		}
		try
		{
			return JsonConvert.DeserializeObject<WikiLegacyUpgradeFile>(File.ReadAllText(filePath));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden von legacy_upgrades.json: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return null;
		}
	}

	private List<WikiItemData> LoadItemFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			return new List<WikiItemData>();
		}
		try
		{
			List<WikiItemData> list = JsonConvert.DeserializeObject<List<WikiItemData>>(File.ReadAllText(filePath));
			return list ?? new List<WikiItemData>();
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden der Item-Datei: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return new List<WikiItemData>();
		}
	}

	private List<WikiItemSourceData> LoadItemSourceFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("item_sources.json wurde nicht gefunden: " + filePath));
			return new List<WikiItemSourceData>();
		}
		try
		{
			List<WikiItemSourceData> list = JsonConvert.DeserializeObject<List<WikiItemSourceData>>(File.ReadAllText(filePath));
			return list ?? new List<WikiItemSourceData>();
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden der Item-Quellen-Datei: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return new List<WikiItemSourceData>();
		}
	}

	private void MergeItemSources(IEnumerable<WikiItemSourceData> sources)
	{
		if (sources == null)
		{
			return;
		}
		foreach (WikiItemSourceData source in sources)
		{
			if (source == null || source.gameItemId <= 0)
			{
				continue;
			}
			WikiItemData wikiItemData = EnsureWikiItemEntry(source.gameItemId, source.fallbackName, "ADDED FROM ITEM SOURCES");
			if (wikiItemData != null)
			{
				wikiItemData.sourceTypeKey = FirstNonEmpty(wikiItemData.sourceTypeKey, source.sourceTypeKey);
				wikiItemData.sourceType = FirstNonEmpty(wikiItemData.sourceType, source.sourceType);
				wikiItemData.sourceTypeDe = FirstNonEmpty(wikiItemData.sourceTypeDe, source.sourceTypeDe);
				wikiItemData.sourceTypeEn = FirstNonEmpty(wikiItemData.sourceTypeEn, source.sourceTypeEn);
				wikiItemData.locations = MergeUniqueStrings(wikiItemData.locations, source.locations);
				wikiItemData.dropsFrom = MergeUniqueStrings(wikiItemData.dropsFrom, source.dropsFrom);
				wikiItemData.questSources = MergeUniqueStrings(wikiItemData.questSources, source.questSources);
				wikiItemData.questRewards = MergeUniqueStrings(wikiItemData.questRewards, source.questRewards);
				wikiItemData.blacksmithSources = MergeUniqueStrings(wikiItemData.blacksmithSources, source.blacksmithSources);
				wikiItemData.sourceNotes = MergeUniqueStrings(wikiItemData.sourceNotes, source.sourceNotes);
				wikiItemData.locationsDe = MergeUniqueStrings(wikiItemData.locationsDe, source.locationsDe);
				wikiItemData.locationsEn = MergeUniqueStrings(wikiItemData.locationsEn, source.locationsEn);
				wikiItemData.dropsFromDe = MergeUniqueStrings(wikiItemData.dropsFromDe, source.dropsFromDe);
				wikiItemData.dropsFromEn = MergeUniqueStrings(wikiItemData.dropsFromEn, source.dropsFromEn);
				wikiItemData.questSourcesDe = MergeUniqueStrings(wikiItemData.questSourcesDe, source.questSourcesDe);
				wikiItemData.questSourcesEn = MergeUniqueStrings(wikiItemData.questSourcesEn, source.questSourcesEn);
				wikiItemData.questRewardsDe = MergeUniqueStrings(wikiItemData.questRewardsDe, source.questRewardsDe);
				wikiItemData.questRewardsEn = MergeUniqueStrings(wikiItemData.questRewardsEn, source.questRewardsEn);
				wikiItemData.blacksmithSourcesDe = MergeUniqueStrings(wikiItemData.blacksmithSourcesDe, source.blacksmithSourcesDe);
				wikiItemData.blacksmithSourcesEn = MergeUniqueStrings(wikiItemData.blacksmithSourcesEn, source.blacksmithSourcesEn);
				wikiItemData.sourceNotesDe = MergeUniqueStrings(wikiItemData.sourceNotesDe, source.sourceNotesDe);
				wikiItemData.sourceNotesEn = MergeUniqueStrings(wikiItemData.sourceNotesEn, source.sourceNotesEn);
				if (source.commission != null)
				{
					wikiItemData.commission = source.commission;
				}
			}
		}
	}

	private WikiItemData EnsureWikiItemEntry(int gameItemId, string fallbackName, string sourceStatus)
	{
		if (gameItemId <= 0)
		{
			return null;
		}
		if (!m_itemsByGameId.TryGetValue(gameItemId, out var value))
		{
			value = new WikiItemData
			{
				gameItemId = gameItemId,
				fallbackName = fallbackName,
				fallbackDescription = "",
				sourceStatus = sourceStatus
			};
			m_items.Add(value);
			m_itemsByGameId.Add(gameItemId, value);
		}
		else
		{
			if (string.IsNullOrWhiteSpace(value.fallbackName) && !string.IsNullOrWhiteSpace(fallbackName))
			{
				value.fallbackName = fallbackName;
			}
			if (string.IsNullOrWhiteSpace(value.sourceStatus) && !string.IsNullOrWhiteSpace(sourceStatus))
			{
				value.sourceStatus = sourceStatus;
			}
		}
		return value;
	}

	private static string FirstNonEmpty(string current, string incoming)
	{
		return (!string.IsNullOrWhiteSpace(incoming)) ? incoming.Trim() : current;
	}

	private static string SelectLocalizedSourceString(string legacy, string german, string english)
	{
		if (UseEnglishUi)
		{
			if (!string.IsNullOrWhiteSpace(english))
			{
				return english;
			}
			if (!string.IsNullOrWhiteSpace(legacy))
			{
				return legacy;
			}
			return german;
		}
		if (!string.IsNullOrWhiteSpace(german))
		{
			return german;
		}
		if (!string.IsNullOrWhiteSpace(legacy))
		{
			return legacy;
		}
		return english;
	}

	private static IEnumerable<string> SelectLocalizedSourceList(IEnumerable<string> legacy, IEnumerable<string> german, IEnumerable<string> english)
	{
		IEnumerable<string> enumerable = (UseEnglishUi ? english : german);
		if (enumerable != null && enumerable.Any((string x) => !string.IsNullOrWhiteSpace(x)))
		{
			return enumerable;
		}
		if (legacy != null && legacy.Any((string x) => !string.IsNullOrWhiteSpace(x)))
		{
			return legacy;
		}
		return UseEnglishUi ? german : english;
	}

	private static List<string> MergeUniqueStrings(List<string> current, IEnumerable<string> additional)
	{
		List<string> list = ((current == null) ? new List<string>() : (from x in current
			where !string.IsNullOrWhiteSpace(x)
			select x.Trim()).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).ToList());
		if (additional == null)
		{
			return list;
		}
		foreach (string item in additional)
		{
			if (!string.IsNullOrWhiteSpace(item))
			{
				string trimmed = item.Trim();
				if (!list.Any((string x) => string.Equals(x, trimmed, StringComparison.CurrentCultureIgnoreCase)))
				{
					list.Add(trimmed);
				}
			}
		}
		return list;
	}

	private List<WikiRecipeData> LoadRecipeFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			return new List<WikiRecipeData>();
		}
		try
		{
			List<WikiRecipeData> list = JsonConvert.DeserializeObject<List<WikiRecipeData>>(File.ReadAllText(filePath));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Rezepte aus Datei geladen: " + (list?.Count ?? 0) + " | " + Path.GetFileName(filePath)));
			return list ?? new List<WikiRecipeData>();
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden der Rezept-Datei: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return new List<WikiRecipeData>();
		}
	}

	private List<WikiEnchantmentData> LoadEnchantmentFile(string filePath)
	{
		if (!File.Exists(filePath))
		{
			return new List<WikiEnchantmentData>();
		}
		try
		{
			List<WikiEnchantmentData> list = JsonConvert.DeserializeObject<List<WikiEnchantmentData>>(File.ReadAllText(filePath));
			return list ?? new List<WikiEnchantmentData>();
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("Fehler beim Laden der Verzauberungs-Datei: " + filePath));
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
			return new List<WikiEnchantmentData>();
		}
	}

	private void LoadFavorites()
	{
		try
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (string.IsNullOrEmpty(directoryName))
			{
				return;
			}
			string text = Path.Combine(directoryName, "UserData");
			Directory.CreateDirectory(text);
			m_favoritesFilePath = Path.Combine(text, "Favorites.json");
			m_favorites.Clear();
			if (!File.Exists(m_favoritesFilePath))
			{
				return;
			}
			List<string> list = JsonConvert.DeserializeObject<List<string>>(File.ReadAllText(m_favoritesFilePath));
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				if (!string.IsNullOrWhiteSpace(item))
				{
					m_favorites.Add(item);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Favoriten geladen: " + m_favorites.Count));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Laden der Favoriten:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	private void SaveFavorites()
	{
		try
		{
			if (string.IsNullOrWhiteSpace(m_favoritesFilePath))
			{
				string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				if (string.IsNullOrEmpty(directoryName))
				{
					return;
				}
				string text = Path.Combine(directoryName, "UserData");
				Directory.CreateDirectory(text);
				m_favoritesFilePath = Path.Combine(text, "Favorites.json");
			}
			File.WriteAllText(m_favoritesFilePath, JsonConvert.SerializeObject((object)m_favorites.OrderBy((string x) => x).ToList(), (Formatting)1));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Fehler beim Speichern der Favoriten:");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}

	private bool IsFavorite(string key)
	{
		return !string.IsNullOrWhiteSpace(key) && m_favorites.Contains(key);
	}

	private void ToggleFavorite(string key, Button starButton)
	{
		if (!string.IsNullOrWhiteSpace(key))
		{
			if (!m_favorites.Add(key))
			{
				m_favorites.Remove(key);
			}
			UpdateFavoriteStarButton(starButton, key);
			SaveFavorites();
			if (m_currentCategory == WikiCategory.Favorites && m_currentViewState == WikiViewState.CategoryList)
			{
				RefreshCurrentCategoryList(((Object)(object)m_searchField == (Object)null) ? "" : m_searchField.text);
			}
		}
	}

	private void UpdateFavoriteStarButton(Button starButton, string key)
	{
		if (!((Object)(object)starButton == (Object)null))
		{
			Text componentInChildren = ((Component)starButton).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = (IsFavorite(key) ? "★" : "☆");
			}
		}
	}

	internal void HandleWikiBack()
	{
		if (!m_wikiOpen || m_lastBackHandledFrame == Time.frameCount)
		{
			return;
		}
		m_lastBackHandledFrame = Time.frameCount;
		if (IsSearchFieldFocused && (Object)(object)m_searchField != (Object)null && !string.IsNullOrEmpty(m_searchField.text))
		{
			ClearSearchFieldWithoutRefresh();
			if (m_currentCategory == WikiCategory.None)
			{
				BuildCategoryOverviewList();
			}
			else
			{
				RefreshCurrentCategoryList("");
			}
			ReassertSearchFieldFocus();
		}
		else if (IsSearchFieldFocused)
		{
			m_searchField.DeactivateInputField();
			FocusFirstListButton(m_currentCategory != WikiCategory.None);
		}
		else if (m_currentViewState == WikiViewState.Article || m_currentViewState == WikiViewState.GenericIngredient)
		{
			ShowCategory(m_currentCategory);
		}
		else if (m_currentViewState == WikiViewState.CategoryList)
		{
			ShowCategoryOverview();
		}
		else
		{
			CloseWiki();
		}
	}

	private void FocusButtonReliable(Button button)
	{
		if (!((Object)(object)button == (Object)null))
		{
			if (m_focusCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(m_focusCoroutine);
			}
			m_focusCoroutine = ((MonoBehaviour)this).StartCoroutine(FocusButtonReliableCoroutine(button));
		}
	}

	private IEnumerator FocusButtonReliableCoroutine(Button button)
	{
		yield return null;
		yield return null;
		Canvas.ForceUpdateCanvases();
		if ((Object)(object)button == (Object)null || !((Component)button).gameObject.activeInHierarchy || !((Selectable)button).interactable)
		{
			yield break;
		}
		EventSystem es = EventSystem.current;
		if (!((Object)(object)es == (Object)null))
		{
			es.SetSelectedGameObject((GameObject)null);
			yield return null;
			((Selectable)button).Select();
			es.SetSelectedGameObject(((Component)button).gameObject);
			yield return null;
			if ((Object)(object)es.currentSelectedGameObject != (Object)(object)((Component)button).gameObject)
			{
				((Selectable)button).Select();
				es.SetSelectedGameObject(((Component)button).gameObject);
			}
			m_focusCoroutine = null;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("UI-Fokus gesetzt auf: " + ((Object)((Component)button).gameObject).name));
		}
	}

	private Button GetCurrentLeftButtonOrFallback()
	{
		EventSystem current = EventSystem.current;
		if ((Object)(object)current != (Object)null && (Object)(object)current.currentSelectedGameObject != (Object)null)
		{
			Button component = current.currentSelectedGameObject.GetComponent<Button>();
			if ((Object)(object)component != (Object)null && (Object)(object)m_entryListContent != (Object)null && ((Component)component).transform.IsChildOf((Transform)(object)m_entryListContent))
			{
				if (m_leftStarToMain.TryGetValue(component, out var value))
				{
					return value;
				}
				return component;
			}
		}
		foreach (Button leftListButton in GetLeftListButtons())
		{
			if ((Object)(object)leftListButton == (Object)null || !((Selectable)leftListButton).interactable || ((Object)((Component)leftListButton).gameObject).name == "Entry_← Kategorien")
			{
				continue;
			}
			return leftListButton;
		}
		return null;
	}

	private List<Button> GetLeftListButtons()
	{
		List<Button> list = new List<Button>();
		if ((Object)(object)m_entryListContent == (Object)null)
		{
			return list;
		}
		for (int i = 0; i < ((Transform)m_entryListContent).childCount; i++)
		{
			Transform child = ((Transform)m_entryListContent).GetChild(i);
			if (!((Component)child).gameObject.activeInHierarchy)
			{
				continue;
			}
			Button component = ((Component)child).GetComponent<Button>();
			if ((Object)(object)component != (Object)null && ((Selectable)component).interactable)
			{
				list.Add(component);
				continue;
			}
			Button[] componentsInChildren = ((Component)child).GetComponentsInChildren<Button>(true);
			Button[] array = componentsInChildren;
			foreach (Button val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Selectable)val).interactable && !((Object)((Component)val).gameObject).name.StartsWith("FavoriteStar_", StringComparison.Ordinal))
				{
					list.Add(val);
					break;
				}
			}
		}
		return list;
	}

	private void RebuildLeftListNavigation()
	{
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		List<Button> leftListButtons = GetLeftListButtons();
		for (int i = 0; i < leftListButtons.Count; i++)
		{
			Button val = leftListButtons[i];
			Button val2 = ((i > 0) ? leftListButtons[i - 1] : leftListButtons[leftListButtons.Count - 1]);
			Button val3 = ((i < leftListButtons.Count - 1) ? leftListButtons[i + 1] : leftListButtons[0]);
			Navigation navigation = ((Selectable)val).navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)val2;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)val3;
			((Navigation)(ref navigation)).selectOnLeft = null;
			((Navigation)(ref navigation)).selectOnRight = (Selectable)(object)(m_leftMainToStar.TryGetValue(val, out var value) ? value : null);
			((Selectable)val).navigation = navigation;
			if ((Object)(object)value != (Object)null)
			{
				Navigation navigation2 = ((Selectable)value).navigation;
				((Navigation)(ref navigation2)).mode = (Mode)4;
				((Navigation)(ref navigation2)).selectOnLeft = (Selectable)(object)val;
				((Navigation)(ref navigation2)).selectOnRight = null;
				((Navigation)(ref navigation2)).selectOnUp = (Selectable)(object)(m_leftMainToStar.TryGetValue(val2, out var value2) ? value2 : val2);
				((Navigation)(ref navigation2)).selectOnDown = (Selectable)(object)(m_leftMainToStar.TryGetValue(val3, out var value3) ? value3 : val3);
				((Selectable)value).navigation = navigation2;
			}
		}
	}

	private void FocusFirstListButton(bool skipBackButton)
	{
		List<Button> leftListButtons = GetLeftListButtons();
		if (leftListButtons.Count != 0)
		{
			Button button = leftListButtons[0];
			if (skipBackButton && leftListButtons.Count > 1)
			{
				button = leftListButtons[1];
			}
			FocusButtonReliable(button);
		}
	}

	private void RebuildArticleNavigation()
	{
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_activeLeftSourceButton == (Object)null || !((Component)m_activeLeftSourceButton).gameObject.activeInHierarchy)
		{
			m_activeLeftSourceButton = GetCurrentLeftButtonOrFallback();
		}
		Button activeLeftSourceButton = m_activeLeftSourceButton;
		List<List<Button>> list = m_articleButtonRows.Where((List<Button> row) => row != null && row.Count > 0).ToList();
		if (list.Count == 0)
		{
			if ((Object)(object)activeLeftSourceButton != (Object)null)
			{
				Navigation navigation = ((Selectable)activeLeftSourceButton).navigation;
				((Navigation)(ref navigation)).selectOnRight = null;
				((Selectable)activeLeftSourceButton).navigation = navigation;
			}
			return;
		}
		if ((Object)(object)activeLeftSourceButton != (Object)null)
		{
			Navigation navigation2 = ((Selectable)activeLeftSourceButton).navigation;
			((Navigation)(ref navigation2)).selectOnRight = (Selectable)(object)list[0][0];
			((Selectable)activeLeftSourceButton).navigation = navigation2;
		}
		for (int num = 0; num < list.Count; num++)
		{
			List<Button> list2 = list[num];
			for (int num2 = 0; num2 < list2.Count; num2++)
			{
				Button val = list2[num2];
				Navigation navigation3 = ((Selectable)val).navigation;
				((Navigation)(ref navigation3)).mode = (Mode)4;
				((Navigation)(ref navigation3)).selectOnLeft = (Selectable)(object)((num2 > 0) ? list2[num2 - 1] : activeLeftSourceButton);
				((Navigation)(ref navigation3)).selectOnRight = (Selectable)(object)((num2 < list2.Count - 1) ? list2[num2 + 1] : null);
				if (num > 0)
				{
					List<Button> list3 = list[num - 1];
					((Navigation)(ref navigation3)).selectOnUp = (Selectable)(object)list3[Mathf.Min(num2, list3.Count - 1)];
				}
				else
				{
					((Navigation)(ref navigation3)).selectOnUp = null;
				}
				if (num < list.Count - 1)
				{
					List<Button> list4 = list[num + 1];
					((Navigation)(ref navigation3)).selectOnDown = (Selectable)(object)list4[Mathf.Min(num2, list4.Count - 1)];
				}
				else
				{
					((Navigation)(ref navigation3)).selectOnDown = null;
				}
				((Selectable)val).navigation = navigation3;
			}
		}
	}

	private void EnsureListElementVisible(RectTransform target)
	{
		EnsureElementVisible(m_entryListScrollRect, m_entryListContent, target);
	}

	private void EnsureArticleElementVisible(RectTransform target)
	{
		EnsureElementVisible(m_articleScrollRect, m_articleContent, target);
	}

	private void EnsureElementVisible(ScrollRect scrollRect, RectTransform content, RectTransform target)
	{
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)scrollRect == (Object)null) && !((Object)(object)content == (Object)null) && !((Object)(object)target == (Object)null) && !((Object)(object)scrollRect.viewport == (Object)null))
		{
			Canvas.ForceUpdateCanvases();
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			target.GetWorldCorners(array);
			scrollRect.viewport.GetWorldCorners(array2);
			float y = array[0].y;
			float y2 = array[1].y;
			float y3 = array2[0].y;
			float y4 = array2[1].y;
			Vector2 anchoredPosition = content.anchoredPosition;
			bool flag = false;
			if (y < y3)
			{
				anchoredPosition.y += y3 - y;
				flag = true;
			}
			else if (y2 > y4)
			{
				anchoredPosition.y -= y2 - y4;
				flag = true;
			}
			if (flag)
			{
				content.anchoredPosition = anchoredPosition;
				Canvas.ForceUpdateCanvases();
				scrollRect.StopMovement();
			}
		}
	}

	private void ClearSearchFieldWithoutRefresh()
	{
		if (!((Object)(object)m_searchField == (Object)null))
		{
			((UnityEvent<string>)(object)m_searchField.onValueChanged).RemoveListener((UnityAction<string>)OnSearchChanged);
			m_searchField.text = "";
			((UnityEvent<string>)(object)m_searchField.onValueChanged).AddListener((UnityAction<string>)OnSearchChanged);
		}
	}

	private Recipe FindGameRecipe(WikiRecipeData wikiRecipe)
	{
		if (wikiRecipe == null)
		{
			return null;
		}
		if (wikiRecipe.gameRecipeId > 0)
		{
			Recipe val = ((IEnumerable<Recipe>)m_allGameRecipes).FirstOrDefault((Func<Recipe, bool>)((Recipe x) => (Object)(object)x != (Object)null && x.RecipeID == wikiRecipe.gameRecipeId));
			if ((Object)(object)val != (Object)null && !ShouldIgnoreRuntimeRecipeCandidate(wikiRecipe, val))
			{
				return val;
			}
		}
		WikiCategory category = GetWikiCategoryForRecipe(wikiRecipe);
		List<Recipe> list = new List<Recipe>();
		if (wikiRecipe.gameResultItemId > 0 && m_gameRecipesByResultItemId.TryGetValue(wikiRecipe.gameResultItemId, out var value))
		{
			list.AddRange(value);
		}
		if (wikiRecipe.results != null)
		{
			foreach (WikiItemReference result in wikiRecipe.results)
			{
				if (result != null && result.gameItemId > 0 && m_gameRecipesByResultItemId.TryGetValue(result.gameItemId, out var value2))
				{
					list.AddRange(value2);
				}
			}
		}
		Recipe val2 = (from x in list.Where((Recipe x) => (Object)(object)x != (Object)null && RecipeMatchesWikiCategory(x, category) && !ShouldIgnoreRuntimeRecipeCandidate(wikiRecipe, x)).Distinct()
			orderby ScoreGameRecipeCandidate(wikiRecipe, x) descending
			select x).FirstOrDefault();
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		string targetName = wikiRecipe.fallbackName;
		if (string.IsNullOrWhiteSpace(targetName))
		{
			return null;
		}
		return ((IEnumerable<Recipe>)(from x in m_allGameRecipes
			where (Object)(object)x != (Object)null && RecipeMatchesWikiCategory(x, category) && !ShouldIgnoreRuntimeRecipeCandidate(wikiRecipe, x)
			orderby (string.Equals(x.EDITOR_Name, targetName, StringComparison.OrdinalIgnoreCase) || string.Equals(x.Name, targetName, StringComparison.OrdinalIgnoreCase)) ? 1 : 0 descending
			select x)).FirstOrDefault((Func<Recipe, bool>)((Recipe x) => string.Equals(x.EDITOR_Name, targetName, StringComparison.OrdinalIgnoreCase) || string.Equals(x.Name, targetName, StringComparison.OrdinalIgnoreCase)));
	}

	private bool ShouldIgnoreRuntimeRecipeCandidate(WikiRecipeData wikiRecipe, Recipe gameRecipe)
	{
		if (wikiRecipe == null || (Object)(object)gameRecipe == (Object)null || m_craftingOverrideFile == null || m_craftingOverrideFile.runtimeRecipeFilters == null)
		{
			return false;
		}
		HashSet<int> hashSet = new HashSet<int>();
		if (wikiRecipe.gameResultItemId > 0)
		{
			hashSet.Add(wikiRecipe.gameResultItemId);
		}
		if (wikiRecipe.results != null)
		{
			foreach (WikiItemReference result in wikiRecipe.results)
			{
				if (result != null && result.gameItemId > 0)
				{
					hashSet.Add(result.gameItemId);
				}
			}
		}
		if (hashSet.Count == 0)
		{
			return false;
		}
		foreach (WikiRuntimeRecipeFilter runtimeRecipeFilter in m_craftingOverrideFile.runtimeRecipeFilters)
		{
			if (runtimeRecipeFilter == null || runtimeRecipeFilter.resultItemIds == null || !runtimeRecipeFilter.hideWhenIngredientContainsResultItem || !runtimeRecipeFilter.resultItemIds.Any(hashSet.Contains) || gameRecipe.Ingredients == null)
			{
				continue;
			}
			foreach (int item in hashSet)
			{
				if (!runtimeRecipeFilter.resultItemIds.Contains(item))
				{
					continue;
				}
				Item gameItemPrefab = GetGameItemPrefab(item);
				if ((Object)(object)gameItemPrefab == (Object)null)
				{
					continue;
				}
				RecipeIngredient[] ingredients = gameRecipe.Ingredients;
				foreach (RecipeIngredient val in ingredients)
				{
					if (val != null && RecipeIngredientMatchesItem(val, gameItemPrefab))
					{
						return true;
					}
				}
			}
		}
		return false;
	}

	private int ScoreGameRecipeCandidate(WikiRecipeData wikiRecipe, Recipe gameRecipe)
	{
		if (wikiRecipe == null || (Object)(object)gameRecipe == (Object)null)
		{
			return int.MinValue;
		}
		int num = 0;
		WikiCategory wikiCategoryForRecipe = GetWikiCategoryForRecipe(wikiRecipe);
		if (RecipeMatchesWikiCategory(gameRecipe, wikiCategoryForRecipe))
		{
			num += 1000;
		}
		HashSet<int> hashSet = new HashSet<int>();
		if (wikiRecipe.gameResultItemId > 0)
		{
			hashSet.Add(wikiRecipe.gameResultItemId);
		}
		if (wikiRecipe.results != null)
		{
			foreach (WikiItemReference result in wikiRecipe.results)
			{
				if (result != null && result.gameItemId > 0)
				{
					hashSet.Add(result.gameItemId);
				}
			}
		}
		if (gameRecipe.Results != null)
		{
			ItemReferenceQuantity[] results = gameRecipe.Results;
			foreach (ItemReferenceQuantity val in results)
			{
				if (hashSet.Contains(val.ItemID))
				{
					num += 250;
				}
			}
		}
		if (wikiRecipe.ingredients != null && wikiRecipe.ingredients.Count > 0)
		{
			List<WikiItemReference> normalizedWikiIngredientsForMatching = GetNormalizedWikiIngredientsForMatching(wikiRecipe);
			List<RecipeIngredient> source = ResolveRuntimeIngredients(wikiRecipe, gameRecipe, normalizedWikiIngredientsForMatching);
			num += source.Count((RecipeIngredient x) => x != null) * 120;
			int num2 = ((gameRecipe.Ingredients != null) ? gameRecipe.Ingredients.Length : 0);
			num -= Math.Abs(num2 - normalizedWikiIngredientsForMatching.Count) * 25;
		}
		return num;
	}

	private List<WikiItemReference> GetNormalizedWikiIngredientsForMatching(WikiRecipeData recipe)
	{
		List<WikiItemReference> list = new List<WikiItemReference>();
		if (recipe == null || recipe.ingredients == null)
		{
			return list;
		}
		bool flag = IsCleanWaterRecipe(recipe, null);
		foreach (WikiItemReference ingredient in recipe.ingredients)
		{
			if (ingredient != null)
			{
				if (flag && ingredient.gameItemId == 5600000)
				{
					list.Add(new WikiItemReference
					{
						gameItemId = 0,
						amount = Math.Max(1, ingredient.amount),
						ingredientCategory = "Water",
						fallbackName = "Water"
					});
				}
				else
				{
					list.Add(ingredient);
				}
			}
		}
		return list;
	}

	private List<RecipeIngredient> ResolveRuntimeIngredients(WikiRecipeData wikiRecipe, Recipe gameRecipe, IList<WikiItemReference> wikiIngredients)
	{
		List<RecipeIngredient> list = new List<RecipeIngredient>();
		if (wikiIngredients == null)
		{
			return list;
		}
		for (int i = 0; i < wikiIngredients.Count; i++)
		{
			list.Add(null);
		}
		if ((Object)(object)gameRecipe == (Object)null || gameRecipe.Ingredients == null || gameRecipe.Ingredients.Length == 0)
		{
			return list;
		}
		List<RecipeIngredient> source = gameRecipe.Ingredients.Where((RecipeIngredient x) => x != null).ToList();
		HashSet<RecipeIngredient> used = new HashSet<RecipeIngredient>();
		for (int num = 0; num < wikiIngredients.Count; num++)
		{
			WikiItemReference wikiItemReference = wikiIngredients[num];
			if (wikiItemReference == null || wikiItemReference.gameItemId <= 0)
			{
				continue;
			}
			Item item = GetGameItemPrefab(wikiItemReference.gameItemId);
			if (!((Object)(object)item == (Object)null))
			{
				RecipeIngredient val = (from x in source
					where !used.Contains(x) && RecipeIngredientMatchesItem(x, item)
					orderby IsGenericRecipeIngredient(x) ? 1 : 0, GetMatchingItems(x).Count
					select x).FirstOrDefault();
				if (val != null)
				{
					list[num] = val;
					used.Add(val);
				}
			}
		}
		for (int num2 = 0; num2 < wikiIngredients.Count; num2++)
		{
			if (list[num2] != null)
			{
				continue;
			}
			WikiItemReference wikiItemReference2 = wikiIngredients[num2];
			if (wikiItemReference2 != null)
			{
				string wanted = NormalizeLookupText((!string.IsNullOrWhiteSpace(wikiItemReference2.ingredientCategory)) ? wikiItemReference2.ingredientCategory : wikiItemReference2.fallbackName);
				RecipeIngredient val2 = (from x in source
					where !used.Contains(x)
					orderby ScoreGenericIngredientNameMatch(wanted, x) descending, IsGenericRecipeIngredient(x) ? 1 : 0 descending, GetMatchingItems(x).Count descending
					select x).FirstOrDefault();
				if (val2 != null)
				{
					list[num2] = val2;
					used.Add(val2);
				}
			}
		}
		return list;
	}

	private bool RecipeIngredientMatchesItem(RecipeIngredient ingredient, Item item)
	{
		if (ingredient == null || (Object)(object)item == (Object)null)
		{
			return false;
		}
		try
		{
			return ingredient.Match(item);
		}
		catch
		{
			return false;
		}
	}

	private bool IsGenericRecipeIngredient(RecipeIngredient ingredient)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		if (ingredient == null)
		{
			return false;
		}
		try
		{
			return (int)ingredient.ActionType == 0;
		}
		catch
		{
			return false;
		}
	}

	private int ScoreGenericIngredientNameMatch(string wanted, RecipeIngredient ingredient)
	{
		if (ingredient == null)
		{
			return 0;
		}
		int num = (IsGenericRecipeIngredient(ingredient) ? 20 : 0);
		if (string.IsNullOrWhiteSpace(wanted))
		{
			return num;
		}
		string text = NormalizeLookupText(GetGenericIngredientDisplayName(null, ingredient));
		if (text == wanted)
		{
			return num + 100;
		}
		if (text.Contains(wanted) || wanted.Contains(text))
		{
			return num + 70;
		}
		return num;
	}

	private List<Item> GetMatchingItems(RecipeIngredient ingredient)
	{
		List<Item> list = new List<Item>();
		if (ingredient == null)
		{
			return list;
		}
		foreach (Item allGameItemPrefab in m_allGameItemPrefabs)
		{
			if ((Object)(object)allGameItemPrefab == (Object)null)
			{
				continue;
			}
			try
			{
				if (ingredient.Match(allGameItemPrefab))
				{
					list.Add(allGameItemPrefab);
				}
			}
			catch
			{
			}
		}
		return (from item in list
			group item by item.ItemID into @group
			select @group.First()).OrderBy(GetGameItemDisplayName).ToList();
	}

	private Item GetGameItemPrefab(int gameItemId)
	{
		if (gameItemId <= 0)
		{
			return null;
		}
		try
		{
			return ResourcesPrefabManager.Instance.GetItemPrefab(gameItemId);
		}
		catch
		{
			return null;
		}
	}

	private Sprite GetGameItemIcon(int gameItemId)
	{
		if (gameItemId <= 0)
		{
			return null;
		}
		try
		{
			return ResourcesPrefabManager.Instance.GetItemIcon(gameItemId);
		}
		catch
		{
			return null;
		}
	}

	private string GetGameItemDisplayName(Item item)
	{
		if ((Object)(object)item == (Object)null)
		{
			return "Unbekanntes Item";
		}
		try
		{
			if (!string.IsNullOrWhiteSpace(item.DisplayName))
			{
				return item.DisplayName;
			}
		}
		catch
		{
		}
		return "Item " + item.ItemID;
	}

	private WikiItemData GetOrCreateWikiItemData(Item item)
	{
		if ((Object)(object)item == (Object)null)
		{
			return null;
		}
		WikiItemData itemByGameId = GetItemByGameId(item.ItemID);
		if (itemByGameId != null)
		{
			return itemByGameId;
		}
		return new WikiItemData
		{
			gameItemId = item.ItemID,
			fallbackName = GetGameItemDisplayName(item),
			fallbackDescription = "",
			sourceStatus = "Outward-Prefab"
		};
	}

	private void ExtractOutwardStyles()
	{
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		Transform val = ((Component)m_inventoryMenu).transform.Find("DetailPanel");
		if ((Object)(object)val != (Object)null)
		{
			Image component = ((Component)val).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				m_backgroundSprite = component.sprite;
			}
		}
		Transform val2 = ((Component)m_inventoryMenu).transform.Find("DetailPanel/ItemDetailsPanel/ItemDetails/Stats/Header/lblItemName");
		if ((Object)(object)val2 != (Object)null)
		{
			Text component2 = ((Component)val2).GetComponent<Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				m_outwardFont = component2.font;
			}
		}
		Transform val3 = FindPauseMenuButton();
		if ((Object)(object)val3 != (Object)null)
		{
			Image component3 = ((Component)val3).GetComponent<Image>();
			if ((Object)(object)component3 != (Object)null)
			{
				m_buttonSprite = component3.sprite;
				m_buttonColor = ((Graphic)component3).color;
				m_buttonImageType = component3.type;
				m_buttonMaterial = ((Graphic)component3).material;
			}
			Button component4 = ((Component)val3).GetComponent<Button>();
			if ((Object)(object)component4 != (Object)null)
			{
				m_buttonTransition = ((Selectable)component4).transition;
				m_buttonColors = ((Selectable)component4).colors;
				m_buttonSpriteState = ((Selectable)component4).spriteState;
			}
			Transform val4 = val3.Find("Text");
			if ((Object)(object)val4 != (Object)null)
			{
				Text component5 = ((Component)val4).GetComponent<Text>();
				if ((Object)(object)component5 != (Object)null)
				{
					m_buttonFont = component5.font;
					m_buttonFontStyle = component5.fontStyle;
					m_buttonTextColor = ((Graphic)component5).color;
					m_buttonFontSize = component5.fontSize;
					m_buttonTextAlignment = component5.alignment;
				}
			}
		}
		Transform val5 = ((Component)m_inventoryMenu).transform.Find("DetailPanel/ItemDetailsPanel/ItemDetails/Stats/Scroll View/Viewport/Content/Separator");
		if ((Object)(object)val5 != (Object)null)
		{
			Image component6 = ((Component)val5).GetComponent<Image>();
			if ((Object)(object)component6 != (Object)null)
			{
				m_separatorSprite = component6.sprite;
				m_separatorColor = ((Graphic)component6).color;
			}
		}
	}

	private Transform FindPauseMenuButton()
	{
		Button[] array = Resources.FindObjectsOfTypeAll<Button>();
		Button[] array2 = array;
		foreach (Button val in array2)
		{
			if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && string.Equals(((Object)((Component)val).gameObject).name, "btnOptions", StringComparison.Ordinal))
			{
				Transform parent = ((Component)val).transform.parent;
				if ((Object)(object)parent != (Object)null && string.Equals(((Object)parent).name, "HideOnPause", StringComparison.Ordinal))
				{
					return ((Component)val).transform;
				}
			}
		}
		return null;
	}

	private void BuildWikiWindow(Transform uiParent)
	{
		//IL_0029: 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_0055: 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_0077: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Unknown result type (might be due to invalid IL or missing references)
		//IL_031c: Expected O, but got Unknown
		//IL_0333: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_037a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0391: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_040d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0424: Unknown result type (might be due to invalid IL or missing references)
		//IL_043b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0448: Unknown result type (might be due to invalid IL or missing references)
		//IL_045f: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0515: Unknown result type (might be due to invalid IL or missing references)
		//IL_056f: Unknown result type (might be due to invalid IL or missing references)
		//IL_058a: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_069f: Unknown result type (might be due to invalid IL or missing references)
		//IL_06b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0724: Unknown result type (might be due to invalid IL or missing references)
		//IL_0733: Unknown result type (might be due to invalid IL or missing references)
		//IL_0742: Unknown result type (might be due to invalid IL or missing references)
		//IL_0751: Unknown result type (might be due to invalid IL or missing references)
		//IL_0791: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_07af: Unknown result type (might be due to invalid IL or missing references)
		//IL_07be: Unknown result type (might be due to invalid IL or missing references)
		//IL_07db: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0814: Unknown result type (might be due to invalid IL or missing references)
		//IL_0821: Unknown result type (might be due to invalid IL or missing references)
		//IL_082e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0845: Unknown result type (might be due to invalid IL or missing references)
		//IL_086f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0901: Unknown result type (might be due to invalid IL or missing references)
		//IL_091c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0937: Unknown result type (might be due to invalid IL or missing references)
		//IL_0948: Unknown result type (might be due to invalid IL or missing references)
		//IL_0959: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		m_wikiWindow = CreateUIObject("SeriousWikiWindow", uiParent);
		RectTransform component = m_wikiWindow.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 = Vector2.zero;
		component.sizeDelta = new Vector2(1100f, 720f);
		GameObject val = CreateUIObject("WikiBackground", m_wikiWindow.transform);
		StretchRect(val.GetComponent<RectTransform>());
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).raycastTarget = false;
		if ((Object)(object)m_wikiBackgroundSprite != (Object)null)
		{
			val2.sprite = m_wikiBackgroundSprite;
			val2.type = (Type)0;
			val2.preserveAspect = false;
			((Graphic)val2).color = Color.white;
		}
		else
		{
			((Graphic)val2).color = new Color(0.025f, 0.025f, 0.025f, 1f);
		}
		GameObject val3 = CreateUIObject("DarkOverlay", m_wikiWindow.transform);
		StretchRect(val3.GetComponent<RectTransform>());
		Image val4 = val3.AddComponent<Image>();
		((Graphic)val4).raycastTarget = false;
		((Graphic)val4).color = new Color(0f, 0f, 0f, 0.16f);
		if ((Object)(object)m_backgroundSprite != (Object)null)
		{
			GameObject val5 = CreateUIObject("OutwardGoldFrame", m_wikiWindow.transform);
			StretchRect(val5.GetComponent<RectTransform>());
			Image val6 = val5.AddComponent<Image>();
			val6.sprite = m_backgroundSprite;
			((Graphic)val6).color = Color.white;
			val6.type = (Type)1;
			((Graphic)val6).raycastTarget = false;
		}
		CanvasGroup val7 = m_wikiWindow.AddComponent<CanvasGroup>();
		val7.alpha = 1f;
		val7.interactable = true;
		val7.blocksRaycasts = true;
		Text val8 = CreateText("MainTitle", m_wikiWindow.transform, "Das Lexikon von Aurai", 32, (TextAnchor)4);
		SetRect(((Graphic)val8).rectTransform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(80f, -70f), new Vector2(-80f, 0f));
		Button val9 = CreateButton("CloseButton", m_wikiWindow.transform, "X");
		RectTransform component2 = ((Component)val9).GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(1f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(1f, 1f);
		component2.anchoredPosition = new Vector2(-15f, -15f);
		component2.sizeDelta = new Vector2(55f, 55f);
		((UnityEvent)val9.onClick).AddListener(new UnityAction(CloseWiki));
		CreateSeparator(m_wikiWindow.transform, new Vector2(25f, -84f), new Vector2(-25f, -78f));
		GameObject val10 = CreatePanel("LeftPanel", m_wikiWindow.transform);
		RectTransform component3 = val10.GetComponent<RectTransform>();
		component3.anchorMin = new Vector2(0f, 0f);
		component3.anchorMax = new Vector2(0f, 1f);
		component3.pivot = new Vector2(0f, 0.5f);
		component3.anchoredPosition = new Vector2(30f, -35f);
		component3.sizeDelta = new Vector2(330f, -120f);
		m_searchField = CreateSearchField(val10.transform);
		RectTransform component4 = ((Component)m_searchField).GetComponent<RectTransform>();
		component4.anchorMin = new Vector2(0f, 1f);
		component4.anchorMax = new Vector2(1f, 1f);
		component4.pivot = new Vector2(0.5f, 1f);
		component4.anchoredPosition = Vector2.zero;
		component4.sizeDelta = new Vector2(0f, 48f);
		((UnityEvent<string>)(object)m_searchField.onValueChanged).AddListener((UnityAction<string>)OnSearchChanged);
		GameObject val11 = CreatePanel("EntryListViewport", val10.transform);
		RectTransform component5 = val11.GetComponent<RectTransform>();
		component5.anchorMin = new Vector2(0f, 0f);
		component5.anchorMax = new Vector2(1f, 1f);
		component5.offsetMin = Vector2.zero;
		component5.offsetMax = new Vector2(-20f, -65f);
		Image val12 = val11.AddComponent<Image>();
		((Graphic)val12).color = new Color(0f, 0f, 0f, 0.01f);
		Mask val13 = val11.AddComponent<Mask>();
		val13.showMaskGraphic = false;
		m_entryListScrollRect = val11.AddComponent<ScrollRect>();
		GameObject val14 = CreateUIObject("EntryListContent", val11.transform);
		m_entryListContent = val14.GetComponent<RectTransform>();
		m_entryListContent.anchorMin = new Vector2(0f, 1f);
		m_entryListContent.anchorMax = new Vector2(1f, 1f);
		m_entryListContent.pivot = new Vector2(0.5f, 1f);
		m_entryListContent.anchoredPosition = Vector2.zero;
		m_entryListContent.sizeDelta = Vector2.zero;
		VerticalLayoutGroup val15 = val14.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)val15).spacing = 8f;
		((HorizontalOrVerticalLayoutGroup)val15).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)val15).childForceExpandWidth = true;
		ContentSizeFitter val16 = val14.AddComponent<ContentSizeFitter>();
		val16.verticalFit = (FitMode)2;
		m_entryListScrollRect.content = m_entryListContent;
		m_entryListScrollRect.viewport = component5;
		m_entryListScrollRect.horizontal = false;
		m_entryListScrollRect.vertical = true;
		m_entryListScrollRect.movementType = (MovementType)2;
		m_entryListScrollRect.scrollSensitivity = 45f;
		CreateLeftScrollbar(val10.transform);
		GameObject val17 = CreatePanel("RightPanel", m_wikiWindow.transform);
		RectTransform component6 = val17.GetComponent<RectTransform>();
		component6.anchorMin = new Vector2(0f, 0f);
		component6.anchorMax = new Vector2(1f, 1f);
		component6.offsetMin = new Vector2(390f, 35f);
		component6.offsetMax = new Vector2(-35f, -100f);
		m_articleTitle = CreateText("ArticleTitle", val17.transform, "", 30, (TextAnchor)3);
		SetRect(((Graphic)m_articleTitle).rectTransform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -60f), new Vector2(0f, 0f));
		m_articleCategory = CreateText("ArticleCategory", val17.transform, "", 18, (TextAnchor)3);
		SetRect(((Graphic)m_articleCategory).rectTransform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -110f), new Vector2(0f, -68f));
		CreateSeparator(val17.transform, new Vector2(0f, -130f), new Vector2(0f, -124f));
		GameObject val18 = CreatePanel("ArticleViewport", val17.transform);
		RectTransform component7 = val18.GetComponent<RectTransform>();
		component7.anchorMin = Vector2.zero;
		component7.anchorMax = Vector2.one;
		component7.offsetMin = Vector2.zero;
		component7.offsetMax = new Vector2(0f, -145f);
		Image val19 = val18.AddComponent<Image>();
		((Graphic)val19).color = new Color(0f, 0f, 0f, 0.01f);
		Mask val20 = val18.AddComponent<Mask>();
		val20.showMaskGraphic = false;
		m_articleScrollRect = val18.AddComponent<ScrollRect>();
		m_articleScrollRect.horizontal = false;
		m_articleScrollRect.vertical = true;
		m_articleScrollRect.movementType = (MovementType)2;
		m_articleScrollRect.scrollSensitivity = 45f;
		GameObject val21 = CreateUIObject("ArticleContent", val18.transform);
		m_articleContent = val21.GetComponent<RectTransform>();
		m_articleContent.anchorMin = new Vector2(0f, 1f);
		m_articleContent.anchorMax = new Vector2(1f, 1f);
		m_articleContent.pivot = new Vector2(0.5f, 1f);
		m_articleContent.anchoredPosition = Vector2.zero;
		m_articleContent.sizeDelta = Vector2.zero;
		VerticalLayoutGroup val22 = val21.AddComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)val22).spacing = 10f;
		((HorizontalOrVerticalLayoutGroup)val22).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)val22).childForceExpandHeight = false;
		ContentSizeFitter val23 = val21.AddComponent<ContentSizeFitter>();
		val23.verticalFit = (FitMode)2;
		m_articleScrollRect.content = m_articleContent;
		m_articleScrollRect.viewport = component7;
		m_wikiWindow.SetActive(true);
		m_wikiWindow.transform.SetAsLastSibling();
	}

	private void CreateLeftScrollbar(Transform leftPanel)
	{
		//IL_001f: 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_004b: 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_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUIObject("EntryListScrollbar", leftPanel);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(1f, 0f);
		component.anchorMax = new Vector2(1f, 1f);
		component.pivot = new Vector2(1f, 0.5f);
		component.offsetMin = new Vector2(-14f, 0f);
		component.offsetMax = new Vector2(0f, -65f);
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = new Color(0.08f, 0.06f, 0.03f, 0.85f);
		m_entryListScrollbar = val.AddComponent<Scrollbar>();
		m_entryListScrollbar.direction = (Direction)2;
		GameObject val3 = CreateUIObject("Sliding Area", val.transform);
		RectTransform component2 = val3.GetComponent<RectTransform>();
		StretchRect(component2);
		component2.offsetMin = new Vector2(2f, 2f);
		component2.offsetMax = new Vector2(-2f, -2f);
		GameObject val4 = CreateUIObject("Handle", val3.transform);
		RectTransform component3 = val4.GetComponent<RectTransform>();
		StretchRect(component3);
		Image val5 = val4.AddComponent<Image>();
		((Graphic)val5).color = new Color(0.72f, 0.55f, 0.28f, 1f);
		m_entryListScrollbar.handleRect = component3;
		((Selectable)m_entryListScrollbar).targetGraphic = (Graphic)(object)val5;
		m_entryListScrollRect.verticalScrollbar = m_entryListScrollbar;
		m_entryListScrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)0;
		m_entryListScrollRect.verticalScrollbarSpacing = 4f;
	}

	private void ShowCategoryOverview()
	{
		m_currentCategory = WikiCategory.None;
		m_currentViewState = WikiViewState.CategoryOverview;
		m_activeLeftSourceButton = null;
		ClearSearchFieldWithoutRefresh();
		Button val = BuildCategoryOverviewList();
		if ((Object)(object)val != (Object)null)
		{
			FocusButtonReliable(val);
		}
	}

	private Button BuildCategoryOverviewList()
	{
		ClearEntryList();
		Button result = AddCategoryButton("Kochrezepte", WikiCategory.Cooking);
		AddCategoryButton("Alchemie", WikiCategory.Alchemy);
		AddCategoryButton("Handwerk", WikiCategory.Crafting);
		AddCategoryButton("Verzauberungen", WikiCategory.Enchantments);
		AddCategoryButton("Items", WikiCategory.Items);
		AddCategoryButton("★ Favoriten", WikiCategory.Favorites);
		SetArticleHeader("Das Lexikon von Aurai", "Übersicht");
		ClearArticleContent();
		AddArticleParagraph("Wähle links eine Kategorie aus oder nutze die Suche für alle Bereiche.");
		RebuildLeftListNavigation();
		return result;
	}

	private Button AddCategoryButton(string label, WikiCategory category)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Expected O, but got Unknown
		Button val = CreateListButton(label);
		((UnityEvent)val.onClick).AddListener((UnityAction)delegate
		{
			ShowCategory(category);
		});
		return val;
	}

	private void ShowCategory(WikiCategory category)
	{
		m_currentCategory = category;
		m_currentViewState = WikiViewState.CategoryList;
		m_activeLeftSourceButton = null;
		ClearSearchFieldWithoutRefresh();
		RefreshCurrentCategoryList("");
		SetArticleHeader(GetCategoryDisplayName(category), "Kategorie");
		ClearArticleContent();
		AddArticleParagraph("Wähle links einen Eintrag aus.");
	}

	private void OnSearchChanged(string searchText)
	{
		if (m_focusCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(m_focusCoroutine);
			m_focusCoroutine = null;
		}
		if (m_currentCategory == WikiCategory.None)
		{
			RefreshGlobalSearchResults(searchText);
		}
		else
		{
			RefreshCurrentCategoryList(searchText);
		}
	}

	private void RefreshGlobalSearchResults(string searchText)
	{
		bool isSearchFieldFocused = IsSearchFieldFocused;
		m_currentViewState = WikiViewState.CategoryOverview;
		if (string.IsNullOrWhiteSpace(searchText))
		{
			BuildCategoryOverviewList();
			if (isSearchFieldFocused)
			{
				ReassertSearchFieldFocus();
			}
			return;
		}
		ClearEntryList();
		ClearArticleContent();
		SetArticleHeader("Globale Suche", "Alle Kategorien");
		string text = searchText.Trim();
		int num = 0;
		foreach (WikiItemData item in m_items.OrderBy(GetItemDisplayName))
		{
			if (num >= 150)
			{
				break;
			}
			string itemDisplayName = GetItemDisplayName(item);
			if (ItemMatchesSearch(item, text))
			{
				WikiItemData captured = item;
				CreateFavoriteListButton("[Item] " + itemDisplayName, GetFavoriteKey(item), delegate
				{
					ShowItem(captured, null, null);
				});
				num++;
			}
		}
		foreach (WikiRecipeData item2 in GetAllWikiRecipes().OrderBy(GetRecipeDisplayName))
		{
			if (num >= 150)
			{
				break;
			}
			string recipeDisplayName = GetRecipeDisplayName(item2);
			if (RecipeMatchesSearch(item2, text))
			{
				WikiRecipeData captured2 = item2;
				CreateFavoriteListButton("[" + GetCategoryDisplayName(GetWikiCategoryForRecipe(item2)) + "] " + recipeDisplayName, GetFavoriteKey(item2), delegate
				{
					ShowRecipe(captured2);
				});
				num++;
			}
		}
		foreach (WikiEnchantmentData item3 in m_enchantments.OrderBy(GetEnchantmentDisplayName))
		{
			if (num >= 150)
			{
				break;
			}
			string enchantmentDisplayName = GetEnchantmentDisplayName(item3);
			if (ContainsIgnoreCase(enchantmentDisplayName, text) || ContainsIgnoreCase(item3.description, text))
			{
				WikiEnchantmentData captured3 = item3;
				CreateFavoriteListButton("[Verzauberung] " + enchantmentDisplayName, GetFavoriteKey(item3), delegate
				{
					ShowEnchantment(captured3);
				});
				num++;
			}
		}
		if (num == 0)
		{
			CreateInfoListEntry("Keine Einträge gefunden.");
		}
		AddArticleParagraph((num >= 150) ? ("Es werden maximal " + 150 + " Treffer angezeigt.") : (num + " Treffer gefunden."));
		Canvas.ForceUpdateCanvases();
		RebuildLeftListNavigation();
		if (isSearchFieldFocused)
		{
			ReassertSearchFieldFocus();
		}
		else
		{
			FocusFirstListButton(skipBackButton: false);
		}
	}

	private void RefreshCurrentCategoryList(string searchText)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Expected O, but got Unknown
		bool isSearchFieldFocused = IsSearchFieldFocused;
		ClearEntryList();
		Button val = CreateListButton("← Kategorien");
		((UnityEvent)val.onClick).AddListener(new UnityAction(ShowCategoryOverview));
		switch (m_currentCategory)
		{
		case WikiCategory.Cooking:
			PopulateRecipeButtons(m_cookingRecipes, searchText);
			break;
		case WikiCategory.Alchemy:
			PopulateRecipeButtons(m_alchemyRecipes, searchText);
			break;
		case WikiCategory.Crafting:
			PopulateRecipeButtons(m_craftingRecipes, searchText);
			break;
		case WikiCategory.Enchantments:
			PopulateEnchantmentButtons(searchText);
			break;
		case WikiCategory.Items:
			PopulateItemButtons(searchText);
			break;
		case WikiCategory.Favorites:
			PopulateFavoriteButtons(searchText);
			break;
		}
		Canvas.ForceUpdateCanvases();
		RebuildLeftListNavigation();
		if (isSearchFieldFocused)
		{
			ReassertSearchFieldFocus();
		}
		else
		{
			FocusFirstListButton(skipBackButton: true);
		}
	}

	private void PopulateRecipeButtons(IEnumerable<WikiRecipeData> recipes, string searchText)
	{
		IEnumerable<WikiRecipeData> source = recipes;
		if (!string.IsNullOrWhiteSpace(searchText))
		{
			source = source.Where((WikiRecipeData recipe) => RecipeMatchesSearch(recipe, searchText));
		}
		List<WikiRecipeData> list = source.OrderBy(GetRecipeDisplayName).ToList();
		if (list.Count == 0)
		{
			CreateInfoListEntry("Keine Einträge gefunden.");
			return;
		}
		foreach (WikiRecipeData item in list)
		{
			WikiRecipeData capturedRecipe = item;
			string favoriteKey = GetFavoriteKey(item);
			CreateFavoriteListButton(GetRecipeDisplayName(item), favoriteKey, delegate
			{
				ShowRecipe(capturedRecipe);
			});
		}
	}

	private bool RecipeMatchesSearch(WikiRecipeData recipe, string query)
	{
		if (recipe == null || string.IsNullOrWhiteSpace(query))
		{
			return recipe != null;
		}
		return ContainsIgnoreCase(GetRecipeDisplayName(recipe), query) || ContainsIgnoreCase(recipe.fallbackName, query) || ContainsIgnoreCase(recipe.description, query) || ContainsIgnoreCase(recipe.descriptionDe, query) || ContainsIgnoreCase(recipe.descriptionEn, query) || ContainsIgnoreCase(recipe.station, query) || ContainsIgnoreCase(recipe.stationDe, query) || ContainsIgnoreCase(recipe.stationEn, query) || ContainsIgnoreCase(recipe.recipeKind, query) || (recipe.gameRecipeId > 0 && recipe.gameRecipeId.ToString().Contains(query)) || (recipe.gameResultItemId > 0 && recipe.gameResultItemId.ToString().Contains(query));
	}

	private bool ItemMatchesSearch(WikiItemData item, string query)
	{
		if (item == null || string.IsNullOrWhiteSpace(query))
		{
			return item != null;
		}
		if (ContainsIgnoreCase(GetItemDisplayName(item), query) || ContainsIgnoreCase(item.fallbackName, query) || ContainsIgnoreCase(item.fallbackDescription, query) || ContainsIgnoreCase(item.sourceType, query) || ContainsIgnoreCase(item.sourceTypeDe, query) || ContainsIgnoreCase(item.sourceTypeEn, query) || ContainsIgnoreCase(item.sourceTypeKey, query) || item.gameItemId.ToString().Contains(query))
		{
			return true;
		}
		IEnumerable<string>[] array = new IEnumerable<string>[18]
		{
			item.locations, item.locationsDe, item.locationsEn, item.dropsFrom, item.dropsFromDe, item.dropsFromEn, item.questSources, item.questSourcesDe, item.questSourcesEn, item.questRewards,
			item.questRewardsDe, item.questRewardsEn, item.blacksmithSources, item.blacksmithSourcesDe, item.blacksmithSourcesEn, item.sourceNotes, item.sourceNotesDe, item.sourceNotesEn
		};
		IEnumerable<string>[] array2 = array;
		foreach (IEnumerable<string> enumerable in array2)
		{
			if (enumerable != null && enumerable.Any((string source) => ContainsIgnoreCase(source, query)))
			{
				return true;
			}
		}
		bool flag = false;
		if (m_legacyUpgradesBySourceItemId.TryGetValue(item.gameItemId, out var value))
		{
			flag = true;
			if (LegacyUpgradesMatchSearch(value, query))
			{
				return true;
			}
		}
		if (m_legacyUpgradesByResultItemId.TryGetValue(item.gameItemId, out value))
		{
			flag = true;
			if (LegacyUpgradesMatchSearch(value, query))
			{
				return true;
			}
		}
		if (flag && m_legacyUpgradeFile != null)
		{
			if (m_legacyUpgradeFile.description != null && (ContainsIgnoreCase(m_legacyUpgradeFile.description.de, query) || ContainsIgnoreCase(m_legacyUpgradeFile.description.en, query)))
			{
				return true;
			}
			if (m_legacyUpgradeFile.chestLocations != null && m_legacyUpgradeFile.chestLocations.Any((WikiLegacyChestLocation location) => location != null && (ContainsIgnoreCase(location.regionDe, query) || ContainsIgnoreCase(location.regionEn, query) || ContainsIgnoreCase(location.locationDe, query) || ContainsIgnoreCase(location.locationEn, query) || ContainsIgnoreCase(location.accessDe, query) || ContainsIgnoreCase(location.accessEn, query))))
			{
				return true;
			}
		}
		return false;
	}

	private bool LegacyUpgradesMatchSearch(IEnumerable<WikiLegacyUpgradeData> upgrades, string query)
	{
		return upgrades?.Any((WikiLegacyUpgradeData upgrade) => upgrade != null && (ContainsIgnoreCase(upgrade.sourceFallbackName, query) || ContainsIgnoreCase(upgrade.sourceWikiName, query) || (upgrade.sourceAliases != null && upgrade.sourceAliases.Any((string alias) => ContainsIgnoreCase(alias, query))) || ContainsIgnoreCase(upgrade.resultFallbackName, query) || ContainsIgnoreCase(upgrade.resultWikiName, query) || (upgrade.resultAliases != null && upgrade.resultAliases.Any((string alias) => ContainsIgnoreCase(alias, query))) || ContainsIgnoreCase(upgrade.sourceTypeKey, query))) ?? false;
	}

	private void PopulateEnchantmentButtons(string searchText)
	{
		IEnumerable<WikiEnchantmentData> source = m_enchantments;
		if (!string.IsNullOrWhiteSpace(searchText))
		{
			source = source.Where((WikiEnchantmentData enchantment) => ContainsIgnoreCase(GetEnchantmentDisplayName(enchantment), searchText) || ContainsIgnoreCase(enchantment.description, searchText));
		}
		List<WikiEnchantmentData> list = source.OrderBy(GetEnchantmentDisplayName).ToList();
		if (list.Count == 0)
		{
			CreateInfoListEntry("Keine Einträge gefunden.");
			return;
		}
		foreach (WikiEnchantmentData item in list)
		{
			WikiEnchantmentData captured = item;
			string favoriteKey = GetFavoriteKey(item);
			CreateFavoriteListButton(GetEnchantmentDisplayName(item), favoriteKey, delegate
			{
				ShowEnchantment(captured);
			});
		}
	}

	private void PopulateItemButtons(string searchText)
	{
		IEnumerable<WikiItemData> source = m_items;
		if (!string.IsNullOrWhiteSpace(searchText))
		{
			source = source.Where((WikiItemData item) => ItemMatchesSearch(item, searchText));
		}
		List<WikiItemData> list = source.ToList();
		List<WikiItemData> list2 = list.OrderBy(GetItemDisplayName).Take(150).ToList();
		if (list2.Count == 0)
		{
			CreateInfoListEntry("Keine Items gefunden.");
			return;
		}
		foreach (WikiItemData item in list2)
		{
			WikiItemData capturedItem = item;
			string favoriteKey = GetFavoriteKey(item);
			CreateFavoriteListButton(GetItemDisplayName(item), favoriteKey, delegate
			{
				m_activeLeftSourceButton = GetCurrentLeftButtonOrFallback();
				ShowItem(capturedItem, null, null);
			});
		}
		if (list.Count > 150)
		{
			CreateInfoListEntry("Es werden maximal 150 Items angezeigt. Nutze die Suche für weitere Treffer.");
		}
	}

	private void PopulateFavoriteButtons(string searchText)
	{
		int num = 0;
		foreach (WikiItemData item in m_items.OrderBy(GetItemDisplayName))
		{
			string favoriteKey = GetFavoriteKey(item);
			string itemDisplayName = GetItemDisplayName(item);
			if (IsFavorite(favoriteKey) && MatchesSearch(itemDisplayName, searchText))
			{
				WikiItemData captured = item;
				CreateFavoriteListButton("[Item] " + itemDisplayName, favoriteKey, delegate
				{
					ShowItem(captured, null, null);
				});
				num++;
			}
		}
		foreach (WikiRecipeData item2 in GetAllWikiRecipes().OrderBy(GetRecipeDisplayName))
		{
			string favoriteKey2 = GetFavoriteKey(item2);
			string recipeDisplayName = GetRecipeDisplayName(item2);
			if (IsFavorite(favoriteKey2) && MatchesSearch(recipeDisplayName, searchText))
			{
				WikiRecipeData captured2 = item2;
				CreateFavoriteListButton("[" + GetCategoryDisplayName(GetWikiCategoryForRecipe(item2)) + "] " + recipeDisplayName, favoriteKey2, delegate
				{
					ShowRecipe(captured2);
				});
				num++;
			}
		}
		foreach (WikiEnchantmentData item3 in m_enchantments.OrderBy(GetEnchantmentDisplayName))
		{
			string favoriteKey3 = GetFavoriteKey(item3);
			string enchantmentDisplayName = GetEnchantmentDisplayName(item3);
			if (IsFavorite(favoriteKey3) && MatchesSearch(enchantmentDisplayName, searchText))
			{
				WikiEnchantmentData captured3 = item3;
				CreateFavoriteListButton("[Verzauberung] " + enchantmentDisplayName, favoriteKey3, delegate
				{
					ShowEnchantment(captured3);
				});
				num++;
			}
		}
		if (num == 0)
		{
			CreateInfoListEntry("Keine Favoriten gefunden.");
		}
	}

	private bool MatchesSearch(string label, string searchText)
	{
		return string.IsNullOrWhiteSpace(searchText) || ContainsIgnoreCase(label, searchText);
	}

	private Button CreateFavoriteListButton(string label, string favoriteKey, Action openAction)
	{
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Expected O, but got Unknown
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Expected O, but got Unknown
		GameObject val = CreateUIObject("FavoriteEntryRow_" + label, (Transform)(object)m_entryListContent);
		LayoutElement val2 = val.AddComponent<LayoutElement>();
		val2.preferredHeight = 58f;
		HorizontalLayoutGroup val3 = val.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)val3).spacing = 6f;
		((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = true;
		((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
		Button val4 = CreateButton("Entry_" + label, val.transform, label);
		LayoutElement val5 = ((Component)val4).gameObject.AddComponent<LayoutElement>();
		val5.preferredWidth = 270f;
		val5.flexibleWidth = 1f;
		val5.preferredHeight = 58f;
		if (openAction != null)
		{
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				openAction();
			});
		}
		Button starButton = CreateButton("FavoriteStar_" + favoriteKey, val.transform, IsFavorite(favoriteKey) ? "★" : "☆");
		LayoutElement val6 = ((Component)starButton).gameObject.AddComponent<LayoutElement>();
		val6.preferredWidth = 48f;
		val6.preferredHeight = 58f;
		((UnityEvent)starButton.onClick).AddListener((UnityAction)delegate
		{
			ToggleFavorite(favoriteKey, starButton);
		});
		m_leftMainToStar[val4] = starButton;
		m_leftStarToMain[starButton] = val4;
		return val4;
	}

	private void ReassertSearchFieldFocus()
	{
		if (!((Object)(object)m_searchField == (Object)null) && ((Component)m_searchField).gameObject.activeInHierarchy)
		{
			if ((Object)(object)m_characterUI != (Object)null)
			{
				m_characterUI.SetSelectedGameObject(((Component)m_searchField).gameObject);
			}
			else if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)m_searchField).gameObject);
			}
			m_searchField.ActivateInputField();
			m_searchField.MoveTextEnd(false);
			((MonoBehaviour)this).StartCoroutine(ReassertSearchFieldFocusNextFrame());
		}
	}

	private IEnumerator ReassertSearchFieldFocusNextFrame()
	{
		yield return null;
		if (!((Object)(object)m_searchField == (Object)null) && ((Component)m_searchField).gameObject.activeInHierarchy)
		{
			if ((Object)(object)m_characterUI != (Object)null)
			{
				m_characterUI.SetSelectedGameObject(((Component)m_searchField).gameObject);
			}
			else if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)m_searchField).gameObject);
			}
			m_searchField.ActivateInputField();
			m_searchField.MoveTextEnd(false);
		}
	}

	private void ShowRecipe(WikiRecipeData recipe)
	{
		ShowRecipe(recipe, null, null);
	}

	private void ShowRecipe(WikiRecipeData recipe, Action backAction, string backLabel)
	{
		if (recipe != null)
		{
			m_currentCategory = GetWikiCategoryForRecipe(recipe);
			m_currentViewState = WikiViewState.Article;
			Button currentLeftButtonOrFallback = GetCurrentLeftButtonOrFallback();
			if ((Object)(object)currentLeftButtonOrFallback != (Object)null)
			{
				m_activeLeftSourceButton = currentLeftButtonOrFallback;
			}
			string recipeDisplayName = GetRecipeDisplayName(recipe);
			Recipe gameRecipe = FindGameRecipe(recipe);
			SetArticleHeader(recipeDisplayName, string.IsNullOrWhiteSpace(recipe.category) ? GetCategoryDisplayName(m_currentCategory) : recipe.category);
			ClearArticleContent();
			if (backAction != null)
			{
				Button item = CreateArticleBackButton(string.IsNullOrWhiteSpace(backLabel) ? "← Zurück" : backLabel, backAction);
				m_articleButtonRows.Add(new List<Button> { item });
			}
			if (recipe.isTestData)
			{
				AddArticleParagraph("⚠ TESTDATENSATZ");
			}
			string localizedRecipeDescription = GetLocalizedRecipeDescription(recipe);
			if (!string.IsNullOrWhiteSpace(localizedRecipeDescription))
			{
				AddArticleParagraph(localizedRecipeDescription);
			}
			string text = GetLocalizedRecipeStation(recipe);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = GetRecipeStationDisplayName(gameRecipe);
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				AddArticleHeading("Herstellungsstation");
				AddArticleParagraph(text);
			}
			if (recipe.silverCost > 0)
			{
				AddArticleHeading(L("Kosten", "Cost"));
				AddArticleParagraph(recipe.silverCost + L(" Silber", " silver"));
			}
			Action action = delegate
			{
				ShowRecipe(recipe, backAction, backLabel);
			};
			AddArticleHeading("Zutaten");
			List<WikiItemReference> effectiveRecipeIngredients = GetEffectiveRecipeIngredients(recipe, gameRecipe);
			if (effectiveRecipeIngredients.Count == 0)
			{
				AddArticleParagraph("Keine Zutaten hinterlegt.");
			}
			else
			{
				AddRecipeIngredientGrid(recipe, gameRecipe, recipeDisplayName, effectiveRecipeIngredients, action);
			}
			AddArticleHeading("Ergebnis");
			List<WikiItemReference> effectiveRecipeResults = GetEffectiveRecipeResults(recipe, gameRecipe);
			if (effectiveRecipeResults.Count == 0)
			{
				AddArticleParagraph("Kein Ergebnis hinterlegt.");
			}
			else
			{
				AddConcreteItemGrid(effectiveRecipeResults, action, "← Zurück zu " + recipeDisplayName);
			}
			Canvas.ForceUpdateCanvases();
			RebuildArticleNavigation();
		}
	}

	private string GetLocalizedRecipeDescription(WikiRecipeData recipe)
	{
		if (recipe == null)
		{
			return "";
		}
		return SelectLocalizedSourceString(recipe.description, recipe.descriptionDe, recipe.descriptionEn) ?? "";
	}

	private string GetLocalizedRecipeStation(WikiRecipeData recipe)
	{
		if (recipe == null)
		{
			return "";
		}
		return SelectLocalizedSourceString(recipe.station, recipe.stationDe, recipe.stationEn) ?? "";
	}

	private string GetRecipeStationDisplayName(Recipe gameRecipe)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)gameRecipe == (Object)null)
		{
			return "";
		}
		try
		{
			return ((object)gameRecipe.CraftingStationType/*cast due to .constrained prefix*/).ToString();
		}
		catch
		{
			return "";
		}
	}

	private List<WikiItemReference> GetEffectiveRecipeIngredients(WikiRecipeData recipe, Recipe gameRecipe)
	{
		if (recipe != null && recipe.ingredients != null && recipe.ingredients.Count > 0)
		{
			return GetNormalizedWikiIngredientsForMatching(recipe);
		}
		List<WikiItemReference> list = new List<WikiItemReference>();
		if ((Object)(object)gameRecipe == (Object)null || gameRecipe.Ingredients == null)
		{
			return list;
		}
		bool flag = IsCleanWaterRecipe(recipe, gameRecipe);
		RecipeIngredient[] ingredients = gameRecipe.Ingredients;
		foreach (RecipeIngredient val in ingredients)
		{
			if (val == null)
			{
				continue;
			}
			List<Item> list2 = GetMatchingItems(val);
			if (flag)
			{
				list2 = list2.Where((Item x) => x.ItemID != 5600000).ToList();
			}
			if (list2.Count == 1)
			{
				list.Add(new WikiItemReference
				{
					gameItemId = list2[0].ItemID,
					amount = 1,
					fallbackName = GetGameItemDisplayName(list2[0])
				});
			}
			else
			{
				list.Add(new WikiItemReference
				{
					gameItemId = 0,
					amount = 1,
					ingredientCategory = (flag ? "Water" : ""),
					fallbackName = (flag ? "Water" : GetGenericIngredientDisplayName(null, val))
				});
			}
		}
		return list;
	}

	private bool IsCleanWaterRecipe(WikiRecipeData wikiRecipe, Recipe gameRecipe)
	{
		if (wikiRecipe != null)
		{
			if (wikiRecipe.gameResultItemId == 5600000)
			{
				return true;
			}
			if (wikiRecipe.results != null && wikiRecipe.results.Any((WikiItemReference x) => x != null && x.gameItemId == 5600000))
			{
				return true;
			}
		}
		if ((Object)(object)gameRecipe != (Object)null && gameRecipe.Results != null)
		{
			return gameRecipe.Results.Any((ItemReferenceQuantity x) => x.ItemID == 5600000);
		}
		return false;
	}

	private List<Item> GetMatchingItemsForRecipeIngredient(RecipeIngredient ingredient, WikiRecipeData sourceRecipe, Recipe gameRecipe)
	{
		if (IsCleanWaterRecipe(sourceRecipe, gameRecipe))
		{
			return GetCleanWaterSourceItems(ingredient);
		}
		return GetMatchingItems(ingredient);
	}

	private List<Item> GetCleanWaterSourceItems(RecipeIngredient fallbackIngredient)
	{
		List<Item> list = (from item in m_allGameItemPrefabs
			where (Object)(object)item != (Object)null && item.ItemID > 0 && item.ItemID != 5600000 && item is WaterItem && IsDisplayableGameItem(item, requireWikiEntry: false)
			group item by item.ItemID into @group
			select @group.First()).OrderBy(GetGameItemDisplayName).ToList();
		if (list.Count > 1 || fallbackIngredient == null)
		{
			return list;
		}
		return (from item in GetMatchingItems(fallbackIngredient)
			where (Object)(object)item != (Object)null && item.ItemID != 5600000 && IsDisplayableGameItem(item, requireWikiEntry: false)
			group item by item.ItemID into @group
			select @group.First()).OrderBy(GetGameItemDisplayName).ToList();
	}

	private bool IsPlayerFacingWikiItem(Item item)
	{
		return IsDisplayableGameItem(item, requireWikiEntry: false);
	}

	private bool IsDisplayableGameItem(Item item, bool requireWikiEntry)
	{
		if ((Object)(object)item == (Object)null || item.ItemID <= 0)
		{
			return false;
		}
		if (requireWikiEntry && !m_itemsByGameId.ContainsKey(item.ItemID))
		{
			return false;
		}
		string gameItemDisplayName = GetGameItemDisplayName(item);
		if (string.IsNullOrWhiteSpace(gameItemDisplayName))
		{
			return false;
		}
		gameItemDisplayName = gameItemDisplayName.Trim();
		if (gameItemDisplayName == "-" || gameItemDisplayName.Equals("Unbekanntes Item", StringComparison.OrdinalIgnoreCase) || gameItemDisplayName.StartsWith("Item ", StringComparison.OrdinalIgnoreCase) || LooksLikeInternalItemName(gameItemDisplayName))
		{
			return false;
		}
		return (Object)(object)GetGameItemIcon(item.ItemID) != (Object)null;
	}

	private bool LooksLikeInternalItemName(string displayName)
	{
		if (string.IsNullOrWhiteSpace(displayName))
		{
			return true;
		}
		if (displayName.IndexOf('_') >= 0 || displayName.IndexOf("Dummy", StringComparison.OrdinalIgnoreCase) >= 0 || displayName.IndexOf("Template", StringComparison.OrdinalIgnoreCase) >= 0 || displayName.IndexOf("NPC", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (displayName.Any(char.IsWhiteSpace))
		{
			return false;
		}
		for (int i = 1; i < displayName.Length; i++)
		{
			if (char.IsLower(displayName[i - 1]) && char.IsUpper(displayName[i]))
			{
				return true;
			}
		}
		return false;
	}

	private List<WikiItemReference> GetEffectiveRecipeResults(WikiRecipeData recipe, Recipe gameRecipe)
	{
		if (recipe != null && recipe.results != null && recipe.results.Count > 0)
		{
			return recipe.results;
		}
		List<WikiItemReference> list = new List<WikiItemReference>();
		if ((Object)(object)gameRecipe == (Object)null || gameRecipe.Results == null)
		{
			return list;
		}
		ItemReferenceQuantity[] results = gameRecipe.Results;
		foreach (ItemReferenceQuantity val in results)
		{
			if (val.ItemID > 0)
			{
				list.Add(new WikiItemReference
				{
					gameItemId = val.ItemID,
					amount = Math.Max(1, GetIntMember(val, "Quantity", "Amount"))
				});
			}
		}
		return list;
	}

	private void AddRecipeIngredientGrid(WikiRecipeData recipe, Recipe gameRecipe, string recipeName, List<WikiItemReference> ingredients, Action returnToRecipe)
	{
		List<RecipeIngredient> list = ResolveRuntimeIngredients(recipe, gameRecipe, ingredients);
		for (int i = 0; i < ingredients.Count; i += 4)
		{
			GameObject val = CreateItemSlotRow("IngredientRow_" + i);
			List<Button> list2 = new List<Button>();
			int num = Mathf.Min(i + 4, ingredients.Count);
			for (int j = i; j < num; j++)
			{
				RecipeIngredient realIngredient = ((j < list.Count) ? list[j] : null);
				Button val2 = CreateRecipeIngredientSlot(val.transform, ingredients[j], realIngredient, recipe, gameRecipe, recipeName, returnToRecipe);
				if ((Object)(object)val2 != (Object)null && ((Selectable)val2).interactable)
				{
					list2.Add(val2);
				}
			}
			if (list2.Count > 0)
			{
				m_articleButtonRows.Add(list2);
			}
		}
	}

	private Button CreateRecipeIngredientSlot(Transform parent, WikiItemReference wikiReference, RecipeIngredient realIngredient, WikiRecipeData sourceRecipe, Recipe gameRecipe, string sourceRecipeName, Action returnToRecipe)
	{
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_015a: Expected O, but got Unknown
		if (wikiReference == null)
		{
			return null;
		}
		if (wikiReference.gameItemId > 0)
		{
			Action action = returnToRecipe;
			if (action == null)
			{
				action = delegate
				{
					ShowRecipe(sourceRecipe);
				};
			}
			return CreateConcreteItemSlot(parent, wikiReference, action, "← Zurück zu " + sourceRecipeName);
		}
		string genericName = GetGenericIngredientDisplayName(wikiReference, realIngredient);
		List<Item> matchingItemsForRecipeIngredient = GetMatchingItemsForRecipeIngredient(realIngredient, sourceRecipe, gameRecipe);
		Item val = ((matchingItemsForRecipeIngredient.Count > 0) ? matchingItemsForRecipeIngredient[0] : null);
		Sprite icon = (((Object)(object)val != (Object)null) ? GetGameItemIcon(val.ItemID) : null);
		Button val2 = CreateInventoryStyleSlot(parent, "GenericIngredient_" + genericName, icon, genericName, wikiReference.amount);
		if (realIngredient == null || matchingItemsForRecipeIngredient.Count == 0)
		{
			((Selectable)val2).interactable = false;
			return val2;
		}
		((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
		{
			ShowGenericIngredientOverview(genericName, realIngredient, sourceRecipe, gameRecipe, sourceRecipeName, returnToRecipe);
		});
		return val2;
	}

	private Button CreateConcreteItemSlot(Transform parent, WikiItemReference itemReference, Action backAction, string backLabel)
	{
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Expected O, but got Unknown
		if (itemReference == null)
		{
			return null;
		}
		int gameItemId = itemReference.gameItemId;
		Item gameItemPrefab = GetGameItemPrefab(gameItemId);
		WikiItemData itemByGameId = GetItemByGameId(gameItemId);
		string displayName = (((Object)(object)gameItemPrefab != (Object)null) ? GetGameItemDisplayName(gameItemPrefab) : ((itemByGameId != null) ? GetItemDisplayName(itemByGameId) : (string.IsNullOrWhiteSpace(itemReference.fallbackName) ? ("Item " + gameItemId) : itemReference.fallbackName)));
		Sprite gameItemIcon = GetGameItemIcon(gameItemId);
		Button val = CreateInventoryStyleSlot(parent, "ItemSlot_" + gameItemId, gameItemIcon, displayName, itemReference.amount);
		WikiItemData wikiItemData = itemByGameId;
		if (wikiItemData == null && (Object)(object)gameItemPrefab != (Object)null)
		{
			wikiItemData = GetOrCreateWikiItemData(gameItemPrefab);
		}
		if (wikiItemData != null)
		{
			WikiItemData capturedItem = wikiItemData;
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				ShowItem(capturedItem, backAction, backLabel);
			});
		}
		else
		{
			((Selectable)val).interactable = false;
		}
		return val;
	}

	private void ShowGenericIngredientOverview(string genericName, RecipeIngredient realIngredient, WikiRecipeData sourceRecipe, Recipe gameRecipe, string sourceRecipeName, Action returnToRecipe)
	{
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Expected O, but got Unknown
		if (realIngredient == null)
		{
			return;
		}
		m_currentCategory = GetWikiCategoryForRecipe(sourceRecipe);
		m_currentViewState = WikiViewState.GenericIngredient;
		List<Item> matchingItemsForRecipeIngredient = GetMatchingItemsForRecipeIngredient(realIngredient, sourceRecipe, gameRecipe);
		SetArticleHeader(genericName, "Zutatenkategorie");
		ClearArticleContent();
		Action action = returnToRecipe;
		if (action == null)
		{
			action = delegate
			{
				ShowRecipe(sourceRecipe);
			};
		}
		Button val = CreateArticleBackButton("← Zurück zu " + sourceRecipeName, action);
		m_articleButtonRows.Add(new List<Button> { val });
		AddArticleHeading("Gültige Items für " + genericName);
		if (matchingItemsForRecipeIngredient.Count == 0)
		{
			AddArticleParagraph("Keine passenden Items gefunden.");
			RebuildArticleNavigation();
			FocusButtonReliable(val);
			return;
		}
		for (int num = 0; num < matchingItemsForRecipeIngredient.Count; num += 4)
		{
			GameObject val2 = CreateItemSlotRow("GenericIngredientRow_" + num);
			List<Button> list = new List<Button>();
			int num2 = Mathf.Min(num + 4, matchingItemsForRecipeIngredient.Count);
			for (int num3 = num; num3 < num2; num3++)
			{
				Item val3 = matchingItemsForRecipeIngredient[num3];
				Button val4 = CreateInventoryStyleSlot(val2.transform, "GenericMatch_" + val3.ItemID, GetGameItemIcon(val3.ItemID), GetGameItemDisplayName(val3), 1);
				Item capturedGameItem = val3;
				((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
				{
					WikiItemData orCreateWikiItemData = GetOrCreateWikiItemData(capturedGameItem);
					ShowItem(orCreateWikiItemData, delegate
					{
						ShowGenericIngredientOverview(genericName, realIngredient, sourceRecipe, gameRecipe, sourceRecipeName, returnToRecipe);
					}, "← Zurück zu " + genericName);
				});
				list.Add(val4);
			}
			if (list.Count > 0)
			{
				m_articleButtonRows.Add(list);
			}
		}
		Canvas.ForceUpdateCanvases();
		RebuildArticleNavigation();
		if (m_articleButtonRows.Count > 1 && m_articleButtonRows[1].Count > 0)
		{
			FocusButtonReliable(m_articleButtonRows[1][0]);
		}
		else
		{
			FocusButtonReliable(val);
		}
	}

	private string GetGenericIngredientDisplayName(WikiItemReference wikiReference, RecipeIngredient realIngredient)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		if (realIngredient != null && (int)realIngredient.ActionType == 0 && (Object)(object)TagSourceManager.Instance != (Object)null)
		{
			try
			{
				string anyTagLoc = TagSourceManager.Instance.GetAnyTagLoc(UidSelector<Tag>.op_Implicit((UidSelector<Tag>)(object)realIngredient.AddedIngredientType));
				if (!string.IsNullOrWhiteSpace(anyTagLoc))
				{
					return anyTagLoc;
				}
			}
			catch
			{
			}
		}
		if (wikiReference != null && !string.IsNullOrWhiteSpace(wikiReference.fallbackName))
		{
			return wikiReference.fallbackName;
		}
		if (wikiReference != null && !string.IsNullOrWhiteSpace(wikiReference.ingredientCategory))
		{
			return "Any " + wikiReference.ingredientCategory;
		}
		return "Beliebige Zutat";
	}

	private Button CreateInventoryStyleSlot(Transform parent, string objectName, Sprite icon, string displayName, int amount)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_025a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUIObject(objectName, parent);
		LayoutElement val2 = val.AddComponent<LayoutElement>();
		val2.preferredWidth = 135f;
		val2.preferredHeight = 150f;
		Image val3 = val.AddComponent<Image>();
		val3.sprite = m_buttonSprite;
		((Graphic)val3).color = m_buttonColor;
		val3.type = m_buttonImageType;
		if ((Object)(object)m_buttonMaterial != (Object)null)
		{
			((Graphic)val3).material = m_buttonMaterial;
		}
		Button val4 = val.AddComponent<Button>();
		((Selectable)val4).targetGraphic = (Graphic)(object)val3;
		((Selectable)val4).transition = m_buttonTransition;
		((Selectable)val4).colors = m_buttonColors;
		((Selectable)val4).spriteState = m_buttonSpriteState;
		GameObject val5 = CreateUIObject("Icon", val.transform);
		RectTransform component = val5.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0.5f, 1f);
		component.anchorMax = new Vector2(0.5f, 1f);
		component.pivot = new Vector2(0.5f, 1f);
		component.anchoredPosition = new Vector2(0f, -12f);
		component.sizeDelta = new Vector2(82f, 82f);
		Image val6 = val5.AddComponent<Image>();
		val6.sprite = icon;
		val6.preserveAspect = true;
		((Graphic)val6).raycastTarget = false;
		if ((Object)(object)icon == (Object)null)
		{
			((Graphic)val6).color = new Color(1f, 1f, 1f, 0.12f);
		}
		Text val7 = CreateText("Amount", val.transform, "x" + Mathf.Max(1, amount), 18, (TextAnchor)5);
		RectTransform rectTransform = ((Graphic)val7).rectTransform;
		rectTransform.anchorMin = new Vector2(0.55f, 0.32f);
		rectTransform.anchorMax = new Vector2(0.95f, 0.5f);
		rectTransform.offsetMin = Vector2.zero;
		rectTransform.offsetMax = Vector2.zero;
		((Graphic)val7).raycastTarget = false;
		Text val8 = CreateText("ItemName", val.transform, displayName, 17, (TextAnchor)4);
		RectTransform rectTransform2 = ((Graphic)val8).rectTransform;
		rectTransform2.anchorMin = new Vector2(0.05f, 0.02f);
		rectTransform2.anchorMax = new Vector2(0.95f, 0.32f);
		rectTransform2.offsetMin = Vector2.zero;
		rectTransform2.offsetMax = Vector2.zero;
		val8.resizeTextForBestFit = true;
		val8.resizeTextMinSize = 12;
		val8.resizeTextMaxSize = 17;
		((Graphic)val8).raycastTarget = false;
		return val4;
	}

	private Button CreateArticleTile(Transform parent, string objectName, Sprite icon, string displayName)
	{
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		Button val = CreateInventoryStyleSlot(parent, objectName, icon, displayName, 1);
		Transform val2 = ((Component)val).transform.Find("Amount");
		if ((Object)(object)val2 != (Object)null)
		{
			((Component)val2).gameObject.SetActive(false);
		}
		if ((Object)(object)icon == (Object)null)
		{
			Transform val3 = ((Component)val).transform.Find("Icon");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
			}
			Transform val4 = ((Component)val).transform.Find("ItemName");
			Text val5 = (((Object)(object)val4 == (Object)null) ? null : ((Component)val4).GetComponent<Text>());
			if ((Object)(object)val5 != (Object)null)
			{
				RectTransform rectTransform = ((Graphic)val5).rectTransform;
				rectTransform.anchorMin = new Vector2(0.08f, 0.08f);
				rectTransform.anchorMax = new Vector2(0.92f, 0.92f);
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
				val5.resizeTextMinSize = 13;
				val5.resizeTextMaxSize = 20;
			}
		}
		return val;
	}

	private GameObject CreateItemSlotRow(string name)
	{
		GameObject val = CreateUIObject(name, (Transform)(object)m_articleContent);
		LayoutElement val2 = val.AddComponent<LayoutElement>();
		val2.preferredHeight = 155f;
		HorizontalLayoutGroup val3 = val.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)val3).spacing = 10f;
		((LayoutGroup)val3).childAlignment = (TextAnchor)0;
		((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
		((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = true;
		return val;
	}

	private Button CreateArticleBackButton(string label, Action action)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Expected O, but got Unknown
		Button val = CreateButton("ArticleBackButton", (Transform)(object)m_articleContent, label);
		LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val2.preferredHeight = 48f;
		if (action != null)
		{
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				action();
			});
		}
		return val;
	}

	private void ShowItem(WikiItemData item, Action backAction, string backLabel)
	{
		if (item != null)
		{
			m_currentCategory = WikiCategory.Items;
			m_currentViewState = WikiViewState.Article;
			string itemDisplayName = GetItemDisplayName(item);
			SetArticleHeader(itemDisplayName, "Item");
			ClearArticleContent();
			if (backAction != null)
			{
				Button item2 = CreateArticleBackButton(string.IsNullOrWhiteSpace(backLabel) ? "← Zurück" : backLabel, backAction);
				m_articleButtonRows.Add(new List<Button> { item2 });
			}
			Action returnToItem = delegate
			{
				ShowItem(item, backAction, backLabel);
			};
			Item gameItemPrefab = GetGameItemPrefab(item.gameItemId);
			Sprite gameItemIcon = GetGameItemIcon(item.gameItemId);
			if ((Object)(object)gameItemIcon != (Object)null)
			{
				AddLargeItemIcon(gameItemIcon);
			}
			AddArticleHeading("Item-ID");
			AddArticleParagraph(item.gameItemId.ToString());
			string bestItemDescription = GetBestItemDescription(item, gameItemPrefab);
			if (!string.IsNullOrWhiteSpace(bestItemDescription))
			{
				AddArticleHeading("Beschreibung");
				AddArticleParagraph(bestItemDescription);
			}
			AddItemRuntimeStats(gameItemPrefab, item);
			AddItemCraftingRelationships(item.gameItemId, returnToItem, "← Zurück zu " + itemDisplayName);
			AddItemCompatibleEnchantments(item.gameItemId, returnToItem, "← Zurück zu " + itemDisplayName);
			AddItemLegacyRelationships(item.gameItemId, returnToItem, "← Zurück zu " + itemDisplayName);
			AddItemSources(item, returnToItem, "← Zurück zu " + itemDisplayName);
			Canvas.ForceUpdateCanvases();
			RebuildArticleNavigation();
		}
	}

	private string GetBestItemDescription(WikiItemData wikiItem, Item gameItem)
	{
		if ((Object)(object)gameItem != (Object)null)
		{
			string stringMember = GetStringMember(gameItem, "Description", "DisplayDescription", "ItemDescription");
			if (!string.IsNullOrWhiteSpace(stringMember))
			{
				return stringMember;
			}
		}
		return (wikiItem == null) ? "" : wikiItem.fallbackDescription;
	}

	private void AddItemRuntimeStats(Item gameItem, WikiItemData wikiItem)
	{
		List<string> list = new List<string>();
		float num = 0f;
		float num2 = 0f;
		if ((Object)(object)gameItem != (Object)null)
		{
			object memberValue = GetMemberValue(gameItem, "Stats", "ItemStats", "m_stats");
			bool flag = gameItem is Weapon || ((object)gameItem).GetType().Name.IndexOf("Weapon", StringComparison.OrdinalIgnoreCase) >= 0;
			string name = ((object)gameItem).GetType().Name;
			bool flag2 = name.IndexOf("Food", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Drink", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Consum", StringComparison.OrdinalIgnoreCase) >= 0;
			if (flag)
			{
				AddReflectedStat(list, "Schaden", gameItem, memberValue, "Damage", "Damages", "RawDamage", "BaseDamage");
				AddReflectedStat(list, "Impact", gameItem, memberValue, "Impact", "ImpactDamage");
				AddReflectedStat(list, "Angriffsgeschwindigkeit", gameItem, memberValue, "AttackSpeed", "AtkSpeed");
			}
			AddReflectedStat(list, "Haltbarkeit", gameItem, memberValue, "MaxDurability", "Durability");
			AddReflectedStat(list, "Schutz", gameItem, memberValue, "Protection");
			AddReflectedStat(list, "Barriere", gameItem, memberValue, "Barrier");
			AddReflectedStat(list, "Impact-Widerstand", gameItem, memberValue, "ImpactResistance", "Stability");
			AddReflectedStat(list, "Resistenzen", gameItem, memberValue, "DamageResistance", "ElementalResistances", "Resistances");
			AddReflectedStat(list, "Hitzeschutz", gameItem, memberValue, "HeatProtection", "HotWeatherDef");
			AddReflectedStat(list, "Kälteschutz", gameItem, memberValue, "ColdProtection", "ColdWeatherDef");
			AddReflectedStat(list, "Mana-Kosten", gameItem, memberValue, "ManaCostReduction", "ManaUseModifier");
			AddReflectedStat(list, "Ausdauer-Kosten", gameItem, memberValue, "StaminaCostReduction", "StaminaUseModifier");
			AddReflectedStat(list, "Bewegungsgeschwindigkeit", gameItem, memberValue, "MovementSpeed", "MovementModifier");
			if (flag2 || HasAnyMember(gameItem, "FoodValue", "Hunger", "PerishTime", "DepletionRate"))
			{
				AddReflectedStat(list, "Sättigung", gameItem, memberValue, "FoodValue", "HungerRestored", "FoodRestore", "Nutrition");
				AddReflectedStat(list, "Durst", gameItem, memberValue, "DrinkValue", "WaterValue", "ThirstRestored", "Hydration");
				AddReflectedStat(list, "Haltbarkeit / Verderb", gameItem, memberValue, "PerishTime", "Perishability", "SpoilTime", "DepletionRate");
			}
			AddBackpackCapacityStat(list, gameItem);
			AddReflectedStat(list, "Gewicht", gameItem, memberValue, "Weight");
			num = GetRuntimeBasePrice(gameItem);
			num2 = GetRuntimeSellPrice(gameItem, num);
		}
		if (wikiItem != null)
		{
			AddUniqueLine(list, "Gewicht", (wikiItem.weight > 0f) ? wikiItem.weight.ToString("0.##") : "");
			bool flag3 = IsUnsellableItem(gameItem, wikiItem);
			float num3 = ((num > 0f) ? num : ((float)wikiItem.buyPrice));
			float num4 = (flag3 ? 0f : ((num2 > 0f) ? num2 : ((float)wikiItem.sellPrice)));
			if (!flag3 && UsesEqualBuyAndSellPrice(gameItem, wikiItem) && num3 > 0f)
			{
				num4 = num3;
			}
			AddUniqueLine(list, "Einkaufspreis", (num3 > 0f) ? (num3.ToString("0.##") + " Silber") : "");
			AddUniqueLine(list, "Verkaufspreis (Basis)", flag3 ? L("Nicht verkäuflich", "Not sellable") : ((num4 > 0f) ? (num4.ToString("0.##") + " Silber") : ""));
		}
		else
		{
			bool flag4 = IsUnsellableItem(gameItem, null);
			if (!flag4 && UsesEqualBuyAndSellPrice(gameItem, null) && num > 0f)
			{
				num2 = num;
			}
			AddUniqueLine(list, "Einkaufspreis", (num > 0f) ? (num.ToString("0.##") + " Silber") : "");
			AddUniqueLine(list, "Verkaufspreis (Basis)", flag4 ? L("Nicht verkäuflich", "Not sellable") : ((num2 > 0f) ? (num2.ToString("0.##") + " Silber") : ""));
		}
		List<string> itemEffectDescriptions = GetItemEffectDescriptions(gameItem);
		if (list.Count > 0)
		{
			AddArticleHeading("Werte");
			foreach (string item in list)
			{
				AddArticleParagraph("• " + item);
			}
		}
		if (itemEffectDescriptions.Count <= 0)
		{
			return;
		}
		AddArticleHeading("Effekte");
		foreach (string item2 in itemEffectDescriptions)
		{
			AddArticleParagraph("• " + item2);
		}
	}

	private bool IsUnsellableItem(Item gameItem, WikiItemData wikiItem)
	{
		int item = (((Object)(object)gameItem != (Object)null) ? gameItem.ItemID : (wikiItem?.gameItemId ?? 0));
		if (s_unsellableItemIDs.Contains(item))
		{
			return true;
		}
		List<string> list = new List<string>();
		if ((Object)(object)gameItem != (Object)null)
		{
			list.Add(GetGameItemDisplayName(gameItem));
			list.Add(((Object)gameItem).name);
			list.Add(GetStringMember(gameItem, "Name", "EDITOR_Name", "EditorName", "ItemName", "PrefabName"));
		}
		if (wikiItem != null)
		{
			list.Add(wikiItem.fallbackName);
		}
		foreach (string item2 in list)
		{
			string text = NormalizeLookupText(item2);
			if (s_unsellableItemNames.Contains(text))
			{
				return true;
			}
			foreach (string s_unsellableItemName in s_unsellableItemNames)
			{
				if (text.EndsWith(s_unsellableItemName, StringComparison.Ordinal))
				{
					return true;
				}
			}
		}
		return false;
	}

	private bool UsesEqualBuyAndSellPrice(Item gameItem, WikiItemData wikiItem)
	{
		int item = (((Object)(object)gameItem != (Object)null) ? gameItem.ItemID : (wikiItem?.gameItemId ?? 0));
		if (s_equalBuySellItemIDs.Contains(item))
		{
			return true;
		}
		List<string> list = new List<string>();
		if ((Object)(object)gameItem != (Object)null)
		{
			list.Add(GetGameItemDisplayName(gameItem));
			list.Add(((Object)gameItem).name);
			list.Add(GetStringMember(gameItem, "Name", "EDITOR_Name", "EditorName", "ItemName", "PrefabName"));
		}
		if (wikiItem != null)
		{
			list.Add(wikiItem.fallbackName);
		}
		foreach (string item2 in list)
		{
			string text = NormalizeLookupText(item2);
			if (s_equalBuySellItemNames.Contains(text))
			{
				return true;
			}
			foreach (string s_equalBuySellItemName in s_equalBuySellItemNames)
			{
				if (text.EndsWith(s_equalBuySellItemName, StringComparison.Ordinal))
				{
					return true;
				}
			}
		}
		return false;
	}

	private void AddBackpackCapacityStat(List<string> lines, Item gameItem)
	{
		if ((Object)(object)gameItem == (Object)null)
		{
			return;
		}
		string text = ((object)gameItem).GetType().Name ?? "";
		bool flag = text.IndexOf("Bag", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Backpack", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Satchel", StringComparison.OrdinalIgnoreCase) >= 0;
		object memberValue = GetMemberValue(gameItem, "Container", "m_container", "BagContainer", "ItemContainer");
		if (!flag && memberValue == null)
		{
			return;
		}
		float num = 0f;
		if (memberValue != null)
		{
			num = GetFloatMember(memberValue, "ContainerCapacity", "Capacity", "MaxCapacity", "WeightCapacity", "CarryCapacity");
			if (num <= 0f)
			{
				float floatMember = GetFloatMember(memberValue, "m_containerCapacity", "BaseContainerCapacity", "BaseCapacity");
				float floatMember2 = GetFloatMember(memberValue, "m_bonusContainerCapacity", "BonusContainerCapacity", "CapacityBonus");
				num = floatMember + floatMember2;
			}
		}
		if (num <= 0f)
		{
			num = GetFloatMember(gameItem, "ContainerCapacity", "BagCapacity", "Capacity", "MaxCapacity", "WeightCapacity", "CarryCapacity");
		}
		AddUniqueLine(lines, "Kapazität", (num > 0f) ? num.ToString("0.##") : "");
	}

	private float GetRuntimeBasePrice(Item gameItem)
	{
		if ((Object)(object)gameItem == (Object)null)
		{
			return 0f;
		}
		return GetFloatMember(gameItem, "RawBaseValue", "BuyPrice", "Value", "BaseValue");
	}

	private float GetRuntimeSellPrice(Item gameItem, float runtimeBasePrice)
	{
		if ((Object)(object)gameItem == (Object)null)
		{
			return 0f;
		}
		if (IsUnsellableItem(gameItem, null))
		{
			return 0f;
		}
		if (UsesEqualBuyAndSellPrice(gameItem, null) && runtimeBasePrice > 0f)
		{
			return runtimeBasePrice;
		}
		try
		{
			object memberValue = GetMemberValue(m_characterUI, "TargetCharacter", "Character", "LocalCharacter", "m_character");
			MethodInfo methodInfo = null;
			Type type = ((object)gameItem).GetType();
			while (type != null && methodInfo == null)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo2 in array)
				{
					if (string.Equals(methodInfo2.Name, "GetSellValue", StringComparison.Ordinal))
					{
						ParameterInfo[] parameters = methodInfo2.GetParameters();
						if (parameters.Length == 0)
						{
							methodInfo = methodInfo2;
							break;
						}
						if (parameters.Length == 1 && memberValue != null && parameters[0].ParameterType.IsInstanceOfType(memberValue))
						{
							methodInfo = methodInfo2;
							break;
						}
					}
				}
				type = type.BaseType;
			}
			if (methodInfo != null)
			{
				ParameterInfo[] parameters2 = methodInfo.GetParameters();
				object value = ((parameters2.Length == 0) ? methodInfo.Invoke(gameItem, null) : methodInfo.Invoke(gameItem, new object[1] { memberValue }));
				float num = Convert.ToSingle(value);
				if (num > 0f)
				{
					return num;
				}
			}
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogDebug((object)("GetSellValue-Fallback für Item " + gameItem.ItemID + ": " + ex.Message));
		}
		float floatMember = GetFloatMember(gameItem, "SellPrice", "SalePrice", "BaseSellPrice");
		if (floatMember > 0f)
		{
			return floatMember;
		}
		return (runtimeBasePrice > 0f) ? Mathf.Floor(runtimeBasePrice * 0.3f) : 0f;
	}

	private void AddReflectedStat(List<string> lines, string label, object primary, object secondary, params string[] memberNames)
	{
		object memberValue = GetMemberValue(primary, memberNames);
		if (IsEmptyDisplayValue(memberValue) && secondary != null)
		{
			memberValue = GetMemberValue(secondary, memberNames);
		}
		string value = FormatMemberValue(memberValue);
		AddUniqueLine(lines, label, value);
	}

	private void AddUniqueLine(List<string> lines, string label, string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return;
		}
		switch (value)
		{
		case "0.00":
			return;
		case "-1":
			return;
		}
		if (!(value == "-1.00"))
		{
			string prefix = label + ":";
			if (!lines.Any((string x) => x.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
			{
				lines.Add(label + ": " + value);
			}
		}
	}

	private List<string> GetItemEffectDescriptions(Item gameItem)
	{
		List<string> list = new List<string>();
		if ((Object)(object)gameItem == (Object)null)
		{
			return list;
		}
		try
		{
			Effect[] componentsInChildren = ((Component)gameItem).GetComponentsInChildren<Effect>(true);
			HashSet<int> visitedStatuses = new HashSet<int>();
			Effect[] array = componentsInChildren;
			foreach (Effect effect in array)
			{
				AddReadableEffectDescriptions(list, effect, null, visitedStatuses, 0);
			}
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Item-Effekte konnten nicht vollständig gelesen werden: " + ex.Message));
		}
		return list.Where((string x) => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
	}

	private void AddReadableEffectDescriptions(List<string> result, Effect effect, StatusEffect owningStatus, HashSet<int> visitedStatuses, int depth)
	{
		if (result == null || (Object)(object)effect == (Object)null || depth > 4)
		{
			return;
		}
		if ((Object)(object)owningStatus == (Object)null)
		{
			try
			{
				owningStatus = ((Component)effect).GetComponentInParent<StatusEffect>();
			}
			catch
			{
			}
		}
		float basePotencyValue = effect.BasePotencyValue;
		AffectFood val = (AffectFood)(object)((effect is AffectFood) ? effect : null);
		if ((Object)(object)val != (Object)null)
		{
			float value = GetFloatMember(val, "m_affectQuantity") * basePotencyValue;
			AddSignedEffectLine(result, "Sättigung", value, "");
			return;
		}
		AffectDrink val2 = (AffectDrink)(object)((effect is AffectDrink) ? effect : null);
		if ((Object)(object)val2 != (Object)null)
		{
			float value2 = GetFloatMember(val2, "m_affectQuantity") * basePotencyValue;
			AddSignedEffectLine(result, "Durst", value2, "");
			return;
		}
		AffectHealth val3 = (AffectHealth)(object)((effect is AffectHealth) ? effect : null);
		if ((Object)(object)val3 != (Object)null)
		{
			float quantity = val3.AffectQuantity * basePotencyValue;
			AddHealthEffectLine(result, val3, quantity, owningStatus);
			return;
		}
		AffectStat val4 = (AffectStat)(object)((effect is AffectStat) ? effect : null);
		if ((Object)(object)val4 != (Object)null)
		{
			float value3 = val4.Value * basePotencyValue;
			string affectedStatDisplayName = GetAffectedStatDisplayName(val4);
			string text = (val4.IsModifier ? " %" : "");
			float duration = (((Object)(object)owningStatus != (Object)null) ? GetStatusDuration(owningStatus) : val4.Duration);
			string text2 = affectedStatDisplayName + ": " + FormatSignedNumber(value3) + text;
			text2 += FormatDurationSuffix(duration, owningStatus);
			AddDistinctEffectLine(result, text2);
			return;
		}
		AddStatusEffect val5 = (AddStatusEffect)(object)((effect is AddStatusEffect) ? effect : null);
		if ((Object)(object)val5 != (Object)null)
		{
			AddGrantedStatusDescription(result, val5, visitedStatuses, depth);
			return;
		}
		AddStatusEffectBuildUp val6 = (AddStatusEffectBuildUp)(object)((effect is AddStatusEffectBuildUp) ? effect : null);
		if ((Object)(object)val6 != (Object)null)
		{
			string statusDisplayName = GetStatusDisplayName(val6.Status);
			float value4 = val6.BuildUpValue * val6.BuildUpMultiplier * basePotencyValue;
			string label = (string.IsNullOrWhiteSpace(statusDisplayName) ? "Statuseffekt-Aufbau" : ("Aufbau von „" + statusDisplayName + "“"));
			AddSignedEffectLine(result, label, value4, "");
		}
		else
		{
			RemoveStatusEffect val7 = (RemoveStatusEffect)(object)((effect is RemoveStatusEffect) ? effect : null);
			if ((Object)(object)val7 != (Object)null)
			{
				AddDistinctEffectLine(result, DescribeRemovedStatus(val7));
			}
			else
			{
				LogUnsupportedEffect(effect);
			}
		}
	}

	private void AddHealthEffectLine(List<string> result, AffectHealth effect, float quantity, StatusEffect owningStatus)
	{
		string text = (effect.IsModifier ? " % der maximalen Gesundheit" : " Gesundheit");
		if ((Object)(object)owningStatus != (Object)null)
		{
			float num = ((owningStatus.RefreshRate > 0.0001f) ? owningStatus.RefreshRate : 1f);
			float num2 = quantity / num;
			string text2 = ((num2 >= 0f) ? "Gesundheitsregeneration" : "Gesundheitsverlust");
			string text3 = text2 + ": " + FormatSignedNumber(num2) + text + " pro Sekunde";
			text3 += FormatDurationSuffix(GetStatusDuration(owningStatus), owningStatus);
			AddDistinctEffectLine(result, text3);
		}
		else
		{
			string text4 = ((quantity >= 0f) ? "Heilung" : "Gesundheitsschaden");
			AddDistinctEffectLine(result, text4 + ": " + FormatSignedNumber(quantity) + text);
		}
	}

	private void AddGrantedStatusDescription(List<string> result, AddStatusEffect addStatus, HashSet<int> visitedStatuses, int depth)
	{
		StatusEffect status = addStatus.Status;
		if ((Object)(object)status != (Object)null)
		{
			try
			{
				status.UpdateTotalData(false);
			}
			catch
			{
			}
		}
		string text = GetStatusDisplayName(status);
		if (string.IsNullOrWhiteSpace(text))
		{
			text = "Statuseffekt";
		}
		List<string> list = new List<string>();
		if (addStatus.BaseChancesToContract < 100)
		{
			list.Add(addStatus.BaseChancesToContract + " % Chance");
		}
		if (addStatus.AdditionalLevel > 0)
		{
			list.Add("Stufe +" + addStatus.AdditionalLevel);
		}
		float statusDuration = GetStatusDuration(status);
		string text2 = FormatDuration(statusDuration, status);
		if (!string.IsNullOrWhiteSpace(text2))
		{
			list.Add(text2);
		}
		string text3 = "Gewährt: " + text;
		if (list.Count > 0)
		{
			text3 = text3 + " (" + string.Join(", ", list.ToArray()) + ")";
		}
		AddDistinctEffectLine(result, text3);
		if ((Object)(object)status == (Object)null || depth >= 4)
		{
			return;
		}
		int instanceID = ((Object)status).GetInstanceID();
		if (!visitedStatuses.Add(instanceID))
		{
			return;
		}
		int count = result.Count;
		try
		{
			Effect[] componentsInChildren = ((Component)status).GetComponentsInChildren<Effect>(true);
			Effect[] array = componentsInChildren;
			foreach (Effect effect in array)
			{
				AddReadableEffectDescriptions(result, effect, status, visitedStatuses, depth + 1);
			}
		}
		catch
		{
		}
		if (result.Count == count)
		{
			string cleanStatusDescription = GetCleanStatusDescription(status);
			if (!string.IsNullOrWhiteSpace(cleanStatusDescription))
			{
				AddDistinctEffectLine(result, text + ": " + cleanStatusDescription);
			}
		}
	}

	private string DescribeRemovedStatus(RemoveStatusEffect effect)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected I4, but got Unknown
		if ((Object)(object)effect == (Object)null)
		{
			return "";
		}
		RemoveTypes cleanseType = effect.CleanseType;
		RemoveTypes val = cleanseType;
		return (int)val switch
		{
			4 => "Entfernt alle negativen Statuseffekte", 
			0 => "Entfernt: " + GetStatusDisplayName(effect.StatusEffect), 
			3 => string.IsNullOrWhiteSpace(effect.StatusName) ? "Entfernt passende Statuseffekte" : ("Entfernt Statuseffekte mit „" + effect.StatusName + "“ im Namen"), 
			2 => "Entfernt Statuseffekte vom Typ: " + GetLocalizedTagName(effect.StatusType), 
			1 => "Entfernt eine Statuseffekt-Familie", 
			_ => "Entfernt einen Statuseffekt", 
		};
	}

	private string GetAffectedStatDisplayName(AffectStat effect)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)effect == (Object)null)
		{
			return "Wert";
		}
		string value = GetLocalizedTagName(effect.AffectedStat);
		if (string.IsNullOrWhiteSpace(value))
		{
			try
			{
				value = effect.AffectedStat.Tag.TagName;
			}
			catch
			{
			}
		}
		return TranslateTechnicalStatName(value);
	}

	private string GetLocalizedTagName(TagSourceSelector selector)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if ((Object)(object)TagSourceManager.Instance != (Object)null)
			{
				string anyTagLoc = TagSourceManager.Instance.GetAnyTagLoc(UidSelector<Tag>.op_Implicit((UidSelector<Tag>)(object)selector));
				if (!string.IsNullOrWhiteSpace(anyTagLoc))
				{
					return anyTagLoc;
				}
			}
		}
		catch
		{
		}
		try
		{
			return selector.Tag.TagName;
		}
		catch
		{
			return "";
		}
	}

	private string GetStatusDisplayName(StatusEffect status)
	{
		if ((Object)(object)status == (Object)null)
		{
			return "";
		}
		try
		{
			if (!string.IsNullOrWhiteSpace(status.StatusName))
			{
				return status.StatusName;
			}
		}
		catch
		{
		}
		try
		{
			if (!string.IsNullOrWhiteSpace(status.IdentifierName))
			{
				return status.IdentifierName;
			}
		}
		catch
		{
		}
		return CleanTypeLabel(((Object)status).name);
	}

	private string GetCleanStatusDescription(StatusEffect status)
	{
		if ((Object)(object)status == (Object)null)
		{
			return "";
		}
		try
		{
			string description = status.Description;
			if (string.IsNullOrWhiteSpace(description) || description.Equals("Description", StringComparison.OrdinalIgnoreCase) || description.IndexOf("[E", StringComparison.OrdinalIgnoreCase) >= 0 || description.IndexOf("{V", StringComparison.OrdinalIgnoreCase) >= 0 || description.IndexOf("{TOT", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "";
			}
			return description.Trim();
		}
		catch
		{
			return "";
		}
	}

	private float GetStatusDuration(StatusEffect status)
	{
		if ((Object)(object)status == (Object)null || status.StatusData == null)
		{
			return -1f;
		}
		try
		{
			return status.StatusData.LifeSpan;
		}
		catch
		{
			return -1f;
		}
	}

	private string FormatDurationSuffix(float duration, StatusEffect status)
	{
		string text = FormatDuration(duration, status);
		return string.IsNullOrWhiteSpace(text) ? "" : (" (" + text + ")");
	}

	private string FormatDuration(float duration, StatusEffect status)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		if (duration <= 0f)
		{
			return "";
		}
		bool flag = false;
		try
		{
			flag = (Object)(object)status != (Object)null && (int)status.LengthType > 0;
		}
		catch
		{
		}
		if (flag)
		{
			return duration.ToString("0.##") + ((Math.Abs(duration - 1f) < 0.001f) ? " Stunde" : " Stunden");
		}
		if (duration >= 3600f && Math.Abs(duration % 3600f) < 0.01f)
		{
			float num = duration / 3600f;
			return num.ToString("0.##") + ((Math.Abs(num - 1f) < 0.001f) ? " Stunde" : " Stunden");
		}
		if (duration >= 60f && Math.Abs(duration % 60f) < 0.01f)
		{
			float num2 = duration / 60f;
			return num2.ToString("0.##") + ((Math.Abs(num2 - 1f) < 0.001f) ? " Minute" : " Minuten");
		}
		return duration.ToString("0.##") + ((Math.Abs(duration - 1f) < 0.001f) ? " Sekunde" : " Sekunden");
	}

	private void AddSignedEffectLine(List<string> result, string label, float value, string suffix)
	{
		if (!(Math.Abs(value) < 0.0001f))
		{
			AddDistinctEffectLine(result, label + ": " + FormatSignedNumber(value) + suffix);
		}
	}

	private void AddDistinctEffectLine(List<string> result, string line)
	{
		if (result != null && !string.IsNullOrWhiteSpace(line))
		{
			string item = line.Trim();
			if (!result.Contains(item))
			{
				result.Add(item);
			}
		}
	}

	private void LogUnsupportedEffect(Effect effect)
	{
		if (!((Object)(object)effect == (Object)null))
		{
			string text = ((object)effect).GetType().FullName ?? ((object)effect).GetType().Name;
			if (m_loggedUnsupportedEffectTypes.Add(text))
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Nicht unterstützter Effekt wurde im Wiki ausgeblendet: " + text));
			}
		}
	}

	private string TranslateTechnicalStatName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "Wert";
		}
		switch (value.Replace("_", "").Replace(" ", "").Replace("-", "")
			.ToLowerInvariant())
		{
		case "health":
		case "maxhealth":
			return "Gesundheit";
		case "healthregen":
		case "healthregeneration":
			return "Gesundheitsregeneration";
		case "stamina":
		case "maxstamina":
			return "Ausdauer";
		case "staminaregen":
		case "staminaregeneration":
			return "Ausdauerregeneration";
		case "mana":
		case "maxmana":
			return "Mana";
		case "manaregen":
		case "manaregeneration":
			return "Manaregeneration";
		case "physicaldamage":
		case "physicaldamagebonus":
			return "Physischer Schaden";
		case "impact":
		case "impactdamage":
		case "impactdamagebonus":
			return "Impact-Schaden";
		case "impactresistance":
			return "Impact-Widerstand";
		case "attackspeed":
			return "Angriffsgeschwindigkeit";
		case "movementspeed":
			return "Bewegungsgeschwindigkeit";
		case "cooldownreduction":
			return "Abklingzeitreduktion";
		case "manacostreduction":
			return "Mana-Kostenreduktion";
		case "staminacostreduction":
			return "Ausdauer-Kostenreduktion";
		case "protection":
			return "Schutz";
		case "barrier":
			return "Barriere";
		case "corruptionresistance":
			return "Verderbnisresistenz";
		case "fooddepletionrate":
			return "Hunger-Verbrauch";
		case "drinkdepletionrate":
			return "Durst-Verbrauch";
		case "sleepdepletionrate":
			return "Schlaf-Verbrauch";
		case "heatprotection":
			return "Hitzeschutz";
		case "coldprotection":
			return "Kälteschutz";
		case "stabilityregen":
			return "Stabilitätsregeneration";
		case "pouchcapacity":
			return "Taschenkapazität";
		case "weight":
			return "Gewicht";
		case "durability":
			return "Haltbarkeit";
		case "fire":
		case "firedamage":
			return "Feuerschaden";
		case "frost":
		case "frostdamage":
			return "Frostschaden";
		case "electric":
		case "electricdamage":
		case "lightningdamage":
			return "Blitzschaden";
		case "decay":
		case "decaydamage":
			return "Fäulnisschaden";
		case "ethereal":
		case "etherealdamage":
			return "Ätherschaden";
		default:
			return value.Trim();
		}
	}

	private void AddItemCraftingRelationships(int itemId, Action returnToItem, string backLabel)
	{
		if (m_recipesByResultItemId.TryGetValue(itemId, out var value) && value.Count > 0)
		{
			AddArticleHeading("Herstellung");
			foreach (WikiRecipeData item in value)
			{
				AddRecipePreview(item, returnToItem, backLabel);
			}
		}
		if (m_recipesUsingItemId.TryGetValue(itemId, out var value2) && value2.Count > 0)
		{
			AddArticleHeading("Verwendet in");
			AddRecipeTileGrid(value2, returnToItem, backLabel);
		}
		if (m_decraftRecipesUsingItemId.TryGetValue(itemId, out var value3) && value3.Count > 0)
		{
			AddArticleHeading("Zerlegen / Decrafting");
			AddRecipeTileGrid(value3, returnToItem, backLabel);
		}
	}

	private void AddRecipePreview(WikiRecipeData recipe, Action returnToItem, string backLabel)
	{
		AddRecipeTileGrid(new WikiRecipeData[1] { recipe }, returnToItem, backLabel);
		string recipeDisplayName = GetRecipeDisplayName(recipe);
		Recipe gameRecipe = FindGameRecipe(recipe);
		List<WikiItemReference> effectiveRecipeIngredients = GetEffectiveRecipeIngredients(recipe, gameRecipe);
		if (effectiveRecipeIngredients.Count > 0)
		{
			AddRecipeIngredientGrid(recipe, gameRecipe, recipeDisplayName, effectiveRecipeIngredients, returnToItem);
		}
	}

	private void AddRecipeTileGrid(IEnumerable<WikiRecipeData> recipes, Action backAction, string backLabel)
	{
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Expected O, but got Unknown
		List<WikiRecipeData> list = recipes.Where((WikiRecipeData recipe) => recipe != null).Distinct().OrderBy(GetRecipeDisplayName)
			.ToList();
		for (int num = 0; num < list.Count; num += 4)
		{
			GameObject val = CreateItemSlotRow("RecipeTileRow_" + num);
			List<Button> list2 = new List<Button>();
			int num2 = Mathf.Min(num + 4, list.Count);
			for (int num3 = num; num3 < num2; num3++)
			{
				WikiRecipeData wikiRecipeData = list[num3];
				Recipe gameRecipe = FindGameRecipe(wikiRecipeData);
				WikiItemReference wikiItemReference = GetEffectiveRecipeResults(wikiRecipeData, gameRecipe).FirstOrDefault((WikiItemReference item) => item != null && item.gameItemId > 0);
				Sprite icon = ((wikiItemReference == null) ? null : GetGameItemIcon(wikiItemReference.gameItemId));
				string recipeDisplayName = GetRecipeDisplayName(wikiRecipeData);
				string categoryDisplayName = GetCategoryDisplayName(GetWikiCategoryForRecipe(wikiRecipeData));
				string displayName = recipeDisplayName + "\n" + categoryDisplayName;
				Button val2 = CreateArticleTile(val.transform, "RecipeTile_" + GetFavoriteKey(wikiRecipeData), icon, displayName);
				WikiRecipeData captured = wikiRecipeData;
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					ShowRecipe(captured, backAction, backLabel);
				});
				list2.Add(val2);
			}
			if (list2.Count > 0)
			{
				m_articleButtonRows.Add(list2);
			}
		}
	}

	private void AddItemCompatibleEnchantments(int itemId, Action returnToItem, string backLabel)
	{
		if (m_compatibleEnchantmentsByItemId.TryGetValue(itemId, out var value) && value.Count != 0)
		{
			AddArticleHeading("Kompatible Verzauberungen");
			List<WikiEnchantmentData> enchantments = (from @group in value.Where((EnchantmentRecipe recipe) => (Object)(object)recipe != (Object)null).GroupBy(GetLogicalEnchantmentKey)
				where !string.IsNullOrWhiteSpace(@group.Key)
				select GetOrCreateWikiEnchantmentData(@group.First()) into data
				where data != null
				select data).OrderBy(GetEnchantmentDisplayName).ToList();
			AddEnchantmentTileGrid(enchantments, returnToItem, backLabel);
		}
	}

	private void AddEnchantmentTileGrid(IEnumerable<WikiEnchantmentData> enchantments, Action backAction, string backLabel)
	{
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Expected O, but got Unknown
		List<WikiEnchantmentData> list = (from @group in enchantments.Where((WikiEnchantmentData enchantment) => enchantment != null).GroupBy(GetFavoriteKey)
			select @group.First()).OrderBy(GetEnchantmentDisplayName).ToList();
		for (int num = 0; num < list.Count; num += 4)
		{
			GameObject val = CreateItemSlotRow("EnchantmentTileRow_" + num);
			List<Button> list2 = new List<Button>();
			int num2 = Mathf.Min(num + 4, list.Count);
			for (int num3 = num; num3 < num2; num3++)
			{
				WikiEnchantmentData wikiEnchantmentData = list[num3];
				Button val2 = CreateArticleTile(val.transform, "EnchantmentTile_" + GetFavoriteKey(wikiEnchantmentData), null, GetEnchantmentDisplayName(wikiEnchantmentData));
				WikiEnchantmentData captured = wikiEnchantmentData;
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					ShowEnchantment(captured, backAction, backLabel);
				});
				list2.Add(val2);
			}
			if (list2.Count > 0)
			{
				m_articleButtonRows.Add(list2);
			}
		}
	}

	private void AddItemLegacyRelationships(int itemId, Action returnToItem, string backLabel)
	{
		List<WikiLegacyUpgradeData> value;
		bool flag = m_legacyUpgradesBySourceItemId.TryGetValue(itemId, out value) && value != null && value.Count > 0;
		List<WikiLegacyUpgradeData> value2;
		bool flag2 = m_legacyUpgradesByResultItemId.TryGetValue(itemId, out value2) && value2 != null && value2.Count > 0;
		if (!flag && !flag2)
		{
			return;
		}
		string key = ((m_legacyUpgradeFile == null) ? "source.legacy_chest" : m_legacyUpgradeFile.sourceTypeKey);
		AddArticleHeading(LocalizeDataKey(key, "Vermächtnistruhe", "Legacy Chest"));
		if (m_legacyUpgradeFile != null && m_legacyUpgradeFile.description != null)
		{
			string text = SelectLocalizedSourceString("", m_legacyUpgradeFile.description.de, m_legacyUpgradeFile.description.en);
			if (!string.IsNullOrWhiteSpace(text))
			{
				AddArticleParagraph(text);
			}
		}
		if (flag)
		{
			List<WikiItemReference> list = (from upgrade in value
				where upgrade != null && upgrade.resultItemId > 0
				group upgrade by upgrade.resultItemId into @group
				select new WikiItemReference
				{
					gameItemId = @group.Key,
					amount = 1,
					fallbackName = GetLegacyPreferredName(@group.First(), source: false)
				}).ToList();
			if (list.Count > 0)
			{
				AddArticleHeading(L("Wird zu", "Transforms Into"));
				AddConcreteItemGrid(list, returnToItem, backLabel);
			}
		}
		if (flag2)
		{
			List<WikiItemReference> list2 = (from upgrade in value2
				where upgrade != null && upgrade.sourceItemId > 0
				group upgrade by upgrade.sourceItemId into @group
				select new WikiItemReference
				{
					gameItemId = @group.Key,
					amount = 1,
					fallbackName = GetLegacyPreferredName(@group.First(), source: true)
				}).ToList();
			if (list2.Count > 0)
			{
				AddArticleHeading(L("Benötigter Ausgangsgegenstand", "Required Source Item"));
				AddConcreteItemGrid(list2, returnToItem, backLabel);
			}
		}
		if (m_legacyUpgradeFile == null || m_legacyUpgradeFile.chestLocations == null || m_legacyUpgradeFile.chestLocations.Count == 0)
		{
			return;
		}
		AddArticleHeading(L("Truhenstandorte", "Chest Locations"));
		foreach (WikiLegacyChestLocation chestLocation in m_legacyUpgradeFile.chestLocations)
		{
			if (chestLocation != null)
			{
				string text2 = SelectLocalizedSourceString("", chestLocation.regionDe, chestLocation.regionEn);
				string text3 = SelectLocalizedSourceString("", chestLocation.locationDe, chestLocation.locationEn);
				string text4 = SelectLocalizedSourceString("", chestLocation.accessDe, chestLocation.accessEn);
				string text5 = string.Join(" – ", new string[2] { text2, text3 }.Where((string value3) => !string.IsNullOrWhiteSpace(value3)).ToArray());
				if (!string.IsNullOrWhiteSpace(text4))
				{
					text5 = text5 + ": " + text4;
				}
				if (!string.IsNullOrWhiteSpace(text5))
				{
					AddArticleParagraph("• " + text5);
				}
			}
		}
	}

	private void AddItemSources(WikiItemData item, Action returnToItem, string backLabel)
	{
		if (item == null)
		{
			return;
		}
		string localizedItemSourceType = GetLocalizedItemSourceType(item);
		IEnumerable<string> localizedSourceValues = GetLocalizedSourceValues(item.locations, item.locationsDe, item.locationsEn);
		IEnumerable<string> localizedSourceValues2 = GetLocalizedSourceValues(item.dropsFrom, item.dropsFromDe, item.dropsFromEn);
		IEnumerable<string> localizedSourceValues3 = GetLocalizedSourceValues(item.questSources, item.questSourcesDe, item.questSourcesEn);
		IEnumerable<string> localizedSourceValues4 = GetLocalizedSourceValues(item.questRewards, item.questRewardsDe, item.questRewardsEn);
		IEnumerable<string> localizedSourceValues5 = GetLocalizedSourceValues(item.blacksmithSources, item.blacksmithSourcesDe, item.blacksmithSourcesEn);
		IEnumerable<string> localizedSourceValues6 = GetLocalizedSourceValues(item.sourceNotes, item.sourceNotesDe, item.sourceNotesEn);
		if (string.IsNullOrWhiteSpace(localizedItemSourceType) && !HasValues(localizedSourceValues) && !HasValues(localizedSourceValues2) && !HasValues(localizedSourceValues3) && !HasValues(localizedSourceValues4) && !HasValues(localizedSourceValues5) && !HasValues(localizedSourceValues6) && item.commission == null)
		{
			return;
		}
		AddArticleHeading("Fundort / Herkunft");
		if (!string.IsNullOrWhiteSpace(localizedItemSourceType))
		{
			AddArticleParagraph("• Art: " + localizedItemSourceType.Trim());
		}
		AddSourceLines("Fundort", localizedSourceValues);
		AddSourceLines("Drop", localizedSourceValues2);
		AddSourceLines("Quest", localizedSourceValues3);
		AddSourceLines("Questbelohnung", localizedSourceValues4);
		AddSourceLines("Schmied", localizedSourceValues5);
		AddSourceLines("Hinweis", localizedSourceValues6);
		if (item.commission != null)
		{
			if (item.commission.silverCost > 0)
			{
				AddArticleParagraph("• " + L("Kosten", "Cost") + ": " + item.commission.silverCost + L(" Silber", " silver"));
			}
			if (item.commission.craftingTimeHours > 0)
			{
				AddArticleParagraph("• " + L("Dauer", "Duration") + ": " + item.commission.craftingTimeHours + L(" Stunden", " hours"));
			}
			if (item.commission.requiredItems != null && item.commission.requiredItems.Any((WikiItemReference reference) => reference != null && reference.gameItemId > 0))
			{
				AddArticleHeading("Benötigtes Material");
				AddConcreteItemGrid(item.commission.requiredItems, returnToItem, backLabel);
			}
		}
	}

	private string GetLocalizedItemSourceType(WikiItemData item)
	{
		if (item == null)
		{
			return "";
		}
		if (!string.IsNullOrWhiteSpace(item.sourceTypeKey))
		{
			string text = LocalizeDataKey(item.sourceTypeKey, FirstNonEmpty(item.sourceType, item.sourceTypeDe), FirstNonEmpty(item.sourceType, item.sourceTypeEn));
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
		}
		return SelectLocalizedSourceString(item.sourceType, item.sourceTypeDe, item.sourceTypeEn) ?? "";
	}

	private static IEnumerable<string> GetLocalizedSourceValues(IEnumerable<string> legacy, IEnumerable<string> german, IEnumerable<string> english)
	{
		IEnumerable<string> enumerable = SelectLocalizedSourceList(legacy, german, english);
		return (enumerable == null) ? Enumerable.Empty<string>() : enumerable.Where((string value) => !string.IsNullOrWhiteSpace(value));
	}

	private void AddSourceLines(string prefix, IEnumerable<string> values)
	{
		if (!HasValues(values))
		{
			return;
		}
		foreach (string item in values.Where((string x) => !string.IsNullOrWhiteSpace(x)))
		{
			AddArticleParagraph("• " + prefix + ": " + item);
		}
	}

	private static bool HasValues(IEnumerable<string> values)
	{
		return values?.Any((string x) => !string.IsNullOrWhiteSpace(x)) ?? false;
	}

	private void AddLargeItemIcon(Sprite icon)
	{
		//IL_0048: 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_0074: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUIObject("LargeItemIconContainer", (Transform)(object)m_articleContent);
		LayoutElement val2 = val.AddComponent<LayoutElement>();
		val2.preferredHeight = 130f;
		GameObject val3 = CreateUIObject("LargeItemIcon", val.transform);
		RectTransform component = val3.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 0.5f);
		component.anchorMax = new Vector2(0f, 0.5f);
		component.pivot = new Vector2(0f, 0.5f);
		component.anchoredPosition = new Vector2(10f, 0f);
		component.sizeDelta = new Vector2(120f, 120f);
		Image val4 = val3.AddComponent<Image>();
		val4.sprite = icon;
		val4.preserveAspect = true;
		((Graphic)val4).raycastTarget = false;
	}

	private void ShowEnchantment(WikiEnchantmentData enchantment)
	{
		ShowEnchantment(enchantment, null, null);
	}

	private void ShowEnchantment(WikiEnchantmentData enchantment, Action backAction, string backLabel)
	{
		if (enchantment != null)
		{
			m_currentCategory = WikiCategory.Enchantments;
			m_currentViewState = WikiViewState.Article;
			Button currentLeftButtonOrFallback = GetCurrentLeftButtonOrFallback();
			if ((Object)(object)currentLeftButtonOrFallback != (Object)null)
			{
				m_activeLeftSourceButton = currentLeftButtonOrFallback;
			}
			List<EnchantmentRecipe> list = FindGameEnchantmentRecipes(enchantment);
			EnchantmentRecipe recipe = UnityEngineExtensions.FirstOrDefault<EnchantmentRecipe>((IList<EnchantmentRecipe>)list);
			Enchantment val = FindGameEnchantment(enchantment, recipe);
			string enchantmentDisplayName = GetEnchantmentDisplayName(enchantment);
			SetArticleHeader(enchantmentDisplayName, "Verzauberung");
			ClearArticleContent();
			if (backAction != null)
			{
				Button item = CreateArticleBackButton(string.IsNullOrWhiteSpace(backLabel) ? "← Zurück" : backLabel, backAction);
				m_articleButtonRows.Add(new List<Button> { item });
			}
			Action action = delegate
			{
				ShowEnchantment(enchantment, backAction, backLabel);
			};
			if (enchantment.isTestData)
			{
				AddArticleParagraph("⚠ TESTDATENSATZ");
			}
			string text = (((Object)(object)val == (Object)null) ? "" : val.Description);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = enchantment.description;
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				AddArticleParagraph(text);
			}
			AddEnchantmentEffectsByVariant(list, enchantment);
			AddEnchantmentRequirements(list, enchantment);
			AddEnchantmentPillars(list, enchantment, enchantmentDisplayName, action);
			AddEnchantmentCompatibleItems(list, enchantment, action, "← Zurück zu " + enchantmentDisplayName);
			Canvas.ForceUpdateCanvases();
			RebuildArticleNavigation();
		}
	}

	private List<EnchantmentRecipe> FindGameEnchantmentRecipes(WikiEnchantmentData data)
	{
		EnchantmentRecipe val = FindGameEnchantmentRecipe(data);
		if ((Object)(object)val == (Object)null)
		{
			return new List<EnchantmentRecipe>();
		}
		string logicalKey = GetLogicalEnchantmentKey(val);
		if (string.IsNullOrWhiteSpace(logicalKey))
		{
			return new List<EnchantmentRecipe> { val };
		}
		return (from recipe in m_allGameEnchantmentRecipes.Where((EnchantmentRecipe recipe) => (Object)(object)recipe != (Object)null && string.Equals(GetLogicalEnchantmentKey(recipe), logicalKey, StringComparison.Ordinal)).Distinct()
			orderby recipe.ResultID
			select recipe).ToList();
	}

	private EnchantmentRecipe FindGameEnchantmentRecipe(WikiEnchantmentData data)
	{
		if (data == null)
		{
			return null;
		}
		if (data.gameRecipeId > 0 && m_enchantmentRecipesByRecipeId.TryGetValue(data.gameRecipeId, out var value))
		{
			return value;
		}
		if (data.gameEnchantmentId > 0 && m_enchantmentRecipesByResultId.TryGetValue(data.gameEnchantmentId, out var value2) && value2.Count > 0)
		{
			return value2[0];
		}
		EnchantmentRecipe val = FindRuntimeEnchantmentRecipeByName(data);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		return null;
	}

	private Enchantment FindGameEnchantment(WikiEnchantmentData data, EnchantmentRecipe recipe)
	{
		int presetId = ((data != null && data.gameEnchantmentId > 0) ? data.gameEnchantmentId : ((!((Object)(object)recipe == (Object)null)) ? recipe.ResultID : 0));
		return GetGameEnchantmentByPresetId(presetId);
	}

	private Enchantment GetGameEnchantmentByPresetId(int presetId)
	{
		if (presetId <= 0)
		{
			return null;
		}
		if (m_enchantmentsByPresetId.TryGetValue(presetId, out var value))
		{
			return value;
		}
		return null;
	}

	private WikiEnchantmentData GetOrCreateWikiEnchantmentData(EnchantmentRecipe recipe)
	{
		if ((Object)(object)recipe == (Object)null)
		{
			return null;
		}
		string logicalKey = GetLogicalEnchantmentKey(recipe);
		WikiEnchantmentData wikiEnchantmentData = m_enchantments.FirstOrDefault((WikiEnchantmentData x) => x != null && ((x.gameRecipeId > 0 && x.gameRecipeId == recipe.RecipeID) || (x.gameEnchantmentId > 0 && x.gameEnchantmentId == recipe.ResultID) || (!string.IsNullOrWhiteSpace(logicalKey) && string.Equals(GetLogicalEnchantmentKey(x), logicalKey, StringComparison.Ordinal))));
		if (wikiEnchantmentData != null)
		{
			return wikiEnchantmentData;
		}
		Enchantment gameEnchantmentByPresetId = GetGameEnchantmentByPresetId(recipe.ResultID);
		string text = (((Object)(object)gameEnchantmentByPresetId == (Object)null) ? "" : gameEnchantmentByPresetId.Name);
		return new WikiEnchantmentData
		{
			gameRecipeId = recipe.RecipeID,
			gameEnchantmentId = recipe.ResultID,
			fallbackName = (string.IsNullOrWhiteSpace(text) ? ("Verzauberung " + recipe.ResultID) : text),
			category = "Verzauberungen"
		};
	}

	private void AddEnchantmentCompatibleItems(IList<EnchantmentRecipe> gameRecipes, WikiEnchantmentData wikiData, Action backAction, string backLabel)
	{
		AddArticleHeading("Geeignete Items");
		Dictionary<string, List<WikiItemReference>> dictionary = new Dictionary<string, List<WikiItemReference>>(StringComparer.CurrentCultureIgnoreCase);
		if (gameRecipes != null)
		{
			foreach (EnchantmentRecipe gameRecipe in gameRecipes)
			{
				if ((Object)(object)gameRecipe == (Object)null || gameRecipe.ResultID <= 0 || !m_compatibleItemsByEnchantmentResultId.TryGetValue(gameRecipe.ResultID, out var value) || value == null)
				{
					continue;
				}
				foreach (Item item in value)
				{
					if (IsPlayerFacingWikiItem(item))
					{
						string equipmentGroupLabel = GetEquipmentGroupLabel(item);
						if (!dictionary.TryGetValue(equipmentGroupLabel, out var value2))
						{
							value2 = new List<WikiItemReference>();
							dictionary.Add(equipmentGroupLabel, value2);
						}
						if (!value2.Any((WikiItemReference x) => x.gameItemId == item.ItemID))
						{
							value2.Add(new WikiItemReference
							{
								gameItemId = item.ItemID,
								amount = 1
							});
						}
					}
				}
			}
		}
		if (dictionary.Count == 0 && wikiData != null && wikiData.compatibleItems != null)
		{
			foreach (WikiItemReference itemReference in wikiData.compatibleItems)
			{
				if (itemReference != null && itemReference.gameItemId > 0)
				{
					Item gameItemPrefab = GetGameItemPrefab(itemReference.gameItemId);
					string equipmentGroupLabel2 = GetEquipmentGroupLabel(gameItemPrefab);
					if (!dictionary.TryGetValue(equipmentGroupLabel2, out var value3))
					{
						value3 = new List<WikiItemReference>();
						dictionary.Add(equipmentGroupLabel2, value3);
					}
					if (!value3.Any((WikiItemReference x) => x.gameItemId == itemReference.gameItemId))
					{
						value3.Add(itemReference);
					}
				}
			}
		}
		if (dictionary.Count == 0)
		{
			AddArticleParagraph("Keine kompatiblen Items gefunden.");
			return;
		}
		foreach (KeyValuePair<string, List<WikiItemReference>> item2 in dictionary.OrderBy((KeyValuePair<string, List<WikiItemReference>> x) => GetEquipmentGroupOrder(x.Key)))
		{
			AddArticleParagraph("<b>" + item2.Key + "</b>");
			AddConcreteItemGrid(item2.Value.OrderBy(delegate(WikiItemReference wikiItemReference)
			{
				Item gameItemPrefab2 = GetGameItemPrefab(wikiItemReference.gameItemId);
				return ((Object)(object)gameItemPrefab2 == (Object)null) ? wikiItemReference.gameItemId.ToString() : GetGameItemDisplayName(gameItemPrefab2);
			}), backAction, backLabel);
		}
	}

	private void AddEnchantmentPillars(IList<EnchantmentRecipe> gameRecipes, WikiEnchantmentData wikiData, string enchantmentName, Action returnToEnchantment)
	{
		if (gameRecipes != null && gameRecipes.Any(IsNewSiroccoGuildRecipe))
		{
			AddArticleHeading("Benötigtes Material");
			List<Item> list = new List<Item>();
			foreach (EnchantmentRecipe gameRecipe in gameRecipes)
			{
				if ((Object)(object)gameRecipe == (Object)null || gameRecipe.PillarDatas == null)
				{
					continue;
				}
				PillarData[] pillarDatas = gameRecipe.PillarDatas;
				foreach (PillarData val in pillarDatas)
				{
					if (val == null)
					{
						continue;
					}
					foreach (Item item in GetMatchingEnchantmentIngredients(val.CompatibleIngredients))
					{
						if ((Object)(object)item != (Object)null && !list.Any((Item x) => x.ItemID == item.ItemID))
						{
							list.Add(item);
						}
					}
				}
			}
			if (list.Count == 0)
			{
				AddArticleParagraph("Kein Material gefunden.");
				return;
			}
			AddConcreteItemGrid(from val3 in list.OrderBy(GetGameItemDisplayName)
				select new WikiItemReference
				{
					gameItemId = val3.ItemID,
					amount = 1
				}, returnToEnchantment, "← Zurück zu " + enchantmentName);
			return;
		}
		AddArticleHeading("Säulenpositionen und Räucherwerk");
		bool flag = false;
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		if (gameRecipes != null)
		{
			foreach (EnchantmentRecipe gameRecipe2 in gameRecipes)
			{
				if ((Object)(object)gameRecipe2 == (Object)null || gameRecipe2.PillarDatas == null || gameRecipe2.PillarDatas.Length == 0)
				{
					continue;
				}
				for (int num = 0; num < gameRecipe2.PillarDatas.Length; num++)
				{
					PillarData val2 = gameRecipe2.PillarDatas[num];
					if (val2 == null)
					{
						continue;
					}
					List<Item> matchingEnchantmentIngredients = GetMatchingEnchantmentIngredients(val2.CompatibleIngredients);
					string text = string.Join(",", (from x in matchingEnchantmentIngredients
						select x.ItemID into x
						orderby x
						select x).ToArray());
					string item2 = ((object)Unsafe.As<CardinalPoint, CardinalPoint>(ref val2.Direction)/*cast due to .constrained prefix*/).ToString() + "|" + val2.IsFar + "|" + text;
					if (!hashSet.Add(item2))
					{
						continue;
					}
					flag = true;
					string text2 = TranslateCardinalDirection(((object)Unsafe.As<CardinalPoint, CardinalPoint>(ref val2.Direction)/*cast due to .constrained prefix*/).ToString());
					string text3 = (val2.IsFar ? "Fern" : "Nah");
					AddArticleParagraph("• " + text2 + " – " + text3);
					if (matchingEnchantmentIngredients.Count == 0)
					{
						continue;
					}
					List<WikiItemReference> items = matchingEnchantmentIngredients.Select((Item x) => new WikiItemReference
					{
						gameItemId = x.ItemID,
						amount = 1
					}).ToList();
					Action action = returnToEnchantment;
					if (action == null)
					{
						action = delegate
						{
							ShowEnchantment(wikiData);
						};
					}
					AddConcreteItemGrid(items, action, "← Zurück zu " + enchantmentName);
				}
			}
		}
		if (flag)
		{
			return;
		}
		if (wikiData != null && wikiData.pillarPositions != null && wikiData.pillarPositions.Count > 0)
		{
			foreach (WikiPillarPosition pillarPosition in wikiData.pillarPositions)
			{
				AddArticleParagraph("• " + TranslateCardinalDirection(pillarPosition.pillar) + " – " + pillarPosition.distance);
			}
			return;
		}
		AddArticleParagraph("Keine Säulenpositionen gefunden.");
	}

	private List<Item> GetMatchingEnchantmentIngredients(IngredientData[] ingredients)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		List<Item> list = new List<Item>();
		if (ingredients == null)
		{
			return list;
		}
		for (int i = 0; i < ingredients.Length; i++)
		{
			IngredientData val = ingredients[i];
			foreach (Item item in m_allGameItemPrefabs)
			{
				if (!((Object)(object)item == (Object)null))
				{
					bool flag = false;
					try
					{
						flag = ((IngredientData)(ref val)).Match(item);
					}
					catch
					{
					}
					if (flag && !list.Any((Item x) => x.ItemID == item.ItemID))
					{
						list.Add(item);
					}
				}
			}
		}
		return list.OrderBy(GetGameItemDisplayName).ToList();
	}

	private unsafe void AddEnchantmentRequirements(IList<EnchantmentRecipe> gameRecipes, WikiEnchantmentData wikiData)
	{
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: 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_02f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0308: Unknown result type (might be due to invalid IL or missing references)
		//IL_0328: Unknown result type (might be due to invalid IL or missing references)
		//IL_0407: Unknown result type (might be due to invalid IL or missing references)
		//IL_040c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0415: Unknown result type (might be due to invalid IL or missing references)
		//IL_042b: Unknown result type (might be due to invalid IL or missing references)
		//IL_042d: Unknown result type (might be due to invalid IL or missing references)
		List<string> list = new List<string>();
		bool flag = gameRecipes?.Any((EnchantmentRecipe val3) => (Object)(object)val3 != (Object)null) ?? false;
		bool flag2 = gameRecipes?.Any(IsNewSiroccoGuildRecipe) ?? false;
		List<string> list2 = new List<string>();
		if (gameRecipes != null)
		{
			list2 = (from recipe in gameRecipes
				where (Object)(object)recipe != (Object)null && !string.IsNullOrWhiteSpace(recipe.OverrideRegionLocKey)
				select TryResolveLocalizationKey(recipe.OverrideRegionLocKey) into value
				where !string.IsNullOrWhiteSpace(value)
				select value).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).ToList();
		}
		if (flag2)
		{
			list.Add("Verzauberungsort: Verzauberungsgilde in Neusirocco");
			if (gameRecipes.Any(IsExpandedLibraryEnchantment))
			{
				list.Add("Ausbau: Erweiterte Bibliothek erforderlich");
			}
		}
		if (!flag2 && list2.Count == 0 && gameRecipes != null)
		{
			List<AreaEnum> list3 = new List<AreaEnum>();
			foreach (EnchantmentRecipe gameRecipe in gameRecipes)
			{
				if ((Object)(object)gameRecipe == (Object)null || gameRecipe.WindAltarActivated || gameRecipe.Region == null)
				{
					continue;
				}
				AreaEnum[] region = gameRecipe.Region;
				foreach (AreaEnum item in region)
				{
					if (!list3.Contains(item))
					{
						list3.Add(item);
					}
				}
			}
			List<string> list4 = (from name in list3.Select(GetRegionDisplayName)
				where !string.IsNullOrWhiteSpace(name)
				select name).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).ToList();
			if (list4.Count > 0)
			{
				bool flag3 = list3.Any(IsSpecificEnchantmentLocation);
				list.Add((flag3 ? "Ort: " : "Region: ") + JoinHumanReadable(list4));
			}
		}
		if (!flag2 && list2.Count > 0)
		{
			list.Add("Ort: " + JoinHumanReadable(list2));
		}
		if (gameRecipes != null)
		{
			foreach (EnchantmentRecipe gameRecipe2 in gameRecipes)
			{
				if ((Object)(object)gameRecipe2 == (Object)null)
				{
					continue;
				}
				if (gameRecipe2.TimeOfDay != null && gameRecipe2.TimeOfDay.Length != 0)
				{
					Vector2[] timeOfDay = gameRecipe2.TimeOfDay;
					foreach (Vector2 val in timeOfDay)
					{
						List<string> list5 = list;
						string[] obj = new string[5] { "Tageszeit: ", null, null, null, null };
						float x = val.x;
						obj[1] = x.ToString("0.##");
						obj[2] = "–";
						x = val.y;
						obj[3] = x.ToString("0.##");
						obj[4] = " Uhr";
						list5.Add(string.Concat(obj));
					}
				}
				if (gameRecipe2.WindAltarActivated)
				{
					list.Add("Windaltar muss aktiviert sein");
				}
				if (gameRecipe2.Temperature != null && gameRecipe2.Temperature.Length != 0)
				{
					list.Add("Temperatur: " + string.Join(", ", gameRecipe2.Temperature.Select((TemperatureSteps val3) => TranslateTechnicalStatName(((object)(*(TemperatureSteps*)(&val3))/*cast due to .constrained prefix*/).ToString())).Distinct().ToArray()));
				}
				if (gameRecipe2.Weather != null && gameRecipe2.Weather.Length != 0)
				{
					WeaterCondition[] weather = gameRecipe2.Weather;
					foreach (WeaterCondition val2 in weather)
					{
						list.Add("Wetter: " + (val2.Invert ? "Nicht " : "") + GetWeatherDisplayName(val2.Weather));
					}
				}
				if (!flag2 && gameRecipe2.TableIsInBuilding)
				{
					list.Add("Verzauberungstisch muss sich in einem Gebäude befinden");
				}
			}
		}
		if (wikiData != null && wikiData.requirements != null)
		{
			foreach (string requirement in wikiData.requirements)
			{
				if (!string.IsNullOrWhiteSpace(requirement))
				{
					string text = requirement.Trim();
					if (!text.StartsWith("Kompatibilität:", StringComparison.OrdinalIgnoreCase) && !text.StartsWith("Compatibility:", StringComparison.OrdinalIgnoreCase) && !flag && !list.Contains(text))
					{
						list.Add(text);
					}
				}
			}
		}
		list = list.Where((string value) => !string.IsNullOrWhiteSpace(value)).Distinct<string>(StringComparer.CurrentCultureIgnoreCase).ToList();
		if (list.Count == 0)
		{
			return;
		}
		AddArticleHeading("Voraussetzungen");
		foreach (string item2 in list)
		{
			AddArticleParagraph("• " + item2);
		}
	}

	private unsafe bool IsNewSiroccoGuildRecipe(EnchantmentRecipe recipe)
	{
		if ((Object)(object)recipe == (Object)null)
		{
			return false;
		}
		bool flag = recipe.Region != null && recipe.Region.Any((AreaEnum region) => ((object)(*(AreaEnum*)(&region))/*cast due to .constrained prefix*/).ToString().IndexOf("NewSirocco", StringComparison.OrdinalIgnoreCase) >= 0);
		bool flag2 = !string.IsNullOrWhiteSpace(recipe.OverrideRegionLocKey) && recipe.OverrideRegionLocKey.IndexOf("BuildingID_", StringComparison.OrdinalIgnoreCase) >= 0;
		return recipe.TableIsInBuilding && (flag || flag2);
	}

	private bool IsExpandedLibraryEnchantment(EnchantmentRecipe recipe)
	{
		if ((Object)(object)recipe == (Object)null)
		{
			return false;
		}
		Enchantment gameEnchantmentByPresetId = GetGameEnchantmentByPresetId(recipe.ResultID);
		string value = string.Join(" ", ((Object)recipe).name ?? "", ((Object)(object)gameEnchantmentByPresetId == (Object)null) ? "" : ((Object)gameEnchantmentByPresetId).name, ((Object)(object)gameEnchantmentByPresetId == (Object)null) ? "" : gameEnchantmentByPresetId.Name);
		string normalized = NormalizeLookupText(value);
		string[] source = new string[9] { "trauma", "tunnelsend", "telekinesis", "midnightdance", "levantinesecret", "inheritanceofthepast", "guidedarm", "protectivepresence", "fechtbuch" };
		return source.Any((string name) => normalized.Contains(name));
	}

	private unsafe bool IsSpecificEnchantmentLocation(AreaEnum region)
	{
		string text = ((object)(*(AreaEnum*)(&region))/*cast due to .constrained prefix*/).ToString();
		return text.IndexOf("Dungeon", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Interior", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Building", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private unsafe string GetRegionDisplayName(AreaEnum region)
	{
		string text = ((object)(*(AreaEnum*)(&region))/*cast due to .constrained prefix*/).ToString();
		switch (NormalizeAreaCode(text))
		{
		case "cierzo":
		case "chersonesenewterrain":
		case "chersonese":
			return L("Chersonese", "Chersonese");
		case "emercar":
		case "enmerkar":
			return L("Enmerkar-Wald", "Enmerkar Forest");
		case "hallowedmarsh":
		case "hallowedmarshnewterrain":
			return L("Geheiligter Sumpf", "Hallowed Marsh");
		case "abrassar":
			return "Abrassar";
		case "antiquefield":
		case "antiqueplateau":
			return L("Antikes Plateau", "Antique Plateau");
		case "caldera":
			return "Caldera";
		case "newsirocco":
			return L("Neusirocco", "New Sirocco");
		case "chersodungeon1":
		case "chersonesedungeon1":
			return "Vendavel Fortress";
		case "chersodungeon2":
		case "chersonesedungeon2":
			return "Blister Burrow";
		case "chersodungeon3":
		case "chersonesedungeon3":
			return "Ghost Pass";
		case "chersodungeon4":
		case "chersonesedungeon4":
		case "chersonesedungeon4commonpath":
			return "Conflux Chambers";
		case "chersodungeon4bc":
		case "chersonesedungeon4bluechamber":
			return "Blue Chamber's Conflux Path";
		case "chersodungeon4hm":
		case "chersonesedungeon4holymission":
			return "Holy Mission's Conflux Path";
		case "chersodungeon4lv":
		case "chersonesedungeon4levant":
			return "Heroic Kingdom's Conflux Path";
		case "chersodungeon5":
		case "chersonesedungeon5":
			return "Voltaic Hatchery";
		case "chersodungeon6":
		case "chersonesedungeon6":
			return "Corrupted Tombs";
		case "chersodungeon8":
		case "chersonesedungeon8":
			return "Cierzo Storage";
		case "chersodungeon9":
		case "chersonesedungeon9":
			return "Montcalm Clan Fort";
		case "chersodungeonssmall":
		case "chersonesedungeonssmall":
		case "chersodungeonsmall":
		case "chersonesedungeonsmall":
			return "Chersonese Minor Dungeons";
		case "abrassardungeon1":
			return "Undercity Passage";
		case "abrassardungeon2":
			return "Electric Lab";
		case "abrassardungeon3":
			return "The Slide";
		case "abrassardungeon4":
			return "Stone Titan Caves";
		case "abrassardungeon5":
			return "Ancient Hive";
		case "abrassardungeon6":
			return "Sand Rose Cave";
		case "abrassardungeonssmall":
		case "abrassardungeonsmall":
			return "Hive Prison";
		case "emercardungeon1":
		case "enmerkardungeon1":
			return "Royal Manticore's Lair";
		case "emercardungeon2":
		case "enmerkardungeon2":
			return "Forest Hives";
		case "emercardungeon3":
		case "enmerkardungeon3":
			return "Cabal of Wind Temple";
		case "emercardungeon4":
		case "enmerkardungeon4":
			return "Face of the Ancients";
		case "emercardungeon5":
		case "enmerkardungeon5":
			return "Ancestor's Resting Place";
		case "emercardungeon6":
		case "enmerkardungeon6":
			return "Necropolis";
		case "emercardungeonssmall":
		case "emercardungeonsmall":
		case "enmerkardungeonssmall":
		case "enmerkardungeonsmall":
			return "Damp Hunter's Cabin";
		case "halloweddungeon1":
			return "Jade Quarry";
		case "halloweddungeon2":
			return "Giants' Village";
		case "halloweddungeon3":
			return "Reptilian Lair";
		case "halloweddungeon4interior":
		case "halloweddungeon4":
			return "Dark Ziggurat Interior";
		case "halloweddungeon5":
			return "Spire of Light";
		case "halloweddungeon6":
			return "Ziggurat Passage";
		case "halloweddungeon7":
			return "Dead Roots";
		case "halloweddungeonssmall":
		case "halloweddungeonsmall":
			return "Hallowed Marsh Minor Dungeons";
		case "antiquefielddungeon1":
			return "Abandoned Living Quarters";
		case "antiquefielddungeon2":
			return "Forgotten Research Laboratory";
		case "antiquefielddungeon3":
			return "Ancient Foundry";
		case "antiquefielddungeon4":
			return "Ruined Warehouse";
		case "antiquefielddungeon5":
			return "Lost Golem Manufacturing Facility";
		case "antiquefielddungeon6":
			return "Crumbling Loading Docks";
		case "antiquefielddungeon7":
			return "Destroyed Test Chambers";
		case "antiquefielddungeon8":
			return "Compromised Mana Transfer Station";
		case "antiquefielddungeon9":
			return "Old Harmattan";
		case "antiquefielddungeonssmall":
		case "antiquefielddungeonsmall":
			return "Antique Plateau Minor Dungeons";
		case "calderadungeon1":
			return "Steam Bath Tunnels";
		case "calderadungeon2":
			return "Sulphuric Caverns";
		case "calderadungeon3":
			return "The Eldest Brother";
		case "calderadungeon4":
			return "Scarlet Sanctuary";
		case "calderadungeon5":
			return "The Grotto of Chalcedony";
		case "calderadungeon6":
			return "Myrmitaur's Haven";
		case "calderadungeon7":
			return "Oil Refinery";
		case "calderadungeon8":
			return "The Vault of Stone";
		case "calderadungeon9":
			return "Old Sirocco";
		case "calderadungeon10":
			return "Ark of the Exiled";
		case "calderadungeonssmall":
		case "calderadungeonsmall":
			return "Oily Cavern";
		default:
		{
			string text2 = TryResolveAreaLocalization(text);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			return FormatTechnicalAreaName(text);
		}
		}
	}

	private string NormalizeAreaCode(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "";
		}
		return new string(value.ToLowerInvariant().Where(char.IsLetterOrDigit).ToArray());
	}

	private string TryResolveAreaLocalization(string areaName)
	{
		if (string.IsNullOrWhiteSpace(areaName))
		{
			return "";
		}
		string[] array = new string[7]
		{
			areaName,
			"Area_" + areaName,
			"AreaName_" + areaName,
			"Location_" + areaName,
			"LocationName_" + areaName,
			"Scene_" + areaName,
			"SceneName_" + areaName
		};
		string[] array2 = array;
		foreach (string localizationKey in array2)
		{
			string text = TryResolveLocalizationKey(localizationKey);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
		}
		return "";
	}

	private string FormatTechnicalAreaName(string areaName)
	{
		if (string.IsNullOrWhiteSpace(areaName))
		{
			return "";
		}
		StringBuilder stringBuilder = new StringBuilder(areaName.Length + 8);
		char c = '\0';
		foreach (char c2 in areaName)
		{
			if (c2 == '_')
			{
				if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != ' ')
				{
					stringBuilder.Append(' ');
				}
				c = c2;
				continue;
			}
			if (stringBuilder.Length > 0 && c2 != ' ' && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && !char.IsDigit(c))) && stringBuilder[stringBuilder.Length - 1] != ' ')
			{
				stringBuilder.Append(' ');
			}
			stringBuilder.Append(c2);
			c = c2;
		}
		return stringBuilder.ToString().Replace("Cherso Dungeon", "Chersonese Dungeon").Replace("Enmerkar Dungeon", "Enmerkar Forest Dungeon")
			.Trim();
	}

	private unsafe string GetWeatherDisplayName(WeaterType weather)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected I4, but got Unknown
		WeaterType val = weather;
		WeaterType val2 = val;
		return (int)val2 switch
		{
			0 => L("Klar", "Clear"), 
			1 => L("Regen", "Rain"), 
			2 => L("Schnee", "Snow"), 
			3 => L("Saisonaler Wettereffekt", "Seasonal weather effect"), 
			_ => ((object)(*(WeaterType*)(&weather))/*cast due to .constrained prefix*/).ToString(), 
		};
	}

	private string TranslateCardinalDirection(string direction)
	{
		if (string.IsNullOrWhiteSpace(direction))
		{
			return "";
		}
		switch (direction.Trim().ToLowerInvariant())
		{
		case "north":
		case "nord":
			return L("Nord", "North");
		case "south":
		case "süd":
		case "sued":
			return L("Süd", "South");
		case "east":
		case "ost":
			return L("Ost", "East");
		case "west":
			return "West";
		default:
			return direction;
		}
	}

	private string TryResolveLocalizationKey(string localizationKey)
	{
		if (string.IsNullOrWhiteSpace(localizationKey))
		{
			return "";
		}
		try
		{
			string loc = LocalizationManager.Instance.GetLoc(localizationKey);
			if (string.IsNullOrWhiteSpace(loc) || string.Equals(loc, localizationKey, StringComparison.OrdinalIgnoreCase) || loc.IndexOf("BuildingID_", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "";
			}
			return loc;
		}
		catch
		{
			return "";
		}
	}

	private void AddEnchantmentEffectsByVariant(IList<EnchantmentRecipe> gameRecipes, WikiEnchantmentData wikiData)
	{
		Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.Ordinal);
		Dictionary<string, List<string>> dictionary2 = new Dictionary<string, List<string>>(StringComparer.Ordinal);
		if (gameRecipes != null)
		{
			foreach (EnchantmentRecipe item in from x in gameRecipes
				where (Object)(object)x != (Object)null
				group x by x.ResultID into @group
				select @group.First())
			{
				Enchantment gameEnchantmentByPresetId = GetGameEnchantmentByPresetId(item.ResultID);
				List<string> enchantmentEffectLines = GetEnchantmentEffectLines(gameEnchantmentByPresetId, null);
				if (enchantmentEffectLines.Count == 0)
				{
					continue;
				}
				string key = string.Join("\u001f", enchantmentEffectLines.ToArray());
				if (!dictionary.ContainsKey(key))
				{
					dictionary.Add(key, enchantmentEffectLines);
				}
				List<string> enchantmentRecipeSlotLabels = GetEnchantmentRecipeSlotLabels(item);
				if (!dictionary2.TryGetValue(key, out var value))
				{
					value = new List<string>();
					dictionary2.Add(key, value);
				}
				foreach (string item2 in enchantmentRecipeSlotLabels)
				{
					if (!value.Contains(item2))
					{
						value.Add(item2);
					}
				}
			}
		}
		if (dictionary.Count == 0)
		{
			List<string> enchantmentEffectLines2 = GetEnchantmentEffectLines(null, wikiData);
			if (enchantmentEffectLines2.Count > 0)
			{
				string key2 = string.Join("\u001f", enchantmentEffectLines2.ToArray());
				dictionary.Add(key2, enchantmentEffectLines2);
				dictionary2.Add(key2, new List<string>());
			}
		}
		if (dictionary.Count == 0)
		{
			return;
		}
		AddArticleHeading("Effekte");
		bool flag = dictionary.Count > 1 || dictionary2.Values.Any((List<string> labels) => labels != null && labels.Count > 0 && (labels.Count != 1 || !(labels[0] == "Allgemein")));
		foreach (KeyValuePair<string, List<string>> item3 in dictionary)
		{
			dictionary2.TryGetValue(item3.Key, out var value2);
			if (flag && value2 != null && value2.Count > 0)
			{
				AddArticleParagraph("<b>" + JoinHumanReadable(value2.OrderBy(GetEquipmentGroupOrder).ToList()) + "</b>");
			}
			foreach (string item4 in item3.Value)
			{
				AddArticleParagraph("• " + item4);
			}
		}
	}

	private List<string> GetEnchantmentEffectLines(Enchantment gameEnchantment, WikiEnchantmentData wikiData)
	{
		//IL_007c: 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)
		List<string> list = new List<string>();
		if ((Object)(object)gameEnchantment != (Object)null)
		{
			if (gameEnchantment.Indestructible)
			{
				list.Add("Unzerstörbar");
			}
			if (gameEnchantment.StatModifications != null)
			{
				foreach (StatModification statModification in gameEnchantment.StatModifications)
				{
					if (statModification != null && !(Math.Abs(statModification.Value) < 0.0001f))
					{
						string enchantmentStatDisplayName = GetEnchantmentStatDisplayName(statModification.Name);
						string text = (((int)statModification.Type == 0) ? " %" : "");
						list.Add(enchantmentStatDisplayName + ": " + FormatSignedNumber(statModification.Value) + text);
					}
				}
			}
			AddAdditionalDamageDescriptions(list, gameEnchantment.AdditionalDamages);
			AddResistanceDescriptions(list, gameEnchantment.ElementalResistances);
			AddDamageModifierDescriptions(list, gameEnchantment.DamageModifier);
			AddDamageBonusDescriptions(list, gameEnchantment.DamageBonus);
			if (gameEnchantment.HealthAbsorbRatio > 0f)
			{
				list.Add("Lebensabsorption: " + FormatSmartPercent(gameEnchantment.HealthAbsorbRatio) + " des verursachten Schadens");
			}
			if (gameEnchantment.StaminaAbsorbRatio > 0f)
			{
				list.Add("Ausdauerabsorption: " + FormatSmartPercent(gameEnchantment.StaminaAbsorbRatio) + " des verursachten Schadens");
			}
			if (gameEnchantment.ManaAbsorbRatio > 0f)
			{
				list.Add("Manaabsorption: " + FormatSmartPercent(gameEnchantment.ManaAbsorbRatio) + " des verursachten Schadens");
			}
			if (Math.Abs(gameEnchantment.GlobalStatusResistance) > 0.0001f)
			{
				list.Add("Globale Statusresistenz: " + FormatSmartPercent(gameEnchantment.GlobalStatusResistance));
			}
			if (gameEnchantment.SelfRepairAmount > 0f)
			{
				string text2 = L("Selbstreparatur", "Self Repair") + ": +" + gameEnchantment.SelfRepairAmount.ToString("0.##") + " " + L("Haltbarkeit", "Durability");
				if (gameEnchantment.SelfRepairFrequency > 0)
				{
					string text3 = gameEnchantment.SelfRepairFrequency.ToString();
					bool flag = string.Equals(text3, "1", StringComparison.Ordinal);
					text2 = text2 + L(" alle ", " every ") + text3 + " " + (flag ? L("Sekunde", "second") : L("Sekunden", "seconds"));
				}
				list.Add(text2);
			}
			try
			{
				HashSet<int> visitedStatuses = new HashSet<int>();
				Effect[] effects = gameEnchantment.Effects;
				foreach (Effect effect in effects)
				{
					AddReadableEffectDescriptions(list, effect, null, visitedStatuses, 0);
				}
			}
			catch
			{
			}
		}
		if ((Object)(object)gameEnchantment == (Object)null && wikiData != null && wikiData.effects != null)
		{
			foreach (string effect2 in wikiData.effects)
			{
				if (!string.IsNullOrWhiteSpace(effect2) && !list.Contains(effect2))
				{
					list.Add(effect2);
				}
			}
		}
		return list.Where((string x) => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
	}

	private List<string> GetEnchantmentRecipeSlotLabels(EnchantmentRecipe recipe)
	{
		if ((Object)(object)recipe == (Object)null)
		{
			return new List<string> { "Allgemein" };
		}
		if (!m_compatibleItemsByEnchantmentResultId.TryGetValue(recipe.ResultID, out var value) || value == null || value.Count == 0)
		{
			return new List<string> { "Allgemein" };
		}
		List<string> list = (from label in value.Where((Item item) => (Object)(object)item != (Object)null).Select(GetEquipmentGroupLabel)
			where !string.IsNullOrWhiteSpace(label)
			select label).Distinct().OrderBy(GetEquipmentGroupOrder).ToList();
		return (list.Count > 0) ? list : new List<string> { "Allgemein" };
	}

	private string GetEquipmentGroupLabel(Item item)
	{
		if ((Object)(object)item == (Object)null)
		{
			return "Sonstige Gegenstände";
		}
		string text = ((object)item).GetType().Name ?? "";
		string text2 = FormatMemberValue(GetMemberValue(item, "EquipSlot", "EquipmentSlot", "SlotType", "Slot", "EquipmentType"));
		string text3 = (text + " " + text2).ToLowerInvariant();
		if (item is Weapon || text3.Contains("weapon") || text3.Contains("sword") || text3.Contains("axe") || text3.Contains("mace") || text3.Contains("spear") || text3.Contains("halberd") || text3.Contains("dagger") || text3.Contains("pistol") || text3.Contains("bow") || text3.Contains("chakram"))
		{
			return "Waffen";
		}
		if (text3.Contains("shield"))
		{
			return "Schilde";
		}
		if (text3.Contains("lexicon"))
		{
			return "Lexika";
		}
		if (text3.Contains("helmet") || text3.Contains("helm") || text3.Contains("head"))
		{
			return "Helme";
		}
		if (text3.Contains("boot") || text3.Contains("feet") || text3.Contains("foot") || text3.Contains("stiefel"))
		{
			return "Stiefel";
		}
		if (text3.Contains("armor") || text3.Contains("armour") || text3.Contains("chest") || text3.Contains("body") || text3.Contains("torso") || text3.Contains("garb") || text3.Contains("robe") || text3.Contains("clothes"))
		{
			return "Brustrüstungen";
		}
		return "Sonstige Gegenstände";
	}

	private int GetEquipmentGroupOrder(string label)
	{
		return label switch
		{
			"Waffen" => 0, 
			"Schilde" => 1, 
			"Lexika" => 2, 
			"Brustrüstungen" => 3, 
			"Helme" => 4, 
			"Stiefel" => 5, 
			"Allgemein" => 6, 
			_ => 7, 
		};
	}

	private string JoinHumanReadable(IList<string> values)
	{
		List<string> list = ((values == null) ? new List<string>() : values.Where((string x) => !string.IsNullOrWhiteSpace(x)).Select(LocalizeUiText).Distinct<string>(StringComparer.CurrentCultureIgnoreCase)
			.ToList());
		if (list.Count == 0)
		{
			return "";
		}
		if (list.Count == 1)
		{
			return list[0];
		}
		string text = L(" und ", " and ");
		if (list.Count == 2)
		{
			return list[0] + text + list[1];
		}
		return string.Join(", ", list.Take(list.Count - 1).ToArray()) + text + list[list.Count - 1];
	}

	private unsafe string GetEnchantmentStatDisplayName(Stat stat)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Expected I4, but got Unknown
		Stat val = stat;
		Stat val2 = val;
		return (int)val2 switch
		{
			0 => "Gewicht", 
			1 => "Haltbarkeit", 
			2 => "Mana-Kostenreduktion", 
			3 => "Ausdauer-Kostenreduktion", 
			4 => "Abklingzeitreduktion", 
			5 => "Bewegungsgeschwindigkeit", 
			6 => "Angriffsgeschwindigkeit", 
			7 => "Impact-Schaden", 
			8 => "Stabilitätsregeneration", 
			9 => "Gesundheitsregeneration", 
			10 => "Manaregeneration", 
			11 => "Schutz", 
			12 => "Verderbnisresistenz", 
			13 => "Hunger-Verbrauch", 
			14 => "Durst-Verbrauch", 
			15 => "Schlaf-Verbrauch", 
			16 => "Taschenkapazität", 
			17 => "Impact-Widerstand", 
			18 => "Hitzeschutz", 
			19 => "Kälteschutz", 
			20 => "Barriere", 
			_ => TranslateTechnicalStatName(((object)(*(Stat*)(&stat))/*cast due to .constrained prefix*/).ToString()), 
		};
	}

	private void AddAdditionalDamageDescriptions(List<string> effects, AdditionalDamage[] additionalDamages)
	{
		//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_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		if (effects == null || additionalDamages == null)
		{
			return;
		}
		foreach (AdditionalDamage val in additionalDamages)
		{
			if (!(Math.Abs(val.ConversionRatio) < 0.0001f))
			{
				effects.Add("Zusatzschaden: " + FormatSmartPercent(val.ConversionRatio) + " des vorhandenen Schadens der Art „" + GetDamageTypeDisplayName(val.SourceDamageType) + "“ als „" + GetDamageTypeDisplayName(val.BonusDamageType) + "“");
			}
		}
	}

	private void AddResistanceDescriptions(List<string> effects, DamageList damageList)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (effects == null || damageList == null)
		{
			return;
		}
		foreach (DamageType item in damageList.List)
		{
			if (item != null && !(Math.Abs(item.Damage) < 0.0001f))
			{
				effects.Add(GetDamageTypeDisplayName(item.Type) + "-Resistenz: " + FormatSignedNumber(item.Damage));
			}
		}
	}

	private void AddDamageModifierDescriptions(List<string> effects, DamageList damageList)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (effects == null || damageList == null)
		{
			return;
		}
		foreach (DamageType item in damageList.List)
		{
			if (item != null && !(Math.Abs(item.Damage) < 0.0001f))
			{
				effects.Add(GetDamageTypeDisplayName(item.Type) + "-Schadensmodifikator: " + FormatSmartPercent(item.Damage));
			}
		}
	}

	private void AddDamageBonusDescriptions(List<string> effects, DamageList damageList)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (effects == null || damageList == null)
		{
			return;
		}
		foreach (DamageType item in damageList.List)
		{
			if (item != null && !(Math.Abs(item.Damage) < 0.0001f))
			{
				effects.Add(GetDamageTypeDisplayName(item.Type) + "-Bonusschaden: " + FormatSignedNumber(item.Damage));
			}
		}
	}

	private unsafe string GetDamageTypeDisplayName(Types type)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Expected I4, but got Unknown
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		Types val = type;
		Types val2 = val;
		switch ((int)val2)
		{
		case 0:
			return L("Physisch", "Physical");
		case 1:
			return L("Äther", "Ethereal");
		case 2:
			return L("Fäulnis", "Decay");
		case 3:
			return L("Blitz", "Lightning");
		case 4:
			return "Frost";
		case 5:
			return L("Feuer", "Fire");
		case 8:
			return L("Roh", "Raw");
		case 6:
			return L("Dunkel", "Dark");
		case 7:
			return L("Licht", "Light");
		default:
			try
			{
				string typeName = DamageType.GetTypeName(type);
				if (!string.IsNullOrWhiteSpace(typeName) && !typeName.StartsWith("DamageType_", StringComparison.OrdinalIgnoreCase))
				{
					return typeName;
				}
			}
			catch
			{
			}
			return ((object)(*(Types*)(&type))/*cast due to .constrained prefix*/).ToString();
		}
	}

	private string FormatSmartPercent(float value)
	{
		float value2 = ((Math.Abs(value) <= 2f) ? (value * 100f) : value);
		return FormatSignedNumber(value2) + " %";
	}

	private void AddConcreteItemGrid(IEnumerable<WikiItemReference> items, Action backAction, string backLabel)
	{
		List<WikiItemReference> list = (from x in items
			where x != null && x.gameItemId > 0
			group x by x.gameItemId into x
			select x.First()).ToList();
		for (int num = 0; num < list.Count; num += 4)
		{
			GameObject val = CreateItemSlotRow("ConcreteItemGrid_" + num);
			List<Button> list2 = new List<Button>();
			int num2 = Mathf.Min(num + 4, list.Count);
			for (int num3 = num; num3 < num2; num3++)
			{
				Button val2 = CreateConcreteItemSlot(val.transform, list[num3], backAction, backLabel);
				if ((Object)(object)val2 != (Object)null && ((Selectable)val2).interactable)
				{
					list2.Add(val2);
				}
			}
			if (list2.Count > 0)
			{
				m_articleButtonRows.Add(list2);
			}
		}
	}

	private Button CreateArticleLinkButton(string label, Action action)
	{
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Expected O, but got Unknown
		Button val = CreateButton("ArticleLink_" + label, (Transform)(object)m_articleContent, label);
		LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val2.preferredHeight = 48f;
		if (action != null)
		{
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				action();
			});
		}
		return val;
	}

	private string GetFavoriteKey(WikiItemData item)
	{
		return (item == null || item.gameItemId <= 0) ? "" : ("Item:" + item.gameItemId);
	}

	private string GetFavoriteKey(WikiRecipeData recipe)
	{
		if (recipe == null)
		{
			return "";
		}
		string text = GetWikiCategoryForRecipe(recipe).ToString();
		if (recipe.gameRecipeId > 0)
		{
			return "Recipe:" + text + ":ID:" + recipe.gameRecipeId;
		}
		if (!string.IsNullOrWhiteSpace(recipe.wikiId))
		{
			return "Recipe:" + text + ":Wiki:" + recipe.wikiId;
		}
		if (recipe.gameResultItemId > 0)
		{
			return "Recipe:" + text + ":Result:" + recipe.gameResultItemId;
		}
		return "Recipe:" + text + ":Name:" + recipe.fallbackName;
	}

	private string GetFavoriteKey(WikiEnchantmentData enchantment)
	{
		if (enchantment == null)
		{
			return "";
		}
		if (enchantment.gameEnchantmentId > 0)
		{
			return "Enchantment:ID:" + enchantment.gameEnchantmentId;
		}
		if (enchantment.gameRecipeId > 0)
		{
			return "Enchantment:Recipe:" + enchantment.gameRecipeId;
		}
		if (!string.IsNullOrWhiteSpace(enchantment.wikiId))
		{
			return "Enchantment:Wiki:" + enchantment.wikiId;
		}
		return "Enchantment:Name:" + enchantment.fallbackName;
	}

	private object GetMemberValue(object source, params string[] names)
	{
		if (source == null || names == null)
		{
			return null;
		}
		BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
		foreach (string text in names)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				continue;
			}
			Type type = source.GetType();
			while (type != null)
			{
				try
				{
					PropertyInfo property = type.GetProperty(text, bindingAttr);
					if (property != null && property.GetIndexParameters().Length == 0)
					{
						return property.GetValue(source, null);
					}
				}
				catch
				{
				}
				try
				{
					FieldInfo field = type.GetField(text, bindingAttr);
					if (field != null)
					{
						return field.GetValue(source);
					}
				}
				catch
				{
				}
				type = type.BaseType;
			}
		}
		return null;
	}

	private float GetFloatMember(object source, params string[] names)
	{
		object memberValue = GetMemberValue(source, names);
		if (memberValue == null)
		{
			return 0f;
		}
		try
		{
			return Convert.ToSingle(memberValue);
		}
		catch
		{
			return 0f;
		}
	}

	private int GetIntMember(object source, params string[] names)
	{
		object memberValue = GetMemberValue(source, names);
		if (memberValue == null)
		{
			return 0;
		}
		try
		{
			return Convert.ToInt32(memberValue);
		}
		catch
		{
			return 0;
		}
	}

	private string GetStringMember(object source, params string[] names)
	{
		object memberValue = GetMemberValue(source, names);
		return (memberValue == null) ? "" : memberValue.ToString();
	}

	private bool HasAnyMember(object source, params string[] names)
	{
		if (source == null || names == null)
		{
			return false;
		}
		BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
		Type type = source.GetType();
		while (type != null)
		{
			foreach (string name in names)
			{
				if (type.GetProperty(name, bindingAttr) != null || type.GetField(name, bindingAttr) != null)
				{
					return true;
				}
			}
			type = type.BaseType;
		}
		return false;
	}

	private bool IsEmptyDisplayValue(object value)
	{
		if (value == null)
		{
			return true;
		}
		string text = FormatMemberValue(value);
		return string.IsNullOrWhiteSpace(text) || text == "0" || text == "0.00";
	}

	private string FormatMemberValue(object value)
	{
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		if (value == null)
		{
			return "";
		}
		if (value is string)
		{
			return (string)value;
		}
		if (value is float num)
		{
			return num.ToString("0.##");
		}
		if (value is double num2)
		{
			return num2.ToString("0.##");
		}
		if (value is decimal num3)
		{
			return num3.ToString("0.##");
		}
		if (value is int || value is long || value is short || value is byte)
		{
			return Convert.ToString(value);
		}
		if (value is bool)
		{
			return ((bool)value) ? "Ja" : "Nein";
		}
		DamageType val = (DamageType)((value is DamageType) ? value : null);
		if (val != null)
		{
			return GetDamageTypeDisplayName(val.Type) + " " + val.Damage.ToString("0.##");
		}
		DamageList val2 = (DamageList)((value is DamageList) ? value : null);
		if (val2 != null)
		{
			return string.Join(", ", (from x in val2.List
				where x != null && Math.Abs(x.Damage) > 0.0001f
				select GetDamageTypeDisplayName(x.Type) + " " + x.Damage.ToString("0.##")).ToArray());
		}
		Type type = value.GetType();
		if (type.IsEnum)
		{
			return value.ToString();
		}
		if (value is IEnumerable enumerable)
		{
			List<string> list = new List<string>();
			foreach (object item in enumerable)
			{
				string text = FormatSimpleObject(item);
				if (!string.IsNullOrWhiteSpace(text) && text != "0")
				{
					list.Add(text);
				}
			}
			if (list.Count > 0)
			{
				return string.Join(", ", list.Distinct().ToArray());
			}
		}
		string text2 = FormatSimpleObject(value);
		return string.IsNullOrWhiteSpace(text2) ? value.ToString() : text2;
	}

	private string FormatSimpleObject(object value)
	{
		if (value == null)
		{
			return "";
		}
		Type type = value.GetType();
		BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public;
		List<string> list = new List<string>();
		FieldInfo[] fields = type.GetFields(bindingAttr);
		foreach (FieldInfo fieldInfo in fields)
		{
			object value2;
			try
			{
				value2 = fieldInfo.GetValue(value);
			}
			catch
			{
				continue;
			}
			string text = FormatScalar(value2);
			if (!string.IsNullOrWhiteSpace(text) && text != "0")
			{
				list.Add(CleanTypeLabel(fieldInfo.Name) + " " + text);
			}
		}
		PropertyInfo[] properties = type.GetProperties(bindingAttr);
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
			{
				object value3;
				try
				{
					value3 = propertyInfo.GetValue(value, null);
				}
				catch
				{
					continue;
				}
				string text2 = FormatScalar(value3);
				if (!string.IsNullOrWhiteSpace(text2) && text2 != "0")
				{
					list.Add(CleanTypeLabel(propertyInfo.Name) + " " + text2);
				}
			}
		}
		if (list.Count > 0)
		{
			return string.Join(", ", list.Distinct().Take(12).ToArray());
		}
		return value.ToString();
	}

	private string FormatScalar(object value)
	{
		if (value == null)
		{
			return "";
		}
		Type type = value.GetType();
		if (type.IsEnum)
		{
			return value.ToString();
		}
		if (value is float num)
		{
			return num.ToString("0.##");
		}
		if (value is double num2)
		{
			return num2.ToString("0.##");
		}
		if (value is decimal num3)
		{
			return num3.ToString("0.##");
		}
		if (value is int || value is long || value is short || value is byte)
		{
			return Convert.ToString(value);
		}
		if (value is bool)
		{
			return ((bool)value) ? "Ja" : "Nein";
		}
		if (value is string)
		{
			return (string)value;
		}
		return "";
	}

	private string CleanTypeLabel(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "";
		}
		string text = value.Replace("_", " ");
		return text.Trim();
	}

	private string FormatSignedNumber(float value)
	{
		return ((value > 0f) ? "+" : "") + value.ToString("0.##");
	}

	private void SetArticleHeader(string title, string category)
	{
		if ((Object)(object)m_articleTitle != (Object)null)
		{
			m_articleTitle.text = LocalizeUiText(title ?? "");
		}
		if ((Object)(object)m_articleCategory != (Object)null)
		{
			m_articleCategory.text = LocalizeUiText("Kategorie: " + category);
		}
	}

	private void ClearArticleContent()
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		m_articleButtonRows.Clear();
		if (!((Object)(object)m_articleContent == (Object)null))
		{
			for (int num = ((Transform)m_articleContent).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)m_articleContent).GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
			m_articleContent.anchoredPosition = Vector2.zero;
		}
	}

	private void AddArticleHeading(string textValue)
	{
		Text val = CreateText("ArticleHeading", (Transform)(object)m_articleContent, textValue, 22, (TextAnchor)3);
		val.fontStyle = (FontStyle)1;
		LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val2.preferredHeight = 38f;
	}

	private void AddArticleParagraph(string textValue)
	{
		Text val = CreateText("ArticleParagraph", (Transform)(object)m_articleContent, textValue, 20, (TextAnchor)0);
		val.horizontalOverflow = (HorizontalWrapMode)0;
		val.verticalOverflow = (VerticalWrapMode)1;
		ContentSizeFitter val2 = ((Component)val).gameObject.AddComponent<ContentSizeFitter>();
		val2.verticalFit = (FitMode)2;
		LayoutElement val3 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val3.minHeight = 28f;
	}

	private void ClearEntryList()
	{
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		m_leftMainToStar.Clear();
		m_leftStarToMain.Clear();
		if (!((Object)(object)m_entryListContent == (Object)null))
		{
			for (int num = ((Transform)m_entryListContent).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)m_entryListContent).GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
			m_entryListContent.anchoredPosition = Vector2.zero;
		}
	}

	private Button CreateListButton(string label)
	{
		Button val = CreateButton("Entry_" + label, (Transform)(object)m_entryListContent, label);
		LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val2.preferredHeight = 58f;
		return val;
	}

	private void CreateInfoListEntry(string message)
	{
		Text val = CreateText("InfoEntry", (Transform)(object)m_entryListContent, message, 17, (TextAnchor)4);
		LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
		val2.preferredHeight = 60f;
	}

	private InputField CreateSearchField(Transform parent)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUIObject("SearchField", parent);
		Image val2 = val.AddComponent<Image>();
		val2.sprite = m_buttonSprite;
		((Graphic)val2).color = m_buttonColor;
		val2.type = m_buttonImageType;
		if ((Object)(object)m_buttonMaterial != (Object)null)
		{
			((Graphic)val2).material = m_buttonMaterial;
		}
		InputField val3 = val.AddComponent<InputField>();
		Text val4 = CreateText("Text", val.transform, "", 20, (TextAnchor)3);
		val4.supportRichText = false;
		RectTransform rectTransform = ((Graphic)val4).rectTransform;
		rectTransform.anchorMin = Vector2.zero;
		rectTransform.anchorMax = Vector2.one;
		rectTransform.offsetMin = new Vector2(12f, 4f);
		rectTransform.offsetMax = new Vector2(-12f, -4f);
		Text val5 = CreateText("Placeholder", val.transform, "Suche...", 20, (TextAnchor)3);
		((Graphic)val5).color = new Color(1f, 1f, 1f, 0.45f);
		RectTransform rectTransform2 = ((Graphic)val5).rectTransform;
		rectTransform2.anchorMin = Vector2.zero;
		rectTransform2.anchorMax = Vector2.one;
		rectTransform2.offsetMin = new Vector2(12f, 4f);
		rectTransform2.offsetMax = new Vector2(-12f, -4f);
		val3.textComponent = val4;
		val3.placeholder = (Graphic)(object)val5;
		return val3;
	}

	private Button CreateButton(string name, Transform parent, string label)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: 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_013c: 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)
		GameObject val = CreateUIObject(name, parent);
		Image val2 = val.AddComponent<Image>();
		val2.sprite = m_buttonSprite;
		((Graphic)val2).color = m_buttonColor;
		val2.type = m_buttonImageType;
		if ((Object)(object)m_buttonMaterial != (Object)null)
		{
			((Graphic)val2).material = m_buttonMaterial;
		}
		Button val3 = val.AddComponent<Button>();
		((Selectable)val3).targetGraphic = (Graphic)(object)val2;
		((Selectable)val3).transition = m_buttonTransition;
		((Selectable)val3).colors = m_buttonColors;
		((Selectable)val3).spriteState = m_buttonSpriteState;
		Navigation navigation = ((Selectable)val3).navigation;
		((Navigation)(ref navigation)).mode = (Mode)3;
		((Selectable)val3).navigation = navigation;
		Text val4 = CreateText("Text", val.transform, label, (m_buttonFontSize > 0) ? m_buttonFontSize : 20, m_buttonTextAlignment);
		if ((Object)(object)m_buttonFont != (Object)null)
		{
			val4.font = m_buttonFont;
		}
		val4.fontStyle = m_buttonFontStyle;
		((Graphic)val4).color = m_buttonTextColor;
		RectTransform rectTransform = ((Graphic)val4).rectTransform;
		rectTransform.anchorMin = Vector2.zero;
		rectTransform.anchorMax = Vector2.one;
		rectTransform.offsetMin = new Vector2(8f, 4f);
		rectTransform.offsetMax = new Vector2(-8f, -4f);
		return val3;
	}

	private Text CreateText(string name, Transform parent, string textValue, int fontSize, TextAnchor alignment)
	{
		//IL_0057: 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_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)
		GameObject val = CreateUIObject(name, parent);
		Text val2 = val.AddComponent<Text>();
		val2.text = LocalizeUiText(textValue);
		if ((Object)(object)m_outwardFont != (Object)null)
		{
			val2.font = m_outwardFont;
		}
		else
		{
			val2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
		}
		val2.fontSize = fontSize;
		val2.alignment = alignment;
		((Graphic)val2).color = Color.white;
		val2.horizontalOverflow = (HorizontalWrapMode)0;
		val2.verticalOverflow = (VerticalWrapMode)1;
		Outline val3 = val.AddComponent<Outline>();
		((Shadow)val3).effectColor = new Color(0f, 0f, 0f, 0.9f);
		((Shadow)val3).effectDistance = new Vector2(1.5f, -1.5f);
		return val2;
	}

	private void CreateSeparator(Transform parent, Vector2 offsetMin, Vector2 offsetMax)
	{
		//IL_004c: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUIObject("Separator", parent);
		Image val2 = val.AddComponent<Image>();
		val2.sprite = m_separatorSprite;
		((Graphic)val2).color = (Color)(((Object)(object)m_separatorSprite != (Object)null) ? m_separatorColor : new Color(0.7f, 0.55f, 0.3f, 1f));
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 1f);
		component.anchorMax = new Vector2(1f, 1f);
		component.offsetMin = offsetMin;
		component.offsetMax = offsetMax;
	}

	private WikiItemData GetItemByGameId(int gameItemId)
	{
		if (m_itemsByGameId.TryGetValue(gameItemId, out var value))
		{
			return value;
		}
		return null;
	}

	private string GetItemDisplayName(WikiItemData item)
	{
		if (item == null)
		{
			return "Unbekanntes Item";
		}
		Item gameItemPrefab = GetGameItemPrefab(item.gameItemId);
		if ((Object)(object)gameItemPrefab != (Object)null)
		{
			string gameItemDisplayName = GetGameItemDisplayName(gameItemPrefab);
			if (!string.IsNullOrWhiteSpace(gameItemDisplayName))
			{
				return gameItemDisplayName;
			}
		}
		if (!string.IsNullOrWhiteSpace(item.fallbackName))
		{
			return item.fallbackName;
		}
		return "Item " + item.gameItemId;
	}

	private string GetRecipeDisplayName(WikiRecipeData recipe)
	{
		if (recipe == null)
		{
			return "Unbekanntes Rezept";
		}
		if (recipe.gameResultItemId > 0)
		{
			Item gameItemPrefab = GetGameItemPrefab(recipe.gameResultItemId);
			if ((Object)(object)gameItemPrefab != (Object)null)
			{
				return GetGameItemDisplayName(gameItemPrefab);
			}
			WikiItemData itemByGameId = GetItemByGameId(recipe.gameResultItemId);
			if (itemByGameId != null)
			{
				return GetItemDisplayName(itemByGameId);
			}
		}
		if (!string.IsNullOrWhiteSpace(recipe.fallbackName))
		{
			return recipe.fallbackName;
		}
		return recipe.wikiId ?? "Unbekanntes Rezept";
	}

	private string GetEnchantmentDisplayName(WikiEnchantmentData enchantment)
	{
		if (enchantment == null)
		{
			return "Unbekannte Verzauberung";
		}
		EnchantmentRecipe recipe = FindGameEnchantmentRecipe(enchantment);
		Enchantment val = FindGameEnchantment(enchantment, recipe);
		if ((Object)(object)val != (Object)null)
		{
			try
			{
				if (!string.IsNullOrWhiteSpace(val.Name))
				{
					return val.Name;
				}
			}
			catch
			{
			}
		}
		if (!string.IsNullOrWhiteSpace(enchantment.fallbackName))
		{
			return enchantment.fallbackName;
		}
		if (enchantment.gameEnchantmentId > 0)
		{
			return "Verzauberung " + enchantment.gameEnchantmentId;
		}
		return enchantment.wikiId ?? "Unbekannte Verzauberung";
	}

	private string GetCategoryDisplayName(WikiCategory category)
	{
		return category switch
		{
			WikiCategory.Cooking => L("Kochrezepte", "Cooking Recipes"), 
			WikiCategory.Alchemy => L("Alchemie", "Alchemy"), 
			WikiCategory.Crafting => L("Handwerk", "Crafting"), 
			WikiCategory.Enchantments => L("Verzauberungen", "Enchantments"), 
			WikiCategory.Items => "Items", 
			WikiCategory.Favorites => L("Favoriten", "Favorites"), 
			_ => L("Übersicht", "Overview"), 
		};
	}

	private static bool ContainsIgnoreCase(string source, string value)
	{
		if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(value))
		{
			return false;
		}
		return source.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private GameObject CreatePanel(string name, Transform parent)
	{
		return CreateUIObject(name, parent);
	}

	private static GameObject CreateUIObject(string name, Transform parent)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_0031: 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)
		GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
		val.transform.SetParent(parent, false);
		RectTransform component = val.GetComponent<RectTransform>();
		((Transform)component).localScale = Vector3.one;
		((Transform)component).localRotation = Quaternion.identity;
		return val;
	}

	private static void StretchRect(RectTransform rect)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)rect == (Object)null))
		{
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}
	}

	private static void SetRect(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: 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)
		if (!((Object)(object)rect == (Object)null))
		{
			rect.anchorMin = anchorMin;
			rect.anchorMax = anchorMax;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}
	}

	internal void CloseWiki()
	{
		if (m_wikiOpen)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Wiki wird geschlossen...");
			if (m_focusCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(m_focusCoroutine);
				m_focusCoroutine = null;
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current != (Object)null)
			{
				current.SetSelectedGameObject((GameObject)null);
			}
			if ((Object)(object)m_wikiWindow != (Object)null)
			{
				Object.Destroy((Object)(object)m_wikiWindow);
				m_wikiWindow = null;
			}
			if ((Object)(object)m_inventoryCanvasGroup != (Object)null)
			{
				m_inventoryCanvasGroup.alpha = m_originalInventoryAlpha;
				m_inventoryCanvasGroup.interactable = m_originalInventoryInteractable;
				m_inventoryCanvasGroup.blocksRaycasts = m_originalInventoryBlocksRaycasts;
			}
			m_searchField = null;
			m_entryListContent = null;
			m_entryListScrollRect = null;
			m_entryListScrollbar = null;
			m_articleContent = null;
			m_articleScrollRect = null;
			m_articleTitle = null;
			m_articleCategory = null;
			m_lastSelectedWikiObject = null;
			m_activeLeftSourceButton = null;
			m_articleButtonRows.Clear();
			m_inventoryCanvasGroup = null;
			m_inventoryMenu = null;
			m_characterUI = null;
			m_currentCategory = WikiCategory.None;
			m_currentViewState = WikiViewState.CategoryOverview;
			m_lastBackHandledFrame = -1;
			m_wikiOpen = false;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Wiki wurde geschlossen. Inventar bleibt geöffnet.");
		}
	}

	private void OnDestroy()
	{
		if (m_wikiOpen)
		{
			CloseWiki();
		}
		if ((Object)(object)m_wikiBackgroundSprite != (Object)null)
		{
			Object.Destroy((Object)(object)m_wikiBackgroundSprite);
			m_wikiBackgroundSprite = null;
		}
		if ((Object)(object)m_wikiBackgroundTexture != (Object)null)
		{
			Object.Destroy((Object)(object)m_wikiBackgroundTexture);
			m_wikiBackgroundTexture = null;
		}
	}
}
internal enum WikiCategory
{
	None,
	Cooking,
	Alchemy,
	Crafting,
	Enchantments,
	Items,
	Favorites
}
internal enum WikiViewState
{
	CategoryOverview,
	CategoryList,
	Article,
	GenericIngredient
}
[Serializable]
public class WikiLocalizedText
{
	public string de;

	public string en;
}
[Serializable]
public class WikiReplacementRule
{
	public string de;

	public string en;
}
[Serializable]
public class WikiLocalizationData
{
	public int schemaVersion;

	public string defaultLanguage;

	public List<string> supportedLanguages;

	public Dictionary<string, WikiLocalizedText> exact;

	public List<WikiReplacementRule> phraseReplacements;

	public List<WikiReplacementRule> unitReplacements;

	public Dictionary<string, WikiLocalizedText> sourceTypeKeys;
}
[Serializable]
public class WikiCraftingOverrideFile
{
	public int schemaVersion;

	public string mergeMode;

	public WikiLocalizedText notes;

	public List<WikiRuntimeRecipeFilter> runtimeRecipeFilters;

	public List<WikiRecipeData> overrides;
}
[Serializable]
public class WikiRuntimeRecipeFilter
{
	public string id;

	public List<int> resultItemIds;

	public bool hideWhenIngredientContainsResultItem;

	public string reasonDe;

	public string reasonEn;
}
[Serializable]
public class WikiLegacyUpgradeFile
{
	public int schemaVersion;

	public string sourceTypeKey;

	public WikiLegacyValidation validation;

	public WikiLegacyIndexPolicy indexPolicy;

	public WikiLegacyNameResolutionPolicy nameResolutionPolicy;

	public WikiLocalizedText description;

	public List<WikiLegacyChestLocation> chestLocations;

	public List<WikiLegacyUpgradeData> upgrades;
}
[Serializable]
public class WikiLegacyValidation
{
	public string checkedAgainst;

	public string checkedOn;

	public int expectedUpgradeCount;

	public int actualUpgradeCount;

	public int duplicateSourceCount;

	public int duplicatePairCount;

	public int verifiedCompleteIdPairs;

	public string noteDe;

	public string noteEn;
}
[Serializable]
public class WikiLegacyIndexPolicy
{
	public bool includeAllSourceItemsInItems;

	public bool includeAllResultItemsInItems;

	public bool includeAllSourceItemsInGlobalSearch;

	public bool includeAllResultItemsInGlobalSearch;

	public bool resolveZeroIdsFromRuntimeItemNames;

	public bool resolveFromAliases;

	public bool preferVerifiedItemIds;
}
[Serializable]
public class WikiLegacyNameResolutionPolicy
{
	public bool preferItemIds;

	public bool useFallbackName;

	public bool useWikiName;

	public bool useAliases;

	public bool caseInsensitive;

	public bool ignorePunctuation;

	public bool normalizeWhitespace;

	public bool normalizeApostrophes;

	public bool normalizeHyphens;

	public bool normalizeSabreSaber;

	public bool normalizeHelmHelmet;

	public bool requireUniqueBestMatch;
}
[Serializable]
public class WikiLegacyChestLocation
{
	public string id;

	public string regionDe;

	public string regionEn;

	public string locationDe;

	public string locationEn;

	public string accessDe;

	public string accessEn;
}
[Serializable]
public class WikiLegacyUpgradeData
{
	public int sourceItemId;

	public string sourceFallbackName;

	public string sourceWikiName;

	public List<string> sourceAliases;

	public int resultItemId;

	public string resultFallbackName;

	public string resultWikiName;

	public List<string> resultAliases;

	public string sourceTypeKey;

	public bool includeSourceInItemIndex;

	public bool includeResultInItemIndex;

	public bool includeSourceInGlobalSearch;

	public bool includeResultInGlobalSearch;

	public bool resolveMissingIdsFromRuntimeName;

	public string idStatus;

	public bool wikiVerified;
}
[Serializable]
public class WikiSourceCommissionData
{
	public List<WikiItemReference> requiredItems;

	public int silverCost;

	public int craftingTimeHours;
}
[Serializable]
public class WikiItemData
{
	public int gameItemId;

	public string fallbackName;

	public string fallbackDescription;

	public string sourceStatus;

	public float weight;

	public int buyPrice;

	public int sellPrice;

	public string sourceTypeKey;

	public string sourceType;

	public string sourceTypeDe;

	public string sourceTypeEn;

	public List<string> locations;

	public List<string> locationsDe;

	public List<string> locationsEn;

	public List<string> dropsFrom;

	public List<string> dropsFromDe;

	public List<string> dropsFromEn;

	public List<string> questSources;

	public List<string> questSourcesDe;

	public List<string> questSourcesEn;

	public List<string> questRewards;

	public List<string> questRewardsDe;

	public List<string> questRewardsEn;

	public List<string> blacksmithSources;

	public List<string> blacksmithSourcesDe;

	public List<string> blacksmithSourcesEn;

	public List<string> sourceNotes;

	public List<string> sourceNotesDe;

	public List<string> sourceNotesEn;

	public WikiSourceCommissionData commission;
}
[Serializable]
public class WikiItemSourceData
{
	public int schemaVersion;

	public int gameItemId;

	public string fallbackName;

	public string sourceTypeKey;

	public string sourceType;

	public List<string> locations;

	public List<string> dropsFrom;

	public List<string> questSources;

	public List<string> questRewards;

	public List<string> blacksmithSources;

	public List<string> sourceNotes;

	public string sourceTypeDe;

	public string sourceTypeEn;

	public List<string> locationsDe;

	public List<string> locationsEn;

	public List<string> dropsFromDe;

	public List<string> dropsFromEn;

	public List<string> questSourcesDe;

	public List<string> questSourcesEn;

	public List<string> questRewardsDe;

	public List<string> questRewardsEn;

	public List<string> blacksmithSourcesDe;

	public List<string> blacksmithSourcesEn;

	public List<string> sourceNotesDe;

	public List<string> sourceNotesEn;

	public WikiSourceCommissionData commission;
}
[Serializable]
public class WikiItemReference
{
	public int gameItemId;

	public int amount = 1;

	public string ingredientCategory;

	public string fallbackName;
}
[Serializable]
public class WikiRecipeData
{
	public string wikiId;

	public string overrideMode;

	public string recipeKind;

	public string category;

	public string categoryKey;

	public int gameRecipeId;

	public int gameResultItemId;

	public string fallbackName;

	public string description;

	public string descriptionDe;

	public string descriptionEn;

	public bool isTestData;

	public string station;

	public string stationDe;

	public string stationEn;

	public int silverCost;

	public List<WikiItemReference> ingredients;

	public List<WikiItemReference> results;
}
[Serializable]
public class WikiPillarPosition
{
	public string pillar;

	public string distance;
}
[Serializable]
public class WikiEnchantmentData
{
	public string wikiId;

	public string category;

	public int gameRecipeId;

	public int gameEnchantmentId;

	public string fallbackName;

	public string description;

	public bool isTestData;

	public List<WikiItemReference> compatibleItems;

	public List<WikiPillarPosition> pillarPositions;

	public List<string> requirements;

	public List<string> effects;
}
[HarmonyPatch(typeof(CharacterUI), "ToggleMenu")]
[HarmonyPatch(new Type[]
{
	typeof(MenuScreens),
	typeof(bool)
})]
internal static class CharacterUIToggleMenuWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance, MenuScreens _menu, ref bool __result)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			return true;
		}
		if (!instance.ShouldBlockCharacterUIInput(__instance))
		{
			return true;
		}
		__result = __instance.GetIsMenuDisplayed(_menu);
		return false;
	}
}
[HarmonyPatch(typeof(CharacterUI), "GoToPreviousTab")]
internal static class CharacterUIPreviousTabWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "GoToNextTab")]
internal static class CharacterUINextTabWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "InfoInputMenu")]
internal static class CharacterUIInfoInputWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "OptionInputMenu")]
internal static class CharacterUIOptionInputWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "TakeAllItemsInput")]
internal static class CharacterUITakeAllItemsWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "ContinueDialogueInput")]
internal static class CharacterUIContinueDialogueWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "ShowAndFocusChat")]
internal static class CharacterUIChatWhileTypingPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		return (Object)(object)instance == (Object)null || !instance.ShouldBlockCharacterUIInput(__instance);
	}
}
[HarmonyPatch(typeof(CharacterUI), "CancelMenu")]
internal static class CharacterUICancelMenuPatch
{
	[HarmonyPrefix]
	private static bool Prefix(CharacterUI __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			return true;
		}
		if (!instance.ShouldHandleCharacterUICancel(__instance))
		{
			return true;
		}
		instance.HandleWikiBack();
		return false;
	}
}
[HarmonyPatch(typeof(InventoryMenu))]
internal static class InventoryMenuCancelPatch
{
	[HarmonyPatch("OnCancelInput")]
	[HarmonyPrefix]
	private static bool OnCancelInputPrefix()
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		if ((Object)(object)instance == (Object)null || !instance.IsWikiOpen)
		{
			return true;
		}
		instance.HandleWikiBack();
		return false;
	}
}
[HarmonyPatch]
internal static class InventoryMenuHideWhileTypingPatch
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from method in typeof(InventoryMenu).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where method.Name == "Hide"
			select method;
	}

	[HarmonyPrefix]
	private static bool Prefix(InventoryMenu __instance)
	{
		WikiBookPlugin instance = WikiBookPlugin.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			return true;
		}
		if (instance.ShouldBlockInventoryHide(__instance))
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(ItemDisplayOptionPanel))]
internal static class ItemDisplayOptionPanelPatches
{
	[HarmonyPatch("StartInit")]
	[HarmonyPostfix]
	private static void StartInitPostfix(ref string[] ___ActionStrings)
	{
		if (___ActionStrings != null)
		{
			string openActionString = WikiBookPlugin.GetOpenActionText();
			int num = Array.FindIndex(___ActionStrings, (string value) => string.Equals(value, openActionString, StringComparison.Ordinal) || string.Equals(value, "Öffnen", StringComparison.Ordinal) || string.Equals(value, "Open", StringComparison.Ordinal));
			if (num >= 0)
			{
				WikiBookPlugin.OpenActionID = num;
				___ActionStrings[num] = openActionString;
				return;
			}
			List<string> list = ___ActionStrings.ToList();
			list.Add(openActionString);
			___ActionStrings = list.ToArray();
			WikiBookPlugin.OpenActionID = ___ActionStrings.Length - 1;
		}
	}

	[HarmonyPatch("GetActiveActions")]
	[HarmonyPatch(new Type[] { typeof(GameObject) })]
	[HarmonyPostfix]
	private static void GetActiveActionsPostfix(Item ___m_pendingItem, ref List<int> __result)
	{
		if (!((Object)(object)___m_pendingItem == (Object)null) && __result != null && WikiBookPlugin.OpenActionID >= 0 && WikiBookPlugin.IsWikiBookItem(___m_pendingItem.ItemID) && !__result.Contains(WikiBookPlugin.OpenActionID))
		{
			__result.Add(WikiBookPlugin.OpenActionID);
		}
	}

	[HarmonyPatch("ActionHasBeenPressed")]
	[HarmonyPatch(new Type[] { typeof(int) })]
	[HarmonyPrefix]
	private static void ActionHasBeenPressedPrefix(int _actionID, ItemDisplay ___m_activatedItemDisplay)
	{
		if (_actionID == WikiBookPlugin.OpenActionID)
		{
			Item val = ((___m_activatedItemDisplay != null) ? ___m_activatedItemDisplay.RefItem : null);
			if (!((Object)(object)val == (Object)null) && WikiBookPlugin.IsWikiBookItem(val.ItemID))
			{
				Debug.Log((object)("[WikiBook] " + WikiBookPlugin.GetOpenActionText() + " action selected. ItemID=" + val.ItemID));
				WikiBookPlugin.Instance?.OpenWiki();
			}
		}
	}
}