using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SimpleCommand.API.Classes;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SimpleCommand.API")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("API for simple command creation.")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2")]
[assembly: AssemblyProduct("SimpleCommand.API")]
[assembly: AssemblyTitle("SimpleCommand.API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SimpleCommand.API
{
	[BepInPlugin("SimpleCommand.API", "SimpleCommand.API", "1.0.2")]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> ConfigSimpleCommandSortCommands;

		public static ConfigEntry<bool> ConfigSimpleCommandLogging;

		public static ManualLogSource Log;

		private readonly Harmony _harmony = new Harmony("SimpleCommand.API");

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			ConfigSimpleCommandSortCommands = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SortCommandsAlphabetically", false, "By default, commands are sorted by plugin. Set the value to 'true' if you want them to be sorted alphabetically.");
			ConfigSimpleCommandLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Developer", "EnableDebugLogging", false, "Enables logging of every SimpleCommand.API action.");
			if (ConfigSimpleCommandLogging.Value)
			{
				Log.LogDebug((object)"Debug Logging enabled. Logging..");
				if (ConfigSimpleCommandSortCommands.Value)
				{
					Log.LogDebug((object)"List of commands is now sorted alphabetically.");
				}
			}
			_harmony.PatchAll();
			PrepareSetup();
			Log.LogInfo((object)"Plugin SimpleCommand.API is loaded!");
		}

		private void PrepareSetup()
		{
			SimpleCommandModule simpleCommandModule = new SimpleCommandModule();
			simpleCommandModule.DisplayName = "modcommands";
			simpleCommandModule.HideFromCommandList = true;
			simpleCommandModule.HasDynamicInput = true;
			simpleCommandModule.Method = ShowModCommands;
			simpleCommandModule.Abbreviations = new string[3] { "mdc", "modc", "modcmds" };
			SimpleCommandModule module = simpleCommandModule;
			SimpleCommand.AddSimpleCommand(module);
		}

		private static TerminalNode ShowModCommands(Terminal __instance)
		{
			string text = "All available mod commands: \n";
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.clearPreviousText = true;
			string s = SimpleCommand.GetInputValue(__instance, 1)[0];
			int num = 1;
			int num2 = 1;
			if (int.TryParse(s, out var result))
			{
				num = ((result <= 1) ? 1 : result);
			}
			if (SimpleCommand.SimpleCommandDictionary != null && SimpleCommand.SimpleCommandDictionary.Count > 0)
			{
				num2 = SimpleCommand.SimpleCommandDictionary.Last().Key;
				if (num > num2)
				{
					num = num2;
				}
				if (SimpleCommand.SimpleCommandDictionary.TryGetValue(num, out var value))
				{
					text = value.Where((string str) => !string.IsNullOrEmpty(str)).Aggregate(text, (string current, string str) => current + str);
				}
			}
			text = text + "\nPage " + num + " of " + num2 + "\n";
			val.displayText = text;
			return val;
		}
	}
	public static class SimpleCommand
	{
		internal static List<SimpleCommandModule> SimpleCommandList = new List<SimpleCommandModule>();

		internal static SortedDictionary<int, List<string>> SimpleCommandDictionary = new SortedDictionary<int, List<string>>();

		public static void AddSimpleCommand(SimpleCommandModule module)
		{
			if (module.DisplayName != null)
			{
				SimpleCommandList.Add(module);
				if (Plugin.ConfigSimpleCommandLogging.Value)
				{
					Plugin.Log.LogDebug((object)("Module " + module.DisplayName + " was successfully registered by SimpleCommand.API."));
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)"Warning, DisplayName of module not assigned. Module will not load!");
			}
		}

		public static void AddSimpleCommands(SimpleCommandModule[] modules)
		{
			foreach (SimpleCommandModule module in modules)
			{
				AddSimpleCommand(module);
			}
		}

		public static string RemovePunctuation(string s)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (char c in s)
			{
				if (!char.IsPunctuation(c))
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().ToLower();
		}

		public static string GetInputValue(Terminal terminal)
		{
			string text = RemovePunctuation(terminal.screenText.text.Substring(terminal.screenText.text.Length - terminal.textAdded));
			if (Plugin.ConfigSimpleCommandLogging.Value)
			{
				Plugin.Log.LogDebug((object)("GetInputValue:" + text));
			}
			return text;
		}

		public static string[] GetInputValue(Terminal terminal, int index)
		{
			string text = RemovePunctuation(terminal.screenText.text.Substring(terminal.screenText.text.Length - terminal.textAdded));
			string[] array = text.Split(" ");
			string[] array2 = array.Skip(Math.Max(0, array.Length - index)).Take(index).ToArray();
			if (Plugin.ConfigSimpleCommandLogging.Value)
			{
				int num = 1;
				Plugin.Log.LogDebug((object)"GetInputValue Array:");
				string[] array3 = array2;
				foreach (string text2 in array3)
				{
					Plugin.Log.LogDebug((object)(num + ": " + text2));
					num++;
				}
			}
			return array2;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "SimpleCommand.API";

		public const string PLUGIN_NAME = "SimpleCommand.API";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace SimpleCommand.API.Patches
{
	[HarmonyPatch(typeof(Terminal))]
	public class SimpleCommandPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void PatchAwake(ref Terminal __instance)
		{
			TMP_InputField screenText = __instance.screenText;
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			int num = 1;
			int num2 = 0;
			if (Plugin.ConfigSimpleCommandLogging.Value)
			{
				Plugin.Log.LogDebug((object)"Patching Terminal Awake");
			}
			if ((Object)(object)__instance.terminalNodes.specialNodes[13] != (Object)null)
			{
				if (Plugin.ConfigSimpleCommandLogging.Value)
				{
					Plugin.Log.LogDebug((object)"Editing SpecialNode 13");
				}
				TerminalNode val = __instance.terminalNodes.specialNodes[13];
				string displayText = val.displayText;
				string text = displayText.Substring(0, displayText.Length - 23);
				string displayText2 = val.displayText;
				int length = displayText2.Length;
				int num3 = length - 23;
				val.displayText = text + ">MODCOMMANDS [page] (short. mdc, modc, modcmds)\nTo see a list of all SimpleCommand.API commands." + displayText2.Substring(num3, length - num3);
			}
			if (SimpleCommand.SimpleCommandList == null || SimpleCommand.SimpleCommandList.Count <= 0)
			{
				return;
			}
			foreach (SimpleCommandModule simpleCommand in SimpleCommand.SimpleCommandList)
			{
				if (!simpleCommand.HideFromCommandList)
				{
					string text2 = "";
					text2 = text2 + "\n>" + simpleCommand.DisplayName.ToUpper();
					if (simpleCommand.Arguments != null && simpleCommand.HasDynamicInput)
					{
						string[] arguments = simpleCommand.Arguments;
						foreach (string text3 in arguments)
						{
							text2 = text2 + " [" + text3.ToLower() + "]";
						}
					}
					if (simpleCommand.Abbreviations != null)
					{
						text2 += " (short. ";
						string[] abbreviations = simpleCommand.Abbreviations;
						foreach (string text4 in abbreviations)
						{
							text2 = text2 + text4.ToLower() + ", ";
						}
						text2 = text2.Substring(0, text2.Length - 2) + ")";
					}
					text2 += "\n";
					if (simpleCommand.Description != null)
					{
						text2 = text2 + simpleCommand.Description + "\n";
					}
					list.Add(text2);
				}
				if (simpleCommand.ChildrenModules != null)
				{
					SimpleCommandModule[] childrenModules = simpleCommand.ChildrenModules;
					foreach (SimpleCommandModule module in childrenModules)
					{
						AddChildrenToList(module, simpleCommand.DisplayName.ToUpper(), list);
					}
				}
			}
			if (Plugin.ConfigSimpleCommandSortCommands.Value)
			{
				list.Sort();
			}
			if (Plugin.ConfigSimpleCommandLogging.Value)
			{
				Plugin.Log.LogDebug((object)"Creating SimpleCommandDictionary");
			}
			SimpleCommand.SimpleCommandDictionary = new SortedDictionary<int, List<string>>();
			foreach (string item5 in list)
			{
				int num4 = Mathf.CeilToInt((float)screenText.textComponent.GetTextInfo(item5).lineCount);
				if (num2 + num4 <= 16)
				{
					list2.Add(item5);
					num2 += num4;
					continue;
				}
				int num5 = 16 - num2;
				if (num5 > 0)
				{
					string item = new string('\n', num5);
					list2.Add(item);
				}
				SimpleCommand.SimpleCommandDictionary.TryAdd(num, list2);
				list2 = new List<string> { item5 };
				num2 = num4;
				num++;
			}
			if (list2.Count > 0)
			{
				int num6 = 16 - num2;
				if (num6 > 0)
				{
					string item2 = new string('\n', num6);
					list2.Add(item2);
				}
				SimpleCommand.SimpleCommandDictionary.TryAdd(num, list2);
			}
			else if (list2.Count == 0)
			{
				string item3 = "\n [ERROR] No commands added to list..\n";
				string item4 = new string('\n', 14);
				list2.Add(item3);
				list2.Add(item4);
				SimpleCommand.SimpleCommandDictionary.TryAdd(num, list2);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnSubmit")]
		private static bool PatchSubmit(ref Terminal __instance)
		{
			if (__instance.terminalInUse && __instance.textAdded != 0 && SimpleCommand.SimpleCommandList != null && SimpleCommand.SimpleCommandList.Count > 0)
			{
				string text = SimpleCommand.RemovePunctuation(__instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded));
				string[] screenTextArray = text.Split(" ", StringSplitOptions.RemoveEmptyEntries);
				foreach (SimpleCommandModule simpleCommand in SimpleCommand.SimpleCommandList)
				{
					if (text.Replace(" ", "") == "")
					{
						break;
					}
					if (simpleCommand.DisplayName != null && screenTextArray[0].Replace(" ", "").Equals(simpleCommand.DisplayName.ToLower()))
					{
						if (simpleCommand.IgnoreModule)
						{
							return true;
						}
						if (__instance.terminalNodes.allKeywords.Any((TerminalKeyword keyword) => keyword.word.Equals(screenTextArray[0].Replace(" ", ""))))
						{
							Plugin.Log.LogWarning((object)(screenTextArray[0].Replace(" ", "") + " already exists as a default terminal keyword. This might cause issues."));
						}
						if (Plugin.ConfigSimpleCommandLogging.Value)
						{
							Plugin.Log.LogDebug((object)("Player submitted sentence: " + text));
						}
						if (screenTextArray.Length > 1)
						{
							if (simpleCommand.HasDynamicInput)
							{
								if (simpleCommand.Method != null)
								{
									__instance.LoadNewNode(simpleCommand.Method(__instance));
									if (Plugin.ConfigSimpleCommandLogging.Value)
									{
										Plugin.Log.LogDebug((object)("Method from module " + simpleCommand.DisplayName + " successfully invoked."));
									}
									LoadNecessarySubmitActions(__instance);
									return false;
								}
								Plugin.Log.LogDebug((object)("No Method found for module " + simpleCommand.DisplayName));
							}
							else
							{
								if (simpleCommand.ChildrenModules == null)
								{
									continue;
								}
								SimpleCommandModule[] childrenModules = simpleCommand.ChildrenModules;
								foreach (SimpleCommandModule module in childrenModules)
								{
									if (IterateThroughChildren(module, __instance, screenTextArray, 1))
									{
										LoadNecessarySubmitActions(__instance);
										return false;
									}
								}
							}
							continue;
						}
						if (simpleCommand.Method != null)
						{
							__instance.LoadNewNode(simpleCommand.Method(__instance));
							if (Plugin.ConfigSimpleCommandLogging.Value)
							{
								Plugin.Log.LogDebug((object)("Method from module " + simpleCommand.DisplayName + " successfully invoked."));
							}
							LoadNecessarySubmitActions(__instance);
							return false;
						}
						Plugin.Log.LogDebug((object)("No Method found for module " + simpleCommand.DisplayName));
					}
					else
					{
						if (simpleCommand.Abbreviations == null)
						{
							continue;
						}
						string[] abbreviations = simpleCommand.Abbreviations;
						foreach (string value in abbreviations)
						{
							if (!screenTextArray[0].Replace(" ", "").Equals(value))
							{
								continue;
							}
							if (Plugin.ConfigSimpleCommandLogging.Value)
							{
								Plugin.Log.LogDebug((object)("Player submitted sentence: " + text));
							}
							if (screenTextArray.Length > 1)
							{
								if (simpleCommand.HasDynamicInput)
								{
									if (simpleCommand.Method != null)
									{
										__instance.LoadNewNode(simpleCommand.Method(__instance));
										if (Plugin.ConfigSimpleCommandLogging.Value)
										{
											Plugin.Log.LogDebug((object)("Method from module " + simpleCommand.DisplayName + " successfully invoked."));
										}
										LoadNecessarySubmitActions(__instance);
										return false;
									}
									Plugin.Log.LogDebug((object)("No Method found for module " + simpleCommand.DisplayName));
								}
								else
								{
									if (simpleCommand.ChildrenModules == null)
									{
										continue;
									}
									SimpleCommandModule[] childrenModules2 = simpleCommand.ChildrenModules;
									foreach (SimpleCommandModule module2 in childrenModules2)
									{
										if (IterateThroughChildren(module2, __instance, screenTextArray, 1))
										{
											LoadNecessarySubmitActions(__instance);
											return false;
										}
									}
								}
								continue;
							}
							if (simpleCommand.Method != null)
							{
								__instance.LoadNewNode(simpleCommand.Method(__instance));
								if (Plugin.ConfigSimpleCommandLogging.Value)
								{
									Plugin.Log.LogDebug((object)("Method from module " + simpleCommand.DisplayName + " successfully invoked."));
								}
								LoadNecessarySubmitActions(__instance);
								return false;
							}
							Plugin.Log.LogDebug((object)("No Method found for module " + simpleCommand.DisplayName));
						}
					}
				}
			}
			return true;
		}

		private static bool IterateThroughChildren(SimpleCommandModule module, Terminal instance, string[] screenTextArray, int count)
		{
			if (module.IgnoreModule)
			{
				return false;
			}
			if (screenTextArray[count].Replace(" ", "").Equals(module.DisplayName))
			{
				if (module.HasDynamicInput && module.Method != null)
				{
					instance.LoadNewNode(module.Method(instance));
					if (Plugin.ConfigSimpleCommandLogging.Value)
					{
						Plugin.Log.LogDebug((object)("Method from module " + module.DisplayName + " successfully invoked."));
					}
					return true;
				}
				if (module.ChildrenModules != null)
				{
					SimpleCommandModule[] childrenModules = module.ChildrenModules;
					foreach (SimpleCommandModule module2 in childrenModules)
					{
						IterateThroughChildren(module2, instance, screenTextArray, count + 1);
					}
				}
				else if (module.Method != null)
				{
					instance.LoadNewNode(module.Method(instance));
					if (Plugin.ConfigSimpleCommandLogging.Value)
					{
						Plugin.Log.LogDebug((object)("Method from module " + module.DisplayName + " successfully invoked."));
					}
					return true;
				}
			}
			else if (module.Abbreviations != null)
			{
				string[] abbreviations = module.Abbreviations;
				foreach (string value in abbreviations)
				{
					if (!screenTextArray[count].Replace(" ", "").Equals(value))
					{
						continue;
					}
					if (module.HasDynamicInput && module.Method != null)
					{
						instance.LoadNewNode(module.Method(instance));
						if (Plugin.ConfigSimpleCommandLogging.Value)
						{
							Plugin.Log.LogDebug((object)("Method from module " + module.DisplayName + " successfully invoked."));
						}
						return true;
					}
					if (module.ChildrenModules != null)
					{
						SimpleCommandModule[] childrenModules2 = module.ChildrenModules;
						foreach (SimpleCommandModule module3 in childrenModules2)
						{
							IterateThroughChildren(module3, instance, screenTextArray, count + 1);
						}
					}
					else if (module.Method != null)
					{
						instance.LoadNewNode(module.Method(instance));
						if (Plugin.ConfigSimpleCommandLogging.Value)
						{
							Plugin.Log.LogDebug((object)("Method from module " + module.DisplayName + " successfully invoked."));
						}
						return true;
					}
				}
			}
			return false;
		}

		private static void AddChildrenToList(SimpleCommandModule module, string nestedString, List<string> commands)
		{
			string text = nestedString + " " + module.DisplayName.ToUpper();
			if (!module.HideFromCommandList)
			{
				string text2 = "\n>" + text;
				if (module.Arguments != null && module.HasDynamicInput)
				{
					string[] arguments = module.Arguments;
					foreach (string text3 in arguments)
					{
						text2 = text2 + " [" + text3.ToLower() + "]";
					}
				}
				if (module.Abbreviations != null)
				{
					text2 += " (short. ";
					string[] abbreviations = module.Abbreviations;
					foreach (string text4 in abbreviations)
					{
						text2 = text2 + text4.ToLower() + ", ";
					}
					string text5 = text2;
					text2 = text5.Substring(0, text5.Length - 2) + ")";
				}
				text2 += "\n";
				if (module.Description != null)
				{
					text2 = text2 + module.Description + "\n";
				}
				commands.Add(text2);
			}
			if (module.ChildrenModules != null)
			{
				SimpleCommandModule[] childrenModules = module.ChildrenModules;
				foreach (SimpleCommandModule module2 in childrenModules)
				{
					AddChildrenToList(module2, text, commands);
				}
			}
		}

		private static void LoadNecessarySubmitActions(Terminal instance)
		{
			if (Plugin.ConfigSimpleCommandLogging.Value)
			{
				Plugin.Log.LogDebug((object)"Loading necessary actions after Method submit.");
			}
			instance.screenText.text = instance.screenText.text.Substring(0, instance.screenText.text.Length - instance.textAdded);
			instance.currentText = instance.screenText.text;
			instance.textAdded = 0;
			instance.screenText.ActivateInputField();
			((Selectable)instance.screenText).Select();
		}
	}
}
namespace SimpleCommand.API.Classes
{
	public class SimpleCommandModule
	{
		public string DisplayName { get; set; }

		public string Description { get; set; }

		public string[] Abbreviations { get; set; }

		public string[] Arguments { get; set; }

		public bool HasDynamicInput { get; set; }

		public bool HideFromCommandList { get; set; }

		public bool IgnoreModule { get; set; }

		public Func<Terminal, TerminalNode> Method { get; set; }

		public SimpleCommandModule[] ChildrenModules { get; set; }
	}
}