using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CapsCrew.ComputerHelp.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Networking;

[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("CapsCrew.ComputerHelp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CapsCrew.ComputerHelp")]
[assembly: AssemblyTitle("CapsCrew.ComputerHelp")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 CapsCrew.ComputerHelp
{
	internal sealed class ComputerHelpAudioRunner : MonoBehaviour
	{
	}
	internal static class ComputerHelpAudio
	{
		private static readonly List<string> ClipPaths = new List<string>();

		private static ComputerHelpAudioRunner? _runner;

		private static AudioSource? _source;

		private static bool _loading;

		private static Coroutine? _playRoutine;

		private static bool _clipListLoaded;

		internal static int ClipCount => ClipPaths.Count;

		internal static void Initialize()
		{
			LoadClipList();
			EnsureRunner(forceRecreate: true);
		}

		internal static void EnsureInitialized()
		{
			LoadClipList();
			EnsureRunner(forceRecreate: false);
		}

		private static void LoadClipList()
		{
			if (_clipListLoaded && ClipPaths.Count > 0)
			{
				return;
			}
			string text = ModContentPaths.ResolveSoundsDirectory();
			if (!Directory.Exists(text))
			{
				Plugin.Log.LogWarning((object)("Sounds folder missing: " + text));
				return;
			}
			ClipPaths.Clear();
			string[] array = new string[3] { "*.mp3", "*.wav", "*.ogg" };
			foreach (string searchPattern in array)
			{
				ClipPaths.AddRange(Directory.GetFiles(text, searchPattern, SearchOption.TopDirectoryOnly));
			}
			_clipListLoaded = true;
			Plugin.Log.LogInfo((object)$"Computer HELP: {ClipPaths.Count} clip(s) in {text}");
		}

		private static void EnsureRunner(bool forceRecreate)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (forceRecreate || !((Object)(object)_runner != (Object)null) || !((Object)(object)_source != (Object)null))
			{
				if ((Object)(object)_runner != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_runner).gameObject);
					_runner = null;
					_source = null;
				}
				GameObject val = new GameObject("CapsCrew_ComputerHelp_Audio");
				Object.DontDestroyOnLoad((Object)val);
				_runner = val.AddComponent<ComputerHelpAudioRunner>();
				_source = val.AddComponent<AudioSource>();
				_source.playOnAwake = false;
				_source.spatialBlend = 0f;
				_source.bypassListenerEffects = false;
				_source.bypassReverbZones = true;
				_source.volume = Plugin.Volume.Value;
				Plugin.Log.LogInfo((object)$"Computer HELP audio runner ready (volume={_source.volume}).");
			}
		}

		private static MonoBehaviour GetCoroutineHost()
		{
			EnsureInitialized();
			if ((Object)(object)StartOfRound.Instance != (Object)null)
			{
				return (MonoBehaviour)(object)StartOfRound.Instance;
			}
			if ((Object)(object)_runner != (Object)null)
			{
				return (MonoBehaviour)(object)_runner;
			}
			return (MonoBehaviour)(object)Plugin.Instance;
		}

		internal static int PickRandomIndex()
		{
			EnsureInitialized();
			if (ClipPaths.Count == 0)
			{
				return -1;
			}
			return Random.Range(0, ClipPaths.Count);
		}

		internal static bool TryPlayIndex(int index)
		{
			EnsureInitialized();
			if (index < 0 || index >= ClipPaths.Count)
			{
				Plugin.Log.LogWarning((object)$"Computer HELP: invalid clip index {index} (count={ClipPaths.Count}).");
				return false;
			}
			if ((Object)(object)_source == (Object)null)
			{
				Plugin.Log.LogError((object)"Computer HELP: audio runner missing after ensure.");
				return false;
			}
			return TryPlayPath(ClipPaths[index], index);
		}

		internal static bool TryPlayRandom()
		{
			int num = PickRandomIndex();
			if (num >= 0)
			{
				return TryPlayIndex(num);
			}
			return false;
		}

		internal static bool TryPlayExternal(string path)
		{
			EnsureInitialized();
			if (string.IsNullOrWhiteSpace(path))
			{
				Plugin.Log.LogWarning((object)"Computer HELP: external clip path empty.");
				return false;
			}
			string fullPath = Path.GetFullPath(path);
			if (!File.Exists(fullPath))
			{
				Plugin.Log.LogWarning((object)("Computer HELP: external clip missing: " + fullPath));
				return false;
			}
			return TryPlayPath(fullPath);
		}

		internal static bool TryPlayAtTerminal(Terminal terminal, string path)
		{
			EnsureInitialized();
			if ((Object)(object)terminal == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Computer HELP: terminal missing for spatial exchange audio.");
				return TryPlayExternal(path);
			}
			if (string.IsNullOrWhiteSpace(path))
			{
				Plugin.Log.LogWarning((object)"Computer HELP: exchange clip path empty.");
				return false;
			}
			string fullPath = Path.GetFullPath(path);
			if (!File.Exists(fullPath))
			{
				Plugin.Log.LogWarning((object)("Computer HELP: exchange clip missing: " + fullPath));
				return false;
			}
			return TryPlayPath(fullPath, -1, terminal);
		}

		private static bool TryPlayPath(string path, int index = -1, Terminal? terminal = null)
		{
			if (_loading)
			{
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Computer HELP: play skipped, already loading (" + Path.GetFileName(path) + ")."));
				}
				return false;
			}
			if (!File.Exists(path))
			{
				Plugin.Log.LogError((object)$"Computer HELP: clip missing on disk (index={index}): {path}");
				return false;
			}
			MonoBehaviour coroutineHost = GetCoroutineHost();
			if (_playRoutine != null && (Object)(object)_runner != (Object)null)
			{
				((MonoBehaviour)_runner).StopCoroutine(_playRoutine);
				_playRoutine = null;
				_loading = false;
			}
			if (Plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)$"Computer HELP: loading clip index={index} file={Path.GetFileName(path)} host={((object)coroutineHost).GetType().Name}");
			}
			_playRoutine = coroutineHost.StartCoroutine(PlayClipCoroutine(path, index, terminal));
			return true;
		}

		internal static string BuildFileUrl(string path)
		{
			return new Uri(Path.GetFullPath(path)).AbsoluteUri;
		}

		private static IEnumerator PlayClipCoroutine(string path, int index, Terminal? terminal)
		{
			_loading = true;
			bool spatialAtTerminal = (Object)(object)terminal != (Object)null && Plugin.ExchangeSpatialAudio.Value;
			string text = BuildFileUrl(path);
			AudioType val = (AudioType)(path.EndsWith(".ogg", StringComparison.OrdinalIgnoreCase) ? 14 : (path.EndsWith(".wav", StringComparison.OrdinalIgnoreCase) ? 20 : 13));
			if (Plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)$"Computer HELP: request url={text} type={val}");
			}
			UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(text, val);
			try
			{
				DownloadHandler downloadHandler = req.downloadHandler;
				DownloadHandlerAudioClip val2 = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val2 != null)
				{
					val2.streamAudio = false;
				}
				yield return req.SendWebRequest();
				try
				{
					if (req.isNetworkError || req.isHttpError)
					{
						Plugin.Log.LogError((object)$"Computer HELP load failed: {req.result} {req.error} (index={index}, path={path})");
						yield break;
					}
					EnsureInitialized();
					AudioClip content = DownloadHandlerAudioClip.GetContent(req);
					if ((Object)(object)content == (Object)null)
					{
						Plugin.Log.LogError((object)$"Computer HELP: null clip after load (index={index}, path={path})");
						yield break;
					}
					if ((int)content.loadState == 3)
					{
						Plugin.Log.LogError((object)$"Computer HELP: clip loadState=Failed (index={index}, path={path})");
						yield break;
					}
					if (content.length <= 0.01f)
					{
						Plugin.Log.LogError((object)$"Computer HELP: clip length too short ({content.length}s) index={index}");
						yield break;
					}
					if (spatialAtTerminal && (Object)(object)terminal != (Object)null && (Object)(object)terminal.terminalAudio != (Object)null)
					{
						AudioSource terminalAudio = terminal.terminalAudio;
						terminalAudio.PlayOneShot(content, Plugin.Volume.Value);
						if (Plugin.DebugLogging.Value)
						{
							Plugin.Log.LogInfo((object)($"Computer HELP playing at terminal: {Path.GetFileName(path)} len={content.length:0.2}s " + $"spatialBlend={terminalAudio.spatialBlend} min={terminalAudio.minDistance} max={terminalAudio.maxDistance}"));
						}
						else
						{
							Plugin.Log.LogInfo((object)("Computer HELP playing at terminal: " + Path.GetFileName(path)));
						}
						yield break;
					}
					if ((Object)(object)_source == (Object)null)
					{
						Plugin.Log.LogError((object)"Computer HELP: audio source lost during load.");
						yield break;
					}
					_source.Stop();
					_source.volume = Plugin.Volume.Value;
					_source.clip = content;
					_source.Play();
					if (Plugin.DebugLogging.Value)
					{
						AudioListener val3 = Object.FindObjectOfType<AudioListener>();
						Plugin.Log.LogInfo((object)($"Computer HELP playing: {Path.GetFileName(path)} len={content.length:0.2}s " + $"sourceVol={_source.volume} isPlaying={_source.isPlaying} listener={(Object)(object)val3 != (Object)null}"));
					}
					else
					{
						Plugin.Log.LogInfo((object)("Computer HELP playing: " + Path.GetFileName(path)));
					}
				}
				finally
				{
					_loading = false;
					_playRoutine = null;
				}
			}
			finally
			{
				((IDisposable)req)?.Dispose();
			}
		}
	}
	internal static class ComputerHelpChase
	{
		private static readonly HashSet<int> ActiveChasers = new HashSet<int>();

		private static readonly List<string> ClipPaths = new List<string>();

		private static AudioSource? _source;

		private static bool _loading;

		private static bool _playing;

		private static Coroutine? _loadRoutine;

		internal static void Initialize()
		{
			//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)
			//IL_0116: Expected O, but got Unknown
			if (!Plugin.EnableChaseMusic.Value)
			{
				Plugin.Log.LogInfo((object)"Computer HELP chase music disabled in config.");
				return;
			}
			string text = ModContentPaths.ResolveChaseDirectory();
			if (!Directory.Exists(text))
			{
				Plugin.Log.LogInfo((object)("Chase music folder missing (optional): " + text));
				return;
			}
			ClipPaths.Clear();
			bool flag = string.Equals(Path.GetFullPath(text), Path.GetFullPath(ModContentPaths.ContentRoot), StringComparison.OrdinalIgnoreCase);
			string[] array = new string[3] { "*.mp3", "*.wav", "*.ogg" };
			foreach (string searchPattern in array)
			{
				string[] files = Directory.GetFiles(text, searchPattern, SearchOption.TopDirectoryOnly);
				foreach (string text2 in files)
				{
					string fileName = Path.GetFileName(text2);
					if (!flag || fileName.StartsWith("CHASE_", StringComparison.OrdinalIgnoreCase))
					{
						ClipPaths.Add(text2);
					}
				}
			}
			if (ClipPaths.Count == 0)
			{
				Plugin.Log.LogInfo((object)("Chase music: no clips in " + text + " — drop an MP3 and restart."));
				return;
			}
			GameObject val = new GameObject("CapsCrew_ComputerHelp_Chase");
			Object.DontDestroyOnLoad((Object)val);
			_source = val.AddComponent<AudioSource>();
			_source.playOnAwake = false;
			_source.loop = true;
			_source.spatialBlend = 0f;
			_source.volume = Plugin.ChaseVolume.Value;
			Plugin.Log.LogInfo((object)$"Computer HELP chase: {ClipPaths.Count} clip(s) in {text}");
		}

		internal static void Tick(EnemyAI enemy)
		{
			if (!Plugin.EnableChaseMusic.Value || ClipPaths.Count == 0 || (Object)(object)_source == (Object)null)
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			PlayerControllerB localPlayerController = instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				return;
			}
			bool num = (Object)(object)enemy.targetPlayer == (Object)(object)localPlayerController && enemy.currentBehaviourStateIndex == 1;
			int instanceID = ((Object)enemy).GetInstanceID();
			if (num)
			{
				if (ActiveChasers.Add(instanceID) && ActiveChasers.Count == 1)
				{
					StartMusic();
				}
			}
			else if (ActiveChasers.Remove(instanceID) && ActiveChasers.Count == 0)
			{
				StopMusic();
			}
		}

		internal static void Reset()
		{
			ActiveChasers.Clear();
			StopMusic();
		}

		private static void StartMusic()
		{
			if (!_playing && !_loading && ClipPaths.Count != 0 && !((Object)(object)_source == (Object)null))
			{
				string path = ClipPaths[Random.Range(0, ClipPaths.Count)];
				if (_loadRoutine != null)
				{
					((MonoBehaviour)Plugin.Instance).StopCoroutine(_loadRoutine);
				}
				_loadRoutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(LoadAndPlayCoroutine(path));
			}
		}

		private static void StopMusic()
		{
			if (_loadRoutine != null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_loadRoutine);
				_loadRoutine = null;
			}
			_loading = false;
			_playing = false;
			if (!((Object)(object)_source == (Object)null))
			{
				_source.Stop();
				_source.clip = null;
			}
		}

		private static IEnumerator LoadAndPlayCoroutine(string path)
		{
			_loading = true;
			string text = ComputerHelpAudio.BuildFileUrl(path);
			AudioType val = (AudioType)(path.EndsWith(".ogg", StringComparison.OrdinalIgnoreCase) ? 14 : (path.EndsWith(".wav", StringComparison.OrdinalIgnoreCase) ? 20 : 13));
			UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(text, val);
			try
			{
				DownloadHandler downloadHandler = req.downloadHandler;
				DownloadHandlerAudioClip val2 = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val2 != null)
				{
					val2.streamAudio = false;
				}
				yield return req.SendWebRequest();
				if (req.isNetworkError || req.isHttpError)
				{
					Plugin.Log.LogError((object)("Chase music load failed: " + req.error + " (" + path + ")"));
					_loading = false;
					yield break;
				}
				AudioClip content = DownloadHandlerAudioClip.GetContent(req);
				if ((Object)(object)content == (Object)null || (Object)(object)_source == (Object)null)
				{
					Plugin.Log.LogError((object)("Chase music: null clip (" + path + ")"));
					_loading = false;
					yield break;
				}
				_source.volume = Plugin.ChaseVolume.Value;
				_source.clip = content;
				_source.loop = true;
				_source.Play();
				_playing = true;
				_loading = false;
				Plugin.Log.LogInfo((object)("Chase music playing: " + Path.GetFileName(path)));
			}
			finally
			{
				((IDisposable)req)?.Dispose();
			}
		}
	}
	internal sealed class ExchangeLine
	{
		internal string Id { get; }

		internal string DisplayText { get; }

		internal string AudioPath { get; }

		internal ExchangeLine(string id, string displayText, string audioPath)
		{
			Id = id;
			DisplayText = displayText;
			AudioPath = audioPath;
		}
	}
	internal sealed class ExchangeManifest
	{
		[JsonProperty("segments")]
		internal List<ExchangeSegment> Segments { get; set; } = new List<ExchangeSegment>();
	}
	internal sealed class ExchangeSegment
	{
		[JsonProperty("filename")]
		internal string Filename { get; set; } = "";

		[JsonProperty("text")]
		internal string Text { get; set; } = "";

		[JsonProperty("turns")]
		internal List<ExchangeTurn>? Turns { get; set; }
	}
	internal sealed class ExchangeTurn
	{
		[JsonProperty("text")]
		internal string Text { get; set; } = "";

		[JsonProperty("speaker_guess")]
		internal string SpeakerGuess { get; set; } = "";
	}
	internal static class ComputerHelpMonitor
	{
		private static readonly List<ExchangeLine> Lines = new List<ExchangeLine>();

		private static bool _loaded;

		internal static int LineCount => Lines.Count;

		internal static void Reload()
		{
			_loaded = false;
			LoadLines();
		}

		internal static void LoadLines()
		{
			if (_loaded)
			{
				return;
			}
			Lines.Clear();
			string text = ModContentPaths.ResolveExchangeDirectory();
			string text2 = Path.Combine(text, "manifest.json");
			if (!Directory.Exists(text))
			{
				Plugin.Log.LogWarning((object)("sounds_exchanges folder missing: " + text));
				TryLoadExchangesFromAudioScan(ModContentPaths.ContentRoot);
				_loaded = true;
				return;
			}
			if (!File.Exists(text2))
			{
				Plugin.Log.LogWarning((object)("sounds_exchanges manifest missing: " + text2));
				TryLoadExchangesFromAudioScan(text);
				if (Lines.Count == 0 && text != ModContentPaths.ContentRoot)
				{
					TryLoadExchangesFromAudioScan(ModContentPaths.ContentRoot);
				}
				_loaded = true;
				return;
			}
			ExchangeManifest exchangeManifest;
			try
			{
				exchangeManifest = JsonConvert.DeserializeObject<ExchangeManifest>(File.ReadAllText(text2)) ?? new ExchangeManifest();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("sounds_exchanges manifest parse failed: " + ex.Message));
				_loaded = true;
				return;
			}
			foreach (ExchangeSegment segment in exchangeManifest.Segments)
			{
				if (string.IsNullOrWhiteSpace(segment.Filename))
				{
					continue;
				}
				string text3 = Path.Combine(text, segment.Filename);
				if (!File.Exists(text3))
				{
					if (Plugin.DebugLogging.Value)
					{
						Plugin.Log.LogInfo((object)("sounds_exchanges: skip missing audio " + segment.Filename));
					}
					continue;
				}
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(segment.Filename);
				string path = Path.Combine(text, fileNameWithoutExtension + ".txt");
				string text4 = SanitizeTranscript(File.Exists(path) ? File.ReadAllText(path).Trim() : BuildDisplayText(segment));
				if (!string.IsNullOrWhiteSpace(text4))
				{
					Lines.Add(new ExchangeLine(fileNameWithoutExtension, text4, text3));
				}
			}
			_loaded = true;
			Plugin.Log.LogInfo((object)$"Computer NEED HELP: {Lines.Count} exchange(s) from {text}");
		}

		internal static bool TryShowOnTerminal(Terminal terminal)
		{
			LoadLines();
			if (Lines.Count == 0)
			{
				ShowErrorNode(terminal, "NO EXCHANGE CLIPS FOUND.\nExpected folder:\n" + ModContentPaths.ResolveExchangeDirectory() + "\nReinstall mod or verify sounds_exchanges shipped with the plugin.");
				return false;
			}
			int index = Random.Range(0, Lines.Count);
			ExchangeLine exchangeLine = Lines[index];
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.clearPreviousText = true;
			val.displayText = BuildPageText(exchangeLine.DisplayText);
			val.maxCharactersToType = 0;
			val.acceptAnything = false;
			terminal.LoadNewNode(val);
			ClearSubmittedInput(terminal);
			if (!ComputerHelpAudio.TryPlayAtTerminal(terminal, exchangeLine.AudioPath))
			{
				ShowErrorNode(terminal, "AUDIO FILE NOT FOUND.\n" + exchangeLine.Id + "\nPath:\n" + exchangeLine.AudioPath);
				Plugin.Log.LogWarning((object)("Computer NEED HELP: audio failed for " + exchangeLine.Id + " at " + exchangeLine.AudioPath));
				return true;
			}
			Plugin.Log.LogInfo((object)("Computer NEED HELP: exchange '" + exchangeLine.Id + "'"));
			ComputerHelpNetwork.SyncExchange(index);
			return true;
		}

		internal static bool TryPlaySyncedExchange(int index)
		{
			LoadLines();
			if (index < 0 || index >= Lines.Count)
			{
				Plugin.Log.LogWarning((object)$"Computer NEED HELP: invalid synced index {index} (count={Lines.Count}).");
				return false;
			}
			return ComputerHelpAudio.TryPlayExternal(Lines[index].AudioPath);
		}

		private static string BuildDisplayText(ExchangeSegment segment)
		{
			if (segment.Turns != null && segment.Turns.Count > 0)
			{
				List<string> list = new List<string>();
				foreach (ExchangeTurn turn in segment.Turns)
				{
					string text = turn.Text.Trim();
					if (!string.IsNullOrWhiteSpace(text))
					{
						list.Add(text);
					}
				}
				if (list.Count > 0)
				{
					return string.Join("\n", list);
				}
			}
			return segment.Text.Replace(" / ", "\n", StringComparison.Ordinal).Trim();
		}

		private static string SanitizeTranscript(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			string[] array = text.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.StartsWith("> COMPUTER:", StringComparison.OrdinalIgnoreCase))
				{
					text2 = text2.Substring("> COMPUTER:".Length).Trim();
				}
				else if (text2.StartsWith("> COURAGE:", StringComparison.OrdinalIgnoreCase))
				{
					text2 = text2.Substring("> COURAGE:".Length).Trim();
				}
				else if (text2.StartsWith(">", StringComparison.Ordinal))
				{
					text2 = text2.Substring(1).Trim();
				}
				if (!string.IsNullOrWhiteSpace(text2))
				{
					list.Add(text2);
				}
			}
			return string.Join("\n", list);
		}

		private static string BuildPageText(string body)
		{
			return "> COMPUTER ASSISTANCE REQUEST\n> STATUS: DISPATCHING EXCHANGE\n> ----------------------------------------\n\n" + body + "\n\n> END TRANSMISSION";
		}

		private static void ShowErrorNode(Terminal terminal, string message)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.clearPreviousText = true;
			val.displayText = "> COMPUTER ASSISTANCE REQUEST\n> STATUS: ERROR\n\n" + message;
			terminal.LoadNewNode(val);
			ClearSubmittedInput(terminal);
		}

		private static void ClearSubmittedInput(Terminal terminal)
		{
			TerminalInput.ClearSubmittedInput(terminal);
		}

		private static void TryLoadExchangesFromAudioScan(string exchangeDir)
		{
			if (!Directory.Exists(exchangeDir))
			{
				return;
			}
			string[] array = new string[3] { "*.wav", "*.mp3", "*.ogg" };
			foreach (string searchPattern in array)
			{
				string[] files = Directory.GetFiles(exchangeDir, searchPattern, SearchOption.TopDirectoryOnly);
				foreach (string text in files)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
					string path = Path.Combine(exchangeDir, fileNameWithoutExtension + ".txt");
					string text2 = (File.Exists(path) ? SanitizeTranscript(File.ReadAllText(path).Trim()) : fileNameWithoutExtension.Replace('_', ' '));
					if (!string.IsNullOrWhiteSpace(text2))
					{
						Lines.Add(new ExchangeLine(fileNameWithoutExtension, text2, text));
					}
				}
			}
			if (Lines.Count > 0)
			{
				Plugin.Log.LogInfo((object)$"Computer NEED HELP: loaded {Lines.Count} exchange(s) via audio scan fallback.");
			}
		}
	}
	internal static class ComputerHelpNetwork
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnNetMessage;
		}

		private const string MessageName = "CapsCrew_ComputerHelp_Net";

		private const byte KindRequestHelp = 0;

		private const byte KindPlayHelp = 1;

		private const byte KindRequestExchange = 2;

		private const byte KindPlayExchange = 3;

		private static bool _registered;

		internal static void TryRegister()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null)
			{
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Computer HELP network register skipped (no NetworkManager yet).");
				}
				return;
			}
			CustomMessagingManager customMessagingManager = singleton.CustomMessagingManager;
			object obj = <>O.<0>__OnNetMessage;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = OnNetMessage;
				<>O.<0>__OnNetMessage = val;
				obj = (object)val;
			}
			customMessagingManager.RegisterNamedMessageHandler("CapsCrew_ComputerHelp_Net", (HandleNamedMessageDelegate)obj);
			_registered = true;
			Plugin.Log.LogInfo((object)"Computer HELP network handler registered.");
		}

		internal static void ServerPlayHelp()
		{
			if (!Plugin.SyncAcrossLobby.Value)
			{
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Computer HELP local-only play (SyncAcrossLobby=false).");
				}
				ComputerHelpAudio.TryPlayRandom();
				return;
			}
			TryRegister();
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsListening || singleton.CustomMessagingManager == null)
			{
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Computer HELP fallback local play (network not listening).");
				}
				ComputerHelpAudio.TryPlayRandom();
			}
			else if (!singleton.IsServer)
			{
				Send(0uL, 0, -1);
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Computer HELP: client asked host to play for the lobby.");
				}
			}
			else
			{
				BroadcastHelpFromServer();
			}
		}

		internal static void SyncExchange(int index)
		{
			if (index < 0 || !Plugin.SyncAcrossLobby.Value)
			{
				return;
			}
			TryRegister();
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsListening || singleton.CustomMessagingManager == null)
			{
				return;
			}
			if (!singleton.IsServer)
			{
				Send(0uL, 2, index);
				if (Plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)$"Computer NEED HELP: client asked host to sync exchange {index}.");
				}
			}
			else
			{
				int num = SendToRemoteClients(3, index, ulong.MaxValue);
				Plugin.Log.LogInfo((object)$"Computer NEED HELP synced exchange index {index} to {num} remote(s).");
			}
		}

		private static void OnNetMessage(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0006: 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_0019: 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)
			byte b = default(byte);
			((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref b, default(ForPrimitives));
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			NetworkManager singleton = NetworkManager.Singleton;
			bool flag = (Object)(object)singleton != (Object)null && singleton.IsServer;
			if (Plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)$"Computer HELP net kind={b} index={num} from={senderClientId} isServer={flag}");
			}
			switch (b)
			{
			case 0:
				if (flag)
				{
					BroadcastHelpFromServer();
				}
				break;
			case 1:
				ComputerHelpAudio.TryPlayIndex(num);
				break;
			case 2:
				if (flag)
				{
					ComputerHelpMonitor.TryPlaySyncedExchange(num);
					int num2 = SendToRemoteClients(3, num, senderClientId);
					Plugin.Log.LogInfo((object)($"Computer NEED HELP host relayed exchange {num} " + $"(except sender {senderClientId}, {num2} other remote(s))."));
				}
				break;
			case 3:
				ComputerHelpMonitor.TryPlaySyncedExchange(num);
				break;
			default:
				Plugin.Log.LogWarning((object)$"Computer HELP unknown net kind {b}");
				break;
			}
		}

		private static void BroadcastHelpFromServer()
		{
			int num = ComputerHelpAudio.PickRandomIndex();
			if (num < 0)
			{
				Plugin.Log.LogWarning((object)"Computer HELP: no clips available to play.");
				return;
			}
			int num2 = SendToRemoteClients(1, num, ulong.MaxValue);
			ComputerHelpAudio.TryPlayIndex(num);
			Plugin.Log.LogInfo((object)$"Computer HELP synced clip index {num} (local + {num2} remote).");
		}

		private static int SendToRemoteClients(byte kind, int index, ulong extraExcept)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null)
			{
				return 0;
			}
			ulong localClientId = singleton.LocalClientId;
			int num = 0;
			foreach (ulong connectedClientsId in singleton.ConnectedClientsIds)
			{
				if (connectedClientsId != localClientId && connectedClientsId != extraExcept)
				{
					Send(connectedClientsId, kind, index);
					num++;
				}
			}
			return num;
		}

		private unsafe static void Send(ulong clientId, byte kind, int index)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(16, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<byte>(ref kind, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref index, default(ForPrimitives));
				singleton.CustomMessagingManager.SendNamedMessage("CapsCrew_ComputerHelp_Net", clientId, val, (NetworkDelivery)2);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Start")]
	internal static class ComputerHelpNetworkBootstrapPatch
	{
		[HarmonyPostfix]
		private static void AfterGameNetworkManagerStart()
		{
			ComputerHelpNetwork.TryRegister();
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Start")]
	internal static class ComputerHelpRoundBootstrapPatch
	{
		[HarmonyPostfix]
		private static void AfterRoundStart()
		{
			ComputerHelpNetwork.TryRegister();
			ComputerHelpAudio.EnsureInitialized();
			ComputerHelpMonitor.Reload();
		}
	}
	internal static class ModContentPaths
	{
		internal static string ContentRoot { get; private set; } = "";

		internal static void Initialize(string dllPath)
		{
			string directoryName = Path.GetDirectoryName(dllPath);
			if (string.IsNullOrWhiteSpace(directoryName))
			{
				ContentRoot = "";
				return;
			}
			ContentRoot = Path.GetFullPath(directoryName);
			Plugin.PluginPath = ContentRoot;
		}

		internal static string GetFolder(string folderName)
		{
			if (string.IsNullOrWhiteSpace(ContentRoot))
			{
				return folderName;
			}
			string text = Path.Combine(ContentRoot, folderName);
			if (Directory.Exists(text))
			{
				return text;
			}
			try
			{
				string text2 = Directory.GetDirectories(ContentRoot, folderName, SearchOption.AllDirectories).FirstOrDefault();
				if (!string.IsNullOrWhiteSpace(text2))
				{
					return text2;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Computer HELP: search for '" + folderName + "' failed: " + ex.Message));
			}
			return text;
		}

		internal static string ResolveExchangeDirectory()
		{
			string folder = GetFolder(Plugin.ExchangeFolderName.Value);
			if (Directory.Exists(folder))
			{
				return folder;
			}
			if (!string.IsNullOrWhiteSpace(ContentRoot) && File.Exists(Path.Combine(ContentRoot, "manifest.json")) && Directory.EnumerateFiles(ContentRoot, "*.wav", SearchOption.TopDirectoryOnly).Any())
			{
				Plugin.Log.LogInfo((object)("Computer HELP: using flattened exchange layout at plugin root (" + ContentRoot + ")."));
				return ContentRoot;
			}
			return folder;
		}

		internal static string ResolveSoundsDirectory()
		{
			string folder = GetFolder(Plugin.SoundsFolderName.Value);
			if (Directory.Exists(folder))
			{
				return folder;
			}
			if (!string.IsNullOrWhiteSpace(ContentRoot) && Directory.EnumerateFiles(ContentRoot, "*.mp3", SearchOption.TopDirectoryOnly).Any())
			{
				Plugin.Log.LogInfo((object)("Computer HELP: using flattened one-liner layout at plugin root (" + ContentRoot + ")."));
				return ContentRoot;
			}
			return folder;
		}

		internal static string ResolveChaseDirectory()
		{
			string folder = GetFolder(Plugin.ChaseFolderName.Value);
			if (Directory.Exists(folder) && HasAudioFiles(folder))
			{
				return folder;
			}
			if (!string.IsNullOrWhiteSpace(ContentRoot))
			{
				string[] files = Directory.GetFiles(ContentRoot, "CHASE_*.mp3", SearchOption.TopDirectoryOnly);
				if (files.Length != 0)
				{
					Plugin.Log.LogInfo((object)$"Computer HELP: using flattened chase clip(s) at plugin root ({files.Length}).");
					return ContentRoot;
				}
			}
			return folder;
		}

		private static bool HasAudioFiles(string dir)
		{
			string[] array = new string[3] { "*.mp3", "*.wav", "*.ogg" };
			foreach (string searchPattern in array)
			{
				if (Directory.GetFiles(dir, searchPattern, SearchOption.TopDirectoryOnly).Length != 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static void LogInventory()
		{
			if (string.IsNullOrWhiteSpace(ContentRoot))
			{
				Plugin.Log.LogError((object)"Computer HELP: plugin content root is empty.");
				return;
			}
			Plugin.Log.LogInfo((object)("Computer HELP content root: " + ContentRoot));
			if (!File.Exists(Path.Combine(ContentRoot, "Newtonsoft.Json.dll")))
			{
				Plugin.Log.LogWarning((object)"Computer HELP: Newtonsoft.Json.dll missing next to plugin DLL.");
			}
			LogFolder("COMPUTER HELP", "*.mp3", "*.wav", "*.ogg");
			LogFolder("sounds_exchanges", "*.wav", "*.mp3", "*.ogg");
			LogFolder(Plugin.ExchangeFolderName.Value, "*.wav", "*.mp3", "*.ogg");
			LogFolder(Plugin.ChaseFolderName.Value, "*.mp3", "*.wav", "*.ogg");
		}

		private static void LogFolder(string folderName, params string[] patterns)
		{
			string dir = GetFolder(folderName);
			if (!Directory.Exists(dir))
			{
				Plugin.Log.LogWarning((object)("Computer HELP: missing folder '" + folderName + "' at " + dir));
				return;
			}
			int num = patterns.Sum((string pattern) => Directory.GetFiles(dir, pattern, SearchOption.TopDirectoryOnly).Length);
			Plugin.Log.LogInfo((object)$"Computer HELP: {num} audio file(s) in {dir}");
		}
	}
	[BepInPlugin("capscrew.computerhelp", "Computer HELP", "0.2.5")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "capscrew.computerhelp";

		public const string PluginName = "Computer HELP";

		public const string PluginVersion = "0.2.5";

		internal static Plugin Instance = null;

		internal static ManualLogSource Log = null;

		internal static string PluginPath = "";

		internal static ConfigEntry<string> TriggerWord = null;

		internal static ConfigEntry<string> SoundTriggers = null;

		internal static ConfigEntry<bool> EnableChatSoundTrigger = null;

		internal static ConfigEntry<bool> EnableTerminalSoundTrigger = null;

		internal static ConfigEntry<string> NeedHelpTrigger = null;

		internal static ConfigEntry<bool> EnableNeedHelp = null;

		internal static ConfigEntry<string> ExchangeFolderName = null;

		internal static ConfigEntry<bool> ExchangeSpatialAudio = null;

		internal static ConfigEntry<float> Volume = null;

		internal static ConfigEntry<string> SoundsFolderName = null;

		internal static ConfigEntry<bool> SyncAcrossLobby = null;

		internal static ConfigEntry<bool> DebugLogging = null;

		internal static ConfigEntry<bool> EnableChaseMusic = null;

		internal static ConfigEntry<float> ChaseVolume = null;

		internal static ConfigEntry<string> ChaseFolderName = null;

		private void Awake()
		{
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			ModContentPaths.Initialize(((BaseUnityPlugin)this).Info.Location);
			PluginPath = ModContentPaths.ContentRoot;
			TriggerWord = ((BaseUnityPlugin)this).Config.Bind<string>("General", "TriggerWord", "help", "Primary trigger word (also listed in SoundTriggers).");
			SoundTriggers = ((BaseUnityPlugin)this).Config.Bind<string>("General", "SoundTriggers", "help", "Comma-separated words that play a random Computer one-liner in chat or at the ship terminal. Default 'help' replaces vanilla terminal help menu with a sound line.");
			EnableChatSoundTrigger = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableChatSoundTrigger", true, "Play random Computer line when TriggerWord is typed in chat.");
			EnableTerminalSoundTrigger = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableTerminalSoundTrigger", true, "Play random Computer line when TriggerWord is typed at ship terminal.");
			NeedHelpTrigger = ((BaseUnityPlugin)this).Config.Bind<string>("General", "NeedHelpTrigger", "need help", "Terminal phrase for full exchange monitor page + audio.");
			EnableNeedHelp = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableNeedHelp", true, "Enable the need help exchange page on the ship terminal.");
			ExchangeFolderName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ExchangeFolderName", "sounds_exchanges", "Subfolder with manifest.json + exchange .wav files for need help.");
			ExchangeSpatialAudio = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ExchangeSpatialAudio", true, "Play need-help exchange audio from the ship terminal speaker (3D/local range).");
			Volume = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Volume", 0.85f, "Playback volume 0-1.");
			SoundsFolderName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "SoundsFolderName", "COMPUTER HELP", "Subfolder under the plugin directory with .mp3 clips.");
			SyncAcrossLobby = ((BaseUnityPlugin)this).Config.Bind<bool>("Network", "SyncAcrossLobby", true, "Any player can trigger help / need help; host relays the same clip so the whole lobby hears it.");
			DebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", true, "Extra BepInEx log lines for trigger/load/play troubleshooting.");
			EnableChaseMusic = ((BaseUnityPlugin)this).Config.Bind<bool>("Chase", "EnableChaseMusic", true, "Play chase music when a monster chases you (needs MP3s in CHASE MUSIC folder).");
			ChaseVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Chase", "ChaseVolume", 0.65f, "Chase music volume 0-1.");
			ChaseFolderName = ((BaseUnityPlugin)this).Config.Bind<string>("Chase", "ChaseFolderName", "CHASE MUSIC", "Subfolder under the plugin directory with chase .mp3 clips.");
			Log.LogInfo((object)("Computer HELP v0.2.5 loading from " + PluginPath));
			new Harmony("capscrew.computerhelp").PatchAll();
			ComputerHelpAudio.Initialize();
			ComputerHelpChase.Initialize();
			ComputerHelpMonitor.Reload();
			ModContentPaths.LogInventory();
		}

		internal static string[] GetSoundTriggers()
		{
			string[] array = (SoundTriggers?.Value ?? TriggerWord?.Value ?? "help").Split(new char[3] { ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
			List<string> list = new List<string>();
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text = array2[i].Trim();
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				bool flag = false;
				foreach (string item in list)
				{
					if (string.Equals(item, text, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(text);
				}
			}
			string text2 = TriggerWord?.Value?.Trim();
			if (!string.IsNullOrWhiteSpace(text2))
			{
				bool flag2 = false;
				foreach (string item2 in list)
				{
					if (string.Equals(item2, text2, StringComparison.OrdinalIgnoreCase))
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					list.Insert(0, text2);
				}
			}
			if (list.Count <= 0)
			{
				return new string[1] { "help" };
			}
			return list.ToArray();
		}
	}
}
namespace CapsCrew.ComputerHelp.Patches
{
	internal static class ChatHelpTriggers
	{
		internal static bool IsNeedHelpMessage(string? message)
		{
			if (string.IsNullOrWhiteSpace(message))
			{
				return false;
			}
			return string.Equals(message.Trim(), Plugin.NeedHelpTrigger.Value, StringComparison.OrdinalIgnoreCase);
		}

		internal static bool IsSoundTriggerMessage(string? message)
		{
			if (string.IsNullOrWhiteSpace(message))
			{
				return false;
			}
			string text = message.Trim();
			if (IsNeedHelpMessage(text))
			{
				return false;
			}
			string[] soundTriggers = Plugin.GetSoundTriggers();
			foreach (string b in soundTriggers)
			{
				if (string.Equals(text, b, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddTextToChatOnServer")]
	internal static class ChatHelpServerPatch
	{
		[HarmonyPostfix]
		private static void AfterServerChat(string chatMessage)
		{
			if (Plugin.EnableChatSoundTrigger.Value && ChatHelpTriggers.IsSoundTriggerMessage(chatMessage))
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (!((Object)(object)singleton != (Object)null) || !singleton.IsListening || singleton.IsServer)
				{
					ComputerHelpNetwork.ServerPlayHelp();
				}
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageServerRpc")]
	internal static class ChatHelpServerRpcPatch
	{
		[HarmonyPostfix]
		private static void AfterPlayerChatServerRpc(string chatMessage)
		{
			if (Plugin.EnableChatSoundTrigger.Value)
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (!((Object)(object)singleton == (Object)null) && singleton.IsServer && ChatHelpTriggers.IsSoundTriggerMessage(chatMessage))
				{
					ComputerHelpNetwork.ServerPlayHelp();
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyAI), "Update")]
	internal static class EnemyChasePatch
	{
		[HarmonyPostfix]
		private static void AfterEnemyUpdate(EnemyAI __instance)
		{
			ComputerHelpChase.Tick(__instance);
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
	internal static class ComputerHelpChaseResetPatch
	{
		[HarmonyPostfix]
		private static void AfterRoundDestroyed()
		{
			ComputerHelpChase.Reset();
		}
	}
	[HarmonyPatch(typeof(Terminal), "OnSubmit")]
	internal static class TerminalComputerPatch
	{
		[HarmonyPrefix]
		private static bool BeforeSubmit(Terminal __instance)
		{
			if (!Plugin.EnableTerminalSoundTrigger.Value)
			{
				return true;
			}
			string submittedCommand = TerminalInput.GetSubmittedCommand(__instance);
			if (ChatHelpTriggers.IsNeedHelpMessage(submittedCommand))
			{
				return true;
			}
			if (!ChatHelpTriggers.IsSoundTriggerMessage(submittedCommand))
			{
				return true;
			}
			Plugin.Log.LogInfo((object)"Computer sound triggered from terminal.");
			ComputerHelpNetwork.ServerPlayHelp();
			TerminalInput.ClearSubmittedInput(__instance);
			return false;
		}
	}
	internal static class TerminalInput
	{
		internal static string GetSubmittedCommand(Terminal terminal)
		{
			if (terminal.textAdded <= 0)
			{
				return string.Empty;
			}
			string text = terminal.currentText ?? string.Empty;
			if (text.Length < terminal.textAdded)
			{
				return string.Empty;
			}
			return text.Substring(text.Length - terminal.textAdded).Trim();
		}

		internal static void ClearSubmittedInput(Terminal terminal)
		{
			terminal.textAdded = 0;
			object value = Traverse.Create((object)terminal).Field("screenText").GetValue();
			if (value != null)
			{
				Traverse.Create(value).Property("text", (object[])null).SetValue((object)terminal.currentText);
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "OnSubmit")]
	internal static class TerminalNeedHelpPatch
	{
		[HarmonyPrefix]
		private static bool BeforeSubmit(Terminal __instance)
		{
			if (!Plugin.EnableNeedHelp.Value)
			{
				return true;
			}
			if (!ChatHelpTriggers.IsNeedHelpMessage(TerminalInput.GetSubmittedCommand(__instance)))
			{
				return true;
			}
			Plugin.Log.LogInfo((object)"Computer NEED HELP triggered from terminal.");
			if (!ComputerHelpMonitor.TryShowOnTerminal(__instance))
			{
				Plugin.Log.LogWarning((object)"Computer NEED HELP: no exchange content available.");
			}
			return false;
		}
	}
}