using System;
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 UnityEngine;
using shadcnui.GUIComponents.Controls;
using shadcnui.GUIComponents.Core;
using shadcnui.GUIComponents.Data;
using shadcnui.GUIComponents.Display;
using shadcnui.GUIComponents.Layout;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ClassLibrary1")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ClassLibrary1")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ef8ee12e-d6b5-4140-a69e-badff5b5b662")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace shadcnui
{
	public static class UnityHelpers
	{
		public class GUIStyle
		{
			private GUIStyle _guiStyle;

			public float fixedWidth
			{
				get
				{
					return _guiStyle.fixedWidth;
				}
				set
				{
					_guiStyle.fixedWidth = value;
				}
			}

			public float fixedHeight
			{
				get
				{
					return _guiStyle.fixedHeight;
				}
				set
				{
					_guiStyle.fixedHeight = value;
				}
			}

			public RectOffset margin
			{
				get
				{
					return _guiStyle.margin;
				}
				set
				{
					_guiStyle.margin = value;
				}
			}

			public bool richText
			{
				get
				{
					return _guiStyle.richText;
				}
				set
				{
					_guiStyle.richText = value;
				}
			}

			public RectOffset padding
			{
				get
				{
					return _guiStyle.padding;
				}
				set
				{
					_guiStyle.padding = value;
				}
			}

			public RectOffset border
			{
				get
				{
					return _guiStyle.border;
				}
				set
				{
					_guiStyle.border = value;
				}
			}

			public RectOffset overflow
			{
				get
				{
					return _guiStyle.overflow;
				}
				set
				{
					_guiStyle.overflow = value;
				}
			}

			public TextAnchor alignment
			{
				get
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					return _guiStyle.alignment;
				}
				set
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					_guiStyle.alignment = value;
				}
			}

			public FontStyle fontStyle
			{
				get
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					return _guiStyle.fontStyle;
				}
				set
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					_guiStyle.fontStyle = value;
				}
			}

			public int fontSize
			{
				get
				{
					return _guiStyle.fontSize;
				}
				set
				{
					_guiStyle.fontSize = value;
				}
			}

			public Font font
			{
				get
				{
					return _guiStyle.font;
				}
				set
				{
					_guiStyle.font = value;
				}
			}

			public GUIStyleState normal
			{
				get
				{
					return _guiStyle.normal;
				}
				set
				{
					_guiStyle.normal = value;
				}
			}

			public GUIStyleState hover
			{
				get
				{
					return _guiStyle.hover;
				}
				set
				{
					_guiStyle.hover = value;
				}
			}

			public GUIStyleState active
			{
				get
				{
					return _guiStyle.active;
				}
				set
				{
					_guiStyle.active = value;
				}
			}

			public GUIStyleState focused
			{
				get
				{
					return _guiStyle.focused;
				}
				set
				{
					_guiStyle.focused = value;
				}
			}

			public GUIStyleState onNormal
			{
				get
				{
					return _guiStyle.onNormal;
				}
				set
				{
					_guiStyle.onNormal = value;
				}
			}

			public GUIStyleState onHover
			{
				get
				{
					return _guiStyle.onHover;
				}
				set
				{
					_guiStyle.onHover = value;
				}
			}

			public GUIStyleState onActive
			{
				get
				{
					return _guiStyle.onActive;
				}
				set
				{
					_guiStyle.onActive = value;
				}
			}

			public GUIStyleState onFocused
			{
				get
				{
					return _guiStyle.onFocused;
				}
				set
				{
					_guiStyle.onFocused = value;
				}
			}

			public TextClipping clipping
			{
				get
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					return _guiStyle.clipping;
				}
				set
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					_guiStyle.clipping = value;
				}
			}

			public ImagePosition imagePosition
			{
				get
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					return _guiStyle.imagePosition;
				}
				set
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					_guiStyle.imagePosition = value;
				}
			}

			public Vector2 contentOffset
			{
				get
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					return _guiStyle.contentOffset;
				}
				set
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					_guiStyle.contentOffset = value;
				}
			}

			public bool wordWrap
			{
				get
				{
					return _guiStyle.wordWrap;
				}
				set
				{
					_guiStyle.wordWrap = value;
				}
			}

			public bool stretchWidth
			{
				get
				{
					return _guiStyle.stretchWidth;
				}
				set
				{
					_guiStyle.stretchWidth = value;
				}
			}

			public bool stretchHeight
			{
				get
				{
					return _guiStyle.stretchHeight;
				}
				set
				{
					_guiStyle.stretchHeight = value;
				}
			}

			public string name
			{
				get
				{
					return _guiStyle.name;
				}
				set
				{
					_guiStyle.name = value;
				}
			}

			public GUIStyle(GUIStyle style)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				_guiStyle = new GUIStyle(style);
			}

			public GUIStyle()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				_guiStyle = new GUIStyle();
			}

			public static implicit operator GUIStyle(GUIStyle style)
			{
				return style._guiStyle;
			}

			public static implicit operator GUIStyle(GUIStyle style)
			{
				return new GUIStyle(style);
			}

			public GUIStyle GetInternalStyle()
			{
				return _guiStyle;
			}
		}

		public class RectOffset
		{
			private RectOffset _rectOffset;

			public int left
			{
				get
				{
					return _rectOffset.left;
				}
				set
				{
					_rectOffset.left = value;
				}
			}

			public int right
			{
				get
				{
					return _rectOffset.right;
				}
				set
				{
					_rectOffset.right = value;
				}
			}

			public int top
			{
				get
				{
					return _rectOffset.top;
				}
				set
				{
					_rectOffset.top = value;
				}
			}

			public int bottom
			{
				get
				{
					return _rectOffset.bottom;
				}
				set
				{
					_rectOffset.bottom = value;
				}
			}

			public int horizontal => _rectOffset.horizontal;

			public int vertical => _rectOffset.vertical;

			public RectOffset(int left, int right, int top, int bottom)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				_rectOffset = new RectOffset();
				_rectOffset.left = left;
				_rectOffset.right = right;
				_rectOffset.top = top;
				_rectOffset.bottom = bottom;
			}

			public RectOffset()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				_rectOffset = new RectOffset();
			}

			public static implicit operator RectOffset(RectOffset rectOffset)
			{
				return rectOffset._rectOffset;
			}

			public static implicit operator RectOffset(RectOffset rectOffset)
			{
				return new RectOffset(rectOffset.left, rectOffset.right, rectOffset.top, rectOffset.bottom);
			}

			public RectOffset GetInternalRectOffset()
			{
				return _rectOffset;
			}
		}

		public class Font
		{
			private Font _font;

			public string name => ((Object)_font).name;

			public Font(string name)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				_font = new Font(name);
			}

			public Font(Font font)
			{
				_font = font;
			}

			public static implicit operator Font(Font font)
			{
				return font._font;
			}

			public static implicit operator Font(Font font)
			{
				return new Font(font);
			}

			public Font GetInternalFont()
			{
				return _font;
			}

			public static Font CreateDynamicFontFromOSFont(string fontname, int size)
			{
				return new Font(Font.CreateDynamicFontFromOSFont(fontname, size));
			}

			public static Font CreateDynamicFontFromOSFont(string[] fontnames, int size)
			{
				return new Font(Font.CreateDynamicFontFromOSFont(fontnames, size));
			}
		}

		public class GUIContent
		{
			private GUIContent _guiContent;

			private static GUIContent _none;

			public string text
			{
				get
				{
					return _guiContent.text;
				}
				set
				{
					_guiContent.text = value;
				}
			}

			public Texture image
			{
				get
				{
					return _guiContent.image;
				}
				set
				{
					_guiContent.image = value;
				}
			}

			public string tooltip
			{
				get
				{
					return _guiContent.tooltip;
				}
				set
				{
					_guiContent.tooltip = value;
				}
			}

			public static GUIContent none
			{
				get
				{
					if (_none == null)
					{
						_none = new GUIContent("");
					}
					return _none;
				}
			}

			public GUIContent()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				_guiContent = new GUIContent();
			}

			public GUIContent(string text)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				_guiContent = new GUIContent(text);
			}

			public GUIContent(string text, Texture image)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				_guiContent = new GUIContent(text, image);
			}

			public GUIContent(string text, Texture image, string tooltip)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				_guiContent = new GUIContent(text, image, tooltip);
			}

			public static implicit operator GUIContent(GUIContent content)
			{
				return content._guiContent;
			}

			public GUIContent GetInternalGUIContent()
			{
				return _guiContent;
			}
		}

		public static bool Button(string text, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.Button(text, (GUIStyle)style, options);
		}

		public static void Label(GUIContent content, GUIStyle style)
		{
			GUILayout.Label(content, (GUIStyle)style, Array.Empty<GUILayoutOption>());
		}

		public static void Label(string text, params GUILayoutOption[] options)
		{
			GUILayout.Label(text, options);
		}

		public static void Label(string text, GUIStyle style)
		{
			GUILayout.Label(text, (GUIStyle)style, Array.Empty<GUILayoutOption>());
		}

		public static bool Button(string text, params GUILayoutOption[] options)
		{
			return GUILayout.Button(text, options);
		}

		public static bool Button(string text, GUIStyle style)
		{
			return GUILayout.Button(text, (GUIStyle)style, Array.Empty<GUILayoutOption>());
		}

		public static bool Toggle(bool value, string text, params GUILayoutOption[] options)
		{
			return GUILayout.Toggle(value, text, options);
		}

		public static bool Toggle(bool value, string text, GUIStyle style)
		{
			return GUILayout.Toggle(value, text, (GUIStyle)style, Array.Empty<GUILayoutOption>());
		}

		public static bool Toggle(bool value, string text, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.Toggle(value, text, (GUIStyle)style, options);
		}

		public static bool Toggle(Rect position, bool value, string text, GUIStyle style)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GUI.Toggle(position, value, text, (GUIStyle)style);
		}

		public static void Label(string text, GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.Label(text, (GUIStyle)style, options);
		}

		public static void Label(Rect position, string text, GUIStyle style)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(position, text, (GUIStyle)style);
		}

		public static void Label(Texture image, params GUILayoutOption[] options)
		{
			GUILayout.Label(image, options);
		}

		public static void Label(Texture image, GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.Label(image, (GUIStyle)style, options);
		}

		public static void Box(string text, GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.Box(text, (GUIStyle)style, options);
		}

		public static void Box(GUIContent content, GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.Box((GUIContent)content, (GUIStyle)style, options);
		}

		public static string TextField(string text, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.TextField(text, (GUIStyle)style, options);
		}

		public static string PasswordField(string password, char maskChar, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.PasswordField(password, maskChar, (GUIStyle)style, options);
		}

		public static string TextArea(string text, params GUILayoutOption[] options)
		{
			return GUILayout.TextArea(text, options);
		}

		public static string TextArea(string text, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.TextArea(text, (GUIStyle)style, options);
		}

		public static string TextArea(string text, int maxLength, GUIStyle style, params GUILayoutOption[] options)
		{
			return GUILayout.TextArea(text, maxLength, (GUIStyle)style, options);
		}
	}
}
namespace shadcnui.GUIComponents.Layout
{
	public class Card : BaseComponent
	{
		public Card(GUIHelper helper)
			: base(helper)
		{
		}

		public void BeginCard(float width = -1f, float height = -1f)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			List<GUILayoutOption> list = new List<GUILayoutOption>();
			if (width > 0f)
			{
				list.Add(GUILayout.Width(width * guiHelper.uiScale));
			}
			if (height > 0f)
			{
				list.Add(GUILayout.Height(height * guiHelper.uiScale));
			}
			layoutComponents.BeginVerticalGroup(styleManager.GetCardStyle(), list.ToArray());
		}

		public void EndCard()
		{
			layoutComponents.EndVerticalGroup();
		}

		public void CardHeader(Action content)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginVerticalGroup(styleManager.GetCardHeaderStyle());
			content();
			layoutComponents.EndVerticalGroup();
		}

		public void CardTitle(string title)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			UnityHelpers.Label(title, (UnityHelpers.GUIStyle)styleManager.GetCardTitleStyle());
		}

		public void CardDescription(string description)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			UnityHelpers.Label(description, (UnityHelpers.GUIStyle)styleManager.GetCardDescriptionStyle());
		}

		public void CardContent(Action content)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginVerticalGroup(styleManager.GetCardContentStyle());
			content();
			layoutComponents.EndVerticalGroup();
		}

		public void CardFooter(Action content)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginHorizontalGroup(styleManager.GetCardFooterStyle());
			content();
			layoutComponents.EndHorizontalGroup();
		}

		public void DrawCard(string title, string description, string content, Action footerContent = null, float width = -1f, float height = -1f)
		{
			BeginCard(width, height);
			if (!string.IsNullOrEmpty(title) || !string.IsNullOrEmpty(description))
			{
				CardHeader(delegate
				{
					if (!string.IsNullOrEmpty(title))
					{
						CardTitle(title);
					}
					if (!string.IsNullOrEmpty(description))
					{
						CardDescription(description);
					}
				});
			}
			if (!string.IsNullOrEmpty(content))
			{
				CardContent(delegate
				{
					StyleManager styleManager = guiHelper.GetStyleManager();
					UnityHelpers.Label(content, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
				});
			}
			if (footerContent != null)
			{
				CardFooter(footerContent);
			}
			EndCard();
		}

		public void CardImage(Texture2D image, float height = 150f)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			guiHelper.GetStyleManager();
			GUI.DrawTexture(GUILayoutUtility.GetRect(0f, height, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }), (Texture)(object)image, (ScaleMode)1);
		}

		public void DrawCardWithImage(Texture2D image, string title, string description, string content, Action footerContent = null, float width = -1f, float height = -1f)
		{
			BeginCard(width, height);
			CardImage(image);
			if (!string.IsNullOrEmpty(title) || !string.IsNullOrEmpty(description))
			{
				CardHeader(delegate
				{
					if (!string.IsNullOrEmpty(title))
					{
						CardTitle(title);
					}
					if (!string.IsNullOrEmpty(description))
					{
						CardDescription(description);
					}
				});
			}
			if (!string.IsNullOrEmpty(content))
			{
				CardContent(delegate
				{
					StyleManager styleManager = guiHelper.GetStyleManager();
					UnityHelpers.Label(content, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
				});
			}
			if (footerContent != null)
			{
				CardFooter(footerContent);
			}
			EndCard();
		}

		public void CardWithAvatar(Texture2D avatar, string title, string subtitle)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginHorizontalGroup(styleManager.GetCardHeaderStyle());
			guiHelper.Avatar(avatar, "", ControlSize.Default, AvatarShape.Circle);
			layoutComponents.BeginVerticalGroup();
			CardTitle(title);
			CardDescription(subtitle);
			layoutComponents.EndVerticalGroup();
			layoutComponents.EndHorizontalGroup();
		}

		public void DrawCardWithAvatar(Texture2D avatar, string title, string subtitle, string content, Action footerContent = null, float width = -1f, float height = -1f)
		{
			BeginCard(width, height);
			CardWithAvatar(avatar, title, subtitle);
			if (!string.IsNullOrEmpty(content))
			{
				CardContent(delegate
				{
					StyleManager styleManager = guiHelper.GetStyleManager();
					UnityHelpers.Label(content, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
				});
			}
			if (footerContent != null)
			{
				CardFooter(footerContent);
			}
			EndCard();
		}

		public void CardHeader(string title, string description, Action Actions)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginHorizontalGroup(styleManager.GetCardHeaderStyle());
			layoutComponents.BeginVerticalGroup();
			CardTitle(title);
			CardDescription(description);
			layoutComponents.EndVerticalGroup();
			GUILayout.FlexibleSpace();
			Actions();
			layoutComponents.EndHorizontalGroup();
		}

		public void DrawCardWithHeader(string title, string description, Action header, string content, Action footerContent = null, float width = -1f, float height = -1f)
		{
			BeginCard(width, height);
			CardHeader(title, description, header);
			if (!string.IsNullOrEmpty(content))
			{
				CardContent(delegate
				{
					StyleManager styleManager = guiHelper.GetStyleManager();
					UnityHelpers.Label(content, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
				});
			}
			if (footerContent != null)
			{
				CardFooter(footerContent);
			}
			EndCard();
		}

		public void DrawSimpleCard(string content, float width = -1f, float height = -1f)
		{
			BeginCard(width, height);
			CardContent(delegate
			{
				StyleManager styleManager = guiHelper.GetStyleManager();
				UnityHelpers.Label(content, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
			});
			EndCard();
		}
	}
	public class Layout
	{
		private GUIHelper guiHelper;

		public Layout(GUIHelper helper)
		{
			guiHelper = helper;
		}

		public Vector2 DrawScrollView(Vector2 scrollPosition, Action drawContent, params GUILayoutOption[] options)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			scrollPosition = GUILayout.BeginScrollView(scrollPosition, options);
			drawContent?.Invoke();
			GUILayout.EndScrollView();
			return scrollPosition;
		}

		public void BeginHorizontalGroup()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		}

		public void BeginHorizontalGroup(params GUILayoutOption[] options)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		}

		public void BeginHorizontalGroup(GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.BeginHorizontal(style, options);
		}

		public void EndHorizontalGroup()
		{
			GUILayout.EndHorizontal();
		}

		public void BeginVerticalGroup()
		{
			GUILayout.BeginVertical(GUIStyle.none, Array.Empty<GUILayoutOption>());
		}

		public void BeginVerticalGroup(params GUILayoutOption[] options)
		{
			GUILayout.BeginVertical(GUIStyle.none, options);
		}

		public void BeginVerticalGroup(GUIStyle style, params GUILayoutOption[] options)
		{
			GUILayout.BeginVertical(style, options);
		}

		public void EndVerticalGroup()
		{
			GUILayout.EndVertical();
		}

		public void AddSpace(float pixels)
		{
			GUILayout.Space(pixels * guiHelper.uiScale);
		}
	}
	public class MenuBar : BaseComponent
	{
		public class MenuItem
		{
			public string Text;

			public Action OnClick;

			public bool Disabled;

			public List<MenuItem> SubItems;

			public string Shortcut;

			public bool IsSeparator;

			public bool IsHeader;

			public MenuItem()
			{
			}

			public MenuItem(string text, Action onClick = null, bool disabled = false, List<MenuItem> subItems = null, string shortcut = "")
			{
				Text = text;
				OnClick = onClick;
				Disabled = disabled;
				SubItems = subItems ?? new List<MenuItem>();
				Shortcut = shortcut;
				IsSeparator = false;
				IsHeader = false;
			}

			public static MenuItem Separator()
			{
				return new MenuItem
				{
					IsSeparator = true
				};
			}

			public static MenuItem Header(string text)
			{
				return new MenuItem
				{
					Text = text,
					IsHeader = true
				};
			}
		}

		public class MenuBarConfig
		{
			public List<MenuItem> Items { get; set; }

			public GUILayoutOption[] Options { get; set; }

			public MenuBarConfig(List<MenuItem> items)
			{
				Items = items;
				Options = Array.Empty<GUILayoutOption>();
			}
		}

		private struct MenuData
		{
			public List<MenuItem> Items;

			public int ParentIndex;

			public MenuData(List<MenuItem> items, int parentIndex)
			{
				Items = items;
				ParentIndex = parentIndex;
			}
		}

		private int _activeMenuIndex = -1;

		private bool _isDropdownOpen;

		private readonly Stack<MenuData> _menuStack = new Stack<MenuData>();

		private Rect _menuBarRect;

		public bool IsDropdownOpen => _isDropdownOpen;

		public MenuBar(GUIHelper helper)
			: base(helper)
		{
		}

		public void Draw(MenuBarConfig config)
		{
			Draw(config.Items, config.Options);
		}

		public void Draw(List<MenuItem> items, params GUILayoutOption[] options)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if (items == null || items.Count == 0)
			{
				return;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginHorizontalGroup(styleManager.GetMenuBarStyle(), options);
			for (int i = 0; i < items.Count; i++)
			{
				MenuItem menuItem = items[i];
				if (menuItem.IsSeparator || menuItem.IsHeader)
				{
					continue;
				}
				GUIStyle buttonStyle = styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default);
				bool enabled = GUI.enabled;
				if (menuItem.Disabled)
				{
					GUI.enabled = false;
				}
				bool num = UnityHelpers.Button(menuItem.Text, buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				GUI.enabled = enabled;
				if (num)
				{
					if (menuItem.SubItems.Count > 0)
					{
						_activeMenuIndex = i;
						_menuStack.Clear();
						_menuStack.Push(new MenuData(menuItem.SubItems, i));
						_isDropdownOpen = true;
					}
					else
					{
						menuItem.OnClick?.Invoke();
						CloseDropdown();
					}
				}
			}
			layoutComponents.EndHorizontalGroup();
			_menuBarRect = GUILayoutUtility.GetLastRect();
			if (_isDropdownOpen && _menuStack.Count > 0)
			{
				DrawDropdownMenu();
			}
			HandleClickOutside();
		}

		private void DrawDropdownMenu()
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			MenuData menuData = _menuStack.Peek();
			layoutComponents.BeginVerticalGroup(styleManager.GetMenuDropdownStyle(), GUILayout.Width(220f * guiHelper.uiScale));
			if (_menuStack.Count > 1)
			{
				if (UnityHelpers.Button("<- Back", styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default)))
				{
					_menuStack.Pop();
					if (_menuStack.Count == 1)
					{
						_activeMenuIndex = _menuStack.Peek().ParentIndex;
					}
					layoutComponents.EndVerticalGroup();
					return;
				}
				UnityHelpers.Box("", GUI.skin.horizontalSlider);
			}
			foreach (MenuItem item in menuData.Items)
			{
				DrawMenuItem(item);
			}
			layoutComponents.EndVerticalGroup();
		}

		private void DrawMenuItem(MenuItem item)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (item.IsHeader)
			{
				UnityHelpers.Label(item.Text, (UnityHelpers.GUIStyle)styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default));
				return;
			}
			if (item.IsSeparator)
			{
				UnityHelpers.Box("", GUI.skin.horizontalSlider);
				return;
			}
			bool enabled = GUI.enabled;
			if (item.Disabled)
			{
				GUI.enabled = false;
			}
			if (item.SubItems.Count > 0)
			{
				if (GUILayout.Button(item.Text, styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
				{
					_menuStack.Push(new MenuData(item.SubItems, _activeMenuIndex));
				}
			}
			else
			{
				GUIStyle buttonStyle = styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default);
				GUIStyle menuBarItemStyle = styleManager.GetMenuBarItemStyle();
				Rect rect = GUILayoutUtility.GetRect(GUIContent.none, buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				if (GUI.Button(rect, "", buttonStyle))
				{
					item.OnClick?.Invoke();
					CloseDropdown();
				}
				GUI.Label(rect, item.Text, menuBarItemStyle);
				if (!string.IsNullOrEmpty(item.Shortcut))
				{
					GUIStyle menuBarItemStyle2 = styleManager.GetMenuBarItemStyle(ControlVariant.Default, ControlSize.Default, isShortcut: true);
					GUI.Label(rect, item.Shortcut, menuBarItemStyle2);
				}
			}
			GUI.enabled = enabled;
		}

		private void HandleClickOutside()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Event.current.type == 0 && _isDropdownOpen)
			{
				Vector2 mousePosition = Event.current.mousePosition;
				if (!((Rect)(ref _menuBarRect)).Contains(mousePosition))
				{
					CloseDropdown();
					Event.current.Use();
				}
			}
		}

		public void CloseDropdown()
		{
			_activeMenuIndex = -1;
			_isDropdownOpen = false;
			_menuStack.Clear();
		}
	}
	public class Separator : BaseComponent
	{
		public Separator(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawSeparator(SeparatorOrientation orientation = SeparatorOrientation.Horizontal, bool decorative = true, params GUILayoutOption[] options)
		{
			GUIStyle separatorStyle = guiHelper.GetStyleManager().GetSeparatorStyle(orientation);
			List<GUILayoutOption> list = new List<GUILayoutOption>();
			if (orientation == SeparatorOrientation.Horizontal)
			{
				list.Add(GUILayout.Height((float)Mathf.RoundToInt(1f * guiHelper.uiScale)));
				list.Add(GUILayout.ExpandWidth(true));
			}
			else
			{
				list.Add(GUILayout.Width((float)Mathf.RoundToInt(1f * guiHelper.uiScale)));
				list.Add(GUILayout.ExpandHeight(true));
			}
			if (options != null && options.Length != 0)
			{
				list.AddRange(options);
			}
			UnityHelpers.Box(UnityHelpers.GUIContent.none, separatorStyle, list.ToArray());
		}

		public void HorizontalSeparator(params GUILayoutOption[] options)
		{
			DrawSeparator(SeparatorOrientation.Horizontal, decorative: true, options);
		}

		public void VerticalSeparator(params GUILayoutOption[] options)
		{
			DrawSeparator(SeparatorOrientation.Vertical, decorative: true, options);
		}

		public void DrawSeparator(Rect rect, SeparatorOrientation orientation = SeparatorOrientation.Horizontal)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle separatorStyle = guiHelper.GetStyleManager().GetSeparatorStyle(orientation);
			GUI.Box(new Rect(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale), (GUIContent)UnityHelpers.GUIContent.none, separatorStyle);
		}

		public void SeparatorWithSpacing(SeparatorOrientation orientation = SeparatorOrientation.Horizontal, float spacingBefore = 8f, float spacingAfter = 8f, params GUILayoutOption[] options)
		{
			if (spacingBefore > 0f)
			{
				GUILayout.Space(spacingBefore * guiHelper.uiScale);
			}
			DrawSeparator(orientation, decorative: true, options);
			if (spacingAfter > 0f)
			{
				GUILayout.Space(spacingAfter * guiHelper.uiScale);
			}
		}

		public void LabeledSeparator(string text, params GUILayoutOption[] options)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawSeparator(SeparatorOrientation.Horizontal, true, GUILayout.ExpandWidth(true));
			if (!string.IsNullOrEmpty(text))
			{
				GUILayout.Space(8f * guiHelper.uiScale);
				UnityHelpers.Label(text, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Muted));
				GUILayout.Space(8f * guiHelper.uiScale);
			}
			DrawSeparator(SeparatorOrientation.Horizontal, true, GUILayout.ExpandWidth(true));
			GUILayout.EndHorizontal();
		}
	}
	public class Table : BaseComponent
	{
		public Table(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawTable(string[] headers, string[,] data, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			if (headers == null || data == null)
			{
				return;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager == null)
			{
				DrawSimpleTable(headers, data);
				return;
			}
			GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
			GUIStyle tableHeaderStyle = styleManager.GetTableHeaderStyle(variant, size);
			GUIStyle tableCellStyle = styleManager.GetTableCellStyle(variant, size, (TextAnchor)3);
			layoutComponents.BeginVerticalGroup(tableStyle, options);
			layoutComponents.BeginHorizontalGroup();
			for (int i = 0; i < headers.Length; i++)
			{
				UnityHelpers.Label(headers[i], (UnityHelpers.GUIStyle)tableHeaderStyle);
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int k = 0; k < length2; k++)
				{
					UnityHelpers.Label(data[j, k] ?? "", (UnityHelpers.GUIStyle)tableCellStyle);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		public void DrawTable(Rect rect, string[] headers, string[,] data, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (headers != null && data != null)
			{
				StyleManager styleManager = guiHelper.GetStyleManager();
				if (styleManager == null)
				{
					GUI.Box(rect, "Table", GUI.skin.box);
					return;
				}
				GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
				Rect val = new Rect(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale);
				GUI.Box(val, "", tableStyle);
				GUILayout.BeginArea(val);
				DrawTable(headers, data, variant, size);
				GUILayout.EndArea();
			}
		}

		public void SortableTable(string[] headers, string[,] data, ref int[] sortColumns, ref bool[] sortAscending, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, Action<int, bool> onSort = null, params GUILayoutOption[] options)
		{
			if (headers == null || data == null)
			{
				return;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager == null)
			{
				DrawSimpleTable(headers, data);
				return;
			}
			GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
			GUIStyle tableHeaderStyle = styleManager.GetTableHeaderStyle(variant, size);
			GUIStyle tableCellStyle = styleManager.GetTableCellStyle(variant, size, (TextAnchor)3);
			layoutComponents.BeginVerticalGroup(tableStyle, options);
			layoutComponents.BeginHorizontalGroup();
			for (int i = 0; i < headers.Length; i++)
			{
				int arg = i;
				string text = headers[i];
				if (sortColumns != null && sortAscending != null && i < sortColumns.Length && sortColumns[i] == i)
				{
					text += (sortAscending[i] ? " ↑" : " ↓");
				}
				if (UnityHelpers.Button(text, tableHeaderStyle, options) && onSort != null)
				{
					bool arg2 = true;
					if (sortColumns != null && sortAscending != null && i < sortColumns.Length && sortColumns[i] == i)
					{
						arg2 = !sortAscending[i];
					}
					onSort(arg, arg2);
				}
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int k = 0; k < length2; k++)
				{
					UnityHelpers.Label(data[j, k] ?? "", (UnityHelpers.GUIStyle)tableCellStyle);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		public void SelectableTable(string[] headers, string[,] data, ref bool[] selectedRows, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, Action<int, bool> onSelectionChange = null, params GUILayoutOption[] options)
		{
			if (headers == null || data == null)
			{
				return;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager == null)
			{
				DrawSimpleTable(headers, data);
				return;
			}
			GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
			GUIStyle tableHeaderStyle = styleManager.GetTableHeaderStyle(variant, size);
			GUIStyle tableCellStyle = styleManager.GetTableCellStyle(variant, size, (TextAnchor)3);
			layoutComponents.BeginVerticalGroup(tableStyle, options);
			layoutComponents.BeginHorizontalGroup();
			UnityHelpers.Label("", GUILayout.Width(20f * guiHelper.uiScale));
			for (int i = 0; i < headers.Length; i++)
			{
				UnityHelpers.Label(headers[i], (UnityHelpers.GUIStyle)tableHeaderStyle);
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			if (selectedRows == null || selectedRows.Length != length)
			{
				selectedRows = new bool[length];
			}
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				bool flag = UnityHelpers.Toggle(selectedRows[j], "", GUILayout.Width(20f * guiHelper.uiScale));
				if (flag != selectedRows[j])
				{
					selectedRows[j] = flag;
					onSelectionChange?.Invoke(j, flag);
				}
				for (int k = 0; k < length2; k++)
				{
					UnityHelpers.Label(data[j, k] ?? "", (UnityHelpers.GUIStyle)tableCellStyle);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		public void CustomTable(string[] headers, object[,] data, Action<object, int, int> cellRenderer, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			if (headers == null || data == null || cellRenderer == null)
			{
				return;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager == null)
			{
				DrawSimpleTable(headers, data);
				return;
			}
			GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
			GUIStyle tableHeaderStyle = styleManager.GetTableHeaderStyle(variant, size);
			layoutComponents.BeginVerticalGroup(tableStyle, options);
			layoutComponents.BeginHorizontalGroup();
			for (int i = 0; i < headers.Length; i++)
			{
				UnityHelpers.Label(headers[i], (UnityHelpers.GUIStyle)tableHeaderStyle);
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int k = 0; k < length2; k++)
				{
					object arg = data[j, k];
					cellRenderer(arg, j, k);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		public void PaginatedTable(string[] headers, string[,] data, ref int currentPage, int pageSize, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, Action<int> onPageChange = null, params GUILayoutOption[] options)
		{
			if (headers == null || data == null)
			{
				return;
			}
			int length = data.GetLength(0);
			int num = Mathf.CeilToInt((float)length / (float)pageSize);
			if (currentPage < 0)
			{
				currentPage = 0;
			}
			if (currentPage >= num)
			{
				currentPage = num - 1;
			}
			int num2 = currentPage * pageSize;
			int num3 = Mathf.Min(num2 + pageSize, length) - num2;
			string[,] array = new string[num3, data.GetLength(1)];
			for (int i = 0; i < num3; i++)
			{
				for (int j = 0; j < data.GetLength(1); j++)
				{
					array[i, j] = data[num2 + i, j];
				}
			}
			DrawTable(headers, array, variant, size, options);
			layoutComponents.AddSpace(8f);
			layoutComponents.BeginHorizontalGroup();
			if (UnityHelpers.Button("← Previous", GUILayout.Width(80f * guiHelper.uiScale)) && currentPage > 0)
			{
				currentPage--;
				onPageChange?.Invoke(currentPage);
			}
			GUILayout.FlexibleSpace();
			string text = $"Page {currentPage + 1} of {num}";
			GUIStyle val = guiHelper.GetStyleManager()?.GetLabelStyle(ControlVariant.Muted) ?? GUI.skin.label;
			UnityHelpers.Label(text, (UnityHelpers.GUIStyle)val);
			GUILayout.FlexibleSpace();
			if (UnityHelpers.Button("Next →", GUILayout.Width(80f * guiHelper.uiScale)) && currentPage < num - 1)
			{
				currentPage++;
				onPageChange?.Invoke(currentPage);
			}
			layoutComponents.EndHorizontalGroup();
		}

		public void SearchableTable(string[] headers, string[,] data, ref string searchQuery, ref string[,] filteredData, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, Action<string> onSearch = null, params GUILayoutOption[] options)
		{
			if (headers != null && data != null)
			{
				layoutComponents.BeginHorizontalGroup();
				StyleManager obj = guiHelper.GetStyleManager();
				GUIStyle val = obj?.GetLabelStyle(ControlVariant.Default) ?? GUI.skin.label;
				GUIStyle val2 = obj?.GetInputStyle(ControlVariant.Default) ?? GUI.skin.textField;
				UnityHelpers.Label("Search:", val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f * guiHelper.uiScale) });
				string text = GUILayout.TextField(searchQuery ?? "", val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f * guiHelper.uiScale) });
				if (text != searchQuery)
				{
					searchQuery = text;
					onSearch?.Invoke(searchQuery);
					filteredData = FilterTableData(data, searchQuery);
				}
				layoutComponents.EndHorizontalGroup();
				layoutComponents.AddSpace(8f);
				string[,] data2 = filteredData ?? data;
				DrawTable(headers, data2, variant, size, options);
			}
		}

		public void ResizableTable(string[] headers, string[,] data, ref float[] columnWidths, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			if (headers == null || data == null)
			{
				return;
			}
			if (columnWidths == null || columnWidths.Length != headers.Length)
			{
				columnWidths = new float[headers.Length];
				for (int i = 0; i < columnWidths.Length; i++)
				{
					columnWidths[i] = 100f;
				}
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager == null)
			{
				DrawSimpleTable(headers, data);
				return;
			}
			GUIStyle tableStyle = styleManager.GetTableStyle(variant, size);
			GUIStyle tableHeaderStyle = styleManager.GetTableHeaderStyle(variant, size);
			GUIStyle tableCellStyle = styleManager.GetTableCellStyle(variant, size, (TextAnchor)3);
			layoutComponents.BeginVerticalGroup(tableStyle, options);
			layoutComponents.BeginHorizontalGroup();
			for (int j = 0; j < headers.Length; j++)
			{
				float num = columnWidths[j] * guiHelper.uiScale;
				UnityHelpers.Label(headers[j], tableHeaderStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num) });
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int k = 0; k < length; k++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int l = 0; l < length2; l++)
				{
					string text = data[k, l] ?? "";
					float num2 = columnWidths[l] * guiHelper.uiScale;
					UnityHelpers.Label(text, tableCellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		private void DrawSimpleTable(string[] headers, string[,] data)
		{
			layoutComponents.BeginVerticalGroup(GUI.skin.box);
			layoutComponents.BeginHorizontalGroup();
			for (int i = 0; i < headers.Length; i++)
			{
				UnityHelpers.Label(headers[i], (UnityHelpers.GUIStyle)GUI.skin.label);
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int k = 0; k < length2; k++)
				{
					UnityHelpers.Label(data[j, k] ?? "", (UnityHelpers.GUIStyle)GUI.skin.label);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		private void DrawSimpleTable(string[] headers, object[,] data)
		{
			layoutComponents.BeginVerticalGroup(GUI.skin.box);
			layoutComponents.BeginHorizontalGroup();
			for (int i = 0; i < headers.Length; i++)
			{
				UnityHelpers.Label(headers[i], (UnityHelpers.GUIStyle)GUI.skin.label);
			}
			layoutComponents.EndHorizontalGroup();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int j = 0; j < length; j++)
			{
				layoutComponents.BeginHorizontalGroup();
				for (int k = 0; k < length2; k++)
				{
					UnityHelpers.Label(data[j, k]?.ToString() ?? "", (UnityHelpers.GUIStyle)GUI.skin.label);
				}
				layoutComponents.EndHorizontalGroup();
			}
			layoutComponents.EndVerticalGroup();
		}

		private string[,] FilterTableData(string[,] data, string searchQuery)
		{
			if (string.IsNullOrEmpty(searchQuery))
			{
				return data;
			}
			List<int> list = new List<int>();
			int length = data.GetLength(0);
			int length2 = data.GetLength(1);
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < length2; j++)
				{
					if ((data[i, j] ?? "").ToLower().Contains(searchQuery.ToLower()))
					{
						list.Add(i);
						break;
					}
				}
			}
			string[,] array = new string[list.Count, length2];
			for (int k = 0; k < list.Count; k++)
			{
				int num = list[k];
				for (int l = 0; l < length2; l++)
				{
					array[k, l] = data[num, l];
				}
			}
			return array;
		}
	}
	public class Tabs : BaseComponent
	{
		public enum TabSide
		{
			Left,
			Right
		}

		public enum TabPosition
		{
			Top,
			Bottom,
			Left,
			Right
		}

		public class TabsConfig
		{
			public string[] TabNames { get; set; }

			public int SelectedIndex { get; set; }

			public Action<int> OnTabChange { get; set; }

			public Action Content { get; set; }

			public int MaxLines { get; set; }

			public TabPosition Position { get; set; }

			public TabSide Side { get; set; }

			public float TabWidth { get; set; }

			public GUILayoutOption[] Options { get; set; }

			public TabsConfig(string[] tabNames, int selectedIndex)
			{
				TabNames = tabNames;
				SelectedIndex = selectedIndex;
				OnTabChange = null;
				Content = null;
				MaxLines = 1;
				Position = TabPosition.Top;
				Side = TabSide.Left;
				TabWidth = 120f;
				Options = Array.Empty<GUILayoutOption>();
			}
		}

		public struct TabConfig
		{
			public string Name;

			public Action Content;

			public bool Disabled;

			public TabConfig(string name, Action content, bool disabled = false)
			{
				Name = name;
				Content = content;
				Disabled = disabled;
			}
		}

		public Tabs(GUIHelper helper)
			: base(helper)
		{
		}

		public int Draw(TabsConfig config)
		{
			return DrawTabsInternal(config);
		}

		public int Draw(string[] tabNames, int selectedIndex, Action content, Action<int> onTabChange = null, int maxLines = 1, TabPosition position = TabPosition.Top, TabSide side = TabSide.Left, float tabWidth = 120f, params GUILayoutOption[] options)
		{
			TabsConfig config = new TabsConfig(tabNames, selectedIndex)
			{
				OnTabChange = onTabChange,
				Content = content,
				MaxLines = maxLines,
				Position = position,
				Side = side,
				TabWidth = tabWidth,
				Options = options
			};
			return DrawTabsInternal(config);
		}

		private int DrawTabsInternal(TabsConfig config)
		{
			if (config.TabNames == null || config.TabNames.Length == 0)
			{
				config.Content?.Invoke();
				return config.SelectedIndex;
			}
			StyleManager styleManager = guiHelper.GetStyleManager();
			int selectedIndex = Mathf.Clamp(config.SelectedIndex, 0, config.TabNames.Length - 1);
			int newSelectedIndex = selectedIndex;
			Action action = delegate
			{
				int num2 = (int)Mathf.Ceil((float)config.TabNames.Length / (float)config.MaxLines);
				for (int k = 0; k < config.MaxLines; k++)
				{
					bool flag4 = false;
					try
					{
						layoutComponents.BeginHorizontalGroup(styleManager.GetTabsListStyle());
						flag4 = true;
						for (int l = k * num2; l < (k + 1) * num2 && l < config.TabNames.Length; l++)
						{
							bool active2 = l == selectedIndex;
							GUIStyle tabsTriggerStyle2 = styleManager.GetTabsTriggerStyle(active2);
							GUILayoutOption[] options2;
							if (config.Options == null || config.Options.Length == 0)
							{
								options2 = (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height((float)Mathf.RoundToInt(36f * guiHelper.uiScale)) };
							}
							else
							{
								List<GUILayoutOption> list2 = new List<GUILayoutOption>(config.Options.Length + 1);
								list2.Add(GUILayout.Height((float)Mathf.RoundToInt(36f * guiHelper.uiScale)));
								list2.AddRange(config.Options);
								options2 = list2.ToArray();
							}
							if (UnityHelpers.Button(config.TabNames[l] ?? $"Tab {l + 1}", tabsTriggerStyle2, options2) && l != selectedIndex)
							{
								newSelectedIndex = l;
								config.OnTabChange?.Invoke(l);
							}
							if (l < (k + 1) * num2 - 1 && l < config.TabNames.Length - 1)
							{
								layoutComponents.AddSpace(2f);
							}
						}
					}
					catch (Exception)
					{
					}
					finally
					{
						if (flag4)
						{
							try
							{
								layoutComponents.EndHorizontalGroup();
							}
							catch
							{
							}
						}
					}
				}
			};
			Action action2 = delegate
			{
				int num = (int)Mathf.Ceil((float)config.TabNames.Length / (float)config.MaxLines);
				for (int i = 0; i < config.MaxLines; i++)
				{
					bool flag3 = false;
					try
					{
						layoutComponents.BeginVerticalGroup(GUILayout.Width(config.TabWidth * guiHelper.uiScale));
						flag3 = true;
						for (int j = i * num; j < (i + 1) * num && j < config.TabNames.Length; j++)
						{
							bool active = j == selectedIndex;
							GUIStyle tabsTriggerStyle = styleManager.GetTabsTriggerStyle(active);
							GUILayoutOption[] options;
							if (config.Options == null || config.Options.Length == 0)
							{
								options = (GUILayoutOption[])(object)new GUILayoutOption[4]
								{
									GUILayout.Width(config.TabWidth * guiHelper.uiScale),
									GUILayout.Height((float)Mathf.RoundToInt(36f * guiHelper.uiScale)),
									GUILayout.ExpandWidth(false),
									GUILayout.ExpandHeight(false)
								};
							}
							else
							{
								List<GUILayoutOption> list = new List<GUILayoutOption>(config.Options.Length + 4);
								list.Add(GUILayout.Width(config.TabWidth * guiHelper.uiScale));
								list.Add(GUILayout.Height((float)Mathf.RoundToInt(36f * guiHelper.uiScale)));
								list.Add(GUILayout.ExpandWidth(false));
								list.Add(GUILayout.ExpandHeight(false));
								list.AddRange(config.Options);
								options = list.ToArray();
							}
							if (UnityHelpers.Button(config.TabNames[j] ?? $"Tab {j + 1}", tabsTriggerStyle, options) && j != selectedIndex)
							{
								newSelectedIndex = j;
								config.OnTabChange?.Invoke(j);
							}
							if (j < (i + 1) * num - 1 && j < config.TabNames.Length - 1)
							{
								layoutComponents.AddSpace(2f);
							}
						}
					}
					catch (Exception)
					{
					}
					finally
					{
						if (flag3)
						{
							try
							{
								layoutComponents.EndVerticalGroup();
							}
							catch
							{
							}
						}
					}
				}
			};
			if (config.Position == TabPosition.Top)
			{
				action();
				config.Content?.Invoke();
			}
			else if (config.Position == TabPosition.Bottom)
			{
				config.Content?.Invoke();
				action();
			}
			else if (config.Position == TabPosition.Left)
			{
				bool flag = false;
				try
				{
					layoutComponents.BeginHorizontalGroup();
					flag = true;
					action2();
					config.Content?.Invoke();
				}
				catch (Exception)
				{
				}
				finally
				{
					if (flag)
					{
						try
						{
							layoutComponents.EndHorizontalGroup();
						}
						catch
						{
						}
					}
				}
			}
			else if (config.Position == TabPosition.Right)
			{
				bool flag2 = false;
				try
				{
					layoutComponents.BeginHorizontalGroup();
					flag2 = true;
					config.Content?.Invoke();
					action2();
				}
				catch (Exception)
				{
				}
				finally
				{
					if (flag2)
					{
						try
						{
							layoutComponents.EndHorizontalGroup();
						}
						catch
						{
						}
					}
				}
			}
			return newSelectedIndex;
		}

		public void BeginTabContent(params GUILayoutOption[] options)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginVerticalGroup(styleManager.GetTabsContentStyle(), options);
		}

		public void EndTabContent()
		{
			layoutComponents.EndVerticalGroup();
		}

		public int TabsWithContent(TabConfig[] tabConfigs, int selectedIndex, Action<int> onTabChange = null)
		{
			if (tabConfigs == null || tabConfigs.Length == 0)
			{
				return selectedIndex;
			}
			string[] array = new string[tabConfigs.Length];
			for (int i = 0; i < tabConfigs.Length; i++)
			{
				array[i] = tabConfigs[i].Name;
			}
			int num = Draw(array, selectedIndex, null, onTabChange, 1, TabPosition.Top, TabSide.Left, 120f);
			if (num >= 0 && num < tabConfigs.Length)
			{
				BeginTabContent(GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
				tabConfigs[num].Content?.Invoke();
				EndTabContent();
			}
			return num;
		}
	}
}
namespace shadcnui.GUIComponents.Display
{
	public class Avatar : BaseComponent
	{
		public struct AvatarData
		{
			public Texture2D Image;

			public string FallbackText;

			public bool IsOnline;

			public string Name;

			public AvatarData(Texture2D image, string fallbackText, bool isOnline = false, string name = "")
			{
				Image = image;
				FallbackText = fallbackText;
				IsOnline = isOnline;
				Name = name;
			}
		}

		public Avatar(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawAvatar(Texture2D image, string fallbackText, ControlSize size = ControlSize.Default, AvatarShape shape = AvatarShape.Circle, params GUILayoutOption[] options)
		{
			StyleManager obj = guiHelper.GetStyleManager();
			GUIStyle avatarStyle = obj.GetAvatarStyle(size, shape);
			GUIStyle avatarStyle2 = obj.GetAvatarStyle(size, shape);
			GUILayoutOption[] options2 = new List<GUILayoutOption>(options).ToArray();
			if ((Object)(object)image != (Object)null)
			{
				UnityHelpers.Label((Texture)(object)image, avatarStyle, options2);
			}
			else
			{
				UnityHelpers.Label(fallbackText ?? "A", avatarStyle2, options2);
			}
		}

		public void DrawAvatar(Rect rect, Texture2D image, string fallbackText, ControlSize size = ControlSize.Default, AvatarShape shape = AvatarShape.Circle)
		{
			//IL_0089: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			StyleManager styleManager = guiHelper.GetStyleManager();
			GUIStyle avatarStyle = styleManager.GetAvatarStyle(size, shape);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale);
			if ((Object)(object)image != (Object)null)
			{
				GUI.Label(val, (Texture)(object)image, avatarStyle);
				return;
			}
			GUIStyle avatarStyle2 = styleManager.GetAvatarStyle(size, shape);
			GUI.Label(val, new GUIContent(fallbackText ?? "A"), avatarStyle2);
		}

		public void AvatarWithStatus(Texture2D image, string fallbackText, bool isOnline, ControlSize size = ControlSize.Default, AvatarShape shape = AvatarShape.Circle, params GUILayoutOption[] options)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginVerticalGroup();
			DrawAvatar(image, fallbackText, size, shape, options);
			Rect lastRect = GUILayoutUtility.GetLastRect();
			if (isOnline && styleManager != null)
			{
				float num = styleManager.GetStatusIndicatorSize(size) * guiHelper.uiScale;
				float num2 = ((Rect)(ref lastRect)).x + ((Rect)(ref lastRect)).width - num * 0.9f;
				float num3 = ((Rect)(ref lastRect)).y + ((Rect)(ref lastRect)).height - num * 0.9f;
				Rect rect = default(Rect);
				((Rect)(ref rect))..ctor(num2, num3, num, num);
				DrawStatusDot(rect, isOnline: true);
			}
			layoutComponents.EndVerticalGroup();
		}

		private void DrawStatusIndicator(bool isOnline, ControlSize size)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager != null)
			{
				Color color = (isOnline ? Color.green : Color.gray);
				float statusIndicatorSize = styleManager.GetStatusIndicatorSize(size);
				GUIStyle val = new UnityHelpers.GUIStyle(GUI.skin.box);
				val.normal.background = styleManager.CreateSolidTexture(color);
				val.fixedWidth = statusIndicatorSize * guiHelper.uiScale;
				val.fixedHeight = statusIndicatorSize * guiHelper.uiScale;
				val.border = new UnityHelpers.RectOffset(0, 0, 0, 0);
				val.padding = new UnityHelpers.RectOffset(0, 0, 0, 0);
				val.margin = new UnityHelpers.RectOffset(0, 0, 0, 0);
				UnityHelpers.Label(GUIContent.none, val);
			}
		}

		private void DrawStatusDot(Rect rect, bool isOnline)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager != null)
			{
				Color color = (isOnline ? Color.green : Color.gray);
				GUIStyle val = new UnityHelpers.GUIStyle(GUI.skin.box);
				val.normal.background = styleManager.CreateSolidTexture(color);
				GUI.Box(rect, GUIContent.none, val);
			}
		}

		public void AvatarWithName(Texture2D image, string fallbackText, string name, ControlSize size = ControlSize.Default, AvatarShape shape = AvatarShape.Circle, bool showNameBelow = false, params GUILayoutOption[] options)
		{
			if (showNameBelow)
			{
				layoutComponents.BeginVerticalGroup();
				DrawAvatar(image, fallbackText, size, shape, options);
				if (!string.IsNullOrEmpty(name))
				{
					layoutComponents.AddSpace(4f);
					GUIStyle val = guiHelper.GetStyleManager()?.GetLabelStyle(ControlVariant.Default) ?? GUI.skin.label;
					UnityHelpers.Label(name, (UnityHelpers.GUIStyle)val);
				}
				layoutComponents.EndVerticalGroup();
				return;
			}
			layoutComponents.BeginHorizontalGroup();
			DrawAvatar(image, fallbackText, size, shape, options);
			if (!string.IsNullOrEmpty(name))
			{
				layoutComponents.AddSpace(8f);
				GUIStyle val2 = guiHelper.GetStyleManager()?.GetLabelStyle(ControlVariant.Default) ?? GUI.skin.label;
				val2.alignment = (TextAnchor)3;
				UnityHelpers.Label(name, (UnityHelpers.GUIStyle)val2);
			}
			layoutComponents.EndHorizontalGroup();
		}

		public void AvatarWithBorder(Texture2D image, string fallbackText, Color borderColor, ControlSize size = ControlSize.Default, AvatarShape shape = AvatarShape.Circle, params GUILayoutOption[] options)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			GUIStyle val = new UnityHelpers.GUIStyle(GUI.skin.box);
			val.normal.background = styleManager.CreateSolidTexture(borderColor);
			val.alignment = (TextAnchor)4;
			val.padding = new UnityHelpers.RectOffset(2, 2, 2, 2);
			layoutComponents.BeginVerticalGroup(val, options);
			DrawAvatar(image, fallbackText, size, shape, options);
			layoutComponents.EndVerticalGroup();
		}
	}
	public class Badge : BaseComponent
	{
		public Badge(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawBadge(string text, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			GUIStyle badgeStyle = guiHelper.GetStyleManager().GetBadgeStyle(variant, size);
			UnityHelpers.Label(text ?? "Badge", badgeStyle, options);
		}

		public void DrawBadge(Rect rect, string text, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle badgeStyle = guiHelper.GetStyleManager().GetBadgeStyle(variant, size);
			UnityHelpers.Label(new Rect(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale), text ?? "Badge", badgeStyle);
		}

		public void BadgeWithIcon(string text, Texture2D icon, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			layoutComponents.BeginHorizontalGroup();
			if ((Object)(object)icon != (Object)null)
			{
				UnityHelpers.Label((Texture)(object)icon, GUILayout.Width(16f * guiHelper.uiScale), GUILayout.Height(16f * guiHelper.uiScale));
				layoutComponents.AddSpace(4f);
			}
			DrawBadge(text, variant, size, options);
			layoutComponents.EndHorizontalGroup();
		}

		public void CountBadge(int count, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, int maxCount = 99, params GUILayoutOption[] options)
		{
			string text = ((count > maxCount) ? $"{maxCount}+" : count.ToString());
			DrawBadge(text, variant, size, options);
		}

		public void StatusBadge(string text, bool isActive, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			layoutComponents.BeginHorizontalGroup();
			Color color = (isActive ? Color.green : Color.gray);
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager != null)
			{
				UnityHelpers.GUIStyle gUIStyle = new UnityHelpers.GUIStyle(GUI.skin.box);
				gUIStyle.normal.background = styleManager.CreateSolidTexture(color);
				gUIStyle.fixedWidth = 8f * guiHelper.uiScale;
				gUIStyle.fixedHeight = 8f * guiHelper.uiScale;
				gUIStyle.border = new UnityHelpers.RectOffset(0, 0, 0, 0);
				gUIStyle.padding = new UnityHelpers.RectOffset(0, 0, 0, 0);
				gUIStyle.margin = new UnityHelpers.RectOffset(0, 0, 0, 0);
				GUIStyle val = gUIStyle;
				UnityHelpers.Label("", (UnityHelpers.GUIStyle)val);
				layoutComponents.AddSpace(4f);
			}
			DrawBadge(text, variant, size, options);
			layoutComponents.EndHorizontalGroup();
		}

		public void ProgressBadge(string text, float progress, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			layoutComponents.BeginVerticalGroup();
			DrawBadge(text, variant, size, options);
			layoutComponents.AddSpace(2f);
			Rect rect = GUILayoutUtility.GetRect(60f * guiHelper.uiScale, 4f * guiHelper.uiScale);
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (styleManager != null)
			{
				GUIStyle val = new UnityHelpers.GUIStyle(GUI.skin.box);
				val.normal.background = styleManager.CreateSolidTexture(Color.gray);
				GUI.Box(rect, "", val);
				Rect val2 = new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * Mathf.Clamp01(progress), ((Rect)(ref rect)).height);
				GUIStyle val3 = new UnityHelpers.GUIStyle(GUI.skin.box);
				val3.normal.background = styleManager.CreateSolidTexture(Color.green);
				GUI.Box(val2, "", val3);
			}
			layoutComponents.EndVerticalGroup();
		}

		public void AnimatedBadge(string text, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			float num = (Mathf.Sin(Time.time * 2f) + 1f) * 0.5f * 0.3f + 0.7f;
			Color color = GUI.color;
			GUI.color = new Color(color.r, color.g, color.b, num);
			DrawBadge(text, variant, size, options);
			GUI.color = color;
		}

		public void RoundedBadge(string text, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, float cornerRadius = 12f, params GUILayoutOption[] options)
		{
			GUIStyle badgeStyle = guiHelper.GetStyleManager().GetBadgeStyle(variant, size);
			GUIStyle val = new UnityHelpers.GUIStyle(badgeStyle);
			int num = Mathf.RoundToInt(cornerRadius * guiHelper.uiScale);
			val.border = new UnityHelpers.RectOffset(num, num, num, num);
			val.padding = new UnityHelpers.RectOffset(badgeStyle.padding.left + 4, badgeStyle.padding.right + 4, badgeStyle.padding.top + 2, badgeStyle.padding.bottom + 2);
			UnityHelpers.Label(text ?? "Badge", val, options);
		}

		public void PillBadge(string text, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default, params GUILayoutOption[] options)
		{
			RoundedBadge(text, variant, size, 999f, options);
		}
	}
	public enum ChartType
	{
		Line,
		Bar,
		Area,
		Pie,
		Scatter
	}
	[Serializable]
	public class ChartDataPoint
	{
		public string Name { get; set; }

		public float Value { get; set; }

		public Color Color { get; set; }

		public Dictionary<string, object> Payload { get; set; }

		public ChartDataPoint(string name, float value, Color color = default(Color))
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Name = name;
			Value = value;
			Color = ((color == default(Color)) ? Color.blue : color);
			Payload = new Dictionary<string, object>();
		}
	}
	[Serializable]
	public class ChartSeries
	{
		public string Key { get; set; }

		public string Label { get; set; }

		public Color Color { get; set; }

		public List<ChartDataPoint> Data { get; set; }

		public bool Visible { get; set; }

		public ChartSeries(string key, string label, Color color = default(Color))
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Key = key;
			Label = label;
			Color = ((color == default(Color)) ? Color.blue : color);
			Data = new List<ChartDataPoint>();
			Visible = true;
		}
	}
	[Serializable]
	public class ChartConfig
	{
		public List<ChartSeries> Series { get; set; }

		public ChartType ChartType { get; set; }

		public Vector2 Size { get; set; }

		public GUILayoutOption[] Options { get; set; }

		public ChartConfig(List<ChartSeries> series, ChartType chartType)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Series = series;
			ChartType = chartType;
			Size = new Vector2(400f, 300f);
			Options = Array.Empty<GUILayoutOption>();
		}
	}
	public class Chart : BaseComponent
	{
		private Rect _chartRect;

		public Chart(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawChart(ChartConfig config)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			List<GUILayoutOption> list = new List<GUILayoutOption>(config.Options);
			if (list.Count == 0)
			{
				list.Add(GUILayout.Width(config.Size.x));
				list.Add(GUILayout.Height(config.Size.y));
			}
			layoutComponents.BeginVerticalGroup(styleManager.GetChartStyle(ControlVariant.Default, ControlSize.Default), list.ToArray());
			DrawChartContent(config);
			layoutComponents.EndVerticalGroup();
		}

		private void DrawChartContent(ChartConfig config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0043: 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)
			Rect rect = GUILayoutUtility.GetRect(config.Size.x, config.Size.y, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			if ((int)Event.current.type == 7)
			{
				_chartRect = rect;
				switch (config.ChartType)
				{
				case ChartType.Line:
					DrawLineChart(config.Series);
					break;
				case ChartType.Bar:
					DrawBarChart(config.Series);
					break;
				case ChartType.Area:
					DrawAreaChart(config.Series);
					break;
				case ChartType.Pie:
					DrawPieChart(config.Series);
					break;
				case ChartType.Scatter:
					DrawScatterChart(config.Series);
					break;
				}
			}
		}

		private void DrawLineChart(List<ChartSeries> series)
		{
			if (series.Count == 0)
			{
				return;
			}
			DrawGrid();
			DrawAxes(series);
			foreach (ChartSeries item in series.Where((ChartSeries s) => s.Visible))
			{
				DrawLineSeries(item, series);
			}
		}

		private void DrawBarChart(List<ChartSeries> series)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (series.Count == 0)
			{
				return;
			}
			DrawGrid();
			DrawAxes(series);
			float num = ((Rect)(ref _chartRect)).width - 60f;
			float num2 = ((Rect)(ref _chartRect)).height - 40f;
			float maxValue = GetMaxValue(series);
			int num3 = series.FirstOrDefault()?.Data.Count ?? 0;
			if (num3 == 0)
			{
				return;
			}
			float num4 = num / (float)num3;
			float num5 = num4 * 0.8f / (float)series.Count;
			float num6 = num4 * 0.1f;
			Rect rect = default(Rect);
			for (int i = 0; i < num3; i++)
			{
				float num7 = ((Rect)(ref _chartRect)).x + 40f + (float)i * num4 + num6;
				for (int j = 0; j < series.Count; j++)
				{
					ChartSeries chartSeries = series[j];
					if (chartSeries.Visible && i < chartSeries.Data.Count)
					{
						float num8 = chartSeries.Data[i].Value / maxValue * num2;
						float num9 = num7 + (float)j * num5;
						float num10 = ((Rect)(ref _chartRect)).y + num2 - num8;
						((Rect)(ref rect))..ctor(num9, num10, num5 - 2f, num8);
						DrawRoundedRect(rect, chartSeries.Color, 4f);
					}
				}
			}
		}

		private void DrawAreaChart(List<ChartSeries> series)
		{
			if (series.Count == 0)
			{
				return;
			}
			DrawGrid();
			DrawAxes(series);
			foreach (ChartSeries item in series.Where((ChartSeries s) => s.Visible))
			{
				DrawAreaSeries(item, series);
			}
		}

		private void DrawPieChart(List<ChartSeries> series)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (series.Count == 0)
			{
				return;
			}
			Vector2 center = default(Vector2);
			((Vector2)(ref center))..ctor(((Rect)(ref _chartRect)).x + ((Rect)(ref _chartRect)).width / 2f, ((Rect)(ref _chartRect)).y + ((Rect)(ref _chartRect)).height / 2f);
			float radius = Mathf.Min(((Rect)(ref _chartRect)).width, ((Rect)(ref _chartRect)).height) / 2f * 0.8f;
			float num = series.SelectMany((ChartSeries s) => s.Data).Sum((ChartDataPoint d) => d.Value);
			float num2 = 0f;
			foreach (ChartSeries item in series.Where((ChartSeries s) => s.Visible))
			{
				foreach (ChartDataPoint datum in item.Data)
				{
					float num3 = datum.Value / num * 360f;
					DrawPieSlice(center, radius, num2, num3, datum.Color);
					num2 += num3;
				}
			}
		}

		private void DrawScatterChart(List<ChartSeries> series)
		{
			if (series.Count == 0)
			{
				return;
			}
			DrawGrid();
			DrawAxes(series);
			foreach (ChartSeries item in series.Where((ChartSeries s) => s.Visible))
			{
				DrawScatterSeries(item, series);
			}
		}

		private void DrawGrid()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			Theme theme = guiHelper.GetStyleManager().GetTheme();
			for (int i = 1; i < 5; i++)
			{
				float num = ((Rect)(ref _chartRect)).y + ((Rect)(ref _chartRect)).height / 5f * (float)i;
				DrawLine(new Vector2(((Rect)(ref _chartRect)).x + 40f, num), new Vector2(((Rect)(ref _chartRect)).x + ((Rect)(ref _chartRect)).width - 20f, num), new Color(theme.Border.r, theme.Border.g, theme.Border.b, 0.3f));
			}
		}

		private void DrawAxes(List<ChartSeries> series)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Theme theme = guiHelper.GetStyleManager().GetTheme();
				StyleManager styleManager = guiHelper.GetStyleManager();
				DrawLine(new Vector2(((Rect)(ref _chartRect)).x + 40f, ((Rect)(ref _chartRect)).y + ((Rect)(ref _chartRect)).height - 20f), new Vector2(((Rect)(ref _chartRect)).x + ((Rect)(ref _chartRect)).width - 20f, ((Rect)(ref _chartRect)).y + ((Rect)(ref _chartRect)).height - 20f), new Color(theme.Muted.r, theme.Muted.g, theme.Muted.b, 0.5f));
				if (series.Count <= 0 || series[0].Data.Count <= 0 || !(((Rect)(ref _chartRect)).width > 60f))
				{
					return;
				}
				float num = (((Rect)(ref _chartRect)).width - 60f) / (float)series[0].Data.Count;
				if (!(num > 0f))
				{
					return;
				}
				Rect val = default(Rect);
				for (int i = 0; i < series[0].Data.Count; i++)
				{
					float num2 = ((Rect)(ref _chartRect)).x + 40f + (float)i * num + num / 2f;
					string text = ((series[0].Data[i].Name.Length > 3) ? series[0].Data[i].Name.Substring(0, 3) : series[0].Data[i].Name);
					((Rect)(ref val))..ctor(num2 - 15f, ((Rect)(ref _chartRect)).y + ((Rect)(ref _chartRect)).height - 15f, 30f, 20f);
					if (((Rect)(ref val)).width > 0f && ((Rect)(ref val)).height > 0f)
					{
						Color color = GUI.color;
						GUI.color = theme.Muted;
						GUI.Label(val, text, styleManager.GetChartAxisStyle());
						GUI.color = color;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("DrawAxes error: " + ex.Message));
			}
		}

		private void DrawLineSeries(ChartSeries seriesData, List<ChartSeries> series)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			if (seriesData.Data.Count >= 2)
			{
				Vector2[] array = (Vector2[])(object)new Vector2[seriesData.Data.Count];
				float maxValue = GetMaxValue(series);
				float num = ((Rect)(ref _chartRect)).width - 60f;
				float num2 = ((Rect)(ref _chartRect)).height - 40f;
				for (int i = 0; i < seriesData.Data.Count; i++)
				{
					float num3 = ((Rect)(ref _chartRect)).x + 40f + (float)i / (float)(seriesData.Data.Count - 1) * num;
					float num4 = ((Rect)(ref _chartRect)).y + num2 - seriesData.Data[i].Value / maxValue * num2;
					array[i] = new Vector2(num3, num4);
				}
				for (int j = 0; j < array.Length - 1; j++)
				{
					DrawThickLine(array[j], array[j + 1], seriesData.Color, 2f);
				}
				Vector2[] array2 = array;
				foreach (Vector2 center in array2)
				{
					DrawCircle(center, 4f, seriesData.Color);
					DrawCircle(center, 2f, Color.white);
				}
			}
		}

		private void DrawAreaSeries(ChartSeries seriesData, List<ChartSeries> series)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			if (seriesData.Data.Count >= 2)
			{
				Vector2[] array = (Vector2[])(object)new Vector2[seriesData.Data.Count + 2];
				float maxValue = GetMaxValue(series);
				float num = ((Rect)(ref _chartRect)).width - 60f;
				float num2 = ((Rect)(ref _chartRect)).height - 40f;
				array[0] = new Vector2(((Rect)(ref _chartRect)).x + 40f, ((Rect)(ref _chartRect)).y + num2);
				for (int i = 0; i < seriesData.Data.Count; i++)
				{
					float num3 = ((Rect)(ref _chartRect)).x + 40f + (float)i / (float)(seriesData.Data.Count - 1) * num;
					float num4 = ((Rect)(ref _chartRect)).y + num2 - seriesData.Data[i].Value / maxValue * num2;
					array[i + 1] = new Vector2(num3, num4);
				}
				array[^1] = new Vector2(((Rect)(ref _chartRect)).x + num + 40f, ((Rect)(ref _chartRect)).y + num2);
				Color color = default(Color);
				((Color)(ref color))..ctor(seriesData.Color.r, seriesData.Color.g, seriesData.Color.b, 0.3f);
				for (int j = 0; j < array.Length - 1; j++)
				{
					DrawLine(array[j], array[j + 1], color);
				}
				for (int k = 1; k < array.Length - 2; k++)
				{
					DrawLine(array[k], array[k + 1], seriesData.Color);
				}
			}
		}

		private void DrawScatterSeries(ChartSeries seriesData, List<ChartSeries> series)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			float maxValue = GetMaxValue(series);
			float num = ((Rect)(ref _chartRect)).width - 60f;
			float num2 = ((Rect)(ref _chartRect)).height - 40f;
			for (int i = 0; i < seriesData.Data.Count; i++)
			{
				float num3 = ((Rect)(ref _chartRect)).x + 40f + (float)i / (float)(seriesData.Data.Count - 1) * num;
				float num4 = ((Rect)(ref _chartRect)).y + num2 - seriesData.Data[i].Value / maxValue * num2;
				DrawCircle(new Vector2(num3, num4), 4f, seriesData.Color);
			}
		}

		private void DrawPieSlice(Vector2 center, float radius, float startAngle, float sliceAngle, Color color)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0092: 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_0094: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(3, Mathf.RoundToInt(sliceAngle / 10f));
			float num2 = sliceAngle / (float)num;
			Vector2 val = center + new Vector2(Mathf.Cos(startAngle * (float)Math.PI / 180f) * radius, Mathf.Sin(startAngle * (float)Math.PI / 180f) * radius);
			for (int i = 1; i <= num; i++)
			{
				float num3 = startAngle + num2 * (float)i;
				Vector2 val2 = center + new Vector2(Mathf.Cos(num3 * (float)Math.PI / 180f) * radius, Mathf.Sin(num3 * (float)Math.PI / 180f) * radius);
				DrawLine(center, val, color);
				DrawLine(val, val2, color);
				val = val2;
			}
			DrawLine(center, val, color);
		}

		private float GetMaxValue(IEnumerable<ChartSeries> series)
		{
			float num = (from d in series.Where((ChartSeries s) => s?.Data != null).SelectMany((ChartSeries s) => s.Data)
				select d.Value).DefaultIfEmpty(0f).Max();
			if (!(num <= 0f))
			{
				return num;
			}
			return 1f;
		}

		private void DrawLine(Vector2 start, Vector2 end, Color color, float width = 1f)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Event.current.type == 7)
			{
				Color color2 = GUI.color;
				GUI.color = color;
				Vector2 val = end - start;
				float num = Mathf.Atan2(val.y, val.x) * 57.29578f;
				float magnitude = ((Vector2)(ref val)).magnitude;
				Matrix4x4 matrix = GUI.matrix;
				GUIUtility.RotateAroundPivot(num, start);
				GUI.DrawTexture(new Rect(start.x, start.y - width * 0.5f, magnitude, width), (Texture)(object)Texture2D.whiteTexture);
				GUI.matrix = matrix;
				GUI.color = color2;
			}
		}

		private void DrawCircle(Vector2 center, float radius, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Color color2 = GUI.color;
			GUI.color = color;
			GUI.DrawTexture(new Rect(center.x - radius, center.y - radius, radius * 2f, radius * 2f), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color2;
		}

		private void DrawThickLine(Vector2 start, Vector2 end, Color color, float thickness)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			DrawLine(start, end, color, thickness);
		}

		private void DrawRoundedRect(Rect rect, Color color, float cornerRadius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Color color2 = GUI.color;
			GUI.color = color;
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color2;
		}
	}
	public class Dialog : BaseComponent
	{
		private bool _isOpen;

		private string _dialogId;

		public bool IsOpen => _isOpen;

		public Dialog(GUIHelper helper)
			: base(helper)
		{
		}

		public void Open(string dialogId)
		{
			_dialogId = dialogId;
			_isOpen = true;
		}

		public void Close()
		{
			_isOpen = false;
			_dialogId = null;
		}

		public void DrawDialog(string dialogId, Action content, float width = 400f, float height = 300f)
		{
			if (_isOpen && !(_dialogId != dialogId))
			{
				StyleManager styleManager = guiHelper.GetStyleManager();
				DrawOverlay();
				layoutComponents.BeginVerticalGroup(styleManager.GetDialogContentStyle(), GUILayout.Width(width), GUILayout.Height(height));
				layoutComponents.BeginHorizontalGroup();
				GUILayout.FlexibleSpace();
				if (UnityHelpers.Button("×", styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(24f),
					GUILayout.Height(24f)
				}))
				{
					Close();
				}
				layoutComponents.EndHorizontalGroup();
				content?.Invoke();
				GUILayout.EndVertical();
			}
		}

		public void DrawDialog(string dialogId, string title, string description, Action content, Action footer = null, float width = 400f, float height = 300f)
		{
			if (_isOpen && !(_dialogId != dialogId))
			{
				StyleManager styleManager = guiHelper.GetStyleManager();
				DrawOverlay();
				layoutComponents.BeginVerticalGroup(styleManager.GetDialogContentStyle(), GUILayout.Width(width), GUILayout.Height(height));
				layoutComponents.BeginHorizontalGroup();
				layoutComponents.BeginVerticalGroup();
				if (!string.IsNullOrEmpty(title))
				{
					UnityHelpers.Label(title, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default, ControlSize.Large));
				}
				if (!string.IsNullOrEmpty(description))
				{
					UnityHelpers.Label(description, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Muted));
				}
				layoutComponents.EndVerticalGroup();
				GUILayout.FlexibleSpace();
				if (UnityHelpers.Button("×", styleManager.GetButtonStyle(ControlVariant.Ghost, ControlSize.Default), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(24f),
					GUILayout.Height(24f)
				}))
				{
					Close();
				}
				layoutComponents.EndHorizontalGroup();
				GUILayout.Space(16f);
				content?.Invoke();
				if (footer != null)
				{
					GUILayout.Space(16f);
					layoutComponents.BeginHorizontalGroup();
					GUILayout.FlexibleSpace();
					footer?.Invoke();
					layoutComponents.EndHorizontalGroup();
				}
				GUILayout.EndVertical();
			}
		}

		public bool DrawDialogTrigger(string label, ControlVariant variant = ControlVariant.Default, ControlSize size = ControlSize.Default)
		{
			return guiHelper.Button(label, variant, size, null, false, 1f);
		}

		public void DrawDialogHeader(string title, string description = null)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			layoutComponents.BeginVerticalGroup();
			if (!string.IsNullOrEmpty(title))
			{
				UnityHelpers.Label(title, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default, ControlSize.Large));
			}
			if (!string.IsNullOrEmpty(description))
			{
				UnityHelpers.Label(description, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Muted));
			}
			layoutComponents.EndVerticalGroup();
		}

		public void DrawDialogContent(Action content)
		{
			layoutComponents.BeginVerticalGroup();
			content?.Invoke();
			layoutComponents.EndVerticalGroup();
		}

		public void DrawDialogFooter(Action footer)
		{
			layoutComponents.BeginHorizontalGroup();
			GUILayout.FlexibleSpace();
			footer?.Invoke();
			layoutComponents.EndHorizontalGroup();
		}

		private void DrawOverlay()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = ThemeManager.Instance.CurrentTheme.Overlay;
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}
	}
	public class Label : BaseComponent
	{
		public Label(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawLabel(string text, ControlVariant variant = ControlVariant.Default, bool disabled = false, params GUILayoutOption[] options)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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)
			GUIStyle labelStyle = guiHelper.GetStyleManager().GetLabelStyle(variant);
			GUIStyle val = new UnityHelpers.GUIStyle(labelStyle);
			val.fontSize = Mathf.RoundToInt((float)labelStyle.fontSize * guiHelper.uiScale);
			if (disabled)
			{
				Color textColor = default(Color);
				((Color)(ref textColor))..ctor(labelStyle.normal.textColor.r, labelStyle.normal.textColor.g, labelStyle.normal.textColor.b, 0.7f);
				val.normal.textColor = textColor;
			}
			GUILayoutOption[] autoScaledOptions = GetAutoScaledOptions(options);
			UnityHelpers.Label(text ?? "", val, autoScaledOptions);
		}

		public void DrawLabel(Rect rect, string text, ControlVariant variant = ControlVariant.Default, bool disabled = false)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle labelStyle = guiHelper.GetStyleManager().GetLabelStyle(variant);
			Rect val = new Rect(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale);
			GUIStyle val2 = new UnityHelpers.GUIStyle(labelStyle);
			val2.fontSize = Mathf.RoundToInt((float)labelStyle.fontSize * guiHelper.uiScale);
			if (disabled)
			{
				Color textColor = default(Color);
				((Color)(ref textColor))..ctor(labelStyle.normal.textColor.r, labelStyle.normal.textColor.g, labelStyle.normal.textColor.b, 0.7f);
				val2.normal.textColor = textColor;
			}
			GUI.Label(val, text ?? "", val2);
		}

		public void SecondaryLabel(string text, params GUILayoutOption[] options)
		{
			DrawLabel(text, ControlVariant.Secondary, disabled: false, options);
		}

		public void MutedLabel(string text, params GUILayoutOption[] options)
		{
			DrawLabel(text, ControlVariant.Muted, disabled: false, options);
		}

		public void DestructiveLabel(string text, params GUILayoutOption[] options)
		{
			DrawLabel(text, ControlVariant.Destructive, disabled: false, options);
		}

		private GUILayoutOption[] GetAutoScaledOptions(GUILayoutOption[] userOptions)
		{
			if (userOptions == null || userOptions.Length == 0)
			{
				return (GUILayoutOption[])(object)new GUILayoutOption[0];
			}
			return userOptions;
		}
	}
	public class Popover : BaseComponent
	{
		private bool isOpen;

		public bool IsOpen => isOpen;

		public Popover(GUIHelper helper)
			: base(helper)
		{
		}

		public void Open()
		{
			isOpen = true;
		}

		public void Close()
		{
			isOpen = false;
		}

		public void DrawPopover(Action content)
		{
			if (isOpen)
			{
				layoutComponents.BeginVerticalGroup(guiHelper.GetStyleManager().GetPopoverContentStyle(), GUILayout.MaxWidth(300f), GUILayout.MaxHeight(200f));
				content?.Invoke();
				GUILayout.EndVertical();
			}
		}
	}
	public class Progress : BaseComponent
	{
		public Progress(GUIHelper helper)
			: base(helper)
		{
		}

		public void DrawProgress(float value, float width = -1f, float height = -1f, params GUILayoutOption[] options)
		{
			//IL_00b2: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			value = Mathf.Clamp01(value);
			float num = ((height > 0f) ? (height * guiHelper.uiScale) : (8f * guiHelper.uiScale));
			float num2 = ((width > 0f) ? (width * guiHelper.uiScale) : (-1f));
			List<GUILayoutOption> list = new List<GUILayoutOption>();
			list.Add(GUILayout.Height(num));
			if (num2 > 0f)
			{
				list.Add(GUILayout.Width(num2));
			}
			else
			{
				list.Add(GUILayout.ExpandWidth(true));
			}
			if (options != null && options.Length != 0)
			{
				list.AddRange(options);
			}
			Rect rect = GUILayoutUtility.GetRect(GUIContent.none, styleManager.GetProgressBarStyle(), list.ToArray());
			GUI.Box(rect, GUIContent.none, styleManager.GetProgressBarStyle());
			if (value > 0f)
			{
				GUI.Box(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * value, ((Rect)(ref rect)).height), GUIContent.none, styleManager.GetProgressBarStyle(ControlVariant.Secondary));
			}
		}

		public void DrawProgress(Rect rect, float value)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			StyleManager styleManager = guiHelper.GetStyleManager();
			value = Mathf.Clamp01(value);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x * guiHelper.uiScale, ((Rect)(ref rect)).y * guiHelper.uiScale, ((Rect)(ref rect)).width * guiHelper.uiScale, ((Rect)(ref rect)).height * guiHelper.uiScale);
			GUI.Box(val, GUIContent.none, styleManager.GetProgressBarStyle());
			if (value > 0f)
			{
				GUI.Box(new Rect(((Rect)(ref val)).x, ((Rect)(ref val)).y, ((Rect)(ref val)).width * value, ((Rect)(ref val)).height), GUIContent.none, styleManager.GetProgressBarStyle(ControlVariant.Secondary));
			}
		}

		public void LabeledProgress(string label, float value, float width = -1f, float height = -1f, bool showPercentage = true, params GUILayoutOption[] options)
		{
			StyleManager styleManager = guiHelper.GetStyleManager();
			if (!string.IsNullOrEmpty(label))
			{
				layoutComponents.BeginHorizontalGroup();
				UnityHelpers.Label(label, (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Default));
				if (showPercentage)
				{
					GUILayout.FlexibleSpace();
					UnityHelpers.Label((value * 100f).ToString("F0") + "%", (UnityHelpers.GUIStyle)styleManager.GetLabelStyle(ControlVariant.Muted));
				}
				layoutComponents.EndHorizontalGroup();
				layoutComponents.AddSpace(4f);
			}
			DrawProgress(value, width, height, options);
		}

		public void CircularProgress(float value, float size = 32f, params GUILayoutOption[] options)
		{
			//IL_0052: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			value = Mathf.Clamp01(value);
			float num = size * guiHelper.uiScale;
			List<GUILayoutOption> list = new List<GUILayoutOption>();
			list.Add(GUILayout.Width(num));
			list.Add(GUILayout.Height(num));
			if (options != null && options.Length != 0)
			{
				list.AddRange(options);
			}
			Rect rect = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, list.ToArray());
			StyleManager styleManager = guiHelper.GetStyleManager();
			GUI.Box(rect, GUIContent.none, styleManager.GetProgressBarStyle());
			if (!(value > 0f))
			{
				return;
			}
			int num2 = Mathf.RoundToInt(value * 8f);
			Rect val = default(Rect);
			for (int i = 0; i < num2; i++)
			{
				_ = (float)i / 8f;
				((Rect)(ref val))..ctor(((Rect)(ref rect)).x + ((Rect)(ref rect)).width * 0.1f, ((Rect)(ref rect)).y + ((Rect)(ref rect)).height * 0.1f, ((Rect)(ref rect)).width * 0.8f, ((Rect)(ref rect)).height * 0.8f);
				if (i < num2)
				{
					GUI.Box(val, GUIContent.none, styleManager.GetProgressBarStyle(ControlVariant.Secon