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.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ExtendedRandomMoons")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ExtendedRandomMoons")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("832d2f86-4282-4d2b-8a6a-b706dcac09b0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HoppinHauler.ExtendedRandomMoons;

internal sealed class ConfigExt
{
	private readonly ConfigFile _cfg;

	public ConfigEntry<bool> DeductCredits;

	public ConfigEntry<bool> SkipConfirmation;

	public ConfigEntry<bool> DifferentPlanetEachTime;

	public ConfigEntry<int> AvoidRepeatCount;

	public ConfigEntry<string> Blacklist;

	public ConfigEntry<bool> ExcludeCompanyMoons;

	public ConfigEntry<string> DisallowedWeathers;

	public ConfigEntry<bool> DebugLogging;

	public readonly HashSet<string> BlacklistSet = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);

	public readonly HashSet<string> DisallowedWeatherSet = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);

	public ConfigExt(ConfigFile cfg)
	{
		_cfg = cfg;
		_cfg.SaveOnConfigSet = false;
		DeductCredits = _cfg.Bind<bool>("General", "DeductCredits", true, "If false, routing via 'route random' will not deduct credits (cost forced to 0).");
		SkipConfirmation = _cfg.Bind<bool>("General", "SkipConfirmation", false, "If true, 'route random' will skip the confirmation node and route immediately.");
		DifferentPlanetEachTime = _cfg.Bind<bool>("General", "DifferentPlanetEachTime", true, "If true, excludes the currently orbited moon.");
		AvoidRepeatCount = _cfg.Bind<int>("General", "AvoidRepeatCount", 3, "Avoids choosing any of the last N selected moons (best-effort).");
		Blacklist = _cfg.Bind<string>("Moons", "Blacklist", "Gordion,Liquidation", "Comma-separated list of moons that will never be selected (e.g. Gordion,Liquidation).");
		ExcludeCompanyMoons = _cfg.Bind<bool>("Moons", "ExcludeCompanyMoons", true, "If true, excludes company moons (best-effort heuristic).");
		DisallowedWeathers = _cfg.Bind<string>("Weather", "DisallowedWeathers", "Eclipsed", "Comma-separated list of weather keys/names to exclude. Vanilla examples: Mild,DustClouds,Rainy,Stormy,Foggy,Flooded,Eclipsed");
		DebugLogging = _cfg.Bind<bool>("Debug", "DebugLogging", false, "If true, enables verbose [ERM] debug logs.");
		_cfg.Save();
		_cfg.SaveOnConfigSet = true;
	}

	public void ReloadDerived()
	{
		Util.ParseCsvToNormalizedSet(Blacklist.Value, BlacklistSet);
		Util.ParseCsvToNormalizedSet(DisallowedWeathers.Value, DisallowedWeatherSet);
		Util.ExpandWeatherAliases(DisallowedWeatherSet);
	}
}
internal static class ERMLog
{
	public static void Debug(string message)
	{
		if (Plugin.Log != null && Plugin.Cfg != null && Plugin.Cfg.DebugLogging != null && Plugin.Cfg.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)message);
		}
	}

	public static void Info(string message)
	{
		if (Plugin.Log != null)
		{
			Plugin.Log.LogInfo((object)message);
		}
	}

	public static void Warn(string message)
	{
		if (Plugin.Log != null)
		{
			Plugin.Log.LogWarning((object)message);
		}
	}

	public static void Error(string message)
	{
		if (Plugin.Log != null)
		{
			Plugin.Log.LogError((object)message);
		}
	}
}
internal static class MoonSelector
{
	private static readonly Random Rand = new Random();

	private static readonly Queue<string> LastKeys = new Queue<string>();

	public static bool TryPickMoon(object terminalInstance, ConfigExt cfg, out MoonCandidate chosen, out string failureReason)
	{
		chosen = default(MoonCandidate);
		failureReason = null;
		object startOfRoundInstance = ReflectionCache.GetStartOfRoundInstance();
		if (startOfRoundInstance == null)
		{
			failureReason = "StartOfRound.Instance not available.";
			return false;
		}
		object[] array = Util.TryGetLevelsArray(startOfRoundInstance);
		if (array == null || array.Length == 0)
		{
			failureReason = "No levels found on StartOfRound.";
			return false;
		}
		object obj = Util.TryGetCurrentLevel(startOfRoundInstance);
		int num = Util.TryGetGroupCredits(terminalInstance, int.MaxValue);
		string text = null;
		int num2 = int.MinValue;
		if (obj != null)
		{
			string text2 = Util.TryGetPlanetName(obj);
			text = (string.IsNullOrEmpty(text2) ? null : Util.NormalizeMoonName(text2));
			num2 = Util.TryGetLevelId(obj, int.MinValue);
		}
		ERMLog.Debug("[ERM] TryPickMoon: levels=" + array.Length + ", current='" + (text ?? "(null)") + "', credits=" + ((num == int.MaxValue) ? (-1) : num) + ", deduct=" + cfg.DeductCredits.Value + ", diffEachTime=" + cfg.DifferentPlanetEachTime.Value + ", excludeCompany=" + cfg.ExcludeCompanyMoons.Value + ", avoidN=" + cfg.AvoidRepeatCount.Value);
		List<MoonCandidate> list = new List<MoonCandidate>(array.Length);
		for (int i = 0; i < array.Length; i++)
		{
			object obj2 = array[i];
			if (obj2 == null)
			{
				continue;
			}
			string text3 = Util.TryGetPlanetName(obj2);
			if (string.IsNullOrEmpty(text3))
			{
				continue;
			}
			string text4 = Util.NormalizeMoonName(text3);
			int num3 = Util.TryGetLevelId(obj2, i);
			if (cfg.DifferentPlanetEachTime.Value)
			{
				bool flag = num2 != int.MinValue && num3 == num2;
				bool flag2 = !string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text4) && string.Equals(text4, text, StringComparison.InvariantCultureIgnoreCase);
				if (flag || flag2)
				{
					ERMLog.Debug("[ERM] Filtered (current moon): " + text3);
					continue;
				}
			}
			if (cfg.BlacklistSet.Contains(text4))
			{
				ERMLog.Debug("[ERM] Filtered (blacklist): " + text3);
				continue;
			}
			if (cfg.ExcludeCompanyMoons.Value && Util.IsCompanyMoonHeuristic(obj2))
			{
				ERMLog.Debug("[ERM] Filtered (company heuristic): " + text3);
				continue;
			}
			string weatherKey = WeatherResolver.GetWeatherKey(obj2);
			if (!string.IsNullOrEmpty(weatherKey) && cfg.DisallowedWeatherSet.Contains(weatherKey))
			{
				ERMLog.Debug("[ERM] Filtered (weather '" + weatherKey + "'): " + text3);
				continue;
			}
			int cost = -1;
			if (TerminalIntegration.TryGetCachedRouteCost(num3, out var cost2))
			{
				cost = cost2;
			}
			MoonCandidate moonCandidate = default(MoonCandidate);
			moonCandidate.PlanetName = text3;
			moonCandidate.NormalizedName = text4;
			moonCandidate.LevelId = num3;
			moonCandidate.Cost = cost;
			moonCandidate.WeatherKey = weatherKey;
			MoonCandidate item = moonCandidate;
			ERMLog.Debug("[ERM] Candidate: planet='" + item.PlanetName + "', levelId=" + item.LevelId + ", cost=" + ((item.Cost == 0) ? "FREE" : item.Cost.ToString()) + ", weather=" + (item.WeatherKey ?? "(null)"));
			if (cfg.DeductCredits.Value && item.Cost > 0 && num != int.MaxValue && num < item.Cost)
			{
				ERMLog.Debug("[ERM] Filtered (cannot afford): " + text3 + " cost=" + item.Cost + " credits=" + num);
			}
			else
			{
				list.Add(item);
			}
		}
		ERMLog.Debug("[ERM] Candidates after filtering: " + list.Count);
		if (list.Count == 0)
		{
			failureReason = "All moons were filtered out.";
			return false;
		}
		int num4 = cfg.AvoidRepeatCount.Value;
		if (num4 > 0)
		{
			if (num4 > 50)
			{
				num4 = 50;
			}
			List<MoonCandidate> list2 = new List<MoonCandidate>(list.Count);
			for (int j = 0; j < list.Count; j++)
			{
				if (!LastKeys.Contains(list[j].RepeatKey))
				{
					list2.Add(list[j]);
				}
			}
			if (list2.Count > 0)
			{
				list = list2;
			}
		}
		chosen = list[Rand.Next(list.Count)];
		ERMLog.Debug("[ERM] Chosen: '" + chosen.PlanetName + "' levelId=" + chosen.LevelId + " cost=" + ((chosen.Cost == 0) ? "FREE" : chosen.Cost.ToString()) + " weather=" + (string.IsNullOrEmpty(chosen.WeatherKey) ? "(null)" : chosen.WeatherKey));
		if (num4 > 0)
		{
			LastKeys.Enqueue(chosen.RepeatKey);
			while (LastKeys.Count > num4)
			{
				LastKeys.Dequeue();
			}
		}
		return true;
	}
}
internal struct MoonCandidate
{
	public string PlanetName;

	public string NormalizedName;

	public int Cost;

	public int LevelId;

	public string WeatherKey;

	public string RepeatKey => string.IsNullOrEmpty(NormalizedName) ? ("id:" + LevelId) : (NormalizedName + "|id:" + LevelId);
}
[BepInPlugin("HoppinHauler.extendedrandommoons", "ExtendedRandomMoons", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "HoppinHauler.extendedrandommoons";

	public const string PluginName = "ExtendedRandomMoons";

	public const string PluginVersion = "1.0.0";

	internal static ManualLogSource Log;

	internal static ConfigExt Cfg;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		try
		{
			Cfg = new ConfigExt(((BaseUnityPlugin)this).Config);
			Cfg.ReloadDerived();
			ReflectionCache.Warmup(Log);
			_harmony = new Harmony("HoppinHauler.extendedrandommoons");
			TerminalIntegration.ApplyPatches(_harmony, Log);
			Log.LogInfo((object)"ExtendedRandomMoons loaded.");
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Failed to initialize ExtendedRandomMoons");
			((BaseUnityPlugin)this).Logger.LogError((object)ex);
		}
	}
}
internal static class ReflectionCache
{
	internal static Type TerminalType;

	internal static Type TerminalNodeType;

	internal static Type TerminalKeywordType;

	internal static Type CompatibleNounType;

	internal static Type StartOfRoundType;

	internal static Type SelectableLevelType;

	internal static void Warmup(ManualLogSource log)
	{
		TerminalType = AccessTools.TypeByName("Terminal");
		TerminalNodeType = AccessTools.TypeByName("TerminalNode");
		TerminalKeywordType = AccessTools.TypeByName("TerminalKeyword");
		CompatibleNounType = AccessTools.TypeByName("CompatibleNoun");
		StartOfRoundType = AccessTools.TypeByName("StartOfRound");
		SelectableLevelType = AccessTools.TypeByName("SelectableLevel");
		if (TerminalType == null || TerminalNodeType == null || TerminalKeywordType == null || CompatibleNounType == null)
		{
			log.LogWarning((object)"Some terminal types could not be resolved by name. Terminal integration may fail.");
		}
		if (StartOfRoundType == null || SelectableLevelType == null)
		{
			log.LogWarning((object)"Some gameplay types could not be resolved by name. Moon selection may fail.");
		}
	}

	internal static object GetStartOfRoundInstance()
	{
		if (StartOfRoundType == null)
		{
			return null;
		}
		PropertyInfo property = StartOfRoundType.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (property != null)
		{
			return property.GetValue(null, null);
		}
		FieldInfo field = StartOfRoundType.GetField("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			return field.GetValue(null);
		}
		return null;
	}
}
internal static class TerminalIntegration
{
	private const string NodeNameRouteRandom = "erm_routeRandom";

	private const string NodeNameNoSuitable = "erm_noSuitable";

	private static ManualLogSource _log;

	private static object _routeKeyword;

	private static object _sampleDenyCompatibleNoun;

	private static object _sampleConfirmKeyword;

	private static readonly Dictionary<int, int> _routeCostByLevelId = new Dictionary<int, int>();

	public static bool TryGetCachedRouteCost(int levelId, out int cost)
	{
		return _routeCostByLevelId.TryGetValue(levelId, out cost);
	}

	public static void ApplyPatches(Harmony harmony, ManualLogSource log)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Expected O, but got Unknown
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Expected O, but got Unknown
		_log = log;
		MethodInfo methodInfo = AccessTools.Method(ReflectionCache.TerminalType, "Awake", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(ReflectionCache.TerminalType, "ParsePlayerSentence", (Type[])null, (Type[])null);
		if (methodInfo != null)
		{
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(TerminalIntegration), "TerminalAwakePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (methodInfo2 != null)
		{
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(TerminalIntegration), "ParsePlayerSentencePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}

	public static void TerminalAwakePostfix(object __instance)
	{
		try
		{
			if (__instance == null)
			{
				return;
			}
			Plugin.Cfg.ReloadDerived();
			_routeKeyword = TerminalNodeFactory.GetKeywordByName(__instance, "Route");
			if (_routeKeyword == null)
			{
				_log.LogWarning((object)"Failed to find Route keyword.");
				return;
			}
			BuildRouteCostCacheFromRouteKeyword(_routeKeyword);
			if (TerminalNodeFactory.HasRouteRandomAlready(__instance))
			{
				ERMLog.Debug("[ERM] route random already registered, skipping.");
				TerminalNodeFactory.TryCacheConfirmDenySamples(__instance, _routeKeyword, out _sampleConfirmKeyword, out _sampleDenyCompatibleNoun);
				return;
			}
			object templateKeyword = null;
			object templateCompatibleNoun = null;
			if (Util.TryGetMemberValue(_routeKeyword, "compatibleNouns") is Array array)
			{
				for (int i = 0; i < array.Length; i++)
				{
					object value = array.GetValue(i);
					if (value != null)
					{
						object obj = Util.TryGetMemberValue(value, "noun");
						if (obj != null)
						{
							templateCompatibleNoun = value;
							templateKeyword = obj;
							break;
						}
					}
				}
			}
			object obj2 = TerminalNodeFactory.CreateTerminalKeywordFromTemplate(templateKeyword, "random", "ExtendedRandom", _routeKeyword);
			object resultNode = TerminalNodeFactory.CreateEmptyResultNode("erm_routeRandom");
			object newCompatibleNoun = TerminalNodeFactory.CreateCompatibleNounFromTemplate(templateCompatibleNoun, obj2, resultNode);
			TerminalNodeFactory.AddKeyword(__instance, obj2);
			TerminalNodeFactory.AddCompatibleNounToKeyword(__instance, "Route", newCompatibleNoun);
			TerminalNodeFactory.AppendMoonsHelp(__instance, "* Random   //   Routes you to a random moon (uses config filters)\n");
			TerminalNodeFactory.TryCacheConfirmDenySamples(__instance, _routeKeyword, out _sampleConfirmKeyword, out _sampleDenyCompatibleNoun);
			_log.LogInfo((object)"Registered terminal command: route random");
		}
		catch (Exception ex)
		{
			_log.LogError((object)"Failed to install terminal keywords.");
			_log.LogError((object)ex);
		}
	}

	public static void ParsePlayerSentencePostfix(ref object __result, object __instance)
	{
		try
		{
			if (__result == null || __instance == null)
			{
				return;
			}
			string a = TerminalNodeFactory.TryGetNodeName(__result);
			if (string.Equals(a, "erm_routeRandom", StringComparison.InvariantCultureIgnoreCase))
			{
				Plugin.Cfg.ReloadDerived();
				if (!MoonSelector.TryPickMoon(__instance, Plugin.Cfg, out var chosen, out var failureReason))
				{
					__result = TerminalNodeFactory.CreateSimpleNode("erm_noSuitable", "\nNo suitable moons found.\nCheck your ExtendedRandomMoons config (blacklist/weather/cost).\n" + (string.IsNullOrEmpty(failureReason) ? "\n\n\n" : ("\n" + failureReason + "\n\n\n")), clearPreviousText: true);
					return;
				}
				bool free = !Plugin.Cfg.DeductCredits.Value;
				object obj = TerminalNodeFactory.CreateRouteNode(__instance, chosen, free, Plugin.Cfg.SkipConfirmation.Value, _sampleConfirmKeyword, _sampleDenyCompatibleNoun);
				__result = obj;
			}
		}
		catch (Exception ex)
		{
			_log.LogError((object)"Failed handling route random.");
			_log.LogError((object)ex);
		}
	}

	private static void BuildRouteCostCacheFromRouteKeyword(object routeKeyword)
	{
		_routeCostByLevelId.Clear();
		object startOfRoundInstance = ReflectionCache.GetStartOfRoundInstance();
		object[] levels = ((startOfRoundInstance != null) ? Util.TryGetLevelsArray(startOfRoundInstance) : null);
		if (!(Util.TryGetMemberValue(routeKeyword, "compatibleNouns") is Array array) || array.Length == 0)
		{
			ERMLog.Debug("[ERM] Route cost cache: route keyword has no compatibleNouns.");
			return;
		}
		for (int i = 0; i < array.Length; i++)
		{
			object value = array.GetValue(i);
			if (value == null)
			{
				continue;
			}
			object obj = Util.TryGetMemberValue(value, "noun");
			object obj2 = Util.TryGetMemberValue(value, "result");
			if (obj == null || obj2 == null)
			{
				continue;
			}
			int num = Util.TryGetIntMember(obj2, "itemCost", int.MinValue);
			if (num == int.MinValue)
			{
				num = Util.TryGetIntMember(obj2, "ItemCost", int.MinValue);
			}
			if (num == int.MinValue)
			{
				continue;
			}
			string text = Util.TryGetStringMember(obj, "name") ?? Util.TryGetStringMember(obj, "word");
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			int num2 = FindLevelIdByName(levels, text);
			if (num2 < 0)
			{
				int num3 = Util.TryGetIntMember(obj2, "buyRerouteToMoon", int.MinValue);
				if (num3 != int.MinValue && num3 >= 0)
				{
					num2 = num3;
				}
			}
			if (num2 >= 0)
			{
				_routeCostByLevelId[num2] = num;
			}
		}
		ERMLog.Debug("[ERM] Route cost cache built: entries=" + _routeCostByLevelId.Count);
	}

	private static int FindLevelIdByName(object[] levels, string nounName)
	{
		if (levels == null || levels.Length == 0)
		{
			return -1;
		}
		string text = Util.NormalizeMoonName(nounName);
		for (int i = 0; i < levels.Length; i++)
		{
			object obj = levels[i];
			if (obj == null)
			{
				continue;
			}
			string text2 = Util.TryGetPlanetName(obj);
			if (!string.IsNullOrEmpty(text2))
			{
				string text3 = Util.NormalizeMoonName(text2);
				if (string.Equals(text3, text, StringComparison.InvariantCultureIgnoreCase) || text3.IndexOf(text, StringComparison.InvariantCultureIgnoreCase) >= 0 || text.IndexOf(text3, StringComparison.InvariantCultureIgnoreCase) >= 0)
				{
					return Util.TryGetLevelId(obj, i);
				}
			}
		}
		return -1;
	}
}
internal static class TerminalNodeFactory
{
	private static object SmartCreateInstance(Type t)
	{
		if (t == null)
		{
			return null;
		}
		if (typeof(ScriptableObject).IsAssignableFrom(t))
		{
			return ScriptableObject.CreateInstance(t);
		}
		return Activator.CreateInstance(t);
	}

	private static object CloneScriptableObject(object template)
	{
		if (template == null)
		{
			return null;
		}
		ScriptableObject val = (ScriptableObject)((template is ScriptableObject) ? template : null);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		return Object.Instantiate<ScriptableObject>(val);
	}

	public static object GetKeywordByName(object terminalInstance, string keywordName)
	{
		if (terminalInstance == null)
		{
			return null;
		}
		object obj = Util.TryGetMemberValue(terminalInstance, "terminalNodes");
		if (obj == null)
		{
			return null;
		}
		if (!(Util.TryGetMemberValue(obj, "allKeywords") is Array array))
		{
			return null;
		}
		for (int i = 0; i < array.Length; i++)
		{
			object value = array.GetValue(i);
			if (value != null)
			{
				string a = Util.TryGetStringMember(value, "name");
				if (string.Equals(a, keywordName, StringComparison.InvariantCultureIgnoreCase))
				{
					return value;
				}
			}
		}
		return null;
	}

	public static object GetKeywordByWord(object terminalInstance, string word)
	{
		if (terminalInstance == null)
		{
			return null;
		}
		object obj = Util.TryGetMemberValue(terminalInstance, "terminalNodes");
		if (obj == null)
		{
			return null;
		}
		if (!(Util.TryGetMemberValue(obj, "allKeywords") is Array array))
		{
			return null;
		}
		for (int i = 0; i < array.Length; i++)
		{
			object value = array.GetValue(i);
			if (value != null)
			{
				string a = Util.TryGetStringMember(value, "word");
				if (string.Equals(a, word, StringComparison.InvariantCultureIgnoreCase))
				{
					return value;
				}
			}
		}
		return null;
	}

	public static bool HasRouteRandomAlready(object terminalInstance)
	{
		object keywordByWord = GetKeywordByWord(terminalInstance, "random");
		if (keywordByWord == null)
		{
			return false;
		}
		object keywordByName = GetKeywordByName(terminalInstance, "Route");
		if (keywordByName == null)
		{
			return false;
		}
		if (!(Util.TryGetMemberValue(keywordByName, "compatibleNouns") is Array array))
		{
			return false;
		}
		for (int i = 0; i < array.Length; i++)
		{
			object value = array.GetValue(i);
			if (value == null)
			{
				continue;
			}
			object obj = Util.TryGetMemberValue(value, "noun");
			if (obj != null)
			{
				if (obj == keywordByWord)
				{
					return true;
				}
				string a = Util.TryGetStringMember(obj, "word");
				if (string.Equals(a, "random", StringComparison.InvariantCultureIgnoreCase))
				{
					return true;
				}
			}
		}
		return false;
	}

	public static void AddKeyword(object terminalInstance, object newKeyword)
	{
		object obj = Util.TryGetMemberValue(terminalInstance, "terminalNodes");
		if (obj != null && Util.TryGetMemberValue(obj, "allKeywords") is Array array)
		{
			Array value = Util.AppendToArray(array, newKeyword);
			Util.TrySetMemberValue(obj, "allKeywords", value);
		}
	}

	public static void AddCompatibleNounToKeyword(object terminalInstance, string keywordName, object newCompatibleNoun)
	{
		object keywordByName = GetKeywordByName(terminalInstance, keywordName);
		if (keywordByName != null)
		{
			Array array = Util.TryGetMemberValue(keywordByName, "compatibleNouns") as Array;
			if (array == null)
			{
				array = Array.CreateInstance(ReflectionCache.CompatibleNounType, 0);
			}
			Array value = Util.AppendToArray(array, newCompatibleNoun);
			Util.TrySetMemberValue(keywordByName, "compatibleNouns", value);
		}
	}

	public static void AppendMoonsHelp(object terminalInstance, string extraText)
	{
		object keywordByName = GetKeywordByName(terminalInstance, "Moons");
		if (keywordByName == null)
		{
			return;
		}
		object obj = Util.TryGetMemberValue(keywordByName, "specialKeywordResult");
		if (obj != null)
		{
			string text = Util.TryGetStringMember(obj, "displayText") ?? "";
			if (text.IndexOf(extraText, StringComparison.InvariantCultureIgnoreCase) < 0 && (extraText.IndexOf("* Random", StringComparison.InvariantCultureIgnoreCase) < 0 || text.IndexOf("* Random", StringComparison.InvariantCultureIgnoreCase) < 0))
			{
				text += extraText;
				Util.TrySetMemberValue(obj, "displayText", text);
			}
		}
	}

	public static object CreateTerminalKeywordFromTemplate(object templateKeyword, string word, string name, object defaultVerbKeyword)
	{
		object obj = CloneScriptableObject(templateKeyword) ?? SmartCreateInstance(ReflectionCache.TerminalKeywordType);
		Util.TrySetMemberValue(obj, "word", word);
		Util.TrySetMemberValue(obj, "name", name);
		Util.TrySetMemberValue(obj, "defaultVerb", defaultVerbKeyword);
		Util.TrySetMemberValue(obj, "compatibleNouns", Array.CreateInstance(ReflectionCache.CompatibleNounType, 0));
		Util.TrySetMemberValue(obj, "isVerb", false);
		Util.TrySetMemberValue(obj, "IsVerb", false);
		return obj;
	}

	public static object CreateCompatibleNounFromTemplate(object templateCompatibleNoun, object nounKeyword, object resultNode)
	{
		object obj = CloneScriptableObject(templateCompatibleNoun) ?? SmartCreateInstance(ReflectionCache.CompatibleNounType);
		Util.TrySetMemberValue(obj, "noun", nounKeyword);
		Util.TrySetMemberValue(obj, "result", resultNode);
		return obj;
	}

	public static object CreateEmptyResultNode(string name)
	{
		object obj = SmartCreateInstance(ReflectionCache.TerminalNodeType);
		Util.TrySetMemberValue(obj, "name", name);
		Util.TrySetMemberValue(obj, "buyRerouteToMoon", -1);
		Util.TrySetMemberValue(obj, "terminalOptions", Array.CreateInstance(ReflectionCache.CompatibleNounType, 0));
		return obj;
	}

	public static object CreateSimpleNode(string name, string displayText, bool clearPreviousText)
	{
		object obj = SmartCreateInstance(ReflectionCache.TerminalNodeType);
		Util.TrySetMemberValue(obj, "name", name);
		Util.TrySetMemberValue(obj, "displayText", displayText);
		Util.TrySetMemberValue(obj, "clearPreviousText", clearPreviousText);
		return obj;
	}

	public static string TryGetNodeName(object terminalNode)
	{
		return Util.TryGetStringMember(terminalNode, "name");
	}

	public static void TryCacheConfirmDenySamples(object terminalInstance, object routeKeyword, out object confirmKeyword, out object denyCompatibleNoun)
	{
		confirmKeyword = GetKeywordByName(terminalInstance, "Confirm");
		denyCompatibleNoun = null;
		if (!(Util.TryGetMemberValue(routeKeyword, "compatibleNouns") is Array array))
		{
			return;
		}
		for (int i = 0; i < array.Length; i++)
		{
			object value = array.GetValue(i);
			if (value == null)
			{
				continue;
			}
			object obj = Util.TryGetMemberValue(value, "result");
			if (obj == null)
			{
				continue;
			}
			int num = Util.TryGetIntMember(obj, "buyRerouteToMoon", int.MinValue);
			if (num != -2 || !(Util.TryGetMemberValue(obj, "terminalOptions") is Array array2))
			{
				continue;
			}
			for (int j = 0; j < array2.Length; j++)
			{
				object value2 = array2.GetValue(j);
				if (value2 == null)
				{
					continue;
				}
				object obj2 = Util.TryGetMemberValue(value2, "noun");
				if (obj2 != null)
				{
					string a = Util.TryGetStringMember(obj2, "name");
					if (string.Equals(a, "Deny", StringComparison.InvariantCultureIgnoreCase))
					{
						denyCompatibleNoun = value2;
						return;
					}
				}
			}
		}
	}

	public static object CreateRouteNode(object terminalInstance, MoonCandidate moon, bool free, bool skipConfirmation, object sampleConfirmKeyword, object sampleDenyCompatibleNoun)
	{
		object obj = SmartCreateInstance(ReflectionCache.TerminalNodeType);
		Util.TrySetMemberValue(obj, "name", "erm_confirmRoute_" + Util.SanitizeId(moon.NormalizedName));
		Util.TrySetMemberValue(obj, "buyRerouteToMoon", moon.LevelId);
		Util.TrySetMemberValue(obj, "clearPreviousText", true);
		int num = ((!free) ? ((moon.Cost >= 0) ? moon.Cost : 0) : 0);
		string text = moon.PlanetName ?? moon.NormalizedName ?? "UNKNOWN";
		string text2 = ((num == 0) ? "FREE" : (num + " credits"));
		ERMLog.Debug("[ERM] CreateRouteNode: planet='" + text + "' levelId=" + moon.LevelId + " cost=" + ((moon.Cost == 0) ? "FREE" : moon.Cost.ToString()) + " freeFlag=" + free + " itemCost=" + ((num == 0) ? "FREE" : num.ToString()) + " skipConfirm=" + skipConfirmation);
		Util.TrySetMemberValue(obj, "itemCost", num);
		string value = "\nRouting autopilot to " + text + " (" + text2 + ").\nYour new balance is [playerCredits].\n\nPlease enjoy your flight.\n\n\n";
		Util.TrySetMemberValue(obj, "displayText", value);
		if (skipConfirmation)
		{
			return obj;
		}
		object obj2 = SmartCreateInstance(ReflectionCache.TerminalNodeType);
		Util.TrySetMemberValue(obj2, "name", "erm_routeNode_" + Util.SanitizeId(moon.NormalizedName));
		Util.TrySetMemberValue(obj2, "buyRerouteToMoon", -2);
		Util.TrySetMemberValue(obj2, "clearPreviousText", true);
		Util.TrySetMemberValue(obj2, "overrideOptions", true);
		Util.TrySetMemberValue(obj2, "displayPlanetInfo", true);
		string value2 = "\nRoute autopilot to " + text + " (" + text2 + ")?\nType 'c' to confirm or 'd' to cancel.\n\n";
		Util.TrySetMemberValue(obj2, "displayText", value2);
		object value3 = CreateCompatibleNounFromTemplate(sampleDenyCompatibleNoun, sampleConfirmKeyword, obj);
		object obj3 = sampleDenyCompatibleNoun;
		if (obj3 == null)
		{
			object resultNode = CreateSimpleNode("erm_deny", "\nCancelled.\n\n\n", clearPreviousText: true);
			object keywordByName = GetKeywordByName(terminalInstance, "Deny");
			obj3 = CreateCompatibleNounFromTemplate(null, keywordByName, resultNode);
		}
		Array array = Array.CreateInstance(ReflectionCache.CompatibleNounType, 2);
		array.SetValue(obj3, 0);
		array.SetValue(value3, 1);
		Util.TrySetMemberValue(obj2, "terminalOptions", array);
		return obj2;
	}
}
internal static class Util
{
	private static readonly Regex LeadingDigits = new Regex("^[0-9]+", RegexOptions.Compiled);

	public static void ParseCsvToNormalizedSet(string csv, HashSet<string> set)
	{
		set.Clear();
		if (string.IsNullOrWhiteSpace(csv))
		{
			return;
		}
		string[] array = csv.Split(',');
		for (int i = 0; i < array.Length; i++)
		{
			string text = ((array[i] == null) ? null : array[i].Trim());
			if (!string.IsNullOrWhiteSpace(text))
			{
				set.Add(NormalizeMoonName(text));
			}
		}
	}

	public static string NormalizeMoonName(string name)
	{
		if (string.IsNullOrWhiteSpace(name))
		{
			return string.Empty;
		}
		string text = LeadingDigits.Replace(name.Trim(), string.Empty);
		text = text.Trim();
		if (text.StartsWith("-", StringComparison.InvariantCulture))
		{
			text = text.Substring(1).Trim();
		}
		return text;
	}

	public static string NormalizeWeatherToken(string token)
	{
		if (string.IsNullOrWhiteSpace(token))
		{
			return null;
		}
		string text = token.Trim().ToLowerInvariant();
		text = text.Replace(" ", "");
		text = text.Replace("_", "");
		text = text.Replace("-", "");
		if (text == "dustcloud" || text == "dustclouds")
		{
			return "dustclouds";
		}
		if (text == "none")
		{
			return "mild";
		}
		return text;
	}

	public static void ExpandWeatherAliases(HashSet<string> set)
	{
		List<string> list = new List<string>(set);
		set.Clear();
		for (int i = 0; i < list.Count; i++)
		{
			string text = NormalizeWeatherToken(list[i]);
			if (!string.IsNullOrEmpty(text))
			{
				set.Add(text);
			}
		}
		if (set.Contains("none"))
		{
			set.Remove("none");
			set.Add("mild");
		}
	}

	public static object[] TryGetLevelsArray(object startOfRoundInstance)
	{
		object obj = TryGetMemberValue(startOfRoundInstance, "levels");
		if (!(obj is Array array))
		{
			return null;
		}
		object[] array2 = new object[array.Length];
		for (int i = 0; i < array.Length; i++)
		{
			array2[i] = array.GetValue(i);
		}
		return array2;
	}

	public static object TryGetCurrentLevel(object startOfRoundInstance)
	{
		return TryGetMemberValue(startOfRoundInstance, "currentLevel");
	}

	public static string TryGetPlanetName(object selectableLevel)
	{
		object obj = TryGetMemberValue(selectableLevel, "PlanetName") ?? TryGetMemberValue(selectableLevel, "planetName") ?? TryGetMemberValue(selectableLevel, "name");
		return obj as string;
	}

	public static int TryGetLevelId(object selectableLevel, int fallbackIndex)
	{
		if ((TryGetMemberValue(selectableLevel, "levelID") ?? TryGetMemberValue(selectableLevel, "LevelID")) is int result)
		{
			return result;
		}
		return fallbackIndex;
	}

	public static bool IsCompanyMoonHeuristic(object selectableLevel)
	{
		object obj = TryGetMemberValue(selectableLevel, "planetHasTime");
		object obj2 = TryGetMemberValue(selectableLevel, "spawnEnemiesAndScrap");
		bool? flag = obj as bool?;
		bool? flag2 = obj2 as bool?;
		if (flag.HasValue && flag2.HasValue)
		{
			return !flag.Value && !flag2.Value;
		}
		return false;
	}

	public static object TryGetMemberValue(object instance, string name)
	{
		if (instance == null || string.IsNullOrEmpty(name))
		{
			return null;
		}
		Type type = instance.GetType();
		FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			return field.GetValue(instance);
		}
		PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (property != null && property.GetIndexParameters().Length == 0)
		{
			return property.GetValue(instance, null);
		}
		return null;
	}

	public static bool TrySetMemberValue(object instance, string name, object value)
	{
		if (instance == null || string.IsNullOrEmpty(name))
		{
			return false;
		}
		Type type = instance.GetType();
		FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			try
			{
				field.SetValue(instance, value);
				return true;
			}
			catch
			{
				return false;
			}
		}
		PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		if (property != null && property.GetIndexParameters().Length == 0 && property.CanWrite)
		{
			try
			{
				property.SetValue(instance, value, null);
				return true;
			}
			catch
			{
				return false;
			}
		}
		return false;
	}

	public static string TryGetStringMember(object instance, string name)
	{
		object obj = TryGetMemberValue(instance, name);
		return obj as string;
	}

	public static int TryGetIntMember(object instance, string name, int fallback)
	{
		return (TryGetMemberValue(instance, name) is int num) ? num : fallback;
	}

	public static Array AppendToArray(Array array, object item)
	{
		if (array == null)
		{
			Array array2 = Array.CreateInstance(item.GetType(), 1);
			array2.SetValue(item, 0);
			return array2;
		}
		Type elementType = array.GetType().GetElementType();
		Array array3 = Array.CreateInstance(elementType, array.Length + 1);
		Array.Copy(array, array3, array.Length);
		array3.SetValue(item, array.Length);
		return array3;
	}

	public static string SanitizeId(string s)
	{
		if (string.IsNullOrEmpty(s))
		{
			return "unknown";
		}
		s = s.Trim().ToLowerInvariant();
		s = Regex.Replace(s, "[^a-z0-9]+", "_");
		return s.Trim('_');
	}

	public static int TryGetGroupCredits(object terminalInstance, int fallback)
	{
		if (TryGetMemberValue(terminalInstance, "groupCredits") is int result)
		{
			return result;
		}
		return fallback;
	}
}
internal static class WeatherResolver
{
	public static string GetWeatherKey(object selectableLevel)
	{
		if (selectableLevel == null)
		{
			return null;
		}
		object obj = Util.TryGetMemberValue(selectableLevel, "currentWeather");
		if (obj != null)
		{
			string text = NormalizeWeather(obj);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
		}
		object obj2 = Util.TryGetMemberValue(selectableLevel, "currentWeatherString") ?? Util.TryGetMemberValue(selectableLevel, "weatherString") ?? Util.TryGetMemberValue(selectableLevel, "Weather") ?? Util.TryGetMemberValue(selectableLevel, "weather");
		if (obj2 is string text2 && !string.IsNullOrWhiteSpace(text2))
		{
			return Util.NormalizeWeatherToken(text2);
		}
		return null;
	}

	private static string NormalizeWeather(object weatherValue)
	{
		string text = weatherValue.ToString();
		if (string.IsNullOrWhiteSpace(text))
		{
			return null;
		}
		if (string.Equals(text, "None", StringComparison.InvariantCultureIgnoreCase))
		{
			return "mild";
		}
		return Util.NormalizeWeatherToken(text);
	}
}