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 BepInEx;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
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(".NETFramework,Version=v4.6", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("LethalTerminalExtender")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+b193c9c48840b420c2907190433c67f83cfd430d")]
[assembly: AssemblyProduct("LethalTerminalExtender")]
[assembly: AssemblyTitle("LethalTerminalExtender")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.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 LethalTerminalExtender
{
	[BepInPlugin("us.domkalan.lethalextendedterminal", "Lethal Extended Terminal", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string GUID = "us.domkalan.lethalextendedterminal";

		public const string NAME = "Lethal Extended Terminal";

		public const string VERSION = "1.1.0";

		public static Plugin instance;

		private void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			instance = this;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin LethalTerminalExtender is loaded!");
			Harmony val = new Harmony("us.domkalan.lethalextendedterminal");
			val.PatchAll(Assembly.GetExecutingAssembly());
		}

		public void Log(LogType type, string contents)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)contents);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LethalTerminalExtender";

		public const string PLUGIN_NAME = "LethalTerminalExtender";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}
namespace LethalTerminalExtender.Patches
{
	public struct TerminalCustomCommand
	{
		public TerminalNode node;

		public TerminalKeyword keyword;

		[CanBeNull]
		public Action<Terminal, TerminalNode> callback;
	}
	public static class TerminalExtenderUtils
	{
		private static List<TerminalCustomCommand> commands = new List<TerminalCustomCommand>();

		private static Terminal terminalInstance = null;

		private static Action<string> currentStapleCommand = null;

		private static bool stapleNoticeShown = false;

		private static TerminalNode blankNodeInstance;

		private static TerminalNode customTextNodeInstance;

		public static bool terminalConnected
		{
			get
			{
				return (Object)(object)terminalInstance != (Object)null;
			}
			set
			{
				throw new Exception("Can not set this!");
			}
		}

		public static bool currentStapleCommandPresent => currentStapleCommand != null;

		public static void addCustomCommand(TerminalCustomCommand custComm)
		{
			commands.Add(custComm);
		}

		public static TerminalCustomCommand addQuickCommand(string keyword, string displayText, bool clearsText = false, Action<Terminal, TerminalNode> callback = null)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)val).name = keyword + "Node";
			val.displayText = displayText;
			val.clearPreviousText = clearsText;
			val.terminalEvent = keyword + "Event";
			TerminalKeyword val2 = ScriptableObject.CreateInstance<TerminalKeyword>();
			((Object)val2).name = keyword + "Keyword";
			val2.word = keyword;
			val2.specialKeywordResult = val;
			TerminalCustomCommand terminalCustomCommand = default(TerminalCustomCommand);
			terminalCustomCommand.keyword = val2;
			terminalCustomCommand.node = val;
			terminalCustomCommand.callback = callback;
			TerminalCustomCommand terminalCustomCommand2 = terminalCustomCommand;
			addCustomCommand(terminalCustomCommand2);
			return terminalCustomCommand2;
		}

		public static void setOnSubmit(Action<string> action)
		{
			if (!stapleNoticeShown)
			{
				stapleNoticeShown = true;
				HUDManager.Instance.DisplayTip("TERMINAL EXTENDER", "This command is from a mod, it may change the default functionality of the terminal.", false, false, "LC_Tip1");
			}
			currentStapleCommand = action;
		}

		public static void releaseOnSubmit()
		{
			currentStapleCommand = null;
		}

		public static void emitOnSubmit(string text)
		{
			currentStapleCommand(text);
		}

		public static void setInputState(bool inputToggle)
		{
			if (inputToggle)
			{
				((Selectable)terminalInstance.screenText).interactable = true;
				terminalInstance.screenText.ActivateInputField();
				((Selectable)terminalInstance.screenText).Select();
			}
			if (!inputToggle)
			{
				((Selectable)terminalInstance.screenText).interactable = false;
				terminalInstance.screenText.DeactivateInputField(false);
			}
		}

		public static void playAudioClip(int clipIndex)
		{
			terminalInstance.PlayTerminalAudioServerRpc(clipIndex);
		}

		public static void cleanTerminalScreen()
		{
			terminalInstance.LoadNewNode(blankNodeInstance);
		}

		public static void writeToTerminal(string text, bool cleanScreen = false)
		{
			Plugin.instance.Log((LogType)3, text + "\n\n is " + text.Length);
			customTextNodeInstance.clearPreviousText = cleanScreen;
			customTextNodeInstance.displayText = "\n" + text;
			terminalInstance.LoadNewNode(customTextNodeInstance);
		}

		public static void displayNodeOnTerminal(TerminalNode node)
		{
			terminalInstance.LoadNewNode(node);
		}

		public static bool handleNodeEvents(TerminalNode node)
		{
			TerminalCustomCommand[] array = commands.ToArray();
			TerminalCustomCommand[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				TerminalCustomCommand terminalCustomCommand = array2[i];
				if ((Object)(object)terminalCustomCommand.node == (Object)(object)node)
				{
					if (terminalCustomCommand.callback != null)
					{
						terminalCustomCommand.callback(terminalInstance, node);
						return false;
					}
					break;
				}
			}
			return true;
		}

		public static TerminalKeyword[] getKeywords()
		{
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[commands.Count];
			for (int i = 0; i < commands.Count; i++)
			{
				array[i] = commands[i].keyword;
			}
			return array;
		}

		public static TerminalKeyword handleKeywordCommand(string typedKeyword)
		{
			TerminalKeyword[] keywords = getKeywords();
			foreach (TerminalKeyword val in keywords)
			{
				if (val.word == typedKeyword)
				{
					return val;
				}
			}
			return null;
		}

		public static bool handleTerminalSubmit()
		{
			if (currentStapleCommandPresent)
			{
				Plugin.instance.Log((LogType)3, "Staple mode is active!");
				string text = terminalInstance.RemovePunctuation(terminalInstance.screenText.text.Substring(terminalInstance.screenText.text.Length - terminalInstance.textAdded));
				Plugin.instance.Log((LogType)3, "Request to parse command in staple mode: " + text);
				emitOnSubmit(text);
				return false;
			}
			return true;
		}

		public static void handleTerminalQuit()
		{
			if (currentStapleCommandPresent)
			{
				releaseOnSubmit();
			}
		}

		public static void connectToTerminal(Terminal terminal)
		{
			if ((Object)(object)terminalInstance != (Object)null)
			{
				return;
			}
			terminalInstance = terminal;
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)val).name = "blankNode";
			val.displayText = "";
			val.clearPreviousText = true;
			blankNodeInstance = val;
			terminalInstance.terminalNodes.terminalNodes.Add(val);
			TerminalNode val2 = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)val2).name = "textNode";
			val2.displayText = "Hello world!";
			val2.clearPreviousText = false;
			customTextNodeInstance = val2;
			terminalInstance.terminalNodes.terminalNodes.Add(val2);
			foreach (TerminalCustomCommand command in commands)
			{
				if (!terminalInstance.terminalNodes.terminalNodes.Contains(command.node))
				{
					terminalInstance.terminalNodes.terminalNodes.Add(command.node);
				}
				if (terminalInstance.terminalNodes.allKeywords.Contains(command.keyword))
				{
					CollectionExtensions.AddToArray<TerminalKeyword>(terminalInstance.terminalNodes.allKeywords, command.keyword);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "RunTerminalEvents")]
	public class TerminalExtender_HandleNodeEvent
	{
		public static bool Prefix(Terminal __instance, TerminalNode node)
		{
			if (!TerminalExtenderUtils.terminalConnected)
			{
				TerminalExtenderUtils.connectToTerminal(__instance);
			}
			return TerminalExtenderUtils.handleNodeEvents(node);
		}
	}
	[HarmonyPatch(typeof(Terminal), "CheckForExactSentences")]
	public class TerminalExtender_KeywordCheck
	{
		public static void Postfix(Terminal __instance, string playerWord, ref TerminalKeyword __result)
		{
			if (!TerminalExtenderUtils.terminalConnected)
			{
				TerminalExtenderUtils.connectToTerminal(__instance);
			}
			if ((Object)(object)__result == (Object)null)
			{
				Plugin.instance.Log((LogType)3, "request to parse command " + playerWord);
				__result = TerminalExtenderUtils.handleKeywordCommand(playerWord);
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "OnSubmit")]
	public class TerminalExtender_OnSubmit
	{
		public static bool Prefix(Terminal __instance)
		{
			if (!TerminalExtenderUtils.terminalConnected)
			{
				TerminalExtenderUtils.connectToTerminal(__instance);
			}
			return TerminalExtenderUtils.handleTerminalSubmit();
		}
	}
	[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
	public class TerminalExtender_QuitTerminal
	{
		public static void Prefix(Terminal __instance)
		{
			if (!TerminalExtenderUtils.terminalConnected)
			{
				TerminalExtenderUtils.connectToTerminal(__instance);
			}
			TerminalExtenderUtils.handleTerminalQuit();
		}
	}
}