using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Hura.Project;
using Hura.Project.Cheats;
using Hura.Project.Utility;
using HuraHappyTimes.Project;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("HuraHappyTimes")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HP")]
[assembly: AssemblyProduct("HuraHappyTimes")]
[assembly: AssemblyCopyright("Copyright © HP 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("36b637e7-d1d5-43d1-94b8-14d41177383c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HuraHappyTimes.Project
{
	[HarmonyPatch(typeof(ShipTeleporter))]
	public class TeleporterCheat
	{
		[HarmonyPatch("PressTeleportButtonClientRpc")]
		[HarmonyPrefix]
		public static void OnTeleportPressedPatch(ref ShipTeleporter __instance)
		{
			__instance.cooldownAmount = 10f;
		}
	}
}
namespace Hura
{
	[BepInPlugin("Hura.HappyTimes", "Hura Happy Times", "1.0.2")]
	public class HuraHappyTimes : BaseUnityPlugin
	{
		private const string MOD_GUID = "Hura.HappyTimes";

		private const string MOD_NAME = "Hura Happy Times";

		private const string MOD_VERSION = "1.0.2";

		private readonly Harmony harmony = new Harmony("Hura.HappyTimes");

		public static HuraHappyTimes Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Log.Init(Logger.CreateLogSource("Hura.HappyTimes"));
			harmony.PatchAll(typeof(HuraHappyTimes));
			harmony.PatchAll(typeof(TerminalHelper));
			harmony.PatchAll(typeof(TerminalCheats));
			harmony.PatchAll(typeof(TeleporterCheat));
			Log.Message("Hura's Happy Times has been loaded!");
		}
	}
	public static class Log
	{
		private static ManualLogSource logger;

		public static void Init(ManualLogSource instance)
		{
			logger = instance;
		}

		public static void Message(string message)
		{
			logger.LogMessage((object)message);
		}

		public static void Error(string error)
		{
			logger.LogError((object)error);
		}

		public static void Warning(string warning)
		{
			logger.LogWarning((object)warning);
		}

		public static void NullReference(object obj, string name)
		{
			logger.LogMessage((object)("Is " + name + " null? " + ((obj == null) ? "Yes" : "No")));
		}
	}
}
namespace Hura.Project
{
	internal static class ItemsHelper
	{
		public const string WALKIE_TALKIE_NAME = "Walkie-talkie";

		public const string FLASHLIGHT_NAME = "Flashlight";

		public const string SHOVEL_NAME = "Shovel";

		public const string LOCKPICKER_NAME = "Lockpicker";

		public const string PRO_FLASHLIGHT_NAME = "Pro-flashlight";

		public const string STUN_GRENADE_NAME = "Stun grenade";

		public const string BOOMBOX_NAME = "Boombox";

		public const string TZP_INHALANT_NAME = "TZP-Inhalant";

		public const string ZAP_GUN_NAME = "Zap gun";

		public const string JETPACK_NAME = "Jetpack";

		public const string EXTENSION_LADDER_NAME = "Extension ladder";

		public const string RADAR_BOOSTER_NAME = "Radar-booster";

		public const string SPRAY_PAINT_NAME = "Spray paint";

		public static Item[] GetItems()
		{
			return TerminalHelper.Terminal.buyableItemsList;
		}

		public static Item GetItem(string itemName)
		{
			Item[] items = GetItems();
			foreach (Item val in items)
			{
				if (val.itemName == itemName)
				{
					return val;
				}
			}
			Log.Error("Couldn't find item with name: " + itemName + ".");
			return null;
		}
	}
	internal static class MoonsHelper
	{
		public struct MoonData
		{
			public int Cost { get; set; }

			public TerminalNode Node { get; set; }

			public TerminalNode ConfirmNode { get; set; }

			public string Name => ((Object)Node).name;
		}

		public enum RerouteID
		{
			Company = -1,
			Moons = -2
		}

		private static List<MoonData> moons;

		public static IReadOnlyList<MoonData> Moons => moons;

		public static bool IsMoonsConfirmationNode(TerminalNode node)
		{
			if (node.buyRerouteToMoon != -1)
			{
				return node.buyRerouteToMoon != -2;
			}
			return false;
		}

		public static void PopulateMoonsData()
		{
			Terminal terminal = TerminalHelper.Terminal;
			if ((Object)(object)terminal == (Object)null)
			{
				Log.Error("Error while populating moons data. Couldn't find the Terminal.");
				return;
			}
			moons = new List<MoonData>();
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if ((Object)(object)val == (Object)null || val.word == null || !(val.word == "route"))
				{
					continue;
				}
				CompatibleNoun[] compatibleNouns = val.compatibleNouns;
				for (int j = 0; j < compatibleNouns.Length; j++)
				{
					TerminalNode result = compatibleNouns[j].result;
					if ((Object)(object)result == (Object)null || result.buyRerouteToMoon != -2)
					{
						continue;
					}
					MoonData item = default(MoonData);
					item.Node = result;
					item.Cost = result.itemCost;
					CompatibleNoun[] terminalOptions = result.terminalOptions;
					foreach (CompatibleNoun val2 in terminalOptions)
					{
						if (val2.result.itemCost > 0)
						{
							item.ConfirmNode = val2.result;
						}
					}
					moons.Add(item);
					Log.Message($"Added Moon. Node: {item.Node}. Cost: {item.Cost}.");
				}
			}
		}
	}
	public enum SpecialTerminalNode
	{
		Login,
		Home,
		CannotAffordItems,
		UnableToRouteNeedOrbit,
		DevileryVehicleIsFull,
		Error,
		MissingCreatureData,
		UnableToBuyDecorationNeedOrbit,
		AlreadyInOrbit,
		DataCorrupted,
		NoActionWasGivenWithWord,
		ParsingError,
		ActionWasIncompatibleWithObject,
		Help,
		AlreadyUnlock,
		ShipIsStuck,
		ItemNotInStock,
		ItemReturnedFromStorage,
		LockedFromDemo,
		BroadcastCodeEntered,
		RadarSwitchToPlayer,
		RadarPinged,
		TransmissionSent,
		FlashedRadar
	}
	[HarmonyPatch(typeof(Terminal))]
	public static class TerminalHelper
	{
		private static StringBuilder stringBuilder = new StringBuilder();

		public static Terminal Terminal { get; private set; }

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void RegisterTerminalInstance(ref Terminal __instance)
		{
			Terminal = __instance;
		}

		public static TerminalNode CreateNode(string text, bool clear = true)
		{
			TerminalNode obj = ScriptableObject.CreateInstance<TerminalNode>();
			obj.displayText = text;
			obj.clearPreviousText = clear;
			return obj;
		}

		public static TerminalKeyword CreateKeyword(string word, bool isVerb, TerminalNode destinationNode)
		{
			TerminalKeyword obj = ScriptableObject.CreateInstance<TerminalKeyword>();
			obj.word = word;
			obj.isVerb = isVerb;
			obj.specialKeywordResult = destinationNode;
			return obj;
		}

		public static void AddKeyworkToTerminal(TerminalKeyword keyword)
		{
			ArrayUtility.Add(ref Terminal.terminalNodes.allKeywords, keyword);
		}

		public static string CreateNodeText(params string[] args)
		{
			stringBuilder.Clear();
			for (int i = 0; i < args.Length; i++)
			{
				stringBuilder.Append(args[i]).Append("\n");
			}
			return stringBuilder.ToString();
		}

		public static CompatibleNoun CreateCompatibleNoun(TerminalKeyword noun, TerminalNode destinationNode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0014: Expected O, but got Unknown
			return new CompatibleNoun
			{
				noun = noun,
				result = destinationNode
			};
		}

		public static void AddCompatibleNounToVerb(TerminalKeyword verb, TerminalKeyword noun, TerminalNode destinationNode)
		{
			if (!verb.isVerb)
			{
				Log.Error("Error while adding compatible noun to verb. Given verb is not a verb: " + verb.word);
				return;
			}
			if (noun.isVerb)
			{
				Log.Error("Error while adding compatible noun to verb. Given noun is a verb: " + noun.word);
				return;
			}
			CompatibleNoun element = CreateCompatibleNoun(noun, destinationNode);
			ArrayUtility.Add(ref verb.compatibleNouns, element);
		}

		public static TerminalNode GetSpecialNode(SpecialTerminalNode specialNode)
		{
			List<TerminalNode> specialNodes = Terminal.terminalNodes.specialNodes;
			if (!specialNodes.IsValidIndex((int)specialNode))
			{
				Log.Error($"Error while trying to get special node at index [{(int)specialNode}]. Returning the first special node...");
				return specialNodes[0];
			}
			return Terminal.terminalNodes.specialNodes[(int)specialNode];
		}
	}
	internal class UpdateHelper
	{
		public static void LogAllSpecialNodes()
		{
			for (int i = 0; i < TerminalHelper.Terminal.terminalNodes.specialNodes.Count; i++)
			{
				TerminalNode val = TerminalHelper.Terminal.terminalNodes.specialNodes[i];
				Log.Message($"Node [{i}]: {val.displayText}]");
			}
		}

		public static void LogAllItemsInfos()
		{
			Item[] buyableItemsList = TerminalHelper.Terminal.buyableItemsList;
			foreach (Item val in buyableItemsList)
			{
				Log.Message($"Item name: {val.itemName}. Item ID: {val.itemId}.");
			}
		}

		public static void LogAllMoonsInfos()
		{
			SelectableLevel[] moonsCatalogueList = TerminalHelper.Terminal.moonsCatalogueList;
			foreach (SelectableLevel val in moonsCatalogueList)
			{
				Log.Message($"Moon. Name: {val.PlanetName}. ID: {val.levelID}. Scene Name: {val.sceneName}");
			}
			Log.Message($"Moon Nodes. {TerminalHelper.Terminal.terminalNodes.terminalNodes.Count}");
			foreach (TerminalNode terminalNode in TerminalHelper.Terminal.terminalNodes.terminalNodes)
			{
				Log.Message($"Moon Node. Name: {((Object)terminalNode).name}. Price: {terminalNode.itemCost}.");
			}
			TerminalKeyword[] allKeywords = TerminalHelper.Terminal.terminalNodes.allKeywords;
			foreach (TerminalKeyword val2 in allKeywords)
			{
				if (val2.word == "route")
				{
					CompatibleNoun[] compatibleNouns = val2.compatibleNouns;
					foreach (CompatibleNoun val3 in compatibleNouns)
					{
						Log.Message($"Moon Node. Node Name: {((Object)val3.result).name}. MoonID: {val3.result.buyRerouteToMoon}. Price: {val3.result.itemCost}.");
					}
				}
			}
		}
	}
}
namespace Hura.Project.Cheats
{
	internal abstract class Cheat : ICheat
	{
		protected TerminalNode node;

		public virtual string ID => GetType().ToString();

		public abstract string Description { get; }

		public abstract bool NeedsOption { get; }

		public TerminalNode Node => node;

		public abstract void AddToTerminal(Terminal terminal, TerminalKeyword cheatVerb);

		public abstract void Execute(string option);
	}
	internal class CustomItemsPriceCheat : ToggleCheat
	{
		private const int SKIP_OVERRIDE_VALUE = -1;

		public static bool currentSettings = false;

		private static Dictionary<string, int> overridePrices = new Dictionary<string, int>
		{
			{ "Walkie-talkie", -1 },
			{ "Flashlight", -1 },
			{ "Shovel", -1 },
			{ "Lockpicker", -1 },
			{ "Pro-flashlight", -1 },
			{ "Stun grenade", -1 },
			{ "Boombox", 25 },
			{ "TZP-Inhalant", 20 },
			{ "Zap gun", -1 },
			{ "Jetpack", 75 },
			{ "Extension ladder", 30 },
			{ "Radar-booster", -1 },
			{ "Spray paint", 10 }
		};

		public override string Description => "Set custom item prices.\n\"cheat customitemsprice on\" to enable.\n\"cheat customitemsprice off\" to disable.";

		public override void AddToTerminal(Terminal terminal, TerminalKeyword cheatVerb)
		{
			node = TerminalHelper.CreateNode(TerminalHelper.CreateNodeText("You have set custom items price!"));
			node.terminalEvent = ID;
			TerminalKeyword val = TerminalHelper.CreateKeyword("customitemsprice", isVerb: false, null);
			TerminalHelper.AddCompatibleNounToVerb(cheatVerb, val, node);
			TerminalHelper.AddKeyworkToTerminal(val);
		}

		protected override void OnEnable()
		{
			OverridePrices();
		}

		protected override void OnDisable()
		{
			ResetPriceToDefault();
		}

		private void OverridePrices()
		{
			Item[] items = ItemsHelper.GetItems();
			foreach (Item val in items)
			{
				if (overridePrices.TryGetValue(val.itemName, out var value) && value != -1)
				{
					val.creditsWorth = value;
					Log.Message($"Priced overriden on item: {val.itemId}. Item name: {val.itemName}");
				}
			}
		}

		private void ResetPriceToDefault()
		{
			Item[] items = ItemsHelper.GetItems();
			foreach (Item val in items)
			{
				if (TerminalCheats.DefaultItemsPrice.TryGetValue(((Object)val).name, out var value))
				{
					val.creditsWorth = value;
				}
			}
		}
	}
	internal class CustomMoonsPrices : ToggleCheat
	{
		public override string Description => "Set custom moons prices.\n\"cheat custommoonsprice on\" to enable.\n\"cheat custommoonsprice off\" to disable.";

		public override void AddToTerminal(Terminal terminal, TerminalKeyword cheatVerb)
		{
			node = TerminalHelper.CreateNode(TerminalHelper.CreateNodeText("You have set custom moons price!"));
			node.terminalEvent = ID;
			TerminalKeyword val = TerminalHelper.CreateKeyword("custommoonsprice", isVerb: false, null);
			TerminalHelper.AddCompatibleNounToVerb(cheatVerb, val, node);
			TerminalHelper.AddKeyworkToTerminal(val);
			UpdateHelper.LogAllMoonsInfos();
		}

		protected override void OnEnable()
		{
			OverridePrices();
		}

		protected override void OnDisable()
		{
			ResetPriceToDefault();
		}

		private void OverridePrices()
		{
			foreach (MoonsHelper.MoonData moon in MoonsHelper.Moons)
			{
				if (moon.Cost > 0)
				{
					moon.Node.itemCost = 100;
					moon.ConfirmNode.itemCost = 100;
				}
			}
		}

		private void ResetPriceToDefault()
		{
			foreach (MoonsHelper.MoonData moon in MoonsHelper.Moons)
			{
				if (moon.Cost > 0)
				{
					moon.Node.itemCost = moon.Cost;
					moon.ConfirmNode.itemCost = moon.Cost;
				}
			}
		}
	}
	internal interface ICheat
	{
		string ID { get; }

		bool NeedsOption { get; }

		TerminalNode Node { get; }

		void AddToTerminal(Terminal terminal, TerminalKeyword cheatVerb);

		void Execute(string option);
	}
	internal class MoneyCheat : Cheat
	{
		private Terminal terminal;

		public override bool NeedsOption => true;

		public override string Description => "Add credits to the group.\n\"cheat addmoney X\" where X is the amount you want to add.";

		public override void AddToTerminal(Terminal terminal, TerminalKeyword cheatVerb)
		{
			this.terminal = terminal;
			node = TerminalHelper.CreateNode(TerminalHelper.CreateNodeText("You have added money!"));
			node.terminalEvent = ID;
			TerminalKeyword val = TerminalHelper.CreateKeyword("addmoney", isVerb: false, null);
			TerminalHelper.AddCompatibleNounToVerb(cheatVerb, val, node);
			TerminalHelper.AddKeyworkToTerminal(val);
		}

		public override void Execute(string option)
		{
			if (int.TryParse(option, out var result))
			{
				AddMoney(result);
			}
		}

		private void AddMoney(int money)
		{
			Terminal obj = terminal;
			obj.groupCredits += money;
			terminal.SyncGroupCreditsServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal static class TerminalCheats
	{
		public const string CHEAT_KEYWORD_NAME = "cheat";

		private static readonly ICheat[] cheats = new ICheat[3]
		{
			new MoneyCheat(),
			new CustomItemsPriceCheat(),
			new CustomMoonsPrices()
		};

		private static Dictionary<string, int> defaultItemsPrice = new Dictionary<string, int>();

		private static string lastInputOption;

		public static IReadOnlyDictionary<string, int> DefaultItemsPrice => defaultItemsPrice;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Initialize()
		{
			SaveItemsPrice();
			MoonsHelper.PopulateMoonsData();
			AddCheatCommandsToTerminal();
			ICheat[] array = cheats;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] is ToggleCheat toggleCheat)
				{
					toggleCheat.Execute("on");
				}
			}
		}

		private static void SaveItemsPrice()
		{
			Item[] buyableItemsList = TerminalHelper.Terminal.buyableItemsList;
			foreach (Item val in buyableItemsList)
			{
				defaultItemsPrice.Add(val.itemName, val.creditsWorth);
			}
		}

		private static void AddCheatCommandsToTerminal()
		{
			TerminalNode destinationNode = TerminalHelper.CreateNode(TerminalHelper.CreateNodeText("Welcome to Hura's cheat codes!"));
			TerminalKeyword val = TerminalHelper.CreateKeyword("cheat", isVerb: true, destinationNode);
			TerminalHelper.AddKeyworkToTerminal(val);
			ICheat[] array = cheats;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].AddToTerminal(TerminalHelper.Terminal, val);
			}
		}

		[HarmonyPatch("RunTerminalEvents")]
		[HarmonyPostfix]
		public static void RunQuizTerminalEvents(TerminalNode node)
		{
			string terminalEvent = node.terminalEvent;
			if (string.IsNullOrEmpty(terminalEvent))
			{
				return;
			}
			ICheat[] array = cheats;
			foreach (ICheat cheat in array)
			{
				if (cheat.ID == terminalEvent)
				{
					cheat.Execute(lastInputOption);
				}
			}
		}

		[HarmonyPatch("ParsePlayerSentence")]
		[HarmonyPrefix]
		private static void ParsePlayerSentencePrefix(ref Terminal __instance, ref TerminalNode __result)
		{
			string[] array = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded).Split(new char[1] { ' ' });
			if (array.Length == 3)
			{
				lastInputOption = array[2];
			}
		}

		[HarmonyPatch("ParsePlayerSentence")]
		[HarmonyPostfix]
		private static void ParsePlayerSentencePostfix(ref Terminal __instance, ref TerminalNode __result)
		{
			string[] array = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded).Split(new char[1] { ' ' });
			if (!(array[0] == "cheat"))
			{
				return;
			}
			ICheat[] array2 = cheats;
			for (int i = 0; i < array2.Length; i++)
			{
				if (array2[i].NeedsOption && array.Length != 3)
				{
					__result = TerminalHelper.GetSpecialNode(SpecialTerminalNode.ParsingError);
				}
			}
		}
	}
	internal abstract class ToggleCheat : Cheat
	{
		public override bool NeedsOption => true;

		public override void Execute(string option)
		{
			string text = option.ToLower();
			if (!(text == "on"))
			{
				if (text == "off")
				{
					OnDisable();
				}
				else
				{
					Log.Warning("No third argument was given when trying to set a toggle cheat.");
				}
			}
			else
			{
				OnEnable();
			}
		}

		protected abstract void OnEnable();

		protected abstract void OnDisable();
	}
}
namespace Hura.Project.Utility
{
	internal static class ArrayUtility
	{
		public static void Add<T>(ref T[] array, T element)
		{
			if (array == null)
			{
				array = new T[0];
			}
			Array.Resize(ref array, array.Length + 1);
			array[array.Length - 1] = element;
		}

		public static bool IsValidIndex<T>(this ICollection<T> list, int index)
		{
			if (index < 0)
			{
				return false;
			}
			if (index >= list.Count)
			{
				return false;
			}
			return true;
		}
	}
}