using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PersistentTerminal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Terminal remembers your last screen")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0")]
[assembly: AssemblyProduct("PersistentTerminal")]
[assembly: AssemblyTitle("PersistentTerminal")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.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 PersistentTerminal
{
	[BepInPlugin("mrbub.persistentterminal", "PersistentTerminal", "1.3.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static ConfigEntry<string> TerminalTheme;

		public static ConfigEntry<string> CustomTextColor;

		public static ConfigEntry<string> CustomBackgroundColor;

		public static ConfigEntry<string> CustomScreenLightColor;

		public static ConfigEntry<bool> AlwaysOnScreen;

		public static ConfigEntry<bool> AlwaysOnLight;

		private void Awake()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			TerminalTheme = ((BaseUnityPlugin)this).Config.Bind<string>("Theme", "Preset", "Default", new ConfigDescription("Terminal color theme preset.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[7] { "Default", "Green", "Amber", "Blue", "Red", "Purple", "Cyan" }), Array.Empty<object>()));
			CustomTextColor = ((BaseUnityPlugin)this).Config.Bind<string>("Custom Colors", "TextColor", "", "Custom text color in RGB format (0-255). Overrides the theme preset if set.\nExample: 0,255,0 for green\nLeave empty to use theme preset.");
			CustomBackgroundColor = ((BaseUnityPlugin)this).Config.Bind<string>("Custom Colors", "BackgroundColor", "", "Custom background color in RGB format (0-255). Overrides the theme preset if set.\nExample: 0,20,0 for dark green\nLeave empty to use theme preset.");
			CustomScreenLightColor = ((BaseUnityPlugin)this).Config.Bind<string>("Custom Colors", "ScreenLightColor", "", "Custom screen light color in RGB format (0-255). Overrides the theme preset if set.\nExample: 0,255,0 for green\nLeave empty to use theme preset.");
			AlwaysOnScreen = ((BaseUnityPlugin)this).Config.Bind<bool>("Behavior", "AlwaysOnScreen", false, "Keep the terminal screen always on, even when not in use.");
			AlwaysOnLight = ((BaseUnityPlugin)this).Config.Bind<bool>("Behavior", "AlwaysOnLight", false, "Keep the terminal light always on.");
			TerminalPresets.InitializeConfig(((BaseUnityPlugin)this).Config);
			new Harmony("mrbub.persistentterminal").PatchAll();
			Logger.LogInfo((object)"PersistentTerminal v1.3.0 loaded!");
		}
	}
	public static class TerminalPresets
	{
		public struct PresetItem
		{
			public string ItemName;

			public int Quantity;

			public int ItemIndex;

			public int UnitCost;

			public PresetItem(string name, int qty)
			{
				ItemName = name;
				Quantity = qty;
				ItemIndex = -1;
				UnitCost = 0;
			}
		}

		public static Dictionary<string, List<PresetItem>> Presets = new Dictionary<string, List<PresetItem>>(StringComparer.OrdinalIgnoreCase);

		private static string pendingPresetName = null;

		private static int pendingTotalCost = 0;

		private static List<PresetItem> pendingItems = null;

		public static ConfigEntry<string> Preset1;

		public static ConfigEntry<string> Preset2;

		public static ConfigEntry<string> Preset3;

		public static ConfigEntry<string> Preset4;

		public static ConfigEntry<string> Preset5;

		public static void InitializeConfig(ConfigFile config)
		{
			Preset1 = config.Bind<string>("Presets", "Preset1", "ESSENTIALS=flashlight:4,shovel:2,walkie-talkie:4", "Preset format: NAME=item1:qty,item2:qty,item3:qty\nItem names must match store names (case-insensitive).\nLeave empty to disable.");
			Preset2 = config.Bind<string>("Presets", "Preset2", "LIGHTS=flashlight:4,pro-flashlight:2", "Preset format: NAME=item1:qty,item2:qty,item3:qty");
			Preset3 = config.Bind<string>("Presets", "Preset3", "", "Preset format: NAME=item1:qty,item2:qty,item3:qty");
			Preset4 = config.Bind<string>("Presets", "Preset4", "", "Preset format: NAME=item1:qty,item2:qty,item3:qty");
			Preset5 = config.Bind<string>("Presets", "Preset5", "", "Preset format: NAME=item1:qty,item2:qty,item3:qty");
			ParsePresets();
		}

		public static void ParsePresets()
		{
			Presets.Clear();
			ParsePresetString(Preset1.Value);
			ParsePresetString(Preset2.Value);
			ParsePresetString(Preset3.Value);
			ParsePresetString(Preset4.Value);
			ParsePresetString(Preset5.Value);
			Plugin.Logger.LogInfo((object)$"[PRESETS] Loaded {Presets.Count} presets");
		}

		private static void ParsePresetString(string presetString)
		{
			if (string.IsNullOrWhiteSpace(presetString))
			{
				return;
			}
			try
			{
				int num = presetString.IndexOf('=');
				if (num <= 0)
				{
					Plugin.Logger.LogWarning((object)("[PRESETS] Invalid preset format (no '='): " + presetString));
					return;
				}
				string text = presetString.Substring(0, num).Trim().ToUpper();
				string text2 = presetString.Substring(num + 1);
				List<PresetItem> list = new List<PresetItem>();
				string[] array = text2.Split(',');
				for (int i = 0; i < array.Length; i++)
				{
					string text3 = array[i].Trim();
					if (string.IsNullOrEmpty(text3))
					{
						continue;
					}
					int num2 = text3.LastIndexOf(':');
					if (num2 <= 0)
					{
						Plugin.Logger.LogWarning((object)("[PRESETS] Invalid item format (no ':'): " + text3));
						continue;
					}
					string text4 = text3.Substring(0, num2).Trim();
					if (int.TryParse(text3.Substring(num2 + 1).Trim(), out var result) && result > 0)
					{
						list.Add(new PresetItem(text4, result));
						Plugin.Logger.LogInfo((object)$"[PRESETS] Parsed item: {text4} x{result}");
					}
				}
				if (list.Count > 0)
				{
					Presets[text] = list;
					Plugin.Logger.LogInfo((object)$"[PRESETS] Added preset '{text}' with {list.Count} items");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[PRESETS] Error parsing preset '" + presetString + "': " + ex.Message));
			}
		}

		public static bool TryHandlePresetCommand(Terminal terminal, string input, out string response)
		{
			response = null;
			string text = input.Trim();
			input = text.ToUpper();
			if (string.IsNullOrEmpty(input))
			{
				return false;
			}
			if (pendingPresetName != null)
			{
				if ("CONFIRM".StartsWith(input) || "YES".StartsWith(input) || input == "Y")
				{
					response = ExecutePendingPreset(terminal, text);
					return true;
				}
				if ("DENY".StartsWith(input) || "NO".StartsWith(input) || "CANCEL".StartsWith(input) || input == "N")
				{
					_ = pendingPresetName;
					pendingPresetName = null;
					pendingItems = null;
					pendingTotalCost = 0;
					response = ">" + text.ToUpper() + "\n\nCancelled order.\n\n";
					return true;
				}
			}
			if (input.Length >= 2 && ("PRESETS".StartsWith(input) || "PRESET".StartsWith(input)))
			{
				pendingPresetName = null;
				pendingItems = null;
				pendingTotalCost = 0;
				response = GeneratePresetsListText(terminal, text);
				return true;
			}
			if (input.Length >= 2)
			{
				foreach (KeyValuePair<string, List<PresetItem>> preset in Presets)
				{
					if (preset.Key.StartsWith(input))
					{
						response = GeneratePresetConfirmation(terminal, preset.Key, preset.Value, text);
						return true;
					}
				}
			}
			if (input.StartsWith("BUY ") && input.Length > 5)
			{
				string value = input.Substring(4).Trim();
				foreach (KeyValuePair<string, List<PresetItem>> preset2 in Presets)
				{
					if (preset2.Key.StartsWith(value))
					{
						response = GeneratePresetConfirmation(terminal, preset2.Key, preset2.Value, text);
						return true;
					}
				}
			}
			return false;
		}

		private static string GeneratePresetsListText(Terminal terminal, string originalInput)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(">" + originalInput.ToUpper() + "\n\n");
			stringBuilder.Append("Welcome to Terminal Presets.\n");
			stringBuilder.Append("Type a preset name to order in bulk.\n");
			stringBuilder.Append("Use CONFIRM and DENY to finalize.\n");
			stringBuilder.Append("________________________________________\n\n");
			if (Presets.Count == 0)
			{
				stringBuilder.Append("No presets configured.\nConfigure presets in the mod config file.\n\n");
				return stringBuilder.ToString();
			}
			foreach (KeyValuePair<string, List<PresetItem>> preset in Presets)
			{
				int num = 0;
				int num2 = 0;
				foreach (PresetItem item in preset.Value)
				{
					int num3 = FindItemIndex(terminal, item.ItemName);
					if (num3 >= 0)
					{
						int itemCost = GetItemCost(terminal, num3);
						num += itemCost * item.Quantity;
						num2 += item.Quantity;
					}
				}
				stringBuilder.Append($"* {preset.Key}  //  ${num} ({num2} items)\n");
			}
			stringBuilder.Append("\n");
			return stringBuilder.ToString();
		}

		private static string GeneratePresetConfirmation(Terminal terminal, string presetName, List<PresetItem> items, string originalInput)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(">" + originalInput.ToUpper() + "\n\n");
			int num = 0;
			int num2 = 0;
			List<PresetItem> list = new List<PresetItem>();
			bool flag = false;
			stringBuilder.Append("You have requested to order " + presetName + ":\n\n");
			foreach (PresetItem item2 in items)
			{
				int num3 = FindItemIndex(terminal, item2.ItemName);
				if (num3 >= 0)
				{
					int itemCost = GetItemCost(terminal, num3);
					int num4 = itemCost * item2.Quantity;
					num += num4;
					num2 += item2.Quantity;
					PresetItem item = new PresetItem(item2.ItemName, item2.Quantity);
					item.ItemIndex = num3;
					item.UnitCost = itemCost;
					list.Add(item);
					stringBuilder.Append($"* {item2.ItemName} x{item2.Quantity}  //  ${num4}\n");
				}
				else
				{
					stringBuilder.Append($"* {item2.ItemName} x{item2.Quantity}  //  NOT IN STORE\n");
					flag = true;
				}
			}
			stringBuilder.Append($"\nTotal: ${num}\n");
			stringBuilder.Append($"Your balance is ${terminal.groupCredits}.\n");
			if (flag)
			{
				stringBuilder.Append("\nWARNING: Some items not found in store!\n");
			}
			if (num > terminal.groupCredits)
			{
				stringBuilder.Append("\nYou could not afford these items!\n\n");
				return stringBuilder.ToString();
			}
			if (num2 + terminal.numberOfItemsInDropship > 12)
			{
				stringBuilder.Append("\nThe dropship cannot hold this many items!\n\n");
				return stringBuilder.ToString();
			}
			pendingPresetName = presetName;
			pendingTotalCost = num;
			pendingItems = list;
			stringBuilder.Append("\nPlease CONFIRM or DENY.\n\n");
			return stringBuilder.ToString();
		}

		private static string ExecutePendingPreset(Terminal terminal, string originalInput)
		{
			if (pendingItems == null || pendingPresetName == null)
			{
				return ">" + originalInput.ToUpper() + "\n\nNo pending order.\n\n";
			}
			if (pendingTotalCost > terminal.groupCredits)
			{
				ClearPending();
				return ">" + originalInput.ToUpper() + "\n\nYou could not afford these items!\n\n";
			}
			int num = 0;
			foreach (PresetItem pendingItem in pendingItems)
			{
				num += pendingItem.Quantity;
			}
			if (num + terminal.numberOfItemsInDropship > 12)
			{
				ClearPending();
				return ">" + originalInput.ToUpper() + "\n\nThe dropship cannot hold this many items!\n\n";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(">" + originalInput.ToUpper() + "\n\n");
			stringBuilder.Append("Ordered " + pendingPresetName + ":\n\n");
			foreach (PresetItem pendingItem2 in pendingItems)
			{
				if (pendingItem2.ItemIndex >= 0)
				{
					for (int i = 0; i < pendingItem2.Quantity; i++)
					{
						terminal.orderedItemsFromTerminal.Add(pendingItem2.ItemIndex);
						terminal.numberOfItemsInDropship++;
					}
					stringBuilder.Append($"* {pendingItem2.ItemName} x{pendingItem2.Quantity}\n");
				}
			}
			terminal.groupCredits -= pendingTotalCost;
			terminal.PlayTerminalAudioServerRpc(0);
			if (!((NetworkBehaviour)terminal).IsServer)
			{
				terminal.SyncGroupCreditsServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
			}
			else
			{
				typeof(Terminal).GetMethod("SyncGroupCreditsClientRpc", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(terminal, new object[2] { terminal.groupCredits, terminal.numberOfItemsInDropship });
			}
			stringBuilder.Append($"\nYour new balance is ${terminal.groupCredits}.\n\n");
			stringBuilder.Append("Our contractors enjoy fast, free shipping while on the job! Any purchased items will arrive within approximately one hour.\n\n");
			ClearPending();
			return stringBuilder.ToString();
		}

		private static void ClearPending()
		{
			pendingPresetName = null;
			pendingTotalCost = 0;
			pendingItems = null;
		}

		private static int FindItemIndex(Terminal terminal, string itemName)
		{
			if (terminal.buyableItemsList == null)
			{
				return -1;
			}
			itemName = itemName.ToLower().Replace("-", " ").Replace("_", " ");
			for (int i = 0; i < terminal.buyableItemsList.Length; i++)
			{
				string text = terminal.buyableItemsList[i].itemName.ToLower();
				if (text == itemName || text.Replace("-", " ") == itemName)
				{
					return i;
				}
			}
			for (int j = 0; j < terminal.buyableItemsList.Length; j++)
			{
				string text2 = terminal.buyableItemsList[j].itemName.ToLower();
				if (text2.Contains(itemName) || itemName.Contains(text2))
				{
					return j;
				}
			}
			return -1;
		}

		private static int GetItemCost(Terminal terminal, int itemIndex)
		{
			if (itemIndex < 0 || itemIndex >= terminal.buyableItemsList.Length)
			{
				return 0;
			}
			int creditsWorth = terminal.buyableItemsList[itemIndex].creditsWorth;
			int num = terminal.itemSalesPercentages[itemIndex];
			return (int)((float)creditsWorth * ((float)num / 100f));
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "mrbub.persistentterminal";

		public const string PLUGIN_NAME = "PersistentTerminal";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}
namespace PersistentTerminal.Patches
{
	[HarmonyPatch(typeof(Terminal))]
	internal class TerminalPatches
	{
		[CompilerGenerated]
		private sealed class <ForceScrollbarUp>d__27 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Terminal terminal;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ForceScrollbarUp>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					terminal.scrollBarVertical.value = 1f;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 5)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static TerminalNode lastNode = null;

		private static string lastScreenText = "";

		private static int lastTextPosition = 0;

		private static int lastSaveFileNum = -1;

		private static bool isRestoring = false;

		private static bool hasRestoredThisSession = false;

		private static bool skipSoundPlayback = false;

		private static bool isShowingPresetPage = false;

		private static string lastPresetPageText = "";

		private static List<string> commandHistory = new List<string>();

		private static int historyIndex = -1;

		private static string currentInput = "";

		private static string savedInput = "";

		private static bool themeApplied = false;

		internal static Light terminalLight = null;

		private static Image terminalBackground = null;

		internal static bool isPlayerInShip = true;

		internal static Terminal cachedTerminal = null;

		[HarmonyPatch("BeginUsingTerminal")]
		[HarmonyPrefix]
		private static void BeginUsingTerminalPrefix(Terminal __instance)
		{
			if ((Object)(object)cachedTerminal == (Object)null)
			{
				cachedTerminal = __instance;
			}
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)GameNetworkManager.Instance == (Object)null) && !hasRestoredThisSession)
			{
				int saveFileNum = GameNetworkManager.Instance.saveFileNum;
				if (saveFileNum != lastSaveFileNum)
				{
					ClearSavedState();
					lastSaveFileNum = saveFileNum;
				}
				else if ((Object)(object)lastNode != (Object)null && !string.IsNullOrEmpty(lastScreenText))
				{
					isRestoring = true;
				}
				else if (isShowingPresetPage && !string.IsNullOrEmpty(lastPresetPageText))
				{
					isRestoring = true;
				}
			}
		}

		[HarmonyPatch("BeginUsingTerminal")]
		[HarmonyPostfix]
		private static void BeginUsingTerminalPostfix(Terminal __instance)
		{
			if (!themeApplied)
			{
				ApplyTheme(__instance);
				themeApplied = true;
			}
			if (!isRestoring)
			{
				if (!string.IsNullOrEmpty(savedInput) && (Object)(object)__instance.screenText != (Object)null)
				{
					Plugin.Logger.LogInfo((object)("[INPUT] Restoring saved input: '" + savedInput + "'"));
					TMP_InputField screenText = __instance.screenText;
					screenText.text += savedInput;
					__instance.textAdded = savedInput.Length;
					__instance.currentText = __instance.screenText.text;
					Plugin.Logger.LogInfo((object)$"[INPUT] Input restored, textAdded: {__instance.textAdded}");
					savedInput = "";
				}
				return;
			}
			try
			{
				if (isShowingPresetPage && !string.IsNullOrEmpty(lastPresetPageText))
				{
					Plugin.Logger.LogInfo((object)"[RESTORE] Restoring preset page");
					typeof(Terminal).GetField("modifyingText", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, true);
					__instance.screenText.text = lastPresetPageText;
					__instance.currentText = lastPresetPageText;
					__instance.textAdded = 0;
					__instance.screenText.ActivateInputField();
					((Selectable)__instance.screenText).Select();
					Plugin.Logger.LogInfo((object)"[RESTORE] Successfully restored preset page");
					hasRestoredThisSession = true;
					isRestoring = false;
				}
				else if (!((Object)(object)lastNode == (Object)null))
				{
					Plugin.Logger.LogInfo((object)("[RESTORE] Starting restoration of node: " + ((Object)lastNode).name));
					skipSoundPlayback = true;
					__instance.LoadNewNode(lastNode);
					skipSoundPlayback = false;
					if (lastTextPosition > 0 && (Object)(object)__instance.screenText != (Object)null)
					{
						__instance.textAdded = lastTextPosition;
						Plugin.Logger.LogInfo((object)$"[RESTORE] Restored scroll position: {lastTextPosition}");
					}
					if (!string.IsNullOrEmpty(savedInput) && (Object)(object)__instance.screenText != (Object)null)
					{
						Plugin.Logger.LogInfo((object)("[INPUT] Restoring saved input after node restore: '" + savedInput + "'"));
						TMP_InputField screenText2 = __instance.screenText;
						screenText2.text += savedInput;
						__instance.textAdded = savedInput.Length;
						__instance.currentText = __instance.screenText.text;
						Plugin.Logger.LogInfo((object)$"[INPUT] Input restored, textAdded: {__instance.textAdded}");
						savedInput = "";
					}
					Plugin.Logger.LogInfo((object)("[RESTORE] Successfully restored to: " + ((Object)lastNode).name));
					hasRestoredThisSession = true;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error restoring terminal state: " + ex.Message));
				skipSoundPlayback = false;
			}
			finally
			{
				isRestoring = false;
			}
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPrefix]
		private static bool LoadNewNodePrefix(Terminal __instance, TerminalNode node)
		{
			if (isRestoring && (Object)(object)node != (Object)null && ((Object)node).name == "Start")
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPostfix]
		private static void LoadNewNodePostfix(Terminal __instance, TerminalNode node)
		{
			if (isRestoring || skipSoundPlayback || !__instance.terminalInUse)
			{
				return;
			}
			if ((Object)(object)node != (Object)null)
			{
				isShowingPresetPage = false;
				lastPresetPageText = "";
			}
			if ((Object)(object)node != (Object)null && (Object)(object)__instance.currentNode == (Object)(object)node)
			{
				lastNode = node;
				if ((Object)(object)__instance.screenText != (Object)null)
				{
					lastScreenText = __instance.screenText.text;
					lastTextPosition = __instance.textAdded;
				}
			}
		}

		[HarmonyPatch("PlayTerminalAudioServerRpc")]
		[HarmonyPrefix]
		private static bool PlayTerminalAudioServerRpcPrefix(int clipIndex)
		{
			if (skipSoundPlayback)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix(Terminal __instance)
		{
			if (!__instance.terminalInUse || (Object)(object)__instance.screenText == (Object)null)
			{
				return;
			}
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return;
			}
			if (((ButtonControl)current.upArrowKey).wasPressedThisFrame && commandHistory.Count > 0)
			{
				if (historyIndex == -1)
				{
					currentInput = GetCurrentInput(__instance);
					Plugin.Logger.LogInfo((object)("[HISTORY] Saved current input: '" + currentInput + "'"));
				}
				if (historyIndex < commandHistory.Count - 1)
				{
					historyIndex++;
					string text = commandHistory[commandHistory.Count - 1 - historyIndex];
					Plugin.Logger.LogInfo((object)$"[HISTORY] Up arrow - showing command {historyIndex + 1}/{commandHistory.Count}: '{text}'");
					SetCurrentInput(__instance, text);
				}
				else
				{
					Plugin.Logger.LogInfo((object)"[HISTORY] Already at oldest command");
				}
			}
			else if (((ButtonControl)current.downArrowKey).wasPressedThisFrame && commandHistory.Count > 0)
			{
				if (historyIndex > 0)
				{
					historyIndex--;
					string text2 = commandHistory[commandHistory.Count - 1 - historyIndex];
					Plugin.Logger.LogInfo((object)$"[HISTORY] Down arrow - showing command {historyIndex + 1}/{commandHistory.Count}: '{text2}'");
					SetCurrentInput(__instance, text2);
				}
				else if (historyIndex == 0)
				{
					Plugin.Logger.LogInfo((object)("[HISTORY] Down arrow - restoring current input: '" + currentInput + "'"));
					historyIndex = -1;
					SetCurrentInput(__instance, currentInput);
				}
				else
				{
					Plugin.Logger.LogInfo((object)"[HISTORY] Already at newest input");
				}
			}
		}

		[HarmonyPatch("OnSubmit")]
		[HarmonyPrefix]
		private static bool OnSubmitPrefix(Terminal __instance)
		{
			if ((Object)(object)__instance.screenText == (Object)null || __instance.textAdded <= 0)
			{
				return true;
			}
			string text = GetCurrentInput(__instance);
			if (!string.IsNullOrWhiteSpace(text))
			{
				if (TerminalPresets.TryHandlePresetCommand(__instance, text, out var response))
				{
					Plugin.Logger.LogInfo((object)("[PRESETS] Handled preset command: '" + text + "'"));
					if (commandHistory.Count == 0 || commandHistory[commandHistory.Count - 1] != text)
					{
						commandHistory.Add(text);
					}
					historyIndex = -1;
					currentInput = "";
					typeof(Terminal).GetField("modifyingText", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(__instance, true);
					string text2 = "\n\n\n" + response;
					__instance.screenText.text = text2;
					__instance.currentText = text2;
					__instance.textAdded = 0;
					isShowingPresetPage = true;
					lastPresetPageText = text2;
					lastNode = null;
					Plugin.Logger.LogInfo((object)$"[PRESETS] Set screen text, length: {__instance.screenText.text.Length}");
					__instance.screenText.ActivateInputField();
					((Selectable)__instance.screenText).Select();
					FieldInfo field = typeof(Terminal).GetField("forceScrollbarCoroutine", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value = field.GetValue(__instance);
						Coroutine val = (Coroutine)((value is Coroutine) ? value : null);
						if (val != null)
						{
							((MonoBehaviour)__instance).StopCoroutine(val);
						}
						Coroutine value2 = ((MonoBehaviour)__instance).StartCoroutine(ForceScrollbarUp(__instance));
						field.SetValue(__instance, value2);
					}
					return false;
				}
				if (commandHistory.Count == 0 || commandHistory[commandHistory.Count - 1] != text)
				{
					commandHistory.Add(text);
					Plugin.Logger.LogInfo((object)$"[HISTORY] Added command to history: '{text}' (total: {commandHistory.Count})");
					if (commandHistory.Count > 50)
					{
						string text3 = commandHistory[0];
						commandHistory.RemoveAt(0);
						Plugin.Logger.LogInfo((object)("[HISTORY] Removed oldest command: '" + text3 + "'"));
					}
				}
				else
				{
					Plugin.Logger.LogInfo((object)("[HISTORY] Skipped duplicate command: '" + text + "'"));
				}
			}
			historyIndex = -1;
			currentInput = "";
			return true;
		}

		private static string GetCurrentInput(Terminal terminal)
		{
			if ((Object)(object)terminal.screenText == (Object)null || terminal.textAdded <= 0)
			{
				return "";
			}
			int num = terminal.screenText.text.Length - terminal.textAdded;
			if (num < 0 || num >= terminal.screenText.text.Length)
			{
				return "";
			}
			return terminal.screenText.text.Substring(num);
		}

		private static void SetCurrentInput(Terminal terminal, string input)
		{
			if (!((Object)(object)terminal.screenText == (Object)null))
			{
				if (terminal.textAdded > 0)
				{
					terminal.screenText.text = terminal.screenText.text.Substring(0, terminal.screenText.text.Length - terminal.textAdded);
				}
				TMP_InputField screenText = terminal.screenText;
				screenText.text += input;
				terminal.textAdded = input.Length;
				terminal.currentText = terminal.screenText.text;
			}
		}

		[IteratorStateMachine(typeof(<ForceScrollbarUp>d__27))]
		private static IEnumerator ForceScrollbarUp(Terminal terminal)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ForceScrollbarUp>d__27(0)
			{
				terminal = terminal
			};
		}

		[HarmonyPatch("QuitTerminal")]
		[HarmonyPrefix]
		private static void QuitTerminalPrefix(Terminal __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.currentNode == (Object)null)
			{
				return;
			}
			try
			{
				lastNode = __instance.currentNode;
				if ((Object)(object)__instance.screenText != (Object)null)
				{
					lastScreenText = __instance.screenText.text;
					lastTextPosition = __instance.textAdded;
					savedInput = GetCurrentInput(__instance);
					if (!string.IsNullOrEmpty(savedInput))
					{
						Plugin.Logger.LogInfo((object)("[INPUT] Saved player input: '" + savedInput + "'"));
					}
				}
				if ((Object)(object)GameNetworkManager.Instance != (Object)null)
				{
					lastSaveFileNum = GameNetworkManager.Instance.saveFileNum;
				}
				Plugin.Logger.LogInfo((object)$"[HISTORY] Command history size: {commandHistory.Count}");
				hasRestoredThisSession = false;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error saving terminal state: " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
		[HarmonyPostfix]
		private static void ResetShipPostfix()
		{
			ClearSavedState();
		}

		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		[HarmonyPostfix]
		private static void EndOfGamePostfix()
		{
			ClearSavedState();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		private static void DisconnectPostfix()
		{
			Plugin.Logger.LogInfo((object)"[STATE] Disconnected - clearing terminal state");
			ClearSavedState();
		}

		private static void ClearSavedState()
		{
			Plugin.Logger.LogInfo((object)"[STATE] Clearing all saved state");
			lastNode = null;
			lastScreenText = "";
			lastTextPosition = 0;
			isRestoring = false;
			hasRestoredThisSession = false;
			skipSoundPlayback = false;
			isShowingPresetPage = false;
			lastPresetPageText = "";
			commandHistory.Clear();
			historyIndex = -1;
			currentInput = "";
			savedInput = "";
			themeApplied = false;
			Plugin.Logger.LogInfo((object)"[STATE] State cleared");
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(Terminal __instance)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)"[INIT] ========== Terminal.Start - Full Object Discovery ==========");
			Plugin.Logger.LogInfo((object)("[INIT] Terminal GameObject: " + ((Object)((Component)__instance).gameObject).name));
			Plugin.Logger.LogInfo((object)("[INIT] Terminal transform: " + ((Object)((Component)__instance).transform).name));
			if ((Object)(object)__instance.terminalLight != (Object)null)
			{
				terminalLight = __instance.terminalLight;
				Plugin.Logger.LogInfo((object)$"[INIT] terminalLight: {((Object)((Component)__instance.terminalLight).gameObject).name} (enabled: {((Behaviour)__instance.terminalLight).enabled})");
				Plugin.Logger.LogInfo((object)$"[INIT] terminalLight color: R:{__instance.terminalLight.color.r} G:{__instance.terminalLight.color.g} B:{__instance.terminalLight.color.b}");
				if (Plugin.AlwaysOnLight.Value)
				{
					((Behaviour)terminalLight).enabled = true;
					Plugin.Logger.LogInfo((object)"[ALWAYS-ON] Terminal light enabled");
				}
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[INIT] terminalLight is null");
			}
			if ((Object)(object)__instance.terminalUIScreen != (Object)null)
			{
				Plugin.Logger.LogInfo((object)("[INIT] terminalUIScreen: " + ((Object)__instance.terminalUIScreen).name));
				LogGameObjectHierarchy(((Component)__instance.terminalUIScreen).gameObject, 0, 3);
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[INIT] terminalUIScreen is null");
			}
			if ((Object)(object)__instance.screenText != (Object)null)
			{
				Plugin.Logger.LogInfo((object)("[INIT] screenText GameObject: " + ((Object)((Component)__instance.screenText).gameObject).name));
				if ((Object)(object)__instance.screenText.textComponent != (Object)null)
				{
					Plugin.Logger.LogInfo((object)("[INIT] screenText.textComponent: " + ((object)__instance.screenText.textComponent).GetType().Name));
					Plugin.Logger.LogInfo((object)$"[INIT] screenText color: R:{((Graphic)__instance.screenText.textComponent).color.r} G:{((Graphic)__instance.screenText.textComponent).color.g} B:{((Graphic)__instance.screenText.textComponent).color.b}");
				}
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[INIT] screenText is null");
			}
			Plugin.Logger.LogInfo((object)"[INIT] === Terminal GameObject Children ===");
			LogGameObjectHierarchy(((Component)__instance).gameObject, 0, 3);
			Plugin.Logger.LogInfo((object)"[INIT] === Searching for UI Image components ===");
			Image[] componentsInChildren = ((Component)__instance.terminalUIScreen).GetComponentsInChildren<Image>(true);
			Plugin.Logger.LogInfo((object)$"[INIT] Found {componentsInChildren.Length} Image components in Canvas");
			Image[] array = componentsInChildren;
			foreach (Image val in array)
			{
				Plugin.Logger.LogInfo((object)$"[INIT] Image: {((Object)((Component)val).gameObject).name} - Color: R:{((Graphic)val).color.r:F2} G:{((Graphic)val).color.g:F2} B:{((Graphic)val).color.b:F2} A:{((Graphic)val).color.a:F2}");
				if (((Object)((Component)val).gameObject).name == "MainContainer" && (Object)(object)terminalBackground == (Object)null)
				{
					terminalBackground = val;
					Plugin.Logger.LogInfo((object)"[INIT] *** Cached MainContainer as terminal background ***");
				}
			}
			Plugin.Logger.LogInfo((object)"[INIT] === Searching for Light components ===");
			Light[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<Light>(true);
			Plugin.Logger.LogInfo((object)$"[INIT] Found {componentsInChildren2.Length} Light components in Terminal");
			Light[] array2 = componentsInChildren2;
			foreach (Light val2 in array2)
			{
				Plugin.Logger.LogInfo((object)$"[INIT] Light: {((Object)((Component)val2).gameObject).name} - Type: {val2.type} - Color: R:{val2.color.r:F2} G:{val2.color.g:F2} B:{val2.color.b:F2} - Enabled: {((Behaviour)val2).enabled}");
			}
			Plugin.Logger.LogInfo((object)"[INIT] ========== End Terminal Object Discovery ==========");
			if (Plugin.AlwaysOnScreen.Value)
			{
				Plugin.Logger.LogInfo((object)"[INIT] Always-on enabled, applying theme immediately");
				ApplyTheme(__instance);
				themeApplied = true;
			}
			if (Plugin.AlwaysOnScreen.Value && (Object)(object)__instance.terminalNodes != (Object)null && __instance.terminalNodes.specialNodes != null && __instance.terminalNodes.specialNodes.Count > 1)
			{
				Plugin.Logger.LogInfo((object)"[ALWAYS-ON] Loading store node for always-on screen");
				__instance.LoadNewNode(__instance.terminalNodes.specialNodes[1]);
			}
		}

		private static void LogGameObjectHierarchy(GameObject obj, int depth, int maxDepth)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)obj == (Object)null || depth > maxDepth)
			{
				return;
			}
			string text = new string(' ', depth * 2);
			Plugin.Logger.LogInfo((object)("[HIERARCHY] " + text + "└─ " + ((Object)obj).name));
			Component[] components = obj.GetComponents<Component>();
			foreach (Component val in components)
			{
				if ((Object)(object)val != (Object)null && !(val is Transform))
				{
					Plugin.Logger.LogInfo((object)("[HIERARCHY] " + text + "   ├─ Component: " + ((object)val).GetType().Name));
				}
			}
			foreach (Transform item in obj.transform)
			{
				LogGameObjectHierarchy(((Component)item).gameObject, depth + 1, maxDepth);
			}
		}

		[HarmonyPatch("waitUntilFrameEndToSetActive")]
		[HarmonyPrefix]
		private static void WaitUntilFrameEndToSetActivePrefix(Terminal __instance, ref bool active)
		{
			if (!isPlayerInShip)
			{
				active = false;
			}
			else if (Plugin.AlwaysOnScreen.Value)
			{
				Plugin.Logger.LogInfo((object)$"[ALWAYS-ON] Forcing terminal canvas to stay active (was: {active})");
				active = true;
			}
		}

		[HarmonyPatch("SetTerminalInUseClientRpc")]
		[HarmonyPostfix]
		private static void SetTerminalInUseClientRpcPostfix(Terminal __instance, bool inUse)
		{
			if (!isPlayerInShip)
			{
				if ((Object)(object)terminalLight != (Object)null)
				{
					((Behaviour)terminalLight).enabled = false;
				}
			}
			else if (Plugin.AlwaysOnLight.Value && (Object)(object)terminalLight != (Object)null)
			{
				((Behaviour)terminalLight).enabled = true;
				Plugin.Logger.LogInfo((object)$"[ALWAYS-ON] Terminal light kept enabled (inUse: {inUse})");
			}
		}

		private static void ApplyTheme(Terminal terminal)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)terminal.screenText == (Object)null || (Object)(object)terminal.screenText.textComponent == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"[THEME] Cannot apply theme - screenText or textComponent is null");
				return;
			}
			bool flag = !string.IsNullOrWhiteSpace(Plugin.CustomTextColor.Value);
			bool flag2 = !string.IsNullOrWhiteSpace(Plugin.CustomScreenLightColor.Value);
			bool flag3 = !string.IsNullOrWhiteSpace(Plugin.CustomBackgroundColor.Value);
			Color val = default(Color);
			Color val2 = default(Color);
			Color val3 = default(Color);
			if (flag || flag2 || flag3)
			{
				Plugin.Logger.LogInfo((object)"[THEME] Using custom colors (overriding theme)");
				val = (Color)(flag ? ParseCustomColor(Plugin.CustomTextColor.Value) : new Color(0f, 1f, 0f, 1f));
				val2 = (Color)(flag2 ? ParseCustomColor(Plugin.CustomScreenLightColor.Value) : new Color(0f, 1f, 0f, 1f));
				val3 = (Color)(flag3 ? ParseCustomColor(Plugin.CustomBackgroundColor.Value) : new Color(0f, 0.08f, 0f, 1f));
			}
			else
			{
				string text = Plugin.TerminalTheme.Value.ToLower();
				switch (text)
				{
				case "green":
					((Color)(ref val))..ctor(0f, 1f, 0f, 1f);
					((Color)(ref val2))..ctor(0f, 1f, 0f, 1f);
					((Color)(ref val3))..ctor(0f, 0.08f, 0f, 1f);
					break;
				case "amber":
					((Color)(ref val))..ctor(1f, 0.75f, 0f, 1f);
					((Color)(ref val2))..ctor(1f, 0.75f, 0f, 1f);
					((Color)(ref val3))..ctor(0.08f, 0.06f, 0f, 1f);
					break;
				case "blue":
					((Color)(ref val))..ctor(0.3f, 0.7f, 1f, 1f);
					((Color)(ref val2))..ctor(0.3f, 0.7f, 1f, 1f);
					((Color)(ref val3))..ctor(0f, 0.03f, 0.08f, 1f);
					break;
				case "red":
					((Color)(ref val))..ctor(1f, 0.2f, 0.2f, 1f);
					((Color)(ref val2))..ctor(1f, 0.2f, 0.2f, 1f);
					((Color)(ref val3))..ctor(0.08f, 0f, 0f, 1f);
					break;
				case "purple":
					((Color)(ref val))..ctor(0.8f, 0.4f, 1f, 1f);
					((Color)(ref val2))..ctor(0.8f, 0.4f, 1f, 1f);
					((Color)(ref val3))..ctor(0.06f, 0f, 0.08f, 1f);
					break;
				case "cyan":
					((Color)(ref val))..ctor(0f, 1f, 1f, 1f);
					((Color)(ref val2))..ctor(0f, 1f, 1f, 1f);
					((Color)(ref val3))..ctor(0f, 0.08f, 0.08f, 1f);
					break;
				default:
					Plugin.Logger.LogInfo((object)"[THEME] Using default terminal colors");
					return;
				}
				Plugin.Logger.LogInfo((object)("[THEME] Using theme preset: " + text));
			}
			((Graphic)terminal.screenText.textComponent).color = val;
			Plugin.Logger.LogInfo((object)$"[THEME] Applied text color: R:{val.r:F2} G:{val.g:F2} B:{val.b:F2}");
			if (terminal.screenText.caretColor != val)
			{
				terminal.screenText.caretColor = val;
				Plugin.Logger.LogInfo((object)"[THEME] Applied caret color");
			}
			if ((Object)(object)terminal.terminalUIScreen != (Object)null)
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)terminal.terminalUIScreen).GetComponentsInChildren<TextMeshProUGUI>(true);
				Plugin.Logger.LogInfo((object)$"[THEME] Found {componentsInChildren.Length} TextMeshProUGUI components");
				TextMeshProUGUI[] array = componentsInChildren;
				foreach (TextMeshProUGUI val4 in array)
				{
					if (!((Object)(object)val4 == (Object)(object)terminal.screenText.textComponent))
					{
						((Graphic)val4).color = val;
						Plugin.Logger.LogInfo((object)("[THEME] Colored text component: " + ((Object)((Component)val4).gameObject).name));
					}
				}
			}
			if ((Object)(object)terminalLight != (Object)null)
			{
				terminalLight.color = val2;
				Plugin.Logger.LogInfo((object)$"[THEME] Applied light color: R:{val2.r:F2} G:{val2.g:F2} B:{val2.b:F2}");
			}
			else
			{
				Plugin.Logger.LogInfo((object)"[THEME] No terminal light found to color");
			}
			if ((Object)(object)terminalBackground != (Object)null)
			{
				((Graphic)terminalBackground).color = val3;
				Plugin.Logger.LogInfo((object)$"[THEME] Applied background color: R:{val3.r:F2} G:{val3.g:F2} B:{val3.b:F2}");
			}
			else
			{
				Plugin.Logger.LogInfo((object)"[THEME] No terminal background found to color");
			}
		}

		private static Color ParseCustomColor(string colorString)
		{
			//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_00a4: 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)
			try
			{
				string[] array = colorString.Split(',');
				if (array.Length == 3)
				{
					float num = float.Parse(array[0].Trim()) / 255f;
					float num2 = float.Parse(array[1].Trim()) / 255f;
					float num3 = float.Parse(array[2].Trim()) / 255f;
					return new Color(num, num2, num3, 1f);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[THEME] Failed to parse custom color '" + colorString + "': " + ex.Message));
			}
			Plugin.Logger.LogWarning((object)"[THEME] Using default green color due to parse error");
			return new Color(0f, 1f, 0f, 1f);
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerPatches
	{
		private static float updateTimer;

		private const float UPDATE_INTERVAL = 0.5f;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				updateTimer += Time.deltaTime;
				if (!(updateTimer < 0.5f))
				{
					updateTimer = 0f;
					UpdateTerminalPerformanceState(__instance);
				}
			}
		}

		private static void UpdateTerminalPerformanceState(PlayerControllerB player)
		{
			if ((Object)(object)TerminalPatches.cachedTerminal == (Object)null)
			{
				Terminal val = Object.FindObjectOfType<Terminal>();
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				TerminalPatches.cachedTerminal = val;
			}
			bool isInHangarShipRoom = player.isInHangarShipRoom;
			if (isInHangarShipRoom == TerminalPatches.isPlayerInShip)
			{
				return;
			}
			TerminalPatches.isPlayerInShip = isInHangarShipRoom;
			if (isInHangarShipRoom)
			{
				if (Plugin.AlwaysOnScreen.Value && (Object)(object)TerminalPatches.cachedTerminal.terminalUIScreen != (Object)null)
				{
					GameObject gameObject = ((Component)TerminalPatches.cachedTerminal.terminalUIScreen).gameObject;
					if ((Object)(object)gameObject != (Object)null)
					{
						gameObject.SetActive(true);
						Plugin.Logger.LogInfo((object)"[PERFORMANCE] Player entered ship - terminal screen enabled");
					}
				}
				if (Plugin.AlwaysOnLight.Value && (Object)(object)TerminalPatches.terminalLight != (Object)null)
				{
					((Behaviour)TerminalPatches.terminalLight).enabled = true;
					Plugin.Logger.LogInfo((object)"[PERFORMANCE] Player entered ship - terminal light enabled");
				}
				return;
			}
			if ((Object)(object)TerminalPatches.cachedTerminal.terminalUIScreen != (Object)null)
			{
				GameObject gameObject2 = ((Component)TerminalPatches.cachedTerminal.terminalUIScreen).gameObject;
				if ((Object)(object)gameObject2 != (Object)null)
				{
					gameObject2.SetActive(false);
					Plugin.Logger.LogInfo((object)"[PERFORMANCE] Player exited ship - terminal screen disabled");
				}
			}
			if ((Object)(object)TerminalPatches.terminalLight != (Object)null)
			{
				((Behaviour)TerminalPatches.terminalLight).enabled = false;
				Plugin.Logger.LogInfo((object)"[PERFORMANCE] Player exited ship - terminal light disabled");
			}
		}
	}
}