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.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OutwardModsCommunicator.EventBus;
using OutwardModsCommunicator.Managers;
using OutwardModsCommunicatorMenu.Events.Publishers;
using OutwardModsCommunicatorMenu.Managers;
using OutwardModsCommunicatorMenu.Patches;
using OutwardModsCommunicatorMenu.UI;
using OutwardModsCommunicatorMenu.UI.Builders;
using OutwardModsCommunicatorMenu.UI.Components;
using OutwardModsCommunicatorMenu.Utility;
using OutwardModsCommunicatorMenu.Utility.Enums;
using OutwardModsCommunicatorMenu.Utility.Helpers;
using SideLoader;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using UniverseLib;
using UniverseLib.Config;
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.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OutwardModsCommunicatorMenu")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OutwardModsCommunicatorMenu")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace OutwardModsCommunicatorMenu
{
	[BepInPlugin("gymmed.mods_communicator_menu", "Mods Communicator Menu", "0.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class OMCM : BaseUnityPlugin
	{
		public const string GUID = "gymmed.mods_communicator_menu";

		public const string NAME = "Mods Communicator Menu";

		public const string VERSION = "0.0.1";

		public static string prefix = "[Mods-Communicator-Menu]";

		public const string EVENTS_LISTENER_GUID = "gymmed.mods_communicator_menu_*";

		internal static ManualLogSource Log;

		internal void Awake()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log = ((BaseUnityPlugin)this).Logger;
				LogMessage("Hello world from Mods Communicator Menu 0.0.1!");
				Universe.Init(1f, (Action)delegate
				{
					LogMessage("UniverseLib initialized");
				}, (Action<string, LogType>)delegate(string msg, LogType type)
				{
					LogMessage("[UniverseLib] " + msg);
				}, new UniverseLibConfig
				{
					Force_Unlock_Mouse = true
				});
				new Harmony("gymmed.mods_communicator_menu").PatchAll();
				UIManager.Instance.Initialize(Log);
				LogMessage("Awake completed successfully");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[OMCM] Error in Awake: " + ex.GetType().Name + ": " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		internal void Update()
		{
			UIManager.Instance.OnUpdate();
		}

		public static void LogMessage(string message)
		{
			Log.LogMessage((object)(prefix + " " + message));
		}

		public static void LogStatusMessage(string message, ChatLogStatus status = ChatLogStatus.Info)
		{
			LogMessage($"[{status}] {message}");
		}

		public static void LogSL(string message)
		{
			SL.Log(prefix + " " + message);
		}

		public static string GetProjectLocation()
		{
			return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		}
	}
}
namespace OutwardModsCommunicatorMenu.Utility
{
	public static class CollectionValueParser
	{
		public static (object result, string error) TryParse(Type collectionType, string valueString)
		{
			if (collectionType == null || string.IsNullOrWhiteSpace(valueString))
			{
				return (null, "Type or value is null/empty");
			}
			if (!IsCollectionType(collectionType))
			{
				return (null, "Type '" + collectionType.Name + "' is not a collection type");
			}
			Type elementType = GetElementType(collectionType);
			if (elementType == null)
			{
				return (null, "Cannot determine element type for '" + collectionType.Name + "'");
			}
			string[] array = valueString.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return (null, "No values provided");
			}
			if (collectionType.IsArray)
			{
				return TryParseArray(elementType, array);
			}
			return TryParseCollection(collectionType, elementType, array);
		}

		private static (object result, string error) TryParseArray(Type elementType, string[] values)
		{
			List<object> list = new List<object>();
			for (int i = 0; i < values.Length; i++)
			{
				var (item, text) = ParseValue(elementType, values[i]);
				if (text != null)
				{
					return (null, $"Invalid value at position {i + 1}: {text}");
				}
				list.Add(item);
			}
			try
			{
				Array array = Array.CreateInstance(elementType, list.Count);
				for (int j = 0; j < list.Count; j++)
				{
					array.SetValue(list[j], j);
				}
				return (array, null);
			}
			catch (Exception ex)
			{
				return (null, "Failed to create array: " + ex.Message);
			}
		}

		private static (object result, string error) TryParseCollection(Type collectionType, Type elementType, string[] values)
		{
			List<object> list = new List<object>();
			for (int i = 0; i < values.Length; i++)
			{
				var (item, text) = ParseValue(elementType, values[i]);
				if (text != null)
				{
					return (null, $"Invalid value at position {i + 1}: {text}");
				}
				list.Add(item);
			}
			try
			{
				bool num = IsSetType(collectionType);
				bool flag = IsListType(collectionType);
				bool flag2 = typeof(ICollection).IsAssignableFrom(collectionType);
				bool flag3 = typeof(IEnumerable).IsAssignableFrom(collectionType);
				object obj;
				if (num || (flag3 && !flag && collectionType.GetConstructor(Type.EmptyTypes) != null))
				{
					Type type = typeof(HashSet<>).MakeGenericType(elementType);
					obj = Activator.CreateInstance(type);
					MethodInfo method = type.GetMethod("Add");
					foreach (object item2 in list)
					{
						method.Invoke(obj, new object[1] { item2 });
					}
				}
				else if (flag || (flag2 && collectionType.GetConstructor(Type.EmptyTypes) != null))
				{
					Type type2 = typeof(List<>).MakeGenericType(elementType);
					obj = Activator.CreateInstance(type2);
					MethodInfo method2 = type2.GetMethod("Add");
					foreach (object item3 in list)
					{
						method2.Invoke(obj, new object[1] { item3 });
					}
				}
				else
				{
					if (!collectionType.IsAssignableFrom(typeof(List<>).MakeGenericType(elementType)))
					{
						return (null, "Cannot instantiate collection type '" + collectionType.Name + "'");
					}
					Type type3 = typeof(List<>).MakeGenericType(elementType);
					obj = Activator.CreateInstance(type3);
					MethodInfo method3 = type3.GetMethod("Add");
					foreach (object item4 in list)
					{
						method3.Invoke(obj, new object[1] { item4 });
					}
				}
				return (obj, null);
			}
			catch (Exception ex)
			{
				return (null, "Failed to create collection: " + ex.Message);
			}
		}

		private static (object result, string error) ParseValue(Type targetType, string valueString)
		{
			if (string.IsNullOrWhiteSpace(valueString))
			{
				return (null, "Empty value");
			}
			valueString = valueString.Trim();
			if (targetType.IsEnum)
			{
				try
				{
					return (Enum.Parse(targetType, valueString, ignoreCase: true), null);
				}
				catch
				{
					string text = string.Join(", ", Enum.GetNames(targetType));
					return (null, "Invalid enum value. Expected one of: " + text);
				}
			}
			object item = default(object);
			Exception ex = default(Exception);
			if (ParseUtility.TryParse(valueString, targetType, ref item, ref ex))
			{
				return (item, null);
			}
			return (null, "Cannot convert '" + valueString + "' to " + targetType.Name);
		}

		public static bool IsCollectionType(Type type)
		{
			if (type == null)
			{
				return false;
			}
			if (type.IsArray)
			{
				return true;
			}
			if (typeof(IEnumerable).IsAssignableFrom(type))
			{
				if (type.IsGenericType)
				{
					Type genericTypeDefinition = type.GetGenericTypeDefinition();
					if (genericTypeDefinition == typeof(HashSet<>) || genericTypeDefinition == typeof(List<>) || genericTypeDefinition == typeof(IList<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IEnumerable<>))
					{
						return true;
					}
				}
				if (typeof(ICollection).IsAssignableFrom(type) && type.GetConstructor(Type.EmptyTypes) != null)
				{
					return true;
				}
			}
			return false;
		}

		public static Type GetElementType(Type collectionType)
		{
			if (collectionType == null)
			{
				return null;
			}
			if (collectionType.IsArray)
			{
				return collectionType.GetElementType();
			}
			if (collectionType.IsGenericType)
			{
				Type[] genericArguments = collectionType.GetGenericArguments();
				if (genericArguments.Length != 0)
				{
					return genericArguments[0];
				}
			}
			Type[] interfaces = collectionType.GetInterfaces();
			foreach (Type type in interfaces)
			{
				if (!type.IsGenericType)
				{
					continue;
				}
				Type genericTypeDefinition = type.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(IEnumerable<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IList<>))
				{
					Type[] genericArguments2 = type.GetGenericArguments();
					if (genericArguments2.Length != 0)
					{
						return genericArguments2[0];
					}
				}
			}
			return null;
		}

		private static bool IsSetType(Type type)
		{
			if (type == null)
			{
				return false;
			}
			if (type.IsGenericType)
			{
				Type genericTypeDefinition = type.GetGenericTypeDefinition();
				if (!(genericTypeDefinition == typeof(HashSet<>)))
				{
					return genericTypeDefinition == typeof(ISet<>);
				}
				return true;
			}
			return false;
		}

		private static bool IsListType(Type type)
		{
			if (type == null)
			{
				return false;
			}
			if (type.IsGenericType)
			{
				Type genericTypeDefinition = type.GetGenericTypeDefinition();
				if (!(genericTypeDefinition == typeof(List<>)) && !(genericTypeDefinition == typeof(IList<>)))
				{
					return genericTypeDefinition == typeof(IList<>);
				}
				return true;
			}
			return typeof(IList).IsAssignableFrom(type);
		}
	}
	public class EventPayloadBuilder
	{
		private readonly struct ParseResult
		{
			public bool Success { get; }

			public object Value { get; }

			public string ErrorMessage { get; }

			private ParseResult(bool success, object value, string errorMessage)
			{
				Success = success;
				Value = value;
				ErrorMessage = errorMessage;
			}

			public static ParseResult CreateSuccess(object value)
			{
				return new ParseResult(success: true, value, null);
			}

			public static ParseResult CreateFailure(string errorMessage)
			{
				return new ParseResult(success: false, null, errorMessage);
			}
		}

		private class PayloadParameter
		{
			public string Name { get; }

			public Type Type { get; }

			public string Value { get; }

			public PayloadParameter(string name, Type type, string value)
			{
				Name = name;
				Type = type;
				Value = value;
			}
		}

		private readonly List<PayloadParameter> _parameters = new List<PayloadParameter>();

		public void AddParameter(string name, Type type, string value)
		{
			_parameters.Add(new PayloadParameter(name, type, value));
		}

		public (EventPayload payload, string errors) Build()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			EventPayload val = new EventPayload();
			StringBuilder stringBuilder = new StringBuilder();
			foreach (PayloadParameter parameter in _parameters)
			{
				if (!string.IsNullOrEmpty(parameter.Name) && !(parameter.Type == null))
				{
					string text = TypeNameFormatter.Format(parameter.Type);
					ParseResult parseResult = TryParseParameterValue(parameter.Type, parameter.Value);
					if (parseResult.Success)
					{
						((Dictionary<string, object>)(object)val)[parameter.Name] = parseResult.Value;
						continue;
					}
					stringBuilder.AppendLine("Failed to parse '" + parameter.Value + "' as " + text + ": " + parseResult.ErrorMessage);
				}
			}
			return (val, stringBuilder.ToString());
		}

		private static ParseResult TryParseParameterValue(Type type, string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return ParseResult.CreateFailure("Empty value");
			}
			if (CollectionValueParser.IsCollectionType(type))
			{
				var (value2, text) = CollectionValueParser.TryParse(type, value);
				if (text != null)
				{
					return ParseResult.CreateFailure(text);
				}
				return ParseResult.CreateSuccess(value2);
			}
			Type enumType = GetEnumType(type);
			if (enumType != null)
			{
				if (TryParseEnumValue(enumType, value, out var result))
				{
					return ParseResult.CreateSuccess(result);
				}
				string text2 = string.Join(", ", Enum.GetNames(enumType));
				return ParseResult.CreateFailure("Expected one of: " + text2);
			}
			object value3 = default(object);
			Exception ex = default(Exception);
			if (ParseUtility.TryParse(value, type, ref value3, ref ex))
			{
				return ParseResult.CreateSuccess(value3);
			}
			return ParseResult.CreateFailure("Unable to parse value");
		}

		private static Type GetEnumType(Type type)
		{
			if (type.IsEnum)
			{
				return type;
			}
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if (underlyingType != null && underlyingType.IsEnum)
			{
				return underlyingType;
			}
			return null;
		}

		private static bool TryParseEnumValue(Type enumType, string valueString, out object result)
		{
			result = null;
			if (string.IsNullOrWhiteSpace(valueString) || enumType == null || !enumType.IsEnum)
			{
				return false;
			}
			try
			{
				result = Enum.Parse(enumType, valueString, ignoreCase: true);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public void Clear()
		{
			_parameters.Clear();
		}
	}
	public static class GenericTypeParser
	{
		private static readonly Dictionary<string, Type> SimpleTypeMap = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"string",
				typeof(string)
			},
			{
				"int",
				typeof(int)
			},
			{
				"bool",
				typeof(bool)
			},
			{
				"float",
				typeof(float)
			},
			{
				"double",
				typeof(double)
			},
			{
				"decimal",
				typeof(decimal)
			},
			{
				"long",
				typeof(long)
			},
			{
				"short",
				typeof(short)
			},
			{
				"byte",
				typeof(byte)
			},
			{
				"char",
				typeof(char)
			},
			{
				"object",
				typeof(object)
			},
			{
				"void",
				typeof(void)
			},
			{
				"hashset",
				typeof(HashSet<>)
			},
			{
				"list",
				typeof(List<>)
			},
			{
				"dictionary",
				typeof(Dictionary<, >)
			},
			{
				"queue",
				typeof(Queue<>)
			},
			{
				"stack",
				typeof(Stack<>)
			},
			{
				"set",
				typeof(HashSet<>)
			}
		};

		public static Type Parse(string typeString)
		{
			if (string.IsNullOrWhiteSpace(typeString))
			{
				return null;
			}
			typeString = typeString.Trim();
			int num = typeString.IndexOf('[');
			int num2 = typeString.IndexOf('<');
			if (num >= 0 && (num2 < 0 || num < num2))
			{
				return ParseArrayType(typeString);
			}
			if (num2 >= 0)
			{
				return ParseGenericType(typeString);
			}
			return ParseSimpleType(typeString);
		}

		private static Type ParseArrayType(string typeString)
		{
			int num = typeString.IndexOf('[');
			if (num < 0)
			{
				return null;
			}
			string typeString2 = typeString.Substring(0, num);
			string text = typeString.Substring(num);
			Type type = Parse(typeString2);
			if (type == null)
			{
				return null;
			}
			if (text == "[]")
			{
				return type.MakeArrayType();
			}
			int num2 = 1;
			for (int i = 1; i < text.Length; i++)
			{
				if (text[i] == ',')
				{
					num2++;
				}
			}
			return type.MakeArrayType(num2);
		}

		private static Type ParseGenericType(string typeString)
		{
			int num = typeString.IndexOf('<');
			int num2 = typeString.LastIndexOf('>');
			if (num < 0 || num2 < 0 || num2 <= num)
			{
				return null;
			}
			string typeName = typeString.Substring(0, num);
			List<Type> list = ParseGenericArguments(typeString.Substring(num + 1, num2 - num - 1));
			if (list == null || list.Count == 0)
			{
				return null;
			}
			Type type = ParseSimpleType(typeName);
			if (type == null)
			{
				return null;
			}
			try
			{
				return type.MakeGenericType(list.ToArray());
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static List<Type> ParseGenericArguments(string argsString)
		{
			List<Type> list = new List<Type>();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i <= argsString.Length; i++)
			{
				switch ((i < argsString.Length) ? argsString[i] : ',')
				{
				case '<':
				case '[':
					num++;
					break;
				case '>':
				case ']':
					num--;
					break;
				case ',':
				{
					if (num != 0)
					{
						break;
					}
					string text = argsString.Substring(num2, i - num2).Trim();
					if (!string.IsNullOrEmpty(text))
					{
						Type type = Parse(text);
						if (type == null)
						{
							return null;
						}
						list.Add(type);
					}
					num2 = i + 1;
					break;
				}
				}
			}
			if (num2 < argsString.Length)
			{
				string text2 = argsString.Substring(num2).Trim();
				if (!string.IsNullOrEmpty(text2))
				{
					Type type2 = Parse(text2);
					if (type2 == null)
					{
						return null;
					}
					list.Add(type2);
				}
			}
			return list;
		}

		private static Type ParseSimpleType(string typeName)
		{
			if (string.IsNullOrWhiteSpace(typeName))
			{
				return null;
			}
			typeName = typeName.Trim();
			if (SimpleTypeMap.TryGetValue(typeName, out var value))
			{
				return value;
			}
			if (typeName.EndsWith("?"))
			{
				Type type = ParseSimpleType(typeName.Substring(0, typeName.Length - 1));
				if (type != null)
				{
					return typeof(Nullable<>).MakeGenericType(type);
				}
				return null;
			}
			return FindTypeInAssemblies(typeName);
		}

		private static Type FindTypeInAssemblies(string typeName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			if (Enumerable.Contains(typeName, '.') || Enumerable.Contains(typeName, '+'))
			{
				Type type = TryResolveNestedClass(typeName);
				if (type != null)
				{
					return type;
				}
			}
			Assembly[] array = assemblies;
			foreach (Assembly assembly in array)
			{
				try
				{
					Type type2 = assembly.GetType(typeName, throwOnError: false, ignoreCase: true);
					if (type2 != null)
					{
						return type2;
					}
				}
				catch (Exception)
				{
				}
			}
			array = assemblies;
			foreach (Assembly assembly2 in array)
			{
				try
				{
					string name = typeName;
					int num = typeName.LastIndexOf('.');
					if (num >= 0)
					{
						name = typeName.Substring(num + 1);
					}
					Type type3 = assembly2.GetType(name, throwOnError: false, ignoreCase: true);
					if (type3 != null)
					{
						return type3;
					}
				}
				catch (Exception)
				{
				}
			}
			array = assemblies;
			foreach (Assembly assembly3 in array)
			{
				try
				{
					Type[] types = assembly3.GetTypes();
					foreach (Type type4 in types)
					{
						if (string.Equals(type4.Name, typeName, StringComparison.OrdinalIgnoreCase) || string.Equals(type4.FullName, typeName, StringComparison.OrdinalIgnoreCase))
						{
							return type4;
						}
					}
				}
				catch (Exception)
				{
				}
			}
			return null;
		}

		private static Type TryResolveNestedClass(string typeName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			List<string> list = new List<string>();
			list.Add(typeName);
			if (Enumerable.Contains(typeName, '.'))
			{
				string[] array = typeName.Split(new char[1] { '.' });
				for (int i = 1; i < array.Length; i++)
				{
					string item = string.Join(".", array, 0, array.Length - i) + "+" + string.Join("+", array, array.Length - i, i);
					if (!list.Contains(item))
					{
						list.Add(item);
					}
				}
				list.Add(typeName.Replace(".", "+"));
			}
			if (Enumerable.Contains(typeName, '+'))
			{
				string item2 = typeName.Replace("+", ".");
				if (!list.Contains(item2))
				{
					list.Add(item2);
				}
				string[] array2 = typeName.Split(new char[1] { '+' });
				for (int j = 1; j < array2.Length; j++)
				{
					string item3 = string.Join("+", array2, 0, array2.Length - j) + "." + string.Join(".", array2, array2.Length - j, j);
					if (!list.Contains(item3))
					{
						list.Add(item3);
					}
				}
			}
			Assembly[] array3 = assemblies;
			foreach (Assembly assembly in array3)
			{
				try
				{
					foreach (string item4 in list)
					{
						try
						{
							Type type = assembly.GetType(item4, throwOnError: false, ignoreCase: true);
							if (type != null)
							{
								return type;
							}
						}
						catch (Exception)
						{
						}
					}
				}
				catch (Exception)
				{
				}
			}
			array3 = assemblies;
			foreach (Assembly assembly2 in array3)
			{
				try
				{
					Type[] types = assembly2.GetTypes();
					foreach (Type type2 in types)
					{
						string fullName = type2.FullName;
						if (fullName != null)
						{
							string a = (Enumerable.Contains(fullName, '+') ? fullName.Substring(fullName.LastIndexOf('+') + 1) : (Enumerable.Contains(fullName, '.') ? fullName.Substring(fullName.LastIndexOf('.') + 1) : fullName));
							string b = (Enumerable.Contains(typeName, '+') ? typeName.Substring(typeName.LastIndexOf('+') + 1) : (Enumerable.Contains(typeName, '.') ? typeName.Substring(typeName.LastIndexOf('.') + 1) : typeName));
							if (string.Equals(a, b, StringComparison.OrdinalIgnoreCase))
							{
								return type2;
							}
						}
					}
				}
				catch (Exception)
				{
				}
			}
			return null;
		}

		public static bool IsGenericType(string typeString)
		{
			if (!string.IsNullOrWhiteSpace(typeString) && Enumerable.Contains(typeString, '<'))
			{
				return Enumerable.Contains(typeString, '>');
			}
			return false;
		}

		public static bool IsArrayType(string typeString)
		{
			if (!string.IsNullOrWhiteSpace(typeString) && Enumerable.Contains(typeString, '['))
			{
				return Enumerable.Contains(typeString, ']');
			}
			return false;
		}
	}
	public static class KeybindingHelper
	{
		private const string CATEGORY = "Mods Communicator Menu";

		public static void Register(string actionName, string displayName)
		{
			CustomKeybindings.AddAction(actionName, (KeybindingsCategory)0, (ControlType)2, (InputType)1);
		}

		public static bool IsKeyDown(string actionName)
		{
			return CustomKeybindings.GetKeyDown(actionName);
		}

		public static bool IsKeyHeld(string actionName)
		{
			return CustomKeybindings.GetKey(actionName);
		}
	}
	public static class TypeNameFormatter
	{
		public static string Format(Type type)
		{
			if (type == null)
			{
				return "null";
			}
			if (type.IsArray)
			{
				return Format(type.GetElementType()) + "[]";
			}
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if (underlyingType != null)
			{
				return Format(underlyingType) + "?";
			}
			if (type.IsGenericType)
			{
				Type genericTypeDefinition = type.GetGenericTypeDefinition();
				Type[] genericArguments = type.GetGenericArguments();
				string genericTypeBaseName = GetGenericTypeBaseName(genericTypeDefinition.Name);
				string text = string.Join(", ", genericArguments.Select(Format));
				return genericTypeBaseName + "<" + text + ">";
			}
			if (type == typeof(string))
			{
				return "string";
			}
			if (type == typeof(int))
			{
				return "int";
			}
			if (type == typeof(bool))
			{
				return "bool";
			}
			if (type == typeof(float))
			{
				return "float";
			}
			if (type == typeof(double))
			{
				return "double";
			}
			return GetDisplayName(type);
		}

		private static string GetGenericTypeBaseName(string genericTypeDefinitionName)
		{
			int num = genericTypeDefinitionName.IndexOf('`');
			if (num > 0)
			{
				return genericTypeDefinitionName.Substring(0, num);
			}
			return genericTypeDefinitionName;
		}

		private static string GetDisplayName(Type type)
		{
			List<string> nestedClassPath = GetNestedClassPath(type);
			bool num = HasNameCollision(nestedClassPath);
			string fullQualifiedName = GetFullQualifiedName(type);
			if (num)
			{
				return fullQualifiedName;
			}
			return string.Join(".", nestedClassPath);
		}

		private static List<string> GetNestedClassPath(Type type)
		{
			List<string> list = new List<string>();
			Type type2 = type;
			while (type2 != null)
			{
				string text = type2.Name;
				int num = text.IndexOf('`');
				if (num > 0)
				{
					text = text.Substring(0, num);
				}
				list.Insert(0, text);
				type2 = type2.DeclaringType;
			}
			return list;
		}

		private static string GetFullQualifiedName(Type type)
		{
			string @namespace = type.Namespace;
			List<string> nestedClassPath = GetNestedClassPath(type);
			if (string.IsNullOrEmpty(@namespace))
			{
				return string.Join(".", nestedClassPath);
			}
			return @namespace + "." + string.Join(".", nestedClassPath);
		}

		private static bool HasNameCollision(List<string> nestedPath)
		{
			if (nestedPath.Count == 0)
			{
				return false;
			}
			string.Join(".", nestedPath);
			List<string> list = new List<string>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type[] types = assembly.GetTypes();
					foreach (Type type in types)
					{
						if (type.FullName == null)
						{
							continue;
						}
						List<string> nestedClassPath = GetNestedClassPath(type);
						if (nestedClassPath.Count != nestedPath.Count)
						{
							continue;
						}
						bool flag = true;
						for (int k = 0; k < nestedClassPath.Count; k++)
						{
							if (!string.Equals(nestedClassPath[k], nestedPath[k], StringComparison.OrdinalIgnoreCase))
							{
								flag = false;
								break;
							}
						}
						if (flag)
						{
							list.Add(type.Namespace ?? "");
						}
					}
				}
				catch
				{
				}
			}
			return list.Distinct().ToList().Count > 1;
		}
	}
	public static class TypeResolver
	{
		public static Type Resolve(string typeName)
		{
			if (string.IsNullOrEmpty(typeName))
			{
				return null;
			}
			if (typeName.EndsWith("?"))
			{
				return ResolveNullableType(typeName);
			}
			return ResolveNonNullableType(typeName);
		}

		private static Type ResolveNullableType(string typeName)
		{
			Type type = ResolveNonNullableType(typeName.Substring(0, typeName.Length - 1));
			if (type != null && type.IsValueType && type != typeof(void))
			{
				return typeof(Nullable<>).MakeGenericType(type);
			}
			return type;
		}

		private static Type ResolveNonNullableType(string typeName)
		{
			if (TryGetSimpleType(typeName, out var result))
			{
				return result;
			}
			return GenericTypeParser.Parse(typeName);
		}

		private static bool TryGetSimpleType(string typeName, out Type result)
		{
			result = typeName.ToLower() switch
			{
				"string" => typeof(string), 
				"int" => typeof(int), 
				"bool" => typeof(bool), 
				"float" => typeof(float), 
				"double" => typeof(double), 
				"vector2" => typeof(Vector2), 
				"vector3" => typeof(Vector3), 
				"vector4" => typeof(Vector4), 
				"quaternion" => typeof(Quaternion), 
				"color" => typeof(Color), 
				_ => null, 
			};
			return result != null;
		}

		public static string GetExampleInput(Type type)
		{
			return ParseUtility.GetExampleInput(type);
		}

		public static bool CanParse(Type type)
		{
			return ParseUtility.CanParse(type);
		}
	}
}
namespace OutwardModsCommunicatorMenu.Utility.Helpers
{
	public static class CharacterHelpers
	{
		public static Character TryToFindOtherCharacterInLobby(Character mainCharacter, string otherCharName)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Character val = null;
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				val = item.ControlledCharacter;
				if ((Object)(object)val != (Object)null && val.UID != mainCharacter.UID && string.Equals(otherCharName, val.Name))
				{
					return val;
				}
			}
			return null;
		}

		public static Character TryToFindOtherCharacterInLobby(Character mainCharacter)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Character val = null;
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				val = item.ControlledCharacter;
				if ((Object)(object)val != (Object)null && val.UID != mainCharacter.UID)
				{
					return val;
				}
			}
			return val;
		}

		public static bool IsCharacterInDistance(Character firstCharacter, Character secondCharacter, float minimumDistance)
		{
			//IL_0006: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)firstCharacter).transform.position - ((Component)secondCharacter).transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			float num = minimumDistance * minimumDistance;
			if (sqrMagnitude > num)
			{
				return false;
			}
			return true;
		}

		public static bool HasManualMovement(Character character)
		{
			CharacterControl characterControl = character.CharacterControl;
			LocalCharacterControl val = (LocalCharacterControl)(object)((characterControl is LocalCharacterControl) ? characterControl : null);
			if (val == null)
			{
				return false;
			}
			if (((Vector2)(ref ((CharacterControl)val).m_moveInput)).sqrMagnitude > 0.01f)
			{
				return true;
			}
			return false;
		}
	}
	public static class ChatHelpers
	{
		public static void SendChatLog(ChatPanel panel, string message, ChatLogStatus status = ChatLogStatus.Info)
		{
			panel.ChatMessageReceived("System", ChatLogStatusHelper.GetChatLogText(message, status));
		}

		public static void SendChatLog(Character character, string message, ChatLogStatus status = ChatLogStatus.Info)
		{
			CharacterUI characterUI = character.CharacterUI;
			if ((Object)(object)((characterUI != null) ? characterUI.ChatPanel : null) == (Object)null)
			{
				OMCM.LogMessage("ChatHelpers@SendChatLog provided character with missing chatPanel!");
			}
			else
			{
				SendChatLog(character.CharacterUI.ChatPanel, message, status);
			}
		}

		public static void SendChatOrLog(Character character, string message, ChatLogStatus status = ChatLogStatus.Info)
		{
			CharacterUI characterUI = character.CharacterUI;
			if ((Object)(object)((characterUI != null) ? characterUI.ChatPanel : null) == (Object)null)
			{
				OMCM.LogStatusMessage(message, status);
			}
			else
			{
				SendChatLog(character.CharacterUI.ChatPanel, message, status);
			}
		}
	}
}
namespace OutwardModsCommunicatorMenu.Utility.Enums
{
	public enum ChatCommandsManagerParams
	{
		CommandName,
		CommandParameters,
		CommandAction,
		IsCheatCommand,
		CommandDescription,
		CommandRequiresDebugMode
	}
	public static class ChatCommandsManagerParamsHelper
	{
		private static readonly Dictionary<ChatCommandsManagerParams, (string key, Type type)> _registry = new Dictionary<ChatCommandsManagerParams, (string, Type)>
		{
			[ChatCommandsManagerParams.CommandName] = ("command", typeof(string)),
			[ChatCommandsManagerParams.CommandParameters] = ("parameters", typeof(Dictionary<string, (string, string)>)),
			[ChatCommandsManagerParams.CommandAction] = ("function", typeof(Action<Character, Dictionary<string, string>>)),
			[ChatCommandsManagerParams.IsCheatCommand] = ("isCheatCommand", typeof(bool)),
			[ChatCommandsManagerParams.CommandDescription] = ("description", typeof(string)),
			[ChatCommandsManagerParams.CommandRequiresDebugMode] = ("debugMode", typeof(bool))
		};

		public static (string key, Type type) Get(ChatCommandsManagerParams param)
		{
			return _registry[param];
		}
	}
	public enum ChatLogStatus
	{
		Info,
		Success,
		Warning,
		Error
	}
	public static class ChatLogStatusHelper
	{
		public static string GetChatLogText(string message, ChatLogStatus status = ChatLogStatus.Info)
		{
			//IL_0019: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			return status switch
			{
				ChatLogStatus.Success => Global.SetTextColor(message, Global.LIGHT_GREEN), 
				ChatLogStatus.Warning => Global.SetTextColor(message, Global.LIGHT_ORANGE), 
				ChatLogStatus.Error => "<color=#" + UnityEngineExtensions.ToHex(Global.LIGHT_RED) + ">" + message + "</color>", 
				_ => message, 
			};
		}
	}
}
namespace OutwardModsCommunicatorMenu.UI
{
	public static class EventPublishingPanelBuilder
	{
		private static GameObject _contentParent;

		private static TabNavigationBuilder _tabNavigationBuilder;

		private static GameObject _publishViewContainer;

		private static SubscribersViewBuilder _subscribersViewBuilder;

		private static PublishersViewBuilder _publishersViewBuilder;

		private static InputSectionBuilder _inputSectionBuilder;

		private static RegisteredParamsBuilder _registeredParamsBuilder;

		private static DynamicParamsBuilder _dynamicParamsBuilder;

		private static ActionButtonsBuilder _actionButtonsBuilder;

		public static void Build(GameObject content)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			_contentParent = content;
			_tabNavigationBuilder = new TabNavigationBuilder();
			_tabNavigationBuilder.Build(content);
			_tabNavigationBuilder.OnTabChanged += OnTabChanged;
			_publishViewContainer = UIFactory.CreateVerticalGroup(content, "PublishViewContainer", false, false, true, true, 5, new Vector4(5f, 5f, 5f, 5f), default(Color), (TextAnchor?)null);
			GameObject publishViewContainer = _publishViewContainer;
			int? num = 9999;
			int? num2 = 9999;
			int? num3 = 400;
			UIFactory.SetLayoutElement(publishViewContainer, (int?)null, num3, num, num2, (int?)null, (int?)null, (bool?)null);
			BuildPublishView(_publishViewContainer);
			_subscribersViewBuilder = new SubscribersViewBuilder();
			_subscribersViewBuilder.Build(content);
			_publishersViewBuilder = new PublishersViewBuilder();
			_publishersViewBuilder.Build(content);
			ShowTab(EventMenuTab.Publish);
		}

		private static void BuildPublishView(GameObject parent)
		{
			CreateTitleLabel(parent);
			_inputSectionBuilder = new InputSectionBuilder();
			_inputSectionBuilder.Build(parent);
			_inputSectionBuilder.OnEventNameChanged += OnInputChanged;
			_inputSectionBuilder.OnModGuidChanged += OnInputChanged;
			_registeredParamsBuilder = new RegisteredParamsBuilder();
			_registeredParamsBuilder.Build(parent);
			_registeredParamsBuilder.OnRegisteredParamClicked += OnRegisteredParamClicked;
			_actionButtonsBuilder = new ActionButtonsBuilder();
			_actionButtonsBuilder.Build(parent);
			_actionButtonsBuilder.OnPublishClicked += PublishEvent;
			_actionButtonsBuilder.OnClearClicked += ClearAll;
			_dynamicParamsBuilder = new DynamicParamsBuilder();
			_dynamicParamsBuilder.Build(parent);
			CreateInfoLabel(parent);
			RefreshRegisteredParams();
		}

		private static void OnTabChanged(EventMenuTab tab)
		{
			ShowTab(tab);
		}

		private static void ShowTab(EventMenuTab tab)
		{
			bool active = tab == EventMenuTab.Publish;
			bool flag = tab == EventMenuTab.Subscribers;
			bool flag2 = tab == EventMenuTab.Publishers;
			if ((Object)(object)_publishViewContainer != (Object)null)
			{
				_publishViewContainer.SetActive(active);
			}
			if (_subscribersViewBuilder != null)
			{
				_subscribersViewBuilder.SetVisible(flag);
				if (flag)
				{
					_subscribersViewBuilder.Refresh();
				}
			}
			if (_publishersViewBuilder != null)
			{
				_publishersViewBuilder.SetVisible(flag2);
				if (flag2)
				{
					_publishersViewBuilder.Refresh();
				}
			}
			ManualLogSource log = UIManager.Instance.Log;
			if (log != null)
			{
				log.LogMessage((object)$"[EventPublishingPanel] Switched to tab: {tab}");
			}
		}

		private static void OnRegisteredParamClicked(string name, string type)
		{
			_dynamicParamsBuilder.AddDynamicParameter(name, type);
		}

		private static void OnInputChanged()
		{
			_actionButtonsBuilder?.ClearValidationMessage();
			RefreshRegisteredParams();
		}

		private static void RefreshRegisteredParams()
		{
			string modGuid = _inputSectionBuilder?.ModGuidInput?.Text ?? string.Empty;
			string text = _inputSectionBuilder?.EventNameInput?.Text ?? string.Empty;
			_registeredParamsBuilder?.Refresh(modGuid, text, text);
		}

		private static void CreateTitleLabel(GameObject content)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(content, "Title", "Publish Event to Mods", (TextAnchor)3, Color.white, true, 16)).gameObject, (int?)300, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
		}

		private static void CreateInfoLabel(GameObject content)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(content, "InfoLabel", "Type mod GUID and event name. Click registered params to add. Dynamic params: click to edit.", (TextAnchor)3, Color.yellow, true, 14)).gameObject, (int?)420, (int?)20, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
		}

		private static void ClearAll()
		{
			_dynamicParamsBuilder?.Clear();
			_inputSectionBuilder?.ModGuidInput?.Clear();
			_inputSectionBuilder?.EventNameInput?.Clear();
			RefreshRegisteredParams();
			_actionButtonsBuilder?.ClearValidationMessage();
			ManualLogSource log = UIManager.Instance.Log;
			if (log != null)
			{
				log.LogMessage((object)"[EventPublishingPanel] Cleared all");
			}
		}

		private static void PublishEvent()
		{
			string text = _inputSectionBuilder?.ModGuidInput?.Text?.Trim() ?? string.Empty;
			string text2 = _inputSectionBuilder?.EventNameInput?.Text?.Trim() ?? string.Empty;
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(text2))
			{
				_actionButtonsBuilder?.SetValidationMessage("Error: Mod GUID and Event Name are required!", isError: true);
				ManualLogSource log = UIManager.Instance.Log;
				if (log != null)
				{
					log.LogMessage((object)"[EventPublishingPanel] Error: Mod GUID and Event Name are required!");
				}
				return;
			}
			EventPayloadBuilder eventPayloadBuilder = new EventPayloadBuilder();
			string text3 = string.Empty;
			IReadOnlyDictionary<string, Dictionary<string, EventDefinition>> registeredEvents = EventBus.GetRegisteredEvents();
			bool flag = false;
			Dictionary<string, EventPayload> value2;
			if (registeredEvents.TryGetValue(text, out var value) && value.ContainsKey(text2))
			{
				flag = true;
			}
			else if (EventBus.GetModPublishedPayloads().TryGetValue(text, out value2) && value2.ContainsKey(text2))
			{
				flag = true;
			}
			if (!flag)
			{
				text3 = text3 + "Warning: Event '" + text2 + "' for mod '" + text + "' is not registered.\n";
			}
			IReadOnlyList<(string, string, string)> readOnlyList = _dynamicParamsBuilder?.DynamicParams;
			if (readOnlyList != null)
			{
				foreach (var (text4, text5, text6) in readOnlyList)
				{
					if (string.IsNullOrEmpty(text4) || string.IsNullOrEmpty(text5))
					{
						continue;
					}
					Type type = TypeResolver.Resolve(text5);
					if (type == null)
					{
						text3 = text3 + "Warning: Unknown type '" + text5 + "' for parameter '" + text4 + "'.\n";
						continue;
					}
					if (CollectionValueParser.IsCollectionType(type) && !string.IsNullOrWhiteSpace(text6))
					{
						string item = CollectionValueParser.TryParse(type, text6).error;
						if (item != null)
						{
							Type elementType = CollectionValueParser.GetElementType(type);
							text3 = ((!(elementType != null) || !elementType.IsEnum) ? (text3 + "Warning: Failed to parse collection '" + text4 + "' (" + text5 + "): " + item + "\n") : (text3 + "Warning: Failed to parse enum collection '" + text4 + "' (" + text5 + "): " + item + ". For enum values, use only member names separated by spaces (e.g., 'Abrassar Enmerkar').\n"));
							continue;
						}
					}
					eventPayloadBuilder.AddParameter(text4, type, text6);
				}
			}
			var (val, text7) = eventPayloadBuilder.Build();
			if (!string.IsNullOrEmpty(text7))
			{
				text3 += text7;
			}
			if (!string.IsNullOrEmpty(text3))
			{
				_actionButtonsBuilder?.SetValidationMessage(text3.TrimEnd(new char[1] { '\n' }), isError: true);
				ManualLogSource log2 = UIManager.Instance.Log;
				if (log2 != null)
				{
					log2.LogMessage((object)("[EventPublishingPanel] Warning publishing event:\n" + text3));
				}
			}
			else
			{
				_actionButtonsBuilder?.SetValidationMessage("Event published successfully!", isError: false);
			}
			EventBus.Publish(text, text2, val);
			ManualLogSource log3 = UIManager.Instance.Log;
			if (log3 != null)
			{
				log3.LogMessage((object)$"[EventPublishingPanel] Published event '{text2}' to mod '{text}' with {readOnlyList?.Count ?? 0} dynamic params");
			}
		}

		public static void Update()
		{
			_inputSectionBuilder?.Update();
			_dynamicParamsBuilder?.Update();
			_subscribersViewBuilder?.Update();
			_publishersViewBuilder?.Update();
		}
	}
	public static class MenuFactory
	{
		public static void CreateEventPublishingPanel(GameObject contentRoot)
		{
			EventPublishingPanelBuilder.Build(contentRoot);
		}
	}
}
namespace OutwardModsCommunicatorMenu.UI.Components
{
	public class AutocompleteInput
	{
		private readonly InputFieldRef _inputField;

		private readonly GameObject _suggestionsScrollView;

		private readonly GameObject _suggestionsContainer;

		private readonly List<ButtonRef> _suggestionButtons = new List<ButtonRef>();

		private readonly List<string> _currentSuggestions = new List<string>();

		private readonly Func<string, List<string>> _getSuggestions;

		private readonly Func<string> _externalFilterProvider;

		private readonly float _width;

		private int _selectedIndex = -1;

		private bool _isInitialized;

		private float _debounceTimer = -1f;

		private string _pendingFilter = string.Empty;

		private const float DEBOUNCE_DELAY = 0.3f;

		public string Text => _inputField.Text;

		public InputFieldRef InputField => _inputField;

		public event Action<string> OnSelect;

		public event Action<string> OnTextChanged;

		public AutocompleteInput(GameObject parent, string name, string placeholder, Vector2 size, Func<string, List<string>> getSuggestions, Func<string> externalFilterProvider = null)
		{
			//IL_004a: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			_getSuggestions = getSuggestions;
			_externalFilterProvider = externalFilterProvider;
			_width = size.x;
			_inputField = UIFactory.CreateInputField(parent, name, placeholder);
			GameObject gameObject = ((Component)_inputField.Component).gameObject;
			int? num = (int)size.x;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(gameObject, num, (int?)(int)size.y, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			(_suggestionsScrollView, _suggestionsContainer) = ScrollViewHelper.CreateScrollView(parent, name + "_Suggestions", new Vector2(size.x, 80f), (Color?)new Color(0.15f, 0.15f, 0.2f, 0.98f));
			_suggestionsScrollView.SetActive(false);
			((UnityEvent<string>)(object)_inputField.Component.onValueChanged).AddListener((UnityAction<string>)OnValueChanged);
			_isInitialized = true;
			UpdateSuggestions(string.Empty);
		}

		public void Update()
		{
			if (_debounceTimer > 0f)
			{
				_debounceTimer -= Time.unscaledDeltaTime;
				if (_debounceTimer <= 0f)
				{
					_debounceTimer = -1f;
					UpdateSuggestions(_pendingFilter);
				}
			}
		}

		private void OnValueChanged(string value)
		{
			_selectedIndex = -1;
			_pendingFilter = value;
			if (string.IsNullOrEmpty(value))
			{
				_debounceTimer = -1f;
				UpdateSuggestions(value);
			}
			else
			{
				_debounceTimer = 0.3f;
			}
			this.OnTextChanged?.Invoke(value);
		}

		private void UpdateSuggestions(string filter)
		{
			if (!_isInitialized)
			{
				return;
			}
			_currentSuggestions.Clear();
			foreach (ButtonRef suggestionButton in _suggestionButtons)
			{
				Object.Destroy((Object)(object)suggestionButton.GameObject);
			}
			_suggestionButtons.Clear();
			_ = filter;
			List<string> list = _getSuggestions?.Invoke(filter) ?? new List<string>();
			if (!string.IsNullOrEmpty(filter))
			{
				list = list.Where((string s) => UnityEngineExtensions.Contains(s, filter, StringComparison.OrdinalIgnoreCase)).ToList();
			}
			_currentSuggestions.AddRange(list);
			if (_currentSuggestions.Count == 0)
			{
				_suggestionsScrollView.SetActive(false);
				return;
			}
			_suggestionsScrollView.SetActive(true);
			for (int i = 0; i < _currentSuggestions.Count; i++)
			{
				string text = _currentSuggestions[i];
				CreateSuggestionButton(text, i);
			}
			UpdateSelectionVisual();
		}

		private void CreateSuggestionButton(string text, int index)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			ButtonRef val = UIFactory.CreateButton(_suggestionsContainer, $"Suggestion_{index}", text, (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject = ((Component)val.Component).gameObject;
			int? num = (int)_width;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(gameObject, num, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			int capturedIndex = index;
			val.OnClick = (Action)Delegate.Combine(val.OnClick, (Action)delegate
			{
				SelectItem(capturedIndex);
			});
			_suggestionButtons.Add(val);
		}

		private void UpdateSelectionVisual()
		{
			//IL_00b9: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _suggestionButtons.Count; i++)
			{
				ButtonRef val = _suggestionButtons[i];
				ColorBlock colors;
				if (i == _selectedIndex)
				{
					Button component = val.Component;
					colors = default(ColorBlock);
					((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.5f, 0.7f, 1f);
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.6f, 0.8f, 1f);
					((ColorBlock)(ref colors)).pressedColor = new Color(0.2f, 0.4f, 0.6f, 1f);
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((ColorBlock)(ref colors)).fadeDuration = 0.1f;
					((Selectable)component).colors = colors;
				}
				else
				{
					Button component2 = val.Component;
					colors = default(ColorBlock);
					((ColorBlock)(ref colors)).normalColor = new Color(0.2f, 0.2f, 0.2f, 0.9f);
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.3f, 0.4f, 0.5f, 1f);
					((ColorBlock)(ref colors)).pressedColor = new Color(0.2f, 0.3f, 0.4f, 1f);
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((ColorBlock)(ref colors)).fadeDuration = 0.1f;
					((Selectable)component2).colors = colors;
				}
			}
		}

		public void HandleKeyDown(KeyCode key)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			if (!_suggestionsScrollView.activeSelf || _currentSuggestions.Count == 0)
			{
				return;
			}
			if ((int)key == 274)
			{
				_selectedIndex = Mathf.Min(_selectedIndex + 1, _currentSuggestions.Count - 1);
				UpdateSelectionVisual();
			}
			else if ((int)key == 273)
			{
				_selectedIndex = Mathf.Max(_selectedIndex - 1, 0);
				UpdateSelectionVisual();
			}
			else if ((int)key == 13 || (int)key == 271)
			{
				if (_selectedIndex >= 0 && _selectedIndex < _currentSuggestions.Count)
				{
					SelectItem(_selectedIndex);
				}
			}
			else if ((int)key == 27)
			{
				_suggestionsScrollView.SetActive(false);
				_selectedIndex = -1;
			}
		}

		private void SelectItem(int index)
		{
			if (index >= 0 && index < _currentSuggestions.Count)
			{
				string text = _currentSuggestions[index];
				_inputField.Text = text;
				_suggestionsScrollView.SetActive(false);
				_selectedIndex = -1;
				_debounceTimer = -1f;
				this.OnSelect?.Invoke(text);
			}
		}

		public void SetText(string text)
		{
			_inputField.Text = text;
		}

		public void Clear()
		{
			_inputField.Text = string.Empty;
			_suggestionsScrollView.SetActive(false);
			_selectedIndex = -1;
			_debounceTimer = -1f;
		}

		public void HideSuggestions()
		{
			_suggestionsScrollView.SetActive(false);
			_selectedIndex = -1;
		}

		public void RefreshSuggestions()
		{
			_pendingFilter = _inputField.Text;
			_debounceTimer = -1f;
			UpdateSuggestions(_pendingFilter);
		}
	}
	public static class ScrollViewHelper
	{
		public static (GameObject root, GameObject content) CreateScrollView(GameObject parent, string name, Vector2 size, Color? bgColor = null)
		{
			//IL_002e: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject item = default(GameObject);
			AutoSliderScrollbar val = default(AutoSliderScrollbar);
			GameObject obj = UIFactory.CreateScrollView(parent, name, ref item, ref val, (Color)(((??)bgColor) ?? new Color(0.2f, 0.2f, 0.25f, 0.95f)));
			int? num = (int)size.x;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(obj, num, (int?)(int)size.y, num2, (int?)9999, (int?)null, (int?)null, (bool?)null);
			return (obj, item);
		}

		public static (GameObject root, GameObject content) CreateScrollView(GameObject parent, string name, int minWidth, int minHeight, Color? bgColor = null)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return CreateScrollView(parent, name, new Vector2((float)minWidth, (float)minHeight), bgColor);
		}
	}
}
namespace OutwardModsCommunicatorMenu.UI.Builders
{
	public class ActionButtonsBuilder
	{
		private Text _validationLabel;

		public event Action OnPublishClicked;

		public event Action OnClearClicked;

		public void Build(GameObject parent)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = UIFactory.CreateHorizontalGroup(parent, "ActionButtonsRow", false, false, true, true, 10, new Vector4(3f, 3f, 3f, 3f), default(Color), (TextAnchor?)null);
			int? num = 35;
			UIFactory.SetLayoutElement(obj, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj2 = UIFactory.CreateButton(obj, "PublishBtn", "PUBLISH EVENT", (Color?)new Color(0.2f, 0.3f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj2.Component).gameObject, (int?)130, (int?)30, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj2.OnClick = (Action)Delegate.Combine(obj2.OnClick, (Action)delegate
			{
				this.OnPublishClicked?.Invoke();
			});
			ButtonRef obj3 = UIFactory.CreateButton(obj, "ClearBtn", "Clear", (Color?)new Color(0.3f, 0.2f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj3.Component).gameObject, (int?)100, (int?)30, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj3.OnClick = (Action)Delegate.Combine(obj3.OnClick, (Action)delegate
			{
				this.OnClearClicked?.Invoke();
			});
			_validationLabel = UIFactory.CreateLabel(parent, "ValidationLabel", "", (TextAnchor)3, Color.yellow, false, 12);
			GameObject gameObject = ((Component)_validationLabel).gameObject;
			num = 9999;
			int? num2 = 20;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
		}

		public void SetValidationMessage(string message, bool isError)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_validationLabel != (Object)null)
			{
				_validationLabel.text = message;
				((Graphic)_validationLabel).color = (isError ? Color.red : Color.green);
			}
		}

		public void ClearValidationMessage()
		{
			if ((Object)(object)_validationLabel != (Object)null)
			{
				_validationLabel.text = "";
			}
		}
	}
	public class ComplexValueFormatter : IValueFormatter
	{
		public class MemberInfo
		{
			public string Name { get; set; }

			public object Value { get; set; }

			public string MemberType { get; set; }
		}

		private const int MaxDepth = 3;

		public bool CanFormat(object value)
		{
			if (value != null)
			{
				return !IsSimpleType(value);
			}
			return false;
		}

		public void CreateDisplay(GameObject parent, string name, object value, Type displayType)
		{
			string text = "unknown";
			try
			{
				text = ((displayType != null) ? TypeNameFormatter.Format(displayType) : (value?.GetType().Name ?? "null"));
			}
			catch
			{
				text = value?.GetType().Name ?? "null";
			}
			ExpandableValueBuilder.Create(parent, name, text, value, displayType);
		}

		private static bool IsSimpleType(object value)
		{
			if (value != null)
			{
				if (!(value is string))
				{
					if (!(value is bool))
					{
						if (!(value is char))
						{
							if (!(value is int))
							{
								if (!(value is long))
								{
									if (!(value is float))
									{
										if (!(value is double))
										{
											if (!(value is decimal))
											{
												if (!(value is DateTime))
												{
													if (!(value is DateTimeOffset))
													{
														if (!(value is TimeSpan))
														{
															if (value is Guid)
															{
																return true;
															}
															return value?.GetType().IsPrimitive ?? false;
														}
														return true;
													}
													return true;
												}
												return true;
											}
											return true;
										}
										return true;
									}
									return true;
								}
								return true;
							}
							return true;
						}
						return true;
					}
					return true;
				}
				return true;
			}
			return true;
		}

		public static string FormatAsString(object value, int depth)
		{
			if (!(value is Array array))
			{
				if (!(value is IDictionary dict))
				{
					if (!(value is ICollection collection))
					{
						if (value is IEnumerable enumerable)
						{
							return FormatEnumerable(enumerable);
						}
						return null;
					}
					return FormatCollection(collection);
				}
				return FormatDictionary(dict);
			}
			return FormatArray(array);
		}

		private static string FormatCollection(ICollection collection)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('[');
			int num = 0;
			foreach (object item in collection)
			{
				if (num > 0)
				{
					stringBuilder.Append(", ");
				}
				if (num >= 10)
				{
					stringBuilder.Append("...");
					break;
				}
				stringBuilder.Append(FormatCollectionItem(item));
				num++;
			}
			stringBuilder.Append(']');
			return stringBuilder.ToString();
		}

		private static string FormatArray(Array array)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('[');
			for (int i = 0; i < array.Length && i < 10; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(FormatCollectionItem(array.GetValue(i)));
			}
			if (array.Length > 10)
			{
				stringBuilder.Append("...");
			}
			stringBuilder.Append(']');
			return stringBuilder.ToString();
		}

		private static string FormatDictionary(IDictionary dict)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('{');
			int num = 0;
			foreach (DictionaryEntry item in dict)
			{
				if (num > 0)
				{
					stringBuilder.Append(", ");
				}
				if (num >= 5)
				{
					stringBuilder.Append("...");
					break;
				}
				stringBuilder.Append(FormatCollectionItem(item.Key) + ": " + FormatCollectionItem(item.Value));
				num++;
			}
			stringBuilder.Append('}');
			return stringBuilder.ToString();
		}

		private static string FormatEnumerable(IEnumerable enumerable)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('[');
			int num = 0;
			foreach (object item in enumerable)
			{
				if (num > 0)
				{
					stringBuilder.Append(", ");
				}
				if (num >= 10)
				{
					stringBuilder.Append("...");
					break;
				}
				stringBuilder.Append(FormatCollectionItem(item));
				num++;
			}
			stringBuilder.Append(']');
			return stringBuilder.ToString();
		}

		private static string FormatCollectionItem(object item)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			if (item != null)
			{
				if (!(item is string text))
				{
					if (!(item is bool))
					{
						if (!(item is int num))
						{
							if (!(item is float num2))
							{
								if (!(item is double num3))
								{
									if (!(item is Vector2 val))
									{
										if (!(item is Vector3 val2))
										{
											if (!(item is Vector4 val3))
											{
												if (!(item is Quaternion val4))
												{
													if (item is Color val5)
													{
														return $"({val5.r:F2},{val5.g:F2},{val5.b:F2},{val5.a:F2})";
													}
													if (item != null && item.GetType().IsPrimitive)
													{
														return item.ToString();
													}
													if (item is ICollection || item is Array || item is IDictionary || item is IEnumerable)
													{
														return "<" + item.GetType().Name + ">";
													}
													return item?.ToString() ?? "null";
												}
												return $"({val4.x:F2},{val4.y:F2},{val4.z:F2},{val4.w:F2})";
											}
											return $"({val3.x:F2},{val3.y:F2},{val3.z:F2},{val3.w:F2})";
										}
										return $"({val2.x:F2},{val2.y:F2},{val2.z:F2})";
									}
									return $"({val.x:F2},{val.y:F2})";
								}
								return num3.ToString("F2");
							}
							return num2.ToString("F2");
						}
						return num.ToString();
					}
					return ((bool)item) ? "true" : "false";
				}
				return "\"" + text + "\"";
			}
			return "null";
		}

		public static string GetValuePreview(object value)
		{
			if (value != null)
			{
				if (!(value is Array array))
				{
					if (!(value is IDictionary dictionary))
					{
						if (!(value is ICollection collection))
						{
							if (value is IEnumerable enumerable)
							{
								return $">= {GetEnumerableCount(enumerable)}";
							}
							return string.Empty;
						}
						return $"Count={collection.Count}";
					}
					return $"Count={dictionary.Count}";
				}
				return $"Length={array.Length}";
			}
			return "(null)";
		}

		private static int GetEnumerableCount(IEnumerable enumerable)
		{
			int num = 0;
			foreach (object item in enumerable)
			{
				_ = item;
				num++;
				if (num > 5)
				{
					break;
				}
			}
			return num;
		}

		public static List<MemberInfo> GetMembers(object value, int depth)
		{
			List<MemberInfo> list = new List<MemberInfo>();
			if (value == null)
			{
				return list;
			}
			Type type = value.GetType();
			try
			{
				PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (propertyInfo.GetIndexParameters().Length == 0)
					{
						try
						{
							object value2 = propertyInfo.GetValue(value);
							list.Add(new MemberInfo
							{
								Name = propertyInfo.Name,
								Value = value2,
								MemberType = "Property"
							});
						}
						catch
						{
							list.Add(new MemberInfo
							{
								Name = propertyInfo.Name,
								Value = null,
								MemberType = "Property"
							});
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					try
					{
						object value3 = fieldInfo.GetValue(value);
						list.Add(new MemberInfo
						{
							Name = fieldInfo.Name,
							Value = value3,
							MemberType = "Field"
						});
					}
					catch
					{
						list.Add(new MemberInfo
						{
							Name = fieldInfo.Name,
							Value = null,
							MemberType = "Field"
						});
					}
				}
			}
			catch
			{
			}
			return list;
		}
	}
	public class DynamicParamsBuilder
	{
		private readonly List<(string name, string type, string value, GameObject button)> _dynamicParams = new List<(string, string, string, GameObject)>();

		private GameObject _dynamicParamsContainer;

		private GameObject _currentRow;

		private GameObject _paramEditorGroup;

		private InputFieldRef _paramNameInput;

		private AutocompleteInput _paramTypeInput;

		private InputFieldRef _paramValueInput;

		private int _editingParamIndex = -1;

		private const int MAX_ROW_WIDTH = 700;

		private const int BUTTON_MIN_WIDTH = 120;

		private const int BUTTON_SPACING = 3;

		private const int ROW_PADDING = 6;

		private int _currentRowWidth;

		public IReadOnlyList<(string name, string type, string value)> DynamicParams => _dynamicParams.ConvertAll(((string name, string type, string value, GameObject button) p) => (p.name, p.type, p.value));

		public event Action OnDynamicParamsChanged;

		public void Update()
		{
			if ((Object)(object)_paramEditorGroup != (Object)null && _paramEditorGroup.activeSelf)
			{
				_paramTypeInput?.Update();
			}
		}

		public void Build(GameObject parent)
		{
			CreateDynamicParamsSection(parent);
			CreateParamEditor(parent);
		}

		private void CreateDynamicParamsSection(GameObject parent)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(parent, "DynamicParamsLabel", "Dynamic Parameters:", (TextAnchor)3, Color.white, true, 14)).gameObject, (int?)200, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_dynamicParamsContainer = UIFactory.CreateVerticalGroup(parent, "DynamicParamsContainer", false, false, true, true, 3, new Vector4(3f, 3f, 3f, 3f), default(Color), (TextAnchor?)null);
			GameObject dynamicParamsContainer = _dynamicParamsContainer;
			int? num = 9999;
			int? num2 = 30;
			UIFactory.SetLayoutElement(dynamicParamsContainer, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			_currentRow = CreateNewRow();
			ButtonRef obj = UIFactory.CreateButton(parent, "AddParamBtn", "+ Add", (Color?)new Color(0.2f, 0.3f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj.Component).gameObject, (int?)80, (int?)30, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj.OnClick = (Action)Delegate.Combine(obj.OnClick, (Action)delegate
			{
				AddDynamicParameter();
			});
		}

		private GameObject CreateNewRow()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = UIFactory.CreateHorizontalGroup(_dynamicParamsContainer, $"Row_{_dynamicParamsContainer.transform.childCount}", false, false, true, true, 3, new Vector4(6f, 2f, 6f, 2f), default(Color), (TextAnchor?)null);
			int? num = 9999;
			int? num2 = 30;
			UIFactory.SetLayoutElement(obj, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			_currentRowWidth = 12;
			return obj;
		}

		private void CreateParamEditor(GameObject parent)
		{
			//IL_0020: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			_paramEditorGroup = UIFactory.CreateVerticalGroup(parent, "ParamEditor", false, false, true, true, 3, new Vector4(5f, 5f, 5f, 5f), new Color(0.15f, 0.15f, 0.2f, 0.95f), (TextAnchor?)null);
			UIFactory.SetLayoutElement(_paramEditorGroup, (int?)300, (int?)120, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_paramEditorGroup.SetActive(false);
			GameObject gameObject = ((Component)UIFactory.CreateLabel(_paramEditorGroup, "EditNameLabel", "Name:", (TextAnchor)3, Color.white, true, 14)).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_paramNameInput = UIFactory.CreateInputField(_paramEditorGroup, "EditNameInput", "");
			GameObject gameObject2 = ((Component)_paramNameInput.Component).gameObject;
			num = 9999;
			int? num2 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject gameObject3 = ((Component)UIFactory.CreateLabel(_paramEditorGroup, "EditTypeLabel", "Type:", (TextAnchor)3, Color.white, true, 14)).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject3, (int?)null, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_paramTypeInput = new AutocompleteInput(_paramEditorGroup, "EditTypeInput", "type", new Vector2(150f, 25f), (string filter) => EventDataManager.Instance.GetSupportedTypes(filter));
			GameObject gameObject4 = ((Component)UIFactory.CreateLabel(_paramEditorGroup, "EditValueLabel", "Value:", (TextAnchor)3, Color.white, true, 14)).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject4, (int?)null, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_paramValueInput = UIFactory.CreateInputField(_paramEditorGroup, "EditValueInput", "");
			GameObject gameObject5 = ((Component)_paramValueInput.Component).gameObject;
			num2 = 9999;
			num = 25;
			UIFactory.SetLayoutElement(gameObject5, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject obj = UIFactory.CreateHorizontalGroup(_paramEditorGroup, "ButtonRow", false, false, true, true, 5, default(Vector4), default(Color), (TextAnchor?)null);
			num = 30;
			UIFactory.SetLayoutElement(obj, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj2 = UIFactory.CreateButton(obj, "SaveBtn", "Save", (Color?)new Color(0.2f, 0.4f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj2.Component).gameObject, (int?)60, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj2.OnClick = (Action)Delegate.Combine(obj2.OnClick, (Action)delegate
			{
				SaveParamEdit();
			});
			ButtonRef obj3 = UIFactory.CreateButton(obj, "DeleteBtn", "Delete", (Color?)new Color(0.4f, 0.2f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj3.Component).gameObject, (int?)60, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj3.OnClick = (Action)Delegate.Combine(obj3.OnClick, (Action)delegate
			{
				DeleteCurrentParam();
			});
			ButtonRef obj4 = UIFactory.CreateButton(obj, "CancelBtn", "Cancel", (Color?)new Color(0.3f, 0.2f, 0.2f));
			UIFactory.SetLayoutElement(((Component)obj4.Component).gameObject, (int?)60, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj4.OnClick = (Action)Delegate.Combine(obj4.OnClick, (Action)delegate
			{
				HideParamEditor();
			});
		}

		public void AddDynamicParameter(string name = null, string type = null)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_dynamicParamsContainer == (Object)null))
			{
				int count = _dynamicParams.Count;
				string text = name ?? $"param{count}";
				string text2 = type ?? "string";
				string item = "";
				int num = Mathf.Max(120, text.Length * 8 + 60);
				if (_currentRowWidth + num > 700 && _dynamicParams.Count > 0)
				{
					_currentRow = CreateNewRow();
				}
				ButtonRef val = UIFactory.CreateButton(_currentRow, $"Param_{count}", $"[{count}] {text}: {text2}", (Color?)new Color(0.2f, 0.25f, 0.3f));
				UIFactory.SetLayoutElement(((Component)val.Component).gameObject, (int?)num, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				_currentRowWidth += num + 3;
				int capturedIndex = count;
				val.OnClick = (Action)Delegate.Combine(val.OnClick, (Action)delegate
				{
					EditDynamicParameter(capturedIndex);
				});
				_dynamicParams.Add((text, text2, item, ((Component)val.Component).gameObject));
				UpdateParamButtonLabels();
				this.OnDynamicParamsChanged?.Invoke();
				ManualLogSource log = UIManager.Instance.Log;
				if (log != null)
				{
					log.LogMessage((object)$"[DynamicParams] Added parameter {count}: {text} ({text2})");
				}
			}
		}

		private void UpdateParamButtonLabels()
		{
			for (int i = 0; i < _dynamicParams.Count; i++)
			{
				(string name, string type, string value, GameObject button) tuple = _dynamicParams[i];
				string item = tuple.name;
				string item2 = tuple.type;
				Text componentInChildren = tuple.button.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = $"[{i}] {item}: {item2}";
				}
			}
		}

		private void EditDynamicParameter(int index)
		{
			if (index >= 0 && index < _dynamicParams.Count)
			{
				_editingParamIndex = index;
				var (text, text2, text3, _) = _dynamicParams[index];
				_paramNameInput.Text = text;
				_paramTypeInput.SetText(text2);
				_paramValueInput.Text = text3;
				_paramEditorGroup.SetActive(true);
			}
		}

		private void SaveParamEdit()
		{
			if (_editingParamIndex >= 0 && _editingParamIndex < _dynamicParams.Count)
			{
				_dynamicParams[_editingParamIndex] = (_paramNameInput.Text, _paramTypeInput.Text, _paramValueInput.Text, _dynamicParams[_editingParamIndex].button);
				UpdateParamButtonLabels();
				this.OnDynamicParamsChanged?.Invoke();
			}
			HideParamEditor();
		}

		private void DeleteCurrentParam()
		{
			if (_editingParamIndex >= 0 && _editingParamIndex < _dynamicParams.Count)
			{
				GameObject item = _dynamicParams[_editingParamIndex].button;
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)item);
				}
				_dynamicParams.RemoveAt(_editingParamIndex);
				RebuildRows();
				this.OnDynamicParamsChanged?.Invoke();
			}
			HideParamEditor();
		}

		private void RebuildRows()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			List<(string, string, string, GameObject)> list = new List<(string, string, string, GameObject)>();
			foreach (Transform item4 in _dynamicParamsContainer.transform)
			{
				Object.Destroy((Object)(object)((Component)item4).gameObject);
			}
			_currentRow = CreateNewRow();
			_currentRowWidth = 12;
			for (int i = 0; i < _dynamicParams.Count; i++)
			{
				(string name, string type, string value, GameObject button) tuple = _dynamicParams[i];
				string item = tuple.name;
				string item2 = tuple.type;
				string item3 = tuple.value;
				int num = Mathf.Max(120, item.Length * 8 + 60);
				if (_currentRowWidth + num > 700 && _dynamicParams.Count > 0)
				{
					_currentRow = CreateNewRow();
				}
				ButtonRef val = UIFactory.CreateButton(_currentRow, $"Param_{i}", $"[{i}] {item}: {item2}", (Color?)new Color(0.2f, 0.25f, 0.3f));
				UIFactory.SetLayoutElement(((Component)val.Component).gameObject, (int?)num, (int?)25, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				int capturedIndex = i;
				val.OnClick = (Action)Delegate.Combine(val.OnClick, (Action)delegate
				{
					EditDynamicParameter(capturedIndex);
				});
				_currentRowWidth += num + 3;
				list.Add((item, item2, item3, ((Component)val.Component).gameObject));
			}
			_dynamicParams.Clear();
			_dynamicParams.AddRange(list);
			UpdateParamButtonLabels();
		}

		private void HideParamEditor()
		{
			_paramEditorGroup.SetActive(false);
			_editingParamIndex = -1;
		}

		public void Clear()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			foreach (var dynamicParam in _dynamicParams)
			{
				Object.Destroy((Object)(object)dynamicParam.button);
			}
			_dynamicParams.Clear();
			foreach (Transform item in _dynamicParamsContainer.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			_currentRow = CreateNewRow();
			this.OnDynamicParamsChanged?.Invoke();
		}
	}
	public class ExpandableItemBuilder
	{
		private readonly ButtonRef _toggleButton;

		private readonly GameObject _detailContent;

		private bool _isExpanded;

		private string _collapsedText;

		private string _expandedText;

		public bool IsExpanded => _isExpanded;

		public GameObject DetailContent => _detailContent;

		public ExpandableItemBuilder(GameObject parent, string name, string title, Color? buttonColor = null, string collapsedSuffix = " [+]", string expandedSuffix = " [-]")
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			_collapsedText = title + collapsedSuffix;
			_expandedText = title + expandedSuffix;
			_toggleButton = UIFactory.CreateButton(parent, name + "_ToggleBtn", _collapsedText, (Color?)(Color)(((??)buttonColor) ?? new Color(0.2f, 0.25f, 0.3f)));
			GameObject gameObject = ((Component)_toggleButton.Component).gameObject;
			int? num = 9999;
			int? num2 = 28;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			_detailContent = UIFactory.CreateVerticalGroup(parent, name + "_DetailContent", false, false, true, true, 2, new Vector4(8f, 5f, 5f, 5f), new Color(0.08f, 0.1f, 0.12f, 0.95f), (TextAnchor?)null);
			GameObject detailContent = _detailContent;
			num2 = 9999;
			UIFactory.SetLayoutElement(detailContent, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			_detailContent.SetActive(false);
			ButtonRef toggleButton = _toggleButton;
			toggleButton.OnClick = (Action)Delegate.Combine(toggleButton.OnClick, new Action(Toggle));
		}

		private void Toggle()
		{
			SetExpanded(!_isExpanded);
		}

		public void SetExpanded(bool expanded)
		{
			_isExpanded = expanded;
			_detailContent.SetActive(_isExpanded);
			Text componentInChildren = ((Component)_toggleButton.Component).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = (_isExpanded ? _expandedText : _collapsedText);
			}
			UpdateButtonColor();
		}

		private void UpdateButtonColor()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Button component = _toggleButton.Component;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = (_isExpanded ? new Color(0.25f, 0.35f, 0.45f, 1f) : new Color(0.2f, 0.25f, 0.3f, 0.9f));
			((ColorBlock)(ref colors)).highlightedColor = (_isExpanded ? new Color(0.35f, 0.45f, 0.55f, 1f) : new Color(0.3f, 0.35f, 0.4f, 1f));
			((ColorBlock)(ref colors)).pressedColor = (_isExpanded ? new Color(0.2f, 0.3f, 0.4f, 1f) : new Color(0.2f, 0.25f, 0.3f, 1f));
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)component).colors = colors;
		}

		public void Collapse()
		{
			SetExpanded(expanded: false);
		}

		public void Expand()
		{
			SetExpanded(expanded: true);
		}

		public void SetTitle(string title, string collapsedSuffix = " [+]", string expandedSuffix = " [-]")
		{
			_collapsedText = title + collapsedSuffix;
			_expandedText = title + expandedSuffix;
			UpdateButtonColor();
		}
	}
	public class ExpandableValueBuilder
	{
		private const int MaxReflectionDepth = 3;

		private const int PageSize = 30;

		private readonly GameObject _rootObject;

		private readonly GameObject _summaryLine;

		private readonly GameObject _detailContent;

		private readonly ButtonRef _toggleButton;

		private readonly bool _isExpanded;

		private readonly string _name;

		private readonly object _storedValue;

		private readonly Type _storedType;

		public GameObject DetailContent => _detailContent;

		private ExpandableValueBuilder(GameObject parent, string name, string typeName, object value, Type displayType, bool isExpanded)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			_name = name;
			_isExpanded = isExpanded;
			_storedValue = value;
			_storedType = displayType;
			GameObject val = UIFactory.CreateVerticalGroup(parent, name + "_Container", false, false, true, true, 2, new Vector4(2f, 2f, 2f, 2f), default(Color), (TextAnchor?)null);
			int? num = 9999;
			int? num2 = 20;
			UIFactory.SetLayoutElement(val, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			_rootObject = val;
			_summaryLine = UIFactory.CreateHorizontalGroup(val, name + "_Summary", false, false, true, true, 3, default(Vector4), default(Color), (TextAnchor?)null);
			GameObject summaryLine = _summaryLine;
			num2 = 20;
			UIFactory.SetLayoutElement(summaryLine, (int?)null, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			_toggleButton = UIFactory.CreateButton(_summaryLine, name + "_Toggle", isExpanded ? "[-]" : "[+]", (Color?)new Color(0.25f, 0.28f, 0.35f));
			ButtonRef toggleButton = _toggleButton;
			toggleButton.OnClick = (Action)Delegate.Combine(toggleButton.OnClick, new Action(OnToggleClicked));
			UIFactory.SetLayoutElement(((Component)_toggleButton.Component).gameObject, (int?)30, (int?)20, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(_summaryLine, name + "_Type", typeName ?? "", (TextAnchor)3, new Color(0.6f, 0.7f, 0.9f, 1f), false, 11)).gameObject, (int?)80, (int?)18, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			if (value != null)
			{
				string valuePreview = GetValuePreview(value);
				if (!string.IsNullOrEmpty(valuePreview))
				{
					GameObject gameObject = ((Component)UIFactory.CreateLabel(_summaryLine, name + "_Preview", valuePreview, (TextAnchor)3, new Color(0.7f, 0.7f, 0.75f, 1f), false, 10)).gameObject;
					num2 = 9999;
					num = 18;
					UIFactory.SetLayoutElement(gameObject, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
				}
			}
			_detailContent = UIFactory.CreateVerticalGroup(val, name + "_Detail", false, false, true, true, 2, new Vector4(10f, 2f, 2f, 2f), default(Color), (TextAnchor?)null);
			GameObject detailContent = _detailContent;
			num = 9999;
			UIFactory.SetLayoutElement(detailContent, (int?)null, (int?)null, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			_detailContent.SetActive(isExpanded);
			if (isExpanded)
			{
				BuildDetailContent(_detailContent, value, displayType, 0);
			}
		}

		public static ExpandableValueBuilder Create(GameObject parent, string name, string typeName, object value, Type displayType)
		{
			return new ExpandableValueBuilder(parent, name, typeName, value, displayType, isExpanded: false);
		}

		private void OnToggleClicked()
		{
			_detailContent.SetActive(!_detailContent.activeSelf);
			Text componentInChildren = ((Component)_toggleButton.Component).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = (_detailContent.activeSelf ? "[-]" : "[+]");
			}
			if (_detailContent.activeSelf && _detailContent.transform.childCount == 0)
			{
				BuildDetailContent(_detailContent, _storedValue, _storedType, 0);
			}
		}

		private void BuildDetailContent(GameObject content, object value, Type displayType, int depth)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				GameObject gameObject = ((Component)UIFactory.CreateLabel(content, ((Object)content).name + "_Null", "  (null)", (TextAnchor)3, new Color(0.5f, 0.5f, 0.5f, 1f), false, 10)).gameObject;
				int? num = 16;
				UIFactory.SetLayoutElement(gameObject, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				return;
			}
			if (value is IEnumerable && !(value is string))
			{
				BuildCollectionContent(content, value, displayType, depth);
				return;
			}
			string text = ComplexValueFormatter.FormatAsString(value, depth);
			if (!string.IsNullOrEmpty(text))
			{
				GameObject gameObject2 = ((Component)UIFactory.CreateLabel(content, ((Object)content).name + "_AsString", "  " + text, (TextAnchor)3, new Color(0.6f, 0.85f, 0.6f, 1f), false, 10)).gameObject;
				int? num = 9999;
				int? num2 = 16;
				UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
				CreateSeparator(content, ((Object)content).name + "_Sep1");
			}
			BuildReflectionContent(content, value, depth);
		}

		private void BuildCollectionContent(GameObject content, object value, Type displayType, int depth)
		{
			if (!(value is IEnumerable enumerable))
			{
				return;
			}
			List<object> list = new List<object>();
			foreach (object item in enumerable)
			{
				list.Add(item);
			}
			int count = list.Count;
			int startIndex = 0;
			int num = Math.Min(30, count);
			bool num2 = count > 30;
			CreateCollectionItems(content, list, startIndex, num, count, depth, ((Object)content).name + "_page0");
			if (num2)
			{
				CreatePaginationControls(content, list, num, count, depth, ((Object)content).name + "_pagination");
			}
		}

		private void CreateCollectionItems(GameObject parent, List<object> items, int startIndex, int displayCount, int totalCount, int depth, string namePrefix)
		{
			//IL_0094: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: 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_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			for (int i = startIndex; i < startIndex + displayCount && i < items.Count; i++)
			{
				object item = items[i];
				string text = $"{namePrefix}_{i}";
				_ = item?.GetType().Name;
				string itemPreview = GetItemPreview(item);
				GameObject val = UIFactory.CreateVerticalGroup(parent, text + "_container", false, false, true, true, 2, new Vector4(2f, 2f, 2f, 2f), default(Color), (TextAnchor?)null);
				int? num = 9999;
				int? num2 = 18;
				UIFactory.SetLayoutElement(val, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
				GameObject val2 = UIFactory.CreateHorizontalGroup(val, text + "_header", false, false, true, true, 3, default(Vector4), default(Color), (TextAnchor?)null);
				num2 = 18;
				UIFactory.SetLayoutElement(val2, (int?)null, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(val2, text + "_index", $"#{i}:", (TextAnchor)3, new Color(0.6f, 0.7f, 0.8f, 1f), false, 13)).gameObject, (int?)35, (int?)20, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				string text2 = item?.GetType().Name ?? "null";
				UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(val2, text + "_type", text2, (TextAnchor)3, new Color(0.6f, 0.7f, 0.9f, 1f), false, 13)).gameObject, (int?)80, (int?)20, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				if (!string.IsNullOrEmpty(itemPreview))
				{
					if (IsSimpleType(item))
					{
						CreateLockedInputField(val2, text + "_preview", itemPreview);
					}
					else
					{
						GameObject gameObject = ((Component)UIFactory.CreateLabel(val2, text + "_preview", " = " + itemPreview, (TextAnchor)3, new Color(0.7f, 0.7f, 0.75f, 1f), false, 13)).gameObject;
						num2 = 9999;
						num = 20;
						UIFactory.SetLayoutElement(gameObject, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
					}
				}
				GameObject detailContent = UIFactory.CreateVerticalGroup(val, text + "_detail", false, false, true, true, 2, new Vector4(10f, 2f, 2f, 2f), default(Color), (TextAnchor?)null);
				GameObject obj = detailContent;
				num = 9999;
				UIFactory.SetLayoutElement(obj, (int?)null, (int?)null, num, (int?)null, (int?)null, (int?)null, (bool?)null);
				detailContent.SetActive(false);
				if (item == null || IsSimpleType(item) || depth >= 3)
				{
					continue;
				}
				ButtonRef expandBtn = UIFactory.CreateButton(val2, text + "_expand", "[+]", (Color?)new Color(0.2f, 0.25f, 0.3f));
				ButtonRef obj2 = expandBtn;
				obj2.OnClick = (Action)Delegate.Combine(obj2.OnClick, (Action)delegate
				{
					bool flag = !detailContent.activeSelf;
					detailContent.SetActive(flag);
					expandBtn.ButtonText.text = (flag ? "[-]" : "[+]");
					if (flag && detailContent.transform.childCount == 0)
					{
						BuildReflectionContent(detailContent, item, depth + 1);
					}
				});
				UIFactory.SetLayoutElement(((Component)expandBtn.Component).gameObject, (int?)30, (int?)16, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			}
		}

		private void CreatePaginationControls(GameObject parent, List<object> items, int currentEnd, int totalCount, int depth, string namePrefix)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			ButtonRef loadMoreBtn = UIFactory.CreateButton(parent, namePrefix + "_loadMore", $"Load More ({totalCount - currentEnd} remaining)", (Color?)new Color(0.2f, 0.3f, 0.4f));
			GameObject gameObject = ((Component)loadMoreBtn.Component).gameObject;
			int? num = 9999;
			int? num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			int capturedStart = currentEnd;
			ButtonRef obj = loadMoreBtn;
			obj.OnClick = (Action)Delegate.Combine(obj.OnClick, (Action)delegate
			{
				Object.Destroy((Object)(object)((Component)loadMoreBtn.Component).gameObject);
				int num3 = Math.Min(capturedStart + 30, totalCount);
				CreateCollectionItems(parent, items, capturedStart, num3 - capturedStart, totalCount, depth, $"{namePrefix}_page{capturedStart / 30}");
				if (num3 < totalCount)
				{
					CreatePaginationControls(parent, items, num3, totalCount, depth, $"{namePrefix}_page{num3 / 30}");
				}
			});
		}

		private bool IsSimpleType(object value)
		{
			if (value != null)
			{
				if (!(value is string))
				{
					if (!(value is bool))
					{
						if (!(value is char))
						{
							if (!(value is int))
							{
								if (!(value is long))
								{
									if (!(value is float))
									{
										if (!(value is double))
										{
											if (!(value is decimal))
											{
												if (value is DateTime)
												{
													return true;
												}
												return value?.GetType().IsPrimitive ?? false;
											}
											return true;
										}
										return true;
									}
									return true;
								}
								return true;
							}
							return true;
						}
						return true;
					}
					return true;
				}
				return true;
			}
			return true;
		}

		private string GetItemPreview(object item)
		{
			if (item == null)
			{
				return "null";
			}
			if (item is string text)
			{
				return "\"" + text + "\"";
			}
			if (item is bool)
			{
				if (!(bool)item)
				{
					return "false";
				}
				return "true";
			}
			if (item is int num)
			{
				return num.ToString();
			}
			if (item is float num2)
			{
				return num2.ToString("F2");
			}
			if (item is double num3)
			{
				return num3.ToString("F2");
			}
			return string.Empty;
		}

		private void BuildReflectionContent(GameObject content, object value, int depth)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			int? num;
			if (depth >= 3)
			{
				GameObject gameObject = ((Component)UIFactory.CreateLabel(content, ((Object)content).name + "_MaxDepth", "  (max depth reached)", (TextAnchor)3, new Color(0.5f, 0.5f, 0.5f, 1f), false, 13)).gameObject;
				num = 20;
				UIFactory.SetLayoutElement(gameObject, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
				return;
			}
			List<ComplexValueFormatter.MemberInfo> list = null;
			try
			{
				list = ComplexValueFormatter.GetMembers(value, depth);
			}
			catch (Exception ex)
			{
				OMCM.LogMessage("[ExpandableValueBuilder] GetMembers failed: " + ex.Message);
			}
			if (list == null || list.Count <= 0)
			{
				return;
			}
			GameObject gameObject2 = ((Component)UIFactory.CreateLabel(content, ((Object)content).name + "_ReflectionHeader", $"  --- Members ({list.Count}) ---", (TextAnchor)3, new Color(0.5f, 0.6f, 0.8f, 1f), true, 13)).gameObject;
			num = 9999;
			int? num2 = 20;
			UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			foreach (ComplexValueFormatter.MemberInfo item in list)
			{
				try
				{
					CreateMemberLabel(content, item.Name, item.Value, item.MemberType, depth + 1);
				}
				catch (Exception ex2)
				{
					OMCM.LogMessage("[ExpandableValueBuilder] CreateMemberLabel failed for " + item.Name + ": " + ex2.Message);
				}
			}
		}

		private void CreateMemberLabel(GameObject parent, string name, object memberValue, string memberType, int depth)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			string text = ((memberType == "Property") ? "P:" : "F:");
			GameObject val = UIFactory.CreateHorizontalGroup(parent, "Member_" + name, false, false, true, true, 5, default(Vector4), default(Color), (TextAnchor?)null);
			int? num = 20;
			UIFactory.SetLayoutElement(val, (int?)null, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(val, "MemberName_" + name, "  " + text + " " + name + ":", (TextAnchor)3, new Color(0.6f, 0.7f, 0.85f, 1f), false, 13)).gameObject, (int?)80, (int?)20, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			if (memberValue == null || IsSimpleType(memberValue))
			{
				string text2 = ((memberValue == null) ? "null" : memberValue.ToString());
				if (text2.Length > 60)
				{
					text2 = text2.Substring(0, 60) + "...";
				}
				CreateLockedInputField(val, "MemberValue_" + name, text2);
				return;
			}
			string text3;
			if (memberValue is ICollection collection)
			{
				text3 = $"<{collection.GetType().Name} Count={collection.Count}>";
			}
			else if (memberValue is Array array)
			{
				text3 = $"<{array.GetType().Name} Length={array.Length}>";
			}
			else
			{
				text3 = memberValue.ToString();
				if (text3.Length > 60)
				{