using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Mono.Cecil;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BepInExConfigManager.Patcher")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BepInExConfigManager.Patcher")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("beabe9b7-0c1c-4071-a99c-1ced983287e9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyVersion("1.0.0.0")]
public static class Patcher
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class ConfigFile_ctor
	{
		internal static void Postfix(ConfigFile __instance, BepInPlugin ownerMetadata)
		{
			CachedConfigFile cachedConfigFile = new CachedConfigFile(__instance, ownerMetadata);
			ConfigFiles.Add(cachedConfigFile);
			ConfigFileCreated?.Invoke(cachedConfigFile);
		}
	}

	internal const string GUID = "com.sinai.bepinexconfigmanager.patcher";

	public static Action<CachedConfigFile> ConfigFileCreated;

	public static List<CachedConfigFile> ConfigFiles { get; }

	public static IEnumerable<string> TargetDLLs { get; }

	public static void Patch(AssemblyDefinition _)
	{
	}

	static Patcher()
	{
		ConfigFiles = new List<CachedConfigFile>();
		TargetDLLs = Enumerable.Empty<string>();
		Init();
	}

	internal static void Init()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("com.sinai.bepinexconfigmanager.patcher").PatchAll();
	}
}
public class CachedConfigFile
{
	public readonly ConfigFile configFile;

	public readonly BepInPlugin metadata;

	public CachedConfigFile(ConfigFile configFile, BepInPlugin metadata)
	{
		this.configFile = configFile;
		this.metadata = metadata;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConfigManager.UI;
using ConfigManager.UI.InteractiveValues;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.Utility;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BepInExConfigManager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BepInExConfigManager")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("51308bd5-5872-4a72-85d2-6194673c8a5f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace ConfigManager
{
	[BepInPlugin("com.sinai.BepInExConfigManager", "BepInExConfigManager", "1.3.0")]
	public class ConfigManager : BaseUnityPlugin
	{
		public const string GUID = "com.sinai.BepInExConfigManager";

		public const string NAME = "BepInExConfigManager";

		public const string AUTHOR = "Sinai";

		public const string VERSION = "1.3.0";

		internal const string CTG_ID = "BepInExConfigManager";

		internal static string CTG = "Settings";

		internal static ConfigEntry<KeyCode> Main_Menu_Toggle;

		internal static ConfigEntry<bool> Auto_Save_Configs;

		internal static ConfigEntry<float> Startup_Delay;

		internal static ConfigEntry<bool> Disable_EventSystem_Override;

		public static ConfigManager Instance { get; private set; }

		public static ManualLogSource LogSource => ((BaseUnityPlugin)Instance).Logger;

		internal static Harmony Harmony { get; } = new Harmony("com.sinai.BepInExConfigManager");


		internal void Awake()
		{
			Instance = this;
			Init();
		}

		internal void Update()
		{
			DoUpdate();
		}

		public static void Init()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			InitConfig();
			Universe.Init(Startup_Delay.Value, (Action)LateInit, (Action<string, LogType>)LogHandler, new UniverseLibConfig
			{
				Disable_EventSystem_Override = Disable_EventSystem_Override.Value,
				Force_Unlock_Mouse = true,
				Unhollowed_Modules_Folder = Path.Combine(Paths.BepInExRootPath, "unhollowed")
			});
		}

		private static void LateInit()
		{
			UIManager.Init();
		}

		public static void DoUpdate()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (UIManager.uiBase != null && InputManager.GetKeyDown(Main_Menu_Toggle.Value))
			{
				UIManager.ShowMenu = !UIManager.ShowMenu;
			}
		}

		public static void InitConfig()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0035: Expected O, but got Unknown
			//IL_004e: 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_006a: Expected O, but got Unknown
			//IL_006a: Expected O, but got Unknown
			Main_Menu_Toggle = ((BaseUnityPlugin)Instance).Config.Bind<KeyCode>(new ConfigDefinition(CTG, "Main Menu Toggle"), (KeyCode)286, new ConfigDescription("The toggle for the Config Manager menu", (AcceptableValueBase)null, new object[0]));
			Auto_Save_Configs = ((BaseUnityPlugin)Instance).Config.Bind<bool>(new ConfigDefinition(CTG, "Auto-save settings"), false, new ConfigDescription("Automatically save settings after changing them? This will mean the undo feature will be unavailable.", (AcceptableValueBase)null, new object[0]));
			Auto_Save_Configs.SettingChanged += Auto_Save_Configs_SettingChanged;
			Startup_Delay = ((BaseUnityPlugin)Instance).Config.Bind<float>(CTG, "Startup Delay", 1f, "Delays the core startup process. Adjust it if you experience issues.");
			Disable_EventSystem_Override = ((BaseUnityPlugin)Instance).Config.Bind<bool>(CTG, "Disable EventSystem Override", false, "Disables the overriding of the EventSystem from the game, if you experience issues with UI Input.");
			Disable_EventSystem_Override.SettingChanged += Disable_EventSystem_Override_SettingChanged;
		}

		private static void Disable_EventSystem_Override_SettingChanged(object sender, EventArgs e)
		{
			bool disable_EventSystem_Override = (bool)((SettingChangedEventArgs)((e is SettingChangedEventArgs) ? e : null)).ChangedSetting.BoxedValue;
			ConfigManager.Disable_EventSystem_Override = disable_EventSystem_Override;
		}

		private static void Auto_Save_Configs_SettingChanged(object sender, EventArgs e)
		{
			bool flag = (bool)((SettingChangedEventArgs)((e is SettingChangedEventArgs) ? e : null)).ChangedSetting.BoxedValue;
			((Component)UIManager.saveButton.Component).gameObject.SetActive(!flag);
		}

		private static void LogHandler(string log, LogType logType)
		{
			//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_001f: Expected I4, but got Unknown
			switch ((int)logType)
			{
			case 3:
				LogSource.LogMessage((object)log);
				break;
			case 1:
			case 2:
				LogSource.LogWarning((object)log);
				break;
			case 0:
			case 4:
				LogSource.LogError((object)log);
				break;
			}
		}
	}
}
namespace ConfigManager.UI
{
	public class CachedConfigEntry
	{
		public InteractiveValue IValue;

		public bool UIConstructed;

		public GameObject parentContent;

		public GameObject ContentGroup;

		public RectTransform ContentRect;

		public GameObject SubContentGroup;

		public Text mainLabel;

		internal GameObject UIroot;

		internal GameObject undoButton;

		public ConfigEntryBase RefConfig { get; }

		public object EditedValue { get; internal set; }

		public Type FallbackType => RefConfig.SettingType;

		public CachedConfigEntry(ConfigEntryBase config, GameObject parent)
		{
			RefConfig = config;
			parentContent = parent;
			EditedValue = config.BoxedValue;
			CreateIValue(config.BoxedValue, FallbackType);
		}

		internal void OnSettingChanged(object sender, EventArgs e)
		{
			object value = (EditedValue = ((SettingChangedEventArgs)((e is SettingChangedEventArgs) ? e : null)).ChangedSetting.BoxedValue);
			IValue.Value = value;
			IValue.OnValueUpdated();
		}

		public void CreateIValue(object value, Type fallbackType)
		{
			ConfigDescription description = RefConfig.Description;
			if (((description != null) ? description.AcceptableValues : null) != null && ((object)RefConfig.Description.AcceptableValues).GetType().Name.StartsWith("AcceptableValueList"))
			{
				Type actualType = ReflectionExtensions.GetActualType(value);
				IValue = new InteractiveValueList(value, actualType);
			}
			else
			{
				IValue = InteractiveValue.Create(value, fallbackType);
			}
			IValue.Owner = this;
			IValue.mainContentParent = ContentGroup;
			IValue.subContentParent = SubContentGroup;
		}

		public void UpdateValue()
		{
			IValue.Value = RefConfig.BoxedValue;
			EditedValue = RefConfig.BoxedValue;
			IValue.OnValueUpdated();
			IValue.RefreshSubContentState();
		}

		public void SetValueFromIValue()
		{
			if (RefConfig.Description.AcceptableValues != null)
			{
				IValue.Value = RefConfig.Description.AcceptableValues.Clamp(IValue.Value);
			}
			object editedValue = EditedValue;
			if ((editedValue == null && IValue.Value == null) || (editedValue != null && editedValue.Equals(IValue.Value)))
			{
				return;
			}
			if (ConfigManager.Auto_Save_Configs.Value)
			{
				RefConfig.BoxedValue = IValue.Value;
				if (!RefConfig.ConfigFile.SaveOnConfigSet)
				{
					RefConfig.ConfigFile.Save();
				}
				UpdateValue();
			}
			else
			{
				EditedValue = IValue.Value;
				UIManager.OnEntryEdit(this);
				undoButton.SetActive(true);
			}
		}

		public void UndoEdits()
		{
			EditedValue = RefConfig.BoxedValue;
			IValue.Value = EditedValue;
			IValue.OnValueUpdated();
			OnSaveOrUndo();
		}

		public void RevertToDefault()
		{
			RefConfig.BoxedValue = RefConfig.DefaultValue;
			UpdateValue();
			OnSaveOrUndo();
		}

		internal void OnSaveOrUndo()
		{
			undoButton.SetActive(false);
			UIManager.OnEntrySaveOrUndo(this);
		}

		public void Enable()
		{
			if (!UIConstructed)
			{
				ConstructUI();
				UpdateValue();
			}
			UIroot.SetActive(true);
			UIroot.transform.SetAsLastSibling();
		}

		public void Disable()
		{
			if (Object.op_Implicit((Object)(object)UIroot))
			{
				UIroot.SetActive(false);
			}
		}

		public void Destroy()
		{
			if (Object.op_Implicit((Object)(object)UIroot))
			{
				Object.Destroy((Object)(object)UIroot);
			}
		}

		internal void ConstructUI()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			UIConstructed = true;
			UIroot = UIFactory.CreateVerticalGroup(parentContent, "CacheObjectBase.MainContent", true, false, true, true, 0, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
			ContentRect = UIroot.GetComponent<RectTransform>();
			ContentRect.SetSizeWithCurrentAnchors((Axis)1, 25f);
			GameObject uIroot = UIroot;
			int? num = 25;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(uIroot, (int?)200, num, (int?)5000, num2, (int?)null, (int?)null, (bool?)null);
			ContentGroup = UIFactory.CreateVerticalGroup(UIroot, "ConfigHolder", true, false, true, true, 5, new Vector4(2f, 2f, 5f, 5f), new Color(0.12f, 0.12f, 0.12f), (TextAnchor?)null);
			GameObject val = UIFactory.CreateHorizontalGroup(ContentGroup, "ConfigEntryHolder", false, false, true, true, 5, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)(TextAnchor)3);
			num2 = 30;
			num = 0;
			UIFactory.SetLayoutElement(val, (int?)null, num2, (int?)null, num, (int?)null, (int?)null, (bool?)null);
			mainLabel = UIFactory.CreateLabel(val, "ConfigLabel", RefConfig.Definition.Key, (TextAnchor)3, new Color(0.9f, 0.9f, 0.7f), true, 14);
			Text obj = mainLabel;
			obj.text = obj.text + " <i>(" + SignatureHighlighter.Parse(RefConfig.SettingType, false, (MemberInfo)null) + ")</i>";
			UIFactory.SetLayoutElement(((Component)mainLabel).gameObject, (int?)200, (int?)22, (int?)9999, (int?)0, (int?)null, (int?)null, (bool?)null);
			ButtonRef val2 = UIFactory.CreateButton(val, "UndoButton", "Undo", (Color?)new Color(0.3f, 0.3f, 0.3f));
			val2.OnClick = (Action)Delegate.Combine(val2.OnClick, new Action(UndoEdits));
			undoButton = ((Component)val2.Component).gameObject;
			undoButton.SetActive(false);
			UIFactory.SetLayoutElement(undoButton, (int?)80, (int?)22, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef val3 = UIFactory.CreateButton(val, "DefaultButton", "Default", (Color?)new Color(0.3f, 0.3f, 0.3f));
			val3.OnClick = (Action)Delegate.Combine(val3.OnClick, new Action(RevertToDefault));
			UIFactory.SetLayoutElement(((Component)val3.Component).gameObject, (int?)80, (int?)22, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			if (RefConfig.Description != null && !string.IsNullOrEmpty(RefConfig.Description.Description))
			{
				Text val4 = UIFactory.CreateLabel(ContentGroup, "Description", "<i>" + RefConfig.Description.Description + "</i>", (TextAnchor)3, Color.grey, true, 14);
				UIFactory.SetLayoutElement(((Component)val4).gameObject, (int?)250, (int?)18, (int?)9999, (int?)0, (int?)null, (int?)null, (bool?)null);
			}
			SubContentGroup = UIFactory.CreateVerticalGroup(ContentGroup, "CacheObjectBase.SubContent", true, false, true, true, 0, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
			GameObject subContentGroup = SubContentGroup;
			num = 30;
			num2 = 9999;
			UIFactory.SetLayoutElement(subContentGroup, (int?)125, num, (int?)9000, num2, (int?)null, (int?)null, (bool?)null);
			SubContentGroup.SetActive(false);
			if (IValue != null)
			{
				IValue.mainContentParent = ContentGroup;
				IValue.subContentParent = SubContentGroup;
			}
		}
	}
	internal class ConfigFileInfo
	{
		public ConfigFile RefConfigFile;

		public BepInPlugin Meta;

		private List<EntryInfo> entries = new List<EntryInfo>();

		internal bool isCompletelyHidden;

		internal ButtonRef listButton;

		internal GameObject contentObj;

		internal IEnumerable<GameObject> HiddenEntries => from it in Entries
			where it.IsHidden
			select it.content;

		internal List<EntryInfo> Entries
		{
			get
			{
				return entries;
			}
			set
			{
				entries = value;
			}
		}
	}
	internal class EntryInfo
	{
		public ConfigEntryBase RefEntry;

		internal GameObject content;

		public CachedConfigEntry Cached { get; }

		public bool IsHidden { get; internal set; }

		public EntryInfo(CachedConfigEntry cached)
		{
			Cached = cached;
		}
	}
	public class UIManager : PanelBase
	{
		private static readonly Dictionary<string, ConfigFileInfo> ConfigFiles = new Dictionary<string, ConfigFileInfo>();

		private static readonly Dictionary<ConfigEntryBase, CachedConfigEntry> configsToCached = new Dictionary<ConfigEntryBase, CachedConfigEntry>();

		private static ConfigFileInfo currentCategory;

		private static readonly HashSet<CachedConfigEntry> editingEntries = new HashSet<CachedConfigEntry>();

		internal static ButtonRef saveButton;

		internal static UIBase uiBase;

		internal static GameObject CategoryListContent;

		internal static GameObject ConfigEditorContent;

		private static string currentFilter;

		private static Color normalInactiveColor = new Color(0.38f, 0.34f, 0.34f);

		private static Color normalActiveColor = UnityHelpers.ToColor("c2b895");

		public static UIManager Instance { get; internal set; }

		public override string Name => "<b>BepInExConfigManager</b> <i>1.3.0</i>";

		public override int MinWidth => 750;

		public override int MinHeight => 750;

		public override Vector2 DefaultAnchorMin => new Vector2(0.2f, 0.02f);

		public override Vector2 DefaultAnchorMax => new Vector2(0.8f, 0.98f);

		public static bool ShowMenu
		{
			get
			{
				return uiBase != null && uiBase.Enabled;
			}
			set
			{
				if (uiBase != null && Object.op_Implicit((Object)(object)uiBase.RootObject) && uiBase.Enabled != value)
				{
					UniversalUI.SetUIActive("com.sinai.BepInExConfigManager", value);
					((UIModel)Instance).SetActive(value);
				}
			}
		}

		public static bool ShowHiddenConfigs { get; internal set; }

		internal static string Filter => currentFilter ?? "";

		public UIManager(UIBase owner)
			: base(owner)
		{
			Instance = this;
		}

		internal static void Init()
		{
			uiBase = UniversalUI.RegisterUI("com.sinai.BepInExConfigManager", (Action)null);
			CreateMenu();
			Canvas.ForceUpdateCanvases();
			ShowMenu = false;
			SetupCategories();
		}

		internal static void SetupCategories()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			ConfigFile val = (ConfigFile)AccessTools.Property(typeof(ConfigFile), "CoreConfig").GetValue(null, null);
			if (val != null)
			{
				SetupCategory(val, null, new BepInPlugin("bepinex.core.config", "BepInEx", "1.0"), isCoreConfig: true, forceAdvanced: true);
			}
			foreach (CachedConfigFile configFile in Patcher.ConfigFiles)
			{
				ProcessConfigFile(configFile);
			}
			Patcher.ConfigFileCreated = (Action<CachedConfigFile>)Delegate.Combine(Patcher.ConfigFileCreated, new Action<CachedConfigFile>(ProcessConfigFile));
		}

		private static void ProcessConfigFile(CachedConfigFile cachedConfig)
		{
			RuntimeHelper.StartCoroutine(DelayedProcess(cachedConfig));
		}

		private static IEnumerator DelayedProcess(CachedConfigFile cachedConfig)
		{
			yield return null;
			SetupCategory(cachedConfig.configFile, null, cachedConfig.metadata, isCoreConfig: false);
			cachedConfig.configFile.SettingChanged += ConfigFile_SettingChanged;
		}

		private static void ConfigFile_SettingChanged(object sender, SettingChangedEventArgs e)
		{
			try
			{
				configsToCached[(ConfigEntryBase)((sender is ConfigEntryBase) ? sender : null)].OnSettingChanged(sender, (EventArgs)(object)e);
			}
			catch (Exception ex)
			{
				ConfigManager.LogSource.LogWarning((object)ex);
			}
		}

		internal static void SetupCategory(ConfigFile configFile, object plugin, BepInPlugin meta, bool isCoreConfig, bool forceAdvanced = false)
		{
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string GUID = ((meta != null) ? meta.GUID : null) ?? Path.GetFileNameWithoutExtension(configFile.ConfigFilePath);
				string text = ((meta != null) ? meta.Name : null) ?? GUID;
				BaseUnityPlugin val = (BaseUnityPlugin)((plugin is BaseUnityPlugin) ? plugin : null);
				if (!forceAdvanced && (Object)(object)val != (Object)null)
				{
					Type type = ((object)val).GetType();
					if (type.GetCustomAttributes(typeof(BrowsableAttribute), inherit: false).Cast<BrowsableAttribute>().Any((BrowsableAttribute it) => !it.Browsable))
					{
						forceAdvanced = true;
					}
				}
				ConfigFileInfo configFileInfo = new ConfigFileInfo
				{
					RefConfigFile = configFile,
					Meta = meta
				};
				ButtonRef val2 = UIFactory.CreateButton(CategoryListContent, "BUTTON_" + GUID, text, (Color?)null);
				val2.OnClick = (Action)Delegate.Combine(val2.OnClick, (Action)delegate
				{
					SetActiveCategory(GUID);
				});
				GameObject gameObject = ((Component)val2.Component).gameObject;
				int? num = 9999;
				int? num2 = 30;
				int? num3 = 0;
				UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num, num3, (int?)null, (int?)null, (bool?)null);
				RuntimeHelper.SetColorBlock((Selectable)(object)val2.Component, (Color?)normalInactiveColor, (Color?)new Color(0.6f, 0.55f, 0.45f), (Color?)new Color(0.2f, 0.18f, 0.15f), (Color?)null);
				configFileInfo.listButton = val2;
				GameObject val3 = UIFactory.CreateVerticalGroup(ConfigEditorContent, "CATEGORY_" + GUID, true, false, true, true, 4, default(Vector4), new Color(0.05f, 0.05f, 0.05f), (TextAnchor?)null);
				Dictionary<string, List<ConfigEntryBase>> dictionary = new Dictionary<string, List<ConfigEntryBase>> { 
				{
					"",
					new List<ConfigEntryBase>()
				} };
				foreach (ConfigDefinition key in configFile.Keys)
				{
					string text2 = key.Section;
					if (text2 == null)
					{
						text2 = "";
					}
					if (!dictionary.ContainsKey(text2))
					{
						dictionary.Add(text2, new List<ConfigEntryBase>());
					}
					dictionary[text2].Add(configFile[key]);
				}
				foreach (KeyValuePair<string, List<ConfigEntryBase>> item in dictionary)
				{
					if (!string.IsNullOrEmpty(item.Key))
					{
						GameObject val4 = UIFactory.CreateHorizontalGroup(val3, "TitleBG", true, true, true, true, 0, default(Vector4), new Color(0.07f, 0.07f, 0.07f), (TextAnchor?)null);
						Text val5 = UIFactory.CreateLabel(val4, "Title_" + item.Key, item.Key, (TextAnchor)4, default(Color), true, 17);
						GameObject gameObject2 = ((Component)val5).gameObject;
						num3 = 30;
						UIFactory.SetLayoutElement(gameObject2, (int?)200, num3, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null);
					}
					foreach (ConfigEntryBase item2 in item.Value)
					{
						CachedConfigEntry cachedConfigEntry = new CachedConfigEntry(item2, val3);
						cachedConfigEntry.Enable();
						configsToCached.Add(item2, cachedConfigEntry);
						GameObject uIroot = cachedConfigEntry.UIroot;
						bool flag = forceAdvanced;
						if (!flag)
						{
							ConfigDescription description = item2.Description;
							object[] array = ((description != null) ? description.Tags : null);
							if (array != null && array.Any())
							{
								if (array.Any((object it) => it is string text3 && text3 == "Advanced"))
								{
									flag = true;
								}
								else
								{
									object obj = array.FirstOrDefault((object it) => it.GetType().Name == "ConfigurationManagerAttributes");
									if (obj != null)
									{
										flag = (bool?)obj.GetType().GetField("IsAdvanced")?.GetValue(obj) == true;
									}
								}
							}
						}
						configFileInfo.Entries.Add(new EntryInfo(cachedConfigEntry)
						{
							RefEntry = item2,
							content = uIroot,
							IsHidden = flag
						});
					}
				}
				if (!configFileInfo.Entries.Any((EntryInfo it) => !it.IsHidden))
				{
					((Component)val2.Component).gameObject.SetActive(false);
					configFileInfo.isCompletelyHidden = true;
				}
				val3.SetActive(false);
				configFileInfo.contentObj = val3;
				ConfigFiles.Add(GUID, configFileInfo);
			}
			catch (Exception arg)
			{
				if (meta != null)
				{
					ConfigManager.LogSource.LogWarning((object)$"Exception setting up category '{meta.GUID}'!\r\n{arg}");
					return;
				}
				string arg2;
				try
				{
					arg2 = Path.GetFileNameWithoutExtension(configFile.ConfigFilePath);
				}
				catch
				{
					arg2 = "UNKNOWN";
				}
				ConfigManager.LogSource.LogWarning((object)$"Exception setting up category (no meta): {arg2}\n{arg}");
			}
		}

		internal static void CreateMenu()
		{
			if (Instance != null)
			{
				ConfigManager.LogSource.LogWarning((object)"An instance of ConfigurationEditor already exists, cannot create another!");
			}
			else
			{
				new UIManager(uiBase);
			}
		}

		public static void OnEntryEdit(CachedConfigEntry entry)
		{
			if (!editingEntries.Contains(entry))
			{
				editingEntries.Add(entry);
			}
			if (!((Selectable)saveButton.Component).interactable)
			{
				((Selectable)saveButton.Component).interactable = true;
			}
		}

		public static void OnEntrySaveOrUndo(CachedConfigEntry entry)
		{
			if (editingEntries.Contains(entry))
			{
				editingEntries.Remove(entry);
			}
			if (!editingEntries.Any())
			{
				((Selectable)saveButton.Component).interactable = false;
			}
		}

		public static void SavePreferences()
		{
			foreach (ConfigFileInfo value in ConfigFiles.Values)
			{
				foreach (EntryInfo entry in value.Entries)
				{
					entry.RefEntry.BoxedValue = entry.Cached.EditedValue;
				}
				ConfigFile refConfigFile = value.RefConfigFile;
				if (!refConfigFile.SaveOnConfigSet)
				{
					refConfigFile.Save();
				}
			}
			for (int num = editingEntries.Count - 1; num >= 0; num--)
			{
				editingEntries.ElementAt(num).OnSaveOrUndo();
			}
			editingEntries.Clear();
			((Selectable)saveButton.Component).interactable = false;
		}

		public static void SetHiddenConfigVisibility(bool show)
		{
			if (ShowHiddenConfigs == show)
			{
				return;
			}
			ShowHiddenConfigs = show;
			foreach (KeyValuePair<string, ConfigFileInfo> configFile in ConfigFiles)
			{
				ConfigFileInfo value = configFile.Value;
				if (value.isCompletelyHidden)
				{
					((Component)value.listButton.Component).gameObject.SetActive(ShowHiddenConfigs);
				}
			}
			if (currentCategory != null && !ShowHiddenConfigs && currentCategory.isCompletelyHidden)
			{
				UnsetActiveCategory();
			}
			RefreshFilter();
		}

		public static void FilterConfigs(string search)
		{
			currentFilter = search.ToLower();
			RefreshFilter();
		}

		internal static void RefreshFilter()
		{
			if (currentCategory == null)
			{
				return;
			}
			using List<EntryInfo>.Enumerator enumerator = currentCategory.Entries.GetEnumerator();
			EntryInfo current;
			int num;
			bool active;
			for (; enumerator.MoveNext(); active = (byte)num != 0, current.content.SetActive(active))
			{
				current = enumerator.Current;
				if (!string.IsNullOrEmpty(currentFilter) && !current.RefEntry.Definition.Key.ToLower().Contains(currentFilter))
				{
					ConfigDescription description = current.RefEntry.Description;
					if (!((description == null) ? null : description.Description?.Contains(currentFilter)).GetValueOrDefault())
					{
						num = 0;
						continue;
					}
				}
				num = ((!current.IsHidden || ShowHiddenConfigs) ? 1 : 0);
			}
		}

		public static void SetActiveCategory(string categoryIdentifier)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigFiles.ContainsKey(categoryIdentifier))
			{
				UnsetActiveCategory();
				ConfigFileInfo configFileInfo = (currentCategory = ConfigFiles[categoryIdentifier]);
				GameObject contentObj = configFileInfo.contentObj;
				contentObj.SetActive(true);
				ButtonRef listButton = configFileInfo.listButton;
				RuntimeHelper.SetColorBlock((Selectable)(object)listButton.Component, (Color?)normalActiveColor, (Color?)null, (Color?)null, (Color?)null);
				RefreshFilter();
			}
		}

		internal static void UnsetActiveCategory()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (currentCategory != null)
			{
				RuntimeHelper.SetColorBlock((Selectable)(object)currentCategory.listButton.Component, (Color?)normalInactiveColor, (Color?)null, (Color?)null, (Color?)null);
				currentCategory.contentObj.SetActive(false);
				currentCategory = null;
			}
		}

		protected override void ConstructPanelContent()
		{
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(((PanelBase)this).ContentRoot, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			ConstructTitleBar();
			ConstructSaveButton();
			ConstructToolbar();
			ConstructEditorViewport();
		}

		protected override void OnClosePanelClicked()
		{
			((PanelBase)this).OnClosePanelClicked();
			ShowMenu = false;
		}

		private void ConstructTitleBar()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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)
			Text component = ((Component)((PanelBase)this).TitleBar.transform.GetChild(0)).GetComponent<Text>();
			component.text = "<b><color=#8b736b>BepInExConfigManager</color></b> <i><color=#ffe690>v1.3.0</color></i>";
			Button componentInChildren = ((PanelBase)this).TitleBar.GetComponentInChildren<Button>();
			RuntimeHelper.SetColorBlock((Selectable)(object)componentInChildren, (Color?)new Color(1f, 0.2f, 0.2f), (Color?)new Color(1f, 0.6f, 0.6f), (Color?)new Color(0.3f, 0.1f, 0.1f), (Color?)null);
			Text componentInChildren2 = ((Component)componentInChildren).GetComponentInChildren<Text>();
			((Graphic)componentInChildren2).color = Color.white;
			componentInChildren2.resizeTextForBestFit = true;
			componentInChildren2.resizeTextMinSize = 8;
			componentInChildren2.resizeTextMaxSize = 14;
		}

		private void ConstructSaveButton()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			saveButton = UIFactory.CreateButton(((PanelBase)this).ContentRoot, "SaveButton", "Save Preferences", (Color?)null);
			ButtonRef obj = saveButton;
			obj.OnClick = (Action)Delegate.Combine(obj.OnClick, new Action(SavePreferences));
			GameObject gameObject = ((Component)saveButton.Component).gameObject;
			int? num = 35;
			int? num2 = 0;
			int? num3 = 9999;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num, num3, num2, (int?)null, (int?)null, (bool?)null);
			RuntimeHelper.SetColorBlock((Selectable)(object)saveButton.Component, (Color?)new Color(0.1f, 0.3f, 0.1f), (Color?)new Color(0.2f, 0.5f, 0.2f), (Color?)new Color(0.1f, 0.2f, 0.1f), (Color?)new Color(0.2f, 0.2f, 0.2f));
			((Selectable)saveButton.Component).interactable = false;
			((Component)saveButton.Component).gameObject.SetActive(!ConfigManager.Auto_Save_Configs.Value);
		}

		private void ConstructToolbar()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			GameObject val2 = UIFactory.CreateHorizontalGroup(((PanelBase)this).ContentRoot, "Toolbar", false, false, true, true, 4, new Vector4(3f, 3f, 3f, 3f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)null);
			Toggle val3 = default(Toggle);
			Text val4 = default(Text);
			GameObject val5 = UIFactory.CreateToggle(val2, "HiddenConfigsToggle", ref val3, ref val4, default(Color), 20, 20);
			val3.isOn = false;
			((UnityEvent<bool>)(object)val3.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				SetHiddenConfigVisibility(val);
			});
			val4.text = "Show Advanced Settings";
			int? num = 280;
			int? num2 = 25;
			int? num3 = 0;
			UIFactory.SetLayoutElement(val5, num, num2, (int?)0, num3, (int?)null, (int?)null, (bool?)null);
			InputFieldRef val6 = UIFactory.CreateInputField(val2, "FilterInput", "Search...");
			GameObject gameObject = ((Component)val6.Component).gameObject;
			num3 = 9999;
			int? num4 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num4, num3, (int?)null, (int?)null, (int?)null, (bool?)null);
			val6.OnValueChanged += FilterConfigs;
		}

		private void ConstructEditorViewport()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.CreateHorizontalGroup(((PanelBase)this).ContentRoot, "Main", true, true, true, true, 2, default(Vector4), new Color(0.08f, 0.08f, 0.08f), (TextAnchor?)null);
			GameObject val2 = default(GameObject);
			AutoSliderScrollbar val3 = default(AutoSliderScrollbar);
			GameObject val4 = UIFactory.CreateScrollView(val, "CategoryList", ref val2, ref val3, new Color(0.1f, 0.1f, 0.1f));
			int? num = 300;
			int? num2 = 0;
			UIFactory.SetLayoutElement(val4, num, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			CategoryListContent = val2;
			GameObject obj = val2;
			num2 = 3;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(obj, (bool?)null, (bool?)null, (bool?)null, (bool?)null, num2, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject configEditorContent = default(GameObject);
			GameObject val5 = UIFactory.CreateScrollView(val, "ConfigEditor", ref configEditorContent, ref val3, new Color(0.05f, 0.05f, 0.05f));
			num2 = 9999;
			UIFactory.SetLayoutElement(val5, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			ConfigEditorContent = configEditorContent;
		}
	}
}
namespace ConfigManager.UI.InteractiveValues
{
	public class InteractiveBool : InteractiveValue
	{
		internal Toggle toggle;

		private Text labelText;

		public InteractiveBool(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return (object)type == typeof(bool);
		}

		public override void RefreshUIForValue()
		{
			bool flag = (bool)Value;
			if (!((Component)toggle).gameObject.activeSelf)
			{
				((Component)toggle).gameObject.SetActive(true);
			}
			if (flag != toggle.isOn)
			{
				toggle.isOn = flag;
			}
			string arg = (flag ? "6bc981" : "c96b6b");
			labelText.text = $"<color=#{arg}>{flag}</color>";
		}

		internal void OnToggleValueChanged(bool val)
		{
			Value = val;
			RefreshUIForValue();
			Owner.SetValueFromIValue();
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			base.ConstructUI(parent);
			bool flag = false;
			Text val2 = default(Text);
			while (!flag)
			{
				GameObject val = null;
				try
				{
					val = UIFactory.CreateToggle(mainContent, "InteractiveBoolToggle", ref toggle, ref val2, new Color(0.1f, 0.1f, 0.1f), 20, 20);
					UIFactory.SetLayoutElement(val, (int?)24, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
					((UnityEvent<bool>)(object)toggle.onValueChanged).AddListener((UnityAction<bool>)OnToggleValueChanged);
					flag = true;
				}
				catch
				{
					if (Object.op_Implicit((Object)(object)val))
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			labelText = UIFactory.CreateLabel(mainContent, "TrueFalseLabel", "False", (TextAnchor)3, default(Color), true, 14);
			UIFactory.SetLayoutElement(((Component)labelText).gameObject, (int?)60, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			RefreshUIForValue();
		}
	}
	public class InteractiveColor : InteractiveValue
	{
		private Image colorImage;

		private readonly InputField[] inputs = (InputField[])(object)new InputField[4];

		private readonly Slider[] sliders = (Slider[])(object)new Slider[4];

		private static readonly string[] fieldNames = new string[4] { "R", "G", "B", "A" };

		public InteractiveColor(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return (object)type == typeof(Color) || (object)type == typeof(Color32);
		}

		public override void RefreshUIForValue()
		{
			base.RefreshUIForValue();
			RefreshColorUI();
		}

		private void RefreshColorUI()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (Value is Color32 val)
			{
				inputs[0].text = val.r.ToString();
				inputs[1].text = val.g.ToString();
				inputs[2].text = val.b.ToString();
				inputs[3].text = val.a.ToString();
				if (Object.op_Implicit((Object)(object)colorImage))
				{
					((Graphic)colorImage).color = Color32.op_Implicit(val);
				}
				return;
			}
			object value = Value;
			if (!(value is Color))
			{
				return;
			}
			Color color = (Color)value;
			if (true)
			{
				inputs[0].text = color.r.ToString();
				inputs[1].text = color.g.ToString();
				inputs[2].text = color.b.ToString();
				inputs[3].text = color.a.ToString();
				if (Object.op_Implicit((Object)(object)colorImage))
				{
					((Graphic)colorImage).color = color;
				}
			}
		}

		protected internal override void OnToggleSubcontent(bool toggle)
		{
			base.OnToggleSubcontent(toggle);
			RefreshColorUI();
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			base.ConstructUI(parent);
			GameObject val = UIFactory.CreateHorizontalGroup(mainContent, "ColorEditor", false, false, true, true, 5, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)(TextAnchor)3);
			GameObject val2 = UIFactory.CreateVerticalGroup(val, "ImgHolder", true, true, true, true, 0, new Vector4(1f, 1f, 1f, 1f), new Color(0.08f, 0.08f, 0.08f), (TextAnchor?)null);
			UIFactory.SetLayoutElement(val2, (int?)50, (int?)25, (int?)999, (int?)0, (int?)null, (int?)null, (bool?)null);
			GameObject val3 = UIFactory.CreateUIObject("ColorImageHelper", val2, new Vector2(100f, 25f));
			colorImage = val3.AddComponent<Image>();
			((Graphic)colorImage).color = (Color)((Value is Color) ? ((Color)Value) : Color32.op_Implicit((Color32)Value));
			GameObject val4 = UIFactory.CreateVerticalGroup(val, "EditorsGroup", false, false, true, true, 3, new Vector4(3f, 3f, 3f, 3f), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
			GameObject val5 = UIFactory.CreateGridGroup(val4, "Grid", new Vector2(140f, 25f), new Vector2(2f, 2f), new Color(1f, 1f, 1f, 0f));
			UIFactory.SetLayoutElement(val5, (int?)580, (int?)25, (int?)900, (int?)null, (int?)null, (int?)null, (bool?)null);
			for (int i = 0; i < 4; i++)
			{
				AddEditorRow(i, val5);
			}
			RefreshUIForValue();
		}

		internal void AddEditorRow(int index, GameObject groupObj)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			GameObject val = UIFactory.CreateHorizontalGroup(groupObj, "EditorRow_" + fieldNames[index], false, true, true, true, 5, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
			Text val2 = UIFactory.CreateLabel(val, "RowLabel", fieldNames[index] + ":", (TextAnchor)5, Color.cyan, true, 14);
			GameObject gameObject = ((Component)val2).gameObject;
			int? num = 17;
			int? num2 = 0;
			UIFactory.SetLayoutElement(gameObject, num, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			InputFieldRef inputField = UIFactory.CreateInputField(val, "InputField", "...");
			UIFactory.SetLayoutElement(((Component)inputField.Component).gameObject, (int?)40, (int?)25, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			inputs[index] = inputField.Component;
			inputField.Component.characterValidation = (CharacterValidation)((!(Value is Color)) ? 1 : 2);
			inputField.OnValueChanged += delegate(string value)
			{
				if (Value is Color)
				{
					float num3 = float.Parse(value);
					SetValueToColor(num3);
					sliders[index].value = num3;
				}
				else
				{
					byte b = byte.Parse(value);
					SetValueToColor32(b);
					sliders[index].value = (int)b;
				}
			};
			Slider val3 = default(Slider);
			GameObject val4 = UIFactory.CreateSlider(val, "Slider", ref val3);
			sliders[index] = val3;
			num2 = 25;
			UIFactory.SetLayoutElement(val4, (int?)70, num2, (int?)999, (int?)0, (int?)null, (int?)null, (bool?)null);
			val3.minValue = 0f;
			if (Value is Color)
			{
				val3.maxValue = 1f;
				val3.value = GetValueFromColor();
			}
			else
			{
				val3.maxValue = 255f;
				val3.value = (int)GetValueFromColor32();
			}
			((UnityEvent<float>)(object)val3.onValueChanged).AddListener((UnityAction<float>)delegate(float value)
			{
				try
				{
					if (Value is Color32)
					{
						string text = ((byte)value).ToString();
						inputField.Text = text;
						SetValueToColor32((byte)value);
						inputs[index].text = text;
					}
					else
					{
						inputField.Text = value.ToString();
						SetValueToColor(value);
						inputs[index].text = value.ToString();
					}
				}
				catch (Exception ex)
				{
					ConfigManager.LogSource.LogMessage((object)ex.ToString());
				}
			});
			float GetValueFromColor()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				Color val6 = (Color)Value;
				if (1 == 0)
				{
				}
				float result2 = index switch
				{
					0 => val6.r, 
					1 => val6.g, 
					2 => val6.b, 
					3 => val6.a, 
					_ => throw new NotImplementedException(), 
				};
				if (1 == 0)
				{
				}
				return result2;
			}
			byte GetValueFromColor32()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				Color32 val5 = (Color32)Value;
				if (1 == 0)
				{
				}
				byte result = index switch
				{
					0 => val5.r, 
					1 => val5.g, 
					2 => val5.b, 
					3 => val5.a, 
					_ => throw new NotImplementedException(), 
				};
				if (1 == 0)
				{
				}
				return result;
			}
			void SetValueToColor(float floatValue)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				Color val8 = (Color)Value;
				switch (index)
				{
				case 0:
					val8.r = floatValue;
					break;
				case 1:
					val8.g = floatValue;
					break;
				case 2:
					val8.b = floatValue;
					break;
				case 3:
					val8.a = floatValue;
					break;
				}
				Value = val8;
				((Graphic)colorImage).color = val8;
				Owner.SetValueFromIValue();
			}
			void SetValueToColor32(byte byteValue)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0078: Unknown result type (might be due to invalid IL or missing references)
				Color32 val7 = (Color32)Value;
				switch (index)
				{
				case 0:
					val7.r = byteValue;
					break;
				case 1:
					val7.g = byteValue;
					break;
				case 2:
					val7.b = byteValue;
					break;
				case 3:
					val7.a = byteValue;
					break;
				}
				Value = val7;
				((Graphic)colorImage).color = Color32.op_Implicit(val7);
				Owner.SetValueFromIValue();
			}
		}
	}
	public class InteractiveEnum : InteractiveValue
	{
		internal static Dictionary<Type, KeyValuePair<long, string>[]> enumNamesCache = new Dictionary<Type, KeyValuePair<long, string>[]>();

		internal KeyValuePair<long, string>[] values = new KeyValuePair<long, string>[0];

		internal Dictionary<string, OptionData> dropdownOptions = new Dictionary<string, OptionData>();

		internal Dropdown dropdown;

		public InteractiveEnum(object value, Type valueType)
			: base(value, valueType)
		{
			if (value != null)
			{
				GetNames();
			}
		}

		public override bool SupportsType(Type type)
		{
			return type.IsEnum;
		}

		internal void GetNames()
		{
			Type type = Value?.GetType() ?? FallbackType;
			if (!enumNamesCache.ContainsKey(type))
			{
				Array array = Enum.GetValues(type);
				List<KeyValuePair<long, string>> list = new List<KeyValuePair<long, string>>();
				HashSet<string> hashSet = new HashSet<string>();
				foreach (object item in array)
				{
					string text = item.ToString();
					if (!hashSet.Contains(text))
					{
						hashSet.Add(text);
						Type underlyingType = Enum.GetUnderlyingType(type);
						long key;
						try
						{
							object value = Convert.ChangeType(item, underlyingType);
							key = (long)Convert.ChangeType(value, typeof(long));
						}
						catch (Exception ex)
						{
							ConfigManager.LogSource.LogWarning((object)("[InteractiveEnum] Could not Unbox underlying type " + underlyingType.Name + " from " + type.FullName));
							ConfigManager.LogSource.LogMessage((object)ex.ToString());
							continue;
						}
						list.Add(new KeyValuePair<long, string>(key, text));
					}
				}
				enumNamesCache.Add(type, list.ToArray());
			}
			values = enumNamesCache[type];
		}

		public override void OnValueUpdated()
		{
			GetNames();
			base.OnValueUpdated();
		}

		public override void RefreshUIForValue()
		{
			base.RefreshUIForValue();
			if (!(this is InteractiveFlags))
			{
				string key = Value.ToString();
				if (dropdownOptions.ContainsKey(key))
				{
					dropdown.value = dropdown.options.IndexOf(dropdownOptions[key]);
				}
			}
		}

		private void SetValueFromDropdown()
		{
			Type type = Value?.GetType() ?? FallbackType;
			int value = dropdown.value;
			object obj = Enum.Parse(type, enumNamesCache[type][value].Value);
			if (obj != null)
			{
				Value = obj;
				Owner.SetValueFromIValue();
				RefreshUIForValue();
			}
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			base.ConstructUI(parent);
			if (!(this is InteractiveFlags))
			{
				GameObject val2 = UIFactory.CreateDropdown(mainContent, "InteractiveDropdown", ref dropdown, "", 14, (Action<int>)null, (string[])null);
				UIFactory.SetLayoutElement(val2, (int?)400, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				((UnityEvent<int>)(object)dropdown.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					SetValueFromDropdown();
				});
				KeyValuePair<long, string>[] array = values;
				for (int i = 0; i < array.Length; i++)
				{
					KeyValuePair<long, string> keyValuePair = array[i];
					OptionData val3 = new OptionData
					{
						text = keyValuePair.Value
					};
					dropdown.options.Add(val3);
					dropdownOptions.Add(keyValuePair.Value, val3);
				}
			}
		}
	}
	public class InteractiveFlags : InteractiveEnum
	{
		internal bool[] enabledFlags;

		internal Toggle[] toggles;

		private bool refreshingToggleStates;

		public override bool HasSubContent => true;

		public override bool SubContentWanted => true;

		public InteractiveFlags(object value, Type valueType)
			: base(value, valueType)
		{
			toggles = (Toggle[])(object)new Toggle[values.Length];
			enabledFlags = new bool[values.Length];
		}

		public override bool SupportsType(Type type)
		{
			return type.IsEnum && type.GetCustomAttributes(inherit: true).Any((object it) => it is FlagsAttribute);
		}

		public override void OnValueUpdated()
		{
			List<string> list = new List<string>();
			IEnumerable<string> enumerable = (from it in Value?.ToString().Split(new char[1] { ',' })
				select it.Trim());
			if (enumerable != null)
			{
				list.AddRange(enumerable);
			}
			for (int i = 0; i < values.Length; i++)
			{
				enabledFlags[i] = list.Contains(values[i].Value);
			}
			base.OnValueUpdated();
		}

		public override void RefreshUIForValue()
		{
			base.RefreshUIForValue();
			if (!subContentConstructed)
			{
				return;
			}
			refreshingToggleStates = true;
			for (int i = 0; i < values.Length; i++)
			{
				Toggle val = toggles[i];
				if (val.isOn != enabledFlags[i])
				{
					val.isOn = enabledFlags[i];
				}
			}
			refreshingToggleStates = false;
		}

		private void SetValueFromToggles()
		{
			string text = "";
			for (int i = 0; i < values.Length; i++)
			{
				if (enabledFlags[i])
				{
					if (text != "")
					{
						text += ", ";
					}
					text += values[i].Value;
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Type enumType = Value?.GetType() ?? FallbackType;
				Value = Enum.Parse(enumType, text);
				RefreshUIForValue();
				Owner.SetValueFromIValue();
			}
		}

		protected internal override void OnToggleSubcontent(bool toggle)
		{
			base.OnToggleSubcontent(toggle);
			RefreshUIForValue();
		}

		public override void ConstructUI(GameObject parent)
		{
			base.ConstructUI(parent);
		}

		public override void ConstructSubcontent()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			subContentConstructed = true;
			GameObject groupObj = UIFactory.CreateVerticalGroup(subContentParent, "InteractiveFlagsContent", false, true, true, true, 5, new Vector4(3f, 3f, 3f, 3f), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
			for (int i = 0; i < values.Length; i++)
			{
				AddToggle(i, groupObj);
			}
		}

		internal void AddToggle(int index, GameObject groupObj)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<long, string> keyValuePair = values[index];
			Toggle val2 = default(Toggle);
			Text val3 = default(Text);
			GameObject val4 = UIFactory.CreateToggle(groupObj, "FlagToggle", ref val2, ref val3, new Color(0.1f, 0.1f, 0.1f), 20, 20);
			int? num = 100;
			int? num2 = 2000;
			UIFactory.SetLayoutElement(val4, num, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			toggles[index] = val2;
			((UnityEvent<bool>)(object)val2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				if (!refreshingToggleStates)
				{
					enabledFlags[index] = val;
					SetValueFromToggles();
					RefreshUIForValue();
				}
			});
			val3.text = keyValuePair.Value;
		}
	}
	public class InteractiveFloatStruct : InteractiveValue
	{
		public class StructInfo
		{
			private readonly FieldInfo[] fields;

			public string[] FieldNames { get; }

			public StructInfo(Type type)
			{
				fields = (from it in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					where !it.IsLiteral
					select it).ToArray();
				FieldNames = fields.Select((FieldInfo it) => it.Name).ToArray();
			}

			public object SetValue(ref object instance, int fieldIndex, float val)
			{
				fields[fieldIndex].SetValue(instance, val);
				return instance;
			}

			public float GetValue(object instance, int fieldIndex)
			{
				return (float)fields[fieldIndex].GetValue(instance);
			}

			public void RefreshUI(InputField[] inputs, object instance)
			{
				try
				{
					for (int i = 0; i < fields.Length; i++)
					{
						FieldInfo fieldInfo = fields[i];
						float num = (float)fieldInfo.GetValue(instance);
						inputs[i].text = num.ToString();
					}
				}
				catch (Exception ex)
				{
					ConfigManager.LogSource.LogMessage((object)ex);
				}
			}
		}

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

		public StructInfo structInfo;

		internal Type lastStructType;

		internal InputField[] inputs;

		public static bool IsTypeSupported(Type type)
		{
			if (!type.IsValueType)
			{
				return false;
			}
			if (_typeSupportCache.TryGetValue(type.AssemblyQualifiedName, out var value))
			{
				return value;
			}
			value = true;
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				if (!fieldInfo.IsLiteral && !typeof(float).IsAssignableFrom(fieldInfo.FieldType))
				{
					value = false;
					break;
				}
			}
			_typeSupportCache.Add(type.AssemblyQualifiedName, value);
			return value;
		}

		public InteractiveFloatStruct(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return IsTypeSupported(type);
		}

		public override void RefreshUIForValue()
		{
			InitializeStructInfo();
			base.RefreshUIForValue();
			structInfo.RefreshUI(inputs, Value);
		}

		internal void InitializeStructInfo()
		{
			Type type = Value?.GetType() ?? FallbackType;
			if (structInfo == null || (object)type != lastStructType)
			{
				lastStructType = type;
				structInfo = new StructInfo(type);
			}
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_0026: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				InitializeStructInfo();
				base.ConstructUI(parent);
				GameObject val = UIFactory.CreateGridGroup(mainContent, "EditorContent", new Vector2(150f, 25f), new Vector2(5f, 5f), new Color(1f, 1f, 1f, 0f));
				int? num = 300;
				int? num2 = 9999;
				UIFactory.SetLayoutElement(val, num, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
				inputs = (InputField[])(object)new InputField[structInfo.FieldNames.Length];
				for (int i = 0; i < structInfo.FieldNames.Length; i++)
				{
					AddEditorRow(i, val);
				}
				RefreshUIForValue();
			}
			catch (Exception ex)
			{
				ConfigManager.LogSource.LogMessage((object)ex);
			}
		}

		internal void AddEditorRow(int index, GameObject groupObj)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val2 = UIFactory.CreateHorizontalGroup(groupObj, "EditorRow", false, true, true, true, 5, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)null);
				string text = structInfo.FieldNames[index];
				if (text.StartsWith("m_"))
				{
					text = text.Substring(2, text.Length - 2);
				}
				if (text.Length > 1)
				{
					text = text.Substring(0, 1);
				}
				Text val3 = UIFactory.CreateLabel(val2, "RowLabel", text + ":", (TextAnchor)5, Color.cyan, true, 14);
				GameObject gameObject = ((Component)val3).gameObject;
				int? num = 30;
				int? num2 = 0;
				UIFactory.SetLayoutElement(gameObject, num, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
				InputFieldRef val4 = UIFactory.CreateInputField(val2, "InputField", "...");
				UIFactory.SetLayoutElement(((Component)val4.Component).gameObject, (int?)120, (int?)25, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
				inputs[index] = val4.Component;
				val4.OnValueChanged += delegate(string val)
				{
					try
					{
						float val5 = float.Parse(val);
						Value = structInfo.SetValue(ref Value, index, val5);
						Owner.SetValueFromIValue();
					}
					catch
					{
					}
				};
			}
			catch (Exception ex)
			{
				ConfigManager.LogSource.LogMessage((object)ex);
			}
		}
	}
	public class InteractiveKeycode : InteractiveValue
	{
		internal Text labelText;

		internal ButtonRef rebindButton;

		internal ButtonRef confirmButton;

		internal ButtonRef cancelButton;

		private readonly bool isInputSystem;

		public InteractiveKeycode(object value, Type valueType)
			: base(value, valueType)
		{
			isInputSystem = !(value is KeyCode);
		}

		public override bool SupportsType(Type type)
		{
			return (object)type == typeof(KeyCode) || type.FullName == "UnityEngine.InputSystem.Key";
		}

		public override void RefreshUIForValue()
		{
			base.RefreshUIForValue();
			labelText.text = Value.ToString();
		}

		public override void OnValueUpdated()
		{
			base.OnValueUpdated();
		}

		public void BeginRebind()
		{
			((Component)rebindButton.Component).gameObject.SetActive(false);
			((Component)confirmButton.Component).gameObject.SetActive(true);
			((Selectable)confirmButton.Component).interactable = false;
			((Component)cancelButton.Component).gameObject.SetActive(true);
			labelText.text = "<i>Press a key...</i>";
			InputManager.BeginRebind((Action<KeyCode>)OnRebindKeyPressed, (Action<KeyCode?>)OnKeycodeConfirmed);
		}

		private void OnRebindKeyPressed(KeyCode kc)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!isInputSystem)
			{
				labelText.text = "<i>" + ((object)(KeyCode)(ref kc)).ToString() + "</i>";
			}
			else
			{
				object obj = InputSystem.KeyCodeToKeyEnum(kc);
				labelText.text = "<i>" + obj.ToString() + "</i>";
			}
			((Selectable)confirmButton.Component).interactable = true;
		}

		private void OnKeycodeConfirmed(KeyCode? kc)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (kc.HasValue)
			{
				if (!isInputSystem)
				{
					Value = kc;
				}
				else
				{
					Value = InputSystem.KeyCodeToKeyEnum(kc.Value);
				}
			}
			Owner.SetValueFromIValue();
			RefreshUIForValue();
		}

		public void ConfirmEndRebind()
		{
			InputManager.EndRebind();
			OnRebindEnd();
		}

		public void CancelEndRebind()
		{
			InputManager.LastRebindKey = null;
			InputManager.EndRebind();
			OnRebindEnd();
		}

		internal void OnRebindEnd()
		{
			((Component)rebindButton.Component).gameObject.SetActive(true);
			((Component)confirmButton.Component).gameObject.SetActive(false);
			((Component)cancelButton.Component).gameObject.SetActive(false);
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			base.ConstructUI(parent);
			labelText = UIFactory.CreateLabel(mainContent, "Label", Value?.ToString() ?? "<notset>", (TextAnchor)3, default(Color), true, 14);
			UIFactory.SetLayoutElement(((Component)labelText).gameObject, (int?)150, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			rebindButton = UIFactory.CreateButton(mainContent, "RebindButton", "Rebind", (Color?)null);
			ButtonRef obj = rebindButton;
			obj.OnClick = (Action)Delegate.Combine(obj.OnClick, new Action(BeginRebind));
			GameObject gameObject = ((Component)rebindButton.Component).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			confirmButton = UIFactory.CreateButton(mainContent, "ConfirmButton", "Confirm", (Color?)new Color(0.1f, 0.4f, 0.1f));
			ButtonRef obj2 = confirmButton;
			obj2.OnClick = (Action)Delegate.Combine(obj2.OnClick, new Action(ConfirmEndRebind));
			GameObject gameObject2 = ((Component)confirmButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Component)confirmButton.Component).gameObject.SetActive(false);
			Button component = confirmButton.Component;
			Color? val = new Color(0.3f, 0.3f, 0.3f);
			RuntimeHelper.SetColorBlock((Selectable)(object)component, (Color?)null, (Color?)null, (Color?)null, val);
			cancelButton = UIFactory.CreateButton(mainContent, "EndButton", "Cancel", (Color?)new Color(0.4f, 0.1f, 0.1f));
			ButtonRef obj3 = cancelButton;
			obj3.OnClick = (Action)Delegate.Combine(obj3.OnClick, new Action(CancelEndRebind));
			GameObject gameObject3 = ((Component)cancelButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject3, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Component)cancelButton.Component).gameObject.SetActive(false);
		}
	}
	public class InteractiveNumber : InteractiveValue
	{
		internal InputFieldRef valueInput;

		private Slider slider;

		private MethodInfo parseMethod;

		public MethodInfo ParseMethod => parseMethod ?? (parseMethod = Value.GetType().GetMethod("Parse", new Type[1] { typeof(string) }));

		public InteractiveNumber(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return (type.IsPrimitive && (object)type != typeof(bool)) || (object)type == typeof(decimal);
		}

		public override void RefreshUIForValue()
		{
			valueInput.Text = Value.ToString();
			if (!((Component)valueInput.Component).gameObject.activeSelf)
			{
				((Component)valueInput.Component).gameObject.SetActive(true);
			}
			if (Object.op_Implicit((Object)(object)slider))
			{
				slider.value = (float)Convert.ChangeType(Value, typeof(float));
			}
		}

		internal void SetValueFromInput()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Value = ParseMethod.Invoke(null, new object[1] { valueInput.Text });
				ConfigDescription description = Owner.RefConfig.Description;
				AcceptableValueBase val = ((description != null) ? description.AcceptableValues : null);
				if (val != null && !val.IsValid(Value))
				{
					throw new Exception();
				}
				Owner.SetValueFromIValue();
				RefreshUIForValue();
				((Graphic)valueInput.Component.textComponent).color = Color.white;
			}
			catch
			{
				((Graphic)valueInput.Component.textComponent).color = Color.red;
			}
		}

		public override void ConstructUI(GameObject parent)
		{
			base.ConstructUI(parent);
			valueInput = UIFactory.CreateInputField(mainContent, "InteractiveNumberInput", "...");
			UIFactory.SetLayoutElement(((Component)valueInput.Component).gameObject, (int?)120, (int?)25, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Component)valueInput.Component).gameObject.SetActive(false);
			valueInput.OnValueChanged += delegate
			{
				SetValueFromInput();
			};
			AcceptableValueBase acceptableValues = Owner.RefConfig.Description.AcceptableValues;
			if (acceptableValues != null)
			{
				Type type = typeof(AcceptableValueRange<>).MakeGenericType(acceptableValues.ValueType);
				object value = AccessTools.Property(type, "MinValue").GetValue(acceptableValues, null);
				object value2 = AccessTools.Property(type, "MaxValue").GetValue(acceptableValues, null);
				Text mainLabel = Owner.mainLabel;
				mainLabel.text = mainLabel.text + " <color=grey><i>[" + value.ToString() + " - " + value2.ToString() + "]</i></color>";
				GameObject val2 = UIFactory.CreateSlider(mainContent, "ValueSlider", ref slider);
				UIFactory.SetLayoutElement(val2, (int?)250, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				slider.minValue = (float)Convert.ChangeType(value, typeof(float));
				slider.maxValue = (float)Convert.ChangeType(value2, typeof(float));
				slider.value = (float)Convert.ChangeType(Value, typeof(float));
				((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate(float val)
				{
					Value = Convert.ChangeType(val, FallbackType);
					Owner.SetValueFromIValue();
					valueInput.Text = Value.ToString();
				});
			}
		}
	}
	public class InteractiveString : InteractiveValue
	{
		internal InputFieldRef valueInput;

		internal GameObject hiddenObj;

		internal Text placeholderText;

		public InteractiveString(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return (object)type == typeof(string);
		}

		public override void RefreshUIForValue()
		{
			if (!hiddenObj.gameObject.activeSelf)
			{
				hiddenObj.gameObject.SetActive(true);
			}
			if (!string.IsNullOrEmpty((string)Value))
			{
				string text = (string)Value;
				if (text.Length > 15000)
				{
					text = text.Substring(0, 15000);
				}
				valueInput.Text = text;
				placeholderText.text = text;
			}
			else
			{
				string text2 = ((Value == null) ? "null" : "empty");
				valueInput.Text = "";
				placeholderText.text = text2;
			}
		}

		internal void SetValueFromInput()
		{
			Value = valueInput.Text;
			Owner.SetValueFromIValue();
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_002a: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			base.ConstructUI(parent);
			hiddenObj = ((Component)UIFactory.CreateLabel(mainContent, "HiddenLabel", "", (TextAnchor)3, default(Color), true, 14)).gameObject;
			hiddenObj.SetActive(false);
			Text hiddenText = hiddenObj.GetComponent<Text>();
			((Graphic)hiddenText).color = Color.clear;
			hiddenText.fontSize = 14;
			((Graphic)hiddenText).raycastTarget = false;
			hiddenText.supportRichText = false;
			ContentSizeFitter val2 = hiddenObj.AddComponent<ContentSizeFitter>();
			val2.verticalFit = (FitMode)2;
			GameObject obj = hiddenObj;
			int? num = 25;
			int? num2 = 500;
			UIFactory.SetLayoutElement(obj, (int?)250, num, (int?)9000, num2, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(hiddenObj, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			valueInput = UIFactory.CreateInputField(hiddenObj, "StringInputField", "...");
			UIFactory.SetLayoutElement(((Component)valueInput.Component).gameObject, (int?)120, (int?)25, (int?)5000, (int?)5000, (int?)null, (int?)null, (bool?)null);
			valueInput.Component.lineType = (LineType)2;
			placeholderText = ((Component)valueInput.Component.placeholder).GetComponent<Text>();
			placeholderText.supportRichText = false;
			valueInput.Component.textComponent.supportRichText = false;
			valueInput.OnValueChanged += delegate(string val)
			{
				hiddenText.text = val ?? "";
				LayoutRebuilder.ForceRebuildLayoutImmediate(Owner.ContentRect);
				SetValueFromInput();
			};
			RefreshUIForValue();
		}
	}
	public class InteractiveTomlObject : InteractiveValue
	{
		internal InputFieldRef valueInput;

		internal GameObject hiddenObj;

		internal Text placeholderText;

		public InteractiveTomlObject(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return true;
		}

		public override void OnValueUpdated()
		{
			base.OnValueUpdated();
			try
			{
				valueInput.Text = TomlTypeConverter.ConvertToString(Value, FallbackType);
				placeholderText.text = valueInput.Text;
			}
			catch
			{
				ConfigManager.LogSource.LogWarning((object)("Unable to edit entry '" + Owner.RefConfig.Definition.Key + "' due to an error with the Toml converter!"));
			}
		}

		internal void SetValueFromInput()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Value = TomlTypeConverter.ConvertToValue(valueInput.Text, FallbackType);
				Owner.SetValueFromIValue();
				((Graphic)valueInput.Component.textComponent).color = Color.white;
			}
			catch
			{
				((Graphic)valueInput.Component.textComponent).color = Color.red;
			}
		}

		public override void RefreshUIForValue()
		{
			if (!hiddenObj.gameObject.activeSelf)
			{
				hiddenObj.gameObject.SetActive(true);
			}
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_002a: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			base.ConstructUI(parent);
			hiddenObj = ((Component)UIFactory.CreateLabel(mainContent, "HiddenLabel", "", (TextAnchor)3, default(Color), true, 14)).gameObject;
			hiddenObj.SetActive(false);
			Text hiddenText = hiddenObj.GetComponent<Text>();
			((Graphic)hiddenText).color = Color.clear;
			hiddenText.fontSize = 14;
			((Graphic)hiddenText).raycastTarget = false;
			hiddenText.supportRichText = false;
			ContentSizeFitter val2 = hiddenObj.AddComponent<ContentSizeFitter>();
			val2.verticalFit = (FitMode)2;
			GameObject obj = hiddenObj;
			int? num = 25;
			int? num2 = 500;
			UIFactory.SetLayoutElement(obj, (int?)250, num, (int?)9000, num2, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(hiddenObj, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			valueInput = UIFactory.CreateInputField(hiddenObj, "StringInputField", "...");
			UIFactory.SetLayoutElement(((Component)valueInput.Component).gameObject, (int?)120, (int?)25, (int?)5000, (int?)5000, (int?)null, (int?)null, (bool?)null);
			valueInput.Component.lineType = (LineType)2;
			placeholderText = ((Component)valueInput.Component.placeholder).GetComponent<Text>();
			placeholderText.supportRichText = false;
			valueInput.Component.textComponent.supportRichText = false;
			OnValueUpdated();
			valueInput.OnValueChanged += delegate(string val)
			{
				hiddenText.text = val ?? "";
				LayoutRebuilder.ForceRebuildLayoutImmediate(Owner.ContentRect);
				SetValueFromInput();
			};
		}
	}
	public abstract class InteractiveValue
	{
		private static readonly HashSet<Type> customIValueTypes = new HashSet<Type>();

		private static readonly List<InteractiveValue> customIValueInstances = new List<InteractiveValue>();

		public CachedConfigEntry Owner;

		public object Value;

		public readonly Type FallbackType;

		public bool UIConstructed;

		protected internal GameObject mainContentParent;

		protected internal GameObject subContentParent;

		protected internal GameObject mainContent;

		protected internal ButtonRef subExpandBtn;

		protected internal bool subContentConstructed;

		public virtual bool HasSubContent => false;

		public virtual bool SubContentWanted => false;

		public static void RegisterIValueType<T>() where T : InteractiveValue
		{
			if (!customIValueTypes.Contains(typeof(T)))
			{
				customIValueInstances.Add((T)Activator.CreateInstance(typeof(T), null, typeof(object)));
				customIValueTypes.Add(typeof(T));
			}
		}

		public static Type GetIValueForType(Type type)
		{
			if ((object)type == typeof(bool))
			{
				return typeof(InteractiveBool);
			}
			if (type.IsPrimitive || typeof(decimal).IsAssignableFrom(type))
			{
				return typeof(InteractiveNumber);
			}
			if ((object)type == typeof(string))
			{
				return typeof(InteractiveString);
			}
			if ((object)type == typeof(KeyCode) || type.FullName == "UnityEngine.InputSystem.Key")
			{
				return typeof(InteractiveKeycode);
			}
			if (typeof(Enum).IsAssignableFrom(type))
			{
				object[] customAttributes = type.GetCustomAttributes(typeof(FlagsAttribute), inherit: true);
				if (customAttributes != null && customAttributes.Any())
				{
					return typeof(InteractiveFlags);
				}
				return typeof(InteractiveEnum);
			}
			if ((object)type == typeof(Color) || (object)type == typeof(Color32))
			{
				return typeof(InteractiveColor);
			}
			if (InteractiveFloatStruct.IsTypeSupported(type))
			{
				return typeof(InteractiveFloatStruct);
			}
			InteractiveValue interactiveValue = customIValueInstances.FirstOrDefault((InteractiveValue it) => it.SupportsType(type));
			if (interactiveValue != null)
			{
				return interactiveValue.GetType();
			}
			return typeof(InteractiveTomlObject);
		}

		public static InteractiveValue Create(object value, Type fallbackType)
		{
			Type type = ReflectionExtensions.GetActualType(value) ?? fallbackType;
			Type iValueForType = GetIValueForType(type);
			return (InteractiveValue)Activator.CreateInstance(iValueForType, value, type);
		}

		public InteractiveValue(object value, Type valueType)
		{
			Value = value;
			FallbackType = valueType;
		}

		public virtual bool SupportsType(Type type)
		{
			return true;
		}

		public virtual void OnValueUpdated()
		{
			if (!UIConstructed)
			{
				ConstructUI(mainContentParent);
			}
			RefreshUIForValue();
		}

		public virtual void RefreshUIForValue()
		{
		}

		public void RefreshSubContentState()
		{
			if (HasSubContent)
			{
				if (((Component)subExpandBtn.Component).gameObject.activeSelf != SubContentWanted)
				{
					((Component)subExpandBtn.Component).gameObject.SetActive(SubContentWanted);
				}
				if (!SubContentWanted && subContentParent.activeSelf)
				{
					ToggleSubcontent();
				}
			}
		}

		public virtual void ConstructSubcontent()
		{
			subContentConstructed = true;
		}

		public virtual void DestroySubContent()
		{
			if (Object.op_Implicit((Object)(object)subContentParent) && HasSubContent)
			{
				for (int i = 0; i < subContentParent.transform.childCount; i++)
				{
					Transform child = subContentParent.transform.GetChild(i);
					if (Object.op_Implicit((Object)(object)child))
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
			}
			subContentConstructed = false;
		}

		public void ToggleSubcontent()
		{
			if (!subContentParent.activeSelf)
			{
				subContentParent.SetActive(true);
				subContentParent.transform.SetAsLastSibling();
				subExpandBtn.ButtonText.text = "▼ Click to hide";
			}
			else
			{
				subContentParent.SetActive(false);
				subExpandBtn.ButtonText.text = "▲ Expand to edit";
			}
			OnToggleSubcontent(subContentParent.activeSelf);
			RefreshSubContentState();
		}

		protected internal virtual void OnToggleSubcontent(bool toggle)
		{
			if (!subContentConstructed)
			{
				ConstructSubcontent();
			}
		}

		public virtual void ConstructUI(GameObject parent)
		{
			//IL_0026: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			UIConstructed = true;
			mainContent = UIFactory.CreateHorizontalGroup(parent, "InteractiveValue_" + GetType().Name, false, false, true, true, 4, default(Vector4), new Color(1f, 1f, 1f, 0f), (TextAnchor?)(TextAnchor)0);
			RectTransform component = mainContent.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)1, 25f);
			GameObject obj = mainContent;
			int? num = 9000;
			UIFactory.SetLayoutElement(obj, (int?)175, (int?)25, num, (int?)0, (int?)null, (int?)null, (bool?)null);
			if (HasSubContent)
			{
				subExpandBtn = UIFactory.CreateButton(mainContent, "ExpandSubcontentButton", "▲ Expand to edit", (Color?)new Color(0.3f, 0.3f, 0.3f));
				ButtonRef obj2 = subExpandBtn;
				obj2.OnClick = (Action)Delegate.Combine(obj2.OnClick, new Action(ToggleSubcontent));
				GameObject gameObject = ((Component)subExpandBtn.Component).gameObject;
				num = 25;
				UIFactory.SetLayoutElement(gameObject, (int?)120, num, (int?)0, (int?)0, (int?)null, (int?)null, (bool?)null);
			}
		}
	}
	public class InteractiveValueList : InteractiveValue
	{
		internal IEnumerable<object> acceptableValues;

		internal Dropdown dropdown;

		internal Dictionary<object, OptionData> dropdownOptions = new Dictionary<object, OptionData>();

		public InteractiveValueList(object value, Type valueType)
			: base(value, valueType)
		{
		}

		public override bool SupportsType(Type type)
		{
			return type.IsEnum;
		}

		internal void GetAcceptableValues()
		{
			if (acceptableValues == null)
			{
				AcceptableValueBase val = Owner.RefConfig.Description.AcceptableValues;
				PropertyInfo property = ((object)val).GetType().GetProperty("AcceptableValues");
				acceptableValues = (property.GetValue(val, null) as IList).Cast<object>();
			}
		}

		public override void OnValueUpdated()
		{
			GetAcceptableValues();
			base.OnValueUpdated();
		}

		public override void RefreshUIForValue()
		{
			base.RefreshUIForValue();
			if (dropdownOptions.ContainsKey(Value))
			{
				dropdown.value = dropdown.options.IndexOf(dropdownOptions[Value]);
			}
		}

		private void SetValueFromDropdown()
		{
			object obj = acceptableValues.ElementAt(dropdown.value);
			if (obj != null)
			{
				Value = obj;
				Owner.SetValueFromIValue();
				RefreshUIForValue();
			}
		}

		public override void ConstructUI(GameObject parent)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			base.ConstructUI(parent);
			GameObject val2 = UIFactory.CreateDropdown(mainContent, "InteractiveValueList", ref dropdown, "", 14, (Action<int>)null, (string[])null);
			UIFactory.SetLayoutElement(val2, (int?)400, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((UnityEvent<int>)(object)dropdown.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				SetValueFromDropdown();
			});
			foreach (object acceptableValue in acceptableValues)
			{
				OptionData val3 = new OptionData
				{
					text = acceptableValue.ToString()
				};
				dropdown.options.Add(val3);
				dropdownOptions.Add(acceptableValue, val3);
			}
		}
	}
}
namespace ConfigManager.Utility
{
	internal sealed class ConfigurationManagerAttributes
	{
		public bool? ShowRangeAsPercent;

		public Action<ConfigEntryBase> CustomDrawer;

		public bool? Browsable;

		public string Category;

		public object DefaultValue;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public string Description;

		public string DispName;

		public int? Order;

		public bool? ReadOnly;

		public bool? IsAdvanced;

		public Func<object, string> ObjToStr;

		public Func<string, object> StrToObj;
	}
}