using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using TMPro;
using TerminalApi;
using TerminalApi.Classes;
using Unity.Netcode;
using UnityEngine;

[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("TerminalSeedPicker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TerminalSeedPicker")]
[assembly: AssemblyTitle("TerminalSeedPicker")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
namespace TerminalSeedPicker
{
	[BepInPlugin("thej01.lc.TerminalSeedPicker", "TerminalSeedPicker", "2.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public enum TerminalSounds
		{
			PurchaseSFX,
			TypoError,
			LoadImage,
			Alarm
		}

		public static class SeedVerbs
		{
			public static List<TerminalKeyword> setVerbs = new List<TerminalKeyword>
			{
				TerminalApi.CreateTerminalKeyword("set", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("s", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("change", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("modify", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("alter", true, (TerminalNode)null)
			};

			public static List<TerminalKeyword> getVerbs = new List<TerminalKeyword>
			{
				TerminalApi.CreateTerminalKeyword("get", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("g", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("recieve", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("check", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("see", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("obtain", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("print", true, (TerminalNode)null)
			};

			public static List<TerminalKeyword> randomVerbs = new List<TerminalKeyword>
			{
				TerminalApi.CreateTerminalKeyword("random", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("rand", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("r", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("randomize", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("randomise", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("generate", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("gen", true, (TerminalNode)null),
				TerminalApi.CreateTerminalKeyword("choose", true, (TerminalNode)null)
			};
		}

		public enum SeedType
		{
			Random,
			SetNum,
			SetString,
			SetRandomized,
			SetChallengeMoon
		}

		[Serializable]
		public class SeedInfo
		{
			[SerializeField]
			public int seedNum;

			[SerializeField]
			public SeedType seedType;

			[SerializeField]
			public string seedWord = "";

			public SeedInfo(bool fromCurrentMoon = false)
			{
				if (fromCurrentMoon)
				{
					InitFromCurrentMoon();
				}
				else
				{
					Reset();
				}
			}

			public SeedInfo(int seedNum, SeedType seedType, string seedWord = "")
			{
				this.seedNum = seedNum;
				this.seedWord = seedWord;
				this.seedType = seedType;
			}

			public void Reset()
			{
				seedNum = 0;
				seedWord = "";
				seedType = SeedType.Random;
			}

			public void InitFromCurrentMoon()
			{
				Reset();
				seedNum = StartOfRound.Instance.randomMapSeed;
				seedType = SeedType.Random;
				if (StartOfRound.Instance.isChallengeFile)
				{
					seedType = SeedType.SetChallengeMoon;
				}
			}

			public string GetTerminalSecondLine()
			{
				string result = "";
				switch (seedType)
				{
				case SeedType.SetString:
					result = "[Generated from '" + seedWord + "']";
					break;
				case SeedType.SetRandomized:
					result = "[Randomly generated]";
					break;
				case SeedType.SetChallengeMoon:
					result = "[Challenge Moon]";
					break;
				default:
					result = $"UNDEFINED SEEDTYPE: {seedType}";
					break;
				case SeedType.Random:
				case SeedType.SetNum:
					break;
				}
				return result;
			}

			public string TerminalTextWhenSet()
			{
				string terminalSecondLine = GetTerminalSecondLine();
				string text = $"[Seed has been set to {seedNum}.]";
				if (!Utility.IsNullOrWhiteSpace(terminalSecondLine))
				{
					text += "\n";
				}
				return text + terminalSecondLine + "\n\n";
			}

			public string GetTerminalEntry()
			{
				string terminalSecondLine = GetTerminalSecondLine();
				string text = $"[Random moon seed is {seedNum}]";
				if (seedType != 0)
				{
					text = $"[Set moon seed is {seedNum}]";
				}
				if (!Utility.IsNullOrWhiteSpace(terminalSecondLine))
				{
					text += "\n";
				}
				return text + terminalSecondLine + "\n\n";
			}

			public string GetLoadingText()
			{
				string text = $"Set Seed: {seedNum}";
				string text2 = "";
				switch (seedType)
				{
				case SeedType.SetString:
					text2 = "(Generated from: '" + seedWord + "')";
					break;
				case SeedType.SetRandomized:
					text2 = "(Randomly Generated)";
					break;
				case SeedType.SetChallengeMoon:
					text2 = "(Challenge Moon)";
					break;
				default:
					text2 = "(Unknown Origin)";
					break;
				case SeedType.SetNum:
					break;
				}
				if (!Utility.IsNullOrWhiteSpace(text2))
				{
					text = text + " " + text2;
				}
				return text;
			}

			public SeedInfo Copy()
			{
				return new SeedInfo(seedNum, seedType, seedWord);
			}
		}

		public const string modGUID = "thej01.lc.TerminalSeedPicker";

		public const string modName = "TerminalSeedPicker";

		public const string modVersion = "2.0.0";

		public static LNetworkMessage<SeedInfo> syncNextMoonSeedInfo;

		public static LNetworkEvent requestSeedFromClient;

		public const int minSeed = 1;

		public const int maxSeed = 100000000;

		public static readonly Harmony harmony;

		public static ManualLogSource Log;

		public static TerminalNode seedNode;

		public static TerminalKeyword seedKeyword;

		public static Terminal? terminal;

		public static SeedInfo currentMoonSeedInfo;

		public static SeedInfo nextMoonSeedInfo;

		public static void AddVerbToSeed(List<TerminalKeyword> keywords)
		{
			foreach (TerminalKeyword keyword in keywords)
			{
				TerminalExtenstionMethods.AddCompatibleNoun(keyword, seedKeyword, seedNode);
				TerminalApi.AddTerminalKeyword(keyword);
			}
		}

		public void Awake()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"TerminalSeedPicker 2.0.0 is loading...");
			Log.LogInfo((object)"Loading patches...");
			harmony.PatchAll();
			Log.LogInfo((object)"Loaded patches.");
			Log.LogInfo((object)"Adding terminal commands...");
			AddVerbToSeed(SeedVerbs.setVerbs);
			AddVerbToSeed(SeedVerbs.getVerbs);
			AddVerbToSeed(SeedVerbs.randomVerbs);
			seedKeyword.defaultVerb = SeedVerbs.getVerbs[0];
			TerminalApi.AddTerminalKeyword(seedKeyword, new CommandInfo
			{
				Title = "[Set/Get/Random] SEED [Seed]",
				TriggerNode = seedNode,
				DisplayTextSupplier = RunSeedCommand,
				Category = "Other",
				Description = "To modify the current moon seed or get information about it. Defaults to \"Get\"\nType \"Set SEED [Seed]\" to set a new moon seed. [Seed] can be text OR numbers.\nType \"Get SEED\" to have the terminal print info on the current seed.\nType \"Random SEED\" to set the moon seed to a completely random one."
			});
			Log.LogInfo((object)"Added terminal commands.");
			Log.LogInfo((object)"TerminalSeedPicker 2.0.0 is loaded.");
		}

		public static string RunSeedCommand()
		{
			string[] array = TerminalApi.GetTerminalInput().Trim().Split(' ');
			bool flag = false;
			List<string> list = new List<string>();
			for (int i = 0; i < array.Length; i++)
			{
				if (flag)
				{
					list.Add(array[i]);
				}
				else if (array[i].ToLower() == seedKeyword.word)
				{
					flag = true;
					i -= 2;
					if (i < -1)
					{
						i = -1;
					}
				}
			}
			array = list.ToArray();
			string text = array[0].ToLower();
			foreach (TerminalKeyword setVerb in SeedVerbs.setVerbs)
			{
				if (setVerb.word == text)
				{
					return SetSeedCommand(array);
				}
			}
			foreach (TerminalKeyword getVerb in SeedVerbs.getVerbs)
			{
				if (getVerb.word == text)
				{
					return GetSeedCommand();
				}
			}
			foreach (TerminalKeyword randomVerb in SeedVerbs.randomVerbs)
			{
				if (randomVerb.word == text)
				{
					return RandomSeedCommand();
				}
			}
			return GetSeedCommand();
		}

		public static string SetSeedCommand(string[] inputSplitOriginal)
		{
			string[] array = new string[3];
			bool flag = false;
			bool flag2 = false;
			string text = "";
			array[0] = inputSplitOriginal[0];
			array[1] = inputSplitOriginal[1];
			for (int i = 2; i < inputSplitOriginal.Length; i++)
			{
				flag2 = false;
				if (!Utility.IsNullOrWhiteSpace(inputSplitOriginal[i]) && !flag)
				{
					flag = true;
					flag2 = true;
					array[2] = inputSplitOriginal[i];
				}
				if (flag && !Utility.IsNullOrWhiteSpace(inputSplitOriginal[i]))
				{
					if (!flag2)
					{
						text += " ";
					}
					text += inputSplitOriginal[i];
				}
			}
			text.Trim();
			text = text.Replace("\"", "");
			text = text.Replace("&", "");
			text = text.Replace("^", "");
			text = text.Replace("@", "");
			text = text.Replace("+", "");
			text = text.Replace("~", "");
			if (inputSplitOriginal.Length < 3 || !flag || Utility.IsNullOrWhiteSpace(text))
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed is empty!]\n\n";
			}
			bool flag3 = false;
			flag3 = int.TryParse(text, out var result);
			if (flag3 && result > 100000000)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be greater than " + 100000000.ToString("N0") + "!]\n\n";
			}
			if (flag3 && result < 1)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be less than " + 1.ToString("N0") + "!]\n\n";
			}
			if (!RoundManager.Instance.playersManager.inShipPhase)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be changed after landing.]\n\n";
			}
			if (StartOfRound.Instance.isChallengeFile)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be changed on a Challenge Moon.]\n\n";
			}
			if (!flag3)
			{
				result = StringToSeed(text);
			}
			nextMoonSeedInfo.Reset();
			nextMoonSeedInfo.seedNum = result;
			if (flag3)
			{
				nextMoonSeedInfo.seedType = SeedType.SetNum;
			}
			else
			{
				nextMoonSeedInfo.seedType = SeedType.SetString;
				nextMoonSeedInfo.seedWord = text;
			}
			SendSeedToAll();
			PlayTerminalAudio(TerminalSounds.LoadImage);
			return nextMoonSeedInfo.TerminalTextWhenSet();
		}

		public static int StringToSeed(string seedString)
		{
			int hashCode = seedString.GetHashCode();
			hashCode = Math.Abs(hashCode);
			hashCode %= 100000000;
			if (hashCode < 1)
			{
				hashCode++;
			}
			return hashCode;
		}

		public static string GetSeedCommand()
		{
			if (StartOfRound.Instance.inShipPhase)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				if (Random.Range(1, 100) == 1)
				{
					return "[No.]\n\n";
				}
				return "[Must land on a moon first before checking seed!]\n\n";
			}
			return currentMoonSeedInfo.GetTerminalEntry();
		}

		public static string RandomSeedCommand()
		{
			if (!RoundManager.Instance.playersManager.inShipPhase)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be changed after landing.]\n\n";
			}
			if (StartOfRound.Instance.isChallengeFile)
			{
				PlayTerminalAudio(TerminalSounds.TypoError);
				return "[Seed cannot be changed on a Challenge Moon.]\n\n";
			}
			PlayTerminalAudio(TerminalSounds.LoadImage);
			nextMoonSeedInfo.seedNum = Random.Range(1, 100000000);
			nextMoonSeedInfo.seedType = SeedType.SetRandomized;
			SendSeedToAll();
			return nextMoonSeedInfo.TerminalTextWhenSet();
		}

		public static void SendSeedToAll()
		{
			if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsServer)
			{
				syncNextMoonSeedInfo.SendClients(nextMoonSeedInfo);
				return;
			}
			syncNextMoonSeedInfo.SendOtherClients(nextMoonSeedInfo);
			syncNextMoonSeedInfo.SendServer(nextMoonSeedInfo);
		}

		public static void SyncNextMoonSeedShared(SeedInfo info)
		{
			Log.LogInfo((object)"Recieved seed info sync, values:");
			nextMoonSeedInfo = info;
			Log.LogInfo((object)$"seedNum: {nextMoonSeedInfo.seedNum} seedType: {nextMoonSeedInfo.seedType} seedWord: {nextMoonSeedInfo.seedWord}");
		}

		public static void SyncNextMoonSeedInfo(SeedInfo info)
		{
			SyncNextMoonSeedShared(info);
		}

		public static void SyncNextMoonSeedInfo(SeedInfo info, ulong clientID)
		{
			SyncNextMoonSeedShared(info);
		}

		public static void RequestSeedFromClient(ulong clientID)
		{
			syncNextMoonSeedInfo.SendClient(nextMoonSeedInfo, clientID);
		}

		public static Terminal GetTerminal()
		{
			if ((Object)(object)terminal == (Object)null)
			{
				terminal = Object.FindObjectOfType<Terminal>();
			}
			return terminal;
		}

		public static void PlayTerminalAudio(TerminalSounds audio)
		{
			GetTerminal().PlayTerminalAudioServerRpc((int)audio);
		}

		static Plugin()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			Action<SeedInfo> action = SyncNextMoonSeedInfo;
			Action<SeedInfo, ulong> action2 = SyncNextMoonSeedInfo;
			syncNextMoonSeedInfo = LNetworkMessage<SeedInfo>.Connect("thej01.lc.TerminalSeedPicker.syncNextMoonSeedInfo", (Action<SeedInfo, ulong>)SyncNextMoonSeedInfo, action, action2);
			requestSeedFromClient = LNetworkEvent.Connect("thej01.lc.TerminalSeedPicker.requestSeedFromClient", (Action<ulong>)RequestSeedFromClient, (Action)null, (Action<ulong>)null);
			harmony = new Harmony("thej01.lc.TerminalSeedPicker");
			Log = new ManualLogSource("thej01.lc.TerminalSeedPicker");
			seedNode = TerminalApi.CreateTerminalNode("this shouldn't appear\n\n", true, "");
			seedKeyword = TerminalApi.CreateTerminalKeyword("seed", false, (TerminalNode)null);
			terminal = null;
			currentMoonSeedInfo = new SeedInfo();
			nextMoonSeedInfo = new SeedInfo();
		}
	}
}
namespace TerminalSeedPicker.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		[HarmonyPatch("ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void ResetSeedInfo()
		{
			Plugin.currentMoonSeedInfo.Reset();
			Plugin.nextMoonSeedInfo.Reset();
			StartOfRound.Instance.overrideRandomSeed = false;
			if (!((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsServer)
			{
				Plugin.requestSeedFromClient.InvokeServer();
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	public class RoundManagerPatch
	{
		[HarmonyPatch("GenerateNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void ChangeText(RoundManager __instance)
		{
			if (Plugin.nextMoonSeedInfo.seedType != 0 && !StartOfRound.Instance.isChallengeFile)
			{
				Plugin.currentMoonSeedInfo = Plugin.nextMoonSeedInfo.Copy();
			}
			else
			{
				Plugin.currentMoonSeedInfo.InitFromCurrentMoon();
			}
			if (Plugin.currentMoonSeedInfo.seedType != 0)
			{
				((TMP_Text)HUDManager.Instance.loadingText).text = Plugin.currentMoonSeedInfo.GetLoadingText();
			}
		}

		[HarmonyPatch("FinishGeneratingNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void ResetNextMoonInfo()
		{
			Plugin.nextMoonSeedInfo.Reset();
		}

		[HarmonyPatch("LoadNewLevel")]
		[HarmonyPostfix]
		public static void DisableOverride()
		{
			StartOfRound.Instance.overrideRandomSeed = false;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("StartGame")]
		[HarmonyPrefix]
		public static void ApplyNewSeed(StartOfRound __instance)
		{
			if (Plugin.nextMoonSeedInfo.seedType != 0 && !StartOfRound.Instance.isChallengeFile)
			{
				__instance.overrideRandomSeed = true;
				__instance.overrideSeedNumber = Plugin.nextMoonSeedInfo.seedNum;
			}
		}
	}
}