using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Permanent Moons")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Permanent Moons")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("aacbef64-ab41-4446-ac10-1b7d30e07acd")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[HarmonyPatch(typeof(TimeOfDay))]
internal class TimeOfDayPatch
{
	[HarmonyPatch("SetNewProfitQuota")]
	[HarmonyPrefix]
	private static void SetNewProfitQuota()
	{
		if (Plugin.IsServer() && Plugin.Instance.unlockedMoons.Count != 0)
		{
			Plugin.Instance.quotaNum++;
			if (Plugin.Instance.quotaReset.Value > 0 && Plugin.Instance.quotaReset.Value <= Plugin.Instance.quotaNum)
			{
				Plugin.ResetMoons();
			}
		}
	}
}
[HarmonyPatch(typeof(GameNetworkManager))]
internal class GameNetworkManagerPatch
{
	[HarmonyPatch("Disconnect")]
	[HarmonyPostfix]
	private static void Disconnect()
	{
		Plugin.Instance.unlockedMoons.Clear();
		Plugin.Instance.originalPrices.Clear();
		Plugin.Instance.quotaNum = 0;
		Plugin.UnregisterMessages();
	}

	[HarmonyPatch("SaveGameValues")]
	[HarmonyPostfix]
	private static void SaveGameValues()
	{
		if (!Plugin.IsServer())
		{
			return;
		}
		try
		{
			Plugin.SetSave();
		}
		catch (Exception arg)
		{
			Plugin.Instance.logger.LogError((object)$"Failed to save unlocked moons: {arg}");
		}
	}

	[HarmonyPatch("ResetSavedGameValues")]
	[HarmonyPostfix]
	private static void ResetSavedGameValues()
	{
		if (Plugin.IsServer())
		{
			Plugin.ResetMoons();
		}
	}
}
[HarmonyPatch(typeof(Terminal))]
internal class TerminalPatch
{
	private static string currentMoon;

	private static int currentCredits;

	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	private static void Start(ref Terminal __instance)
	{
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		Plugin.RegisterMessages();
		Plugin.Instance.terminal = __instance;
		if (Plugin.IsServer())
		{
			Dictionary<string, object> save = Plugin.GetSave();
			if (save.ContainsKey("UnlockedMoons"))
			{
				Plugin.Instance.unlockedMoons = (List<string>)save["UnlockedMoons"];
			}
			if (save.ContainsKey("OriginalMoonPrices"))
			{
				Plugin.Instance.originalPrices = (Dictionary<string, int>)save["OriginalMoonPrices"];
			}
			if (save.ContainsKey("MoonQuotaNum"))
			{
				Plugin.Instance.quotaNum = (int)save["MoonQuotaNum"];
			}
			if (Plugin.Instance.unlockedMoons.Count == 0)
			{
				Plugin.Instance.quotaNum = 0;
			}
			Plugin.SyncData();
		}
		else
		{
			NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("PM_RetrieveData", 0uL, new FastBufferWriter(0, (Allocator)2, -1), (NetworkDelivery)3);
		}
	}

	[HarmonyPatch("LoadNewNodeIfAffordable")]
	[HarmonyPrefix]
	private static void LoadNewNodeIfAffordable_Before(TerminalNode node)
	{
		SelectableLevel[] moonsCatalogueList = Plugin.Instance.terminal.moonsCatalogueList;
		foreach (SelectableLevel val in moonsCatalogueList)
		{
			if (val.levelID == node.buyRerouteToMoon)
			{
				currentMoon = val.PlanetName;
				currentCredits = Plugin.Instance.terminal.groupCredits;
				break;
			}
		}
	}

	[HarmonyPatch("LoadNewNodeIfAffordable")]
	[HarmonyPostfix]
	private static void LoadNewNodeIfAffordable_After()
	{
		if (currentCredits != Plugin.Instance.terminal.groupCredits)
		{
			string text = currentMoon.ToLower();
			if (!Plugin.Instance.unlockedMoons.Contains(text))
			{
				Plugin.Instance.unlockedMoons.Add(text);
			}
			if (!Plugin.Instance.originalPrices.ContainsKey(text))
			{
				Plugin.Instance.originalPrices.Add(text, currentCredits - Plugin.Instance.terminal.groupCredits);
			}
			Plugin.SyncData();
			currentMoon = null;
			currentCredits = 0;
		}
	}
}
[BepInPlugin("BULLETBOT.PermanentMoons", "Permanent Moons", "1.0.1")]
public class Plugin : BaseUnityPlugin
{
	private const string modGUID = "BULLETBOT.PermanentMoons";

	private const string modName = "Permanent Moons";

	private const string modVer = "1.0.1";

	private readonly Harmony harmony = new Harmony("BULLETBOT.PermanentMoons");

	public static Plugin Instance;

	public Terminal terminal;

	internal ManualLogSource logger;

	public ConfigEntry<int> quotaReset;

	public List<string> unlockedMoons = new List<string>();

	public Dictionary<string, int> originalPrices = new Dictionary<string, int>();

	public int quotaNum;

	private void Awake()
	{
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		logger = Logger.CreateLogSource("Permanent Moons");
		harmony.PatchAll();
		logger.LogInfo((object)"Permanent Moons has been initialized!");
		quotaReset = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Quota Reset", 1, "This makes it so that every x quota, the permanent moons reset. (set to 0 for no reset)");
	}

	public static Dictionary<string, object> GetSave()
	{
		Dictionary<string, object> dictionary = new Dictionary<string, object>();
		if (ES3.KeyExists("UnlockedMoons", GameNetworkManager.Instance.currentSaveFileName))
		{
			dictionary.Add("UnlockedMoons", ES3.Load<List<string>>("UnlockedMoons", GameNetworkManager.Instance.currentSaveFileName));
		}
		if (ES3.KeyExists("OriginalMoonPrices", GameNetworkManager.Instance.currentSaveFileName))
		{
			dictionary.Add("OriginalMoonPrices", ES3.Load<Dictionary<string, int>>("OriginalMoonPrices", GameNetworkManager.Instance.currentSaveFileName));
		}
		if (ES3.KeyExists("MoonQuotaNum", GameNetworkManager.Instance.currentSaveFileName))
		{
			dictionary.Add("MoonQuotaNum", ES3.Load<int>("MoonQuotaNum", GameNetworkManager.Instance.currentSaveFileName));
		}
		return dictionary;
	}

	public static void SetSave()
	{
		if (Instance.unlockedMoons.Count != 0)
		{
			ES3.Save<List<string>>("UnlockedMoons", Instance.unlockedMoons, GameNetworkManager.Instance.currentSaveFileName);
		}
		else if (ES3.KeyExists("UnlockedMoons", GameNetworkManager.Instance.currentSaveFileName))
		{
			ES3.DeleteKey("UnlockedMoons", GameNetworkManager.Instance.currentSaveFileName);
		}
		if (Instance.originalPrices.Count != 0)
		{
			ES3.Save<Dictionary<string, int>>("OriginalMoonPrices", Instance.originalPrices, GameNetworkManager.Instance.currentSaveFileName);
		}
		else if (ES3.KeyExists("OriginalMoonPrices", GameNetworkManager.Instance.currentSaveFileName))
		{
			ES3.DeleteKey("OriginalMoonPrices", GameNetworkManager.Instance.currentSaveFileName);
		}
		ES3.Save<int>("MoonQuotaNum", Instance.quotaNum, GameNetworkManager.Instance.currentSaveFileName);
	}

	public static void ResetMoons()
	{
		Instance.unlockedMoons.Clear();
		Instance.quotaNum = 0;
		SetSave();
		SyncData();
	}

	public static bool IsServerAndSenderIsClient(ulong senderId)
	{
		if (IsServer())
		{
			return senderId != 0;
		}
		return false;
	}

	public static bool IsServer()
	{
		return NetworkManager.Singleton.IsServer;
	}

	public static void RegisterMessages()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected O, but got Unknown
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Expected O, but got Unknown
		NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("PM_SyncData", new HandleNamedMessageDelegate(SyncDataHandler));
		NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("PM_RetrieveData", new HandleNamedMessageDelegate(RetrieveDataHandler));
	}

	public static void UnregisterMessages()
	{
		NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("PM_SyncData");
		NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler("PM_RetrieveData");
	}

	private static void SyncDataHandler(ulong senderId, 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)
		byte[] bytes = default(byte[]);
		((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref bytes, default(ForPrimitives));
		if (IsServerAndSenderIsClient(senderId))
		{
			SyncData(bytes);
			return;
		}
		Dictionary<string, object> dictionary = Deserialize(bytes);
		Instance.quotaNum = (int)dictionary["MoonQuotaNum"];
		List<string> list = (dictionary.ContainsKey("UnlockedMoons") ? ((List<string>)dictionary["UnlockedMoons"]) : new List<string>());
		Instance.unlockedMoons = list;
		Dictionary<string, int> dictionary2 = (dictionary.ContainsKey("OriginalMoonPrices") ? ((Dictionary<string, int>)dictionary["OriginalMoonPrices"]) : new Dictionary<string, int>());
		Instance.originalPrices = dictionary2;
		List<TerminalKeyword> list2 = Instance.terminal.terminalNodes.allKeywords.ToList();
		CompatibleNoun[] compatibleNouns = list2.Find((TerminalKeyword keyword) => keyword.word == "route").compatibleNouns;
		foreach (CompatibleNoun val in compatibleNouns)
		{
			string word = val.noun.word.ToLower();
			if (Instance.originalPrices.Keys.ToList().Exists((string str) => str.Contains(word)) && val.result.itemCost > 0)
			{
				foreach (string item in Instance.originalPrices.Keys.ToList())
				{
					if (item.Contains(word) && val.result.itemCost != Instance.originalPrices[item])
					{
						Instance.originalPrices[item] = val.result.itemCost;
					}
				}
			}
			int itemCost = val.result.itemCost;
			if (Instance.unlockedMoons.Exists((string str) => str.Contains(word)))
			{
				itemCost = 0;
			}
			else if (Instance.originalPrices.Keys.ToList().Exists((string str) => str.Contains(word)) && val.result.itemCost <= 0)
			{
				foreach (string key in Instance.originalPrices.Keys)
				{
					if (key.Contains(word))
					{
						itemCost = Instance.originalPrices[key];
					}
				}
			}
			val.result.itemCost = itemCost;
			CompatibleNoun[] terminalOptions = val.result.terminalOptions;
			foreach (CompatibleNoun val2 in terminalOptions)
			{
				if (val2.noun.word.ToLower() == "confirm")
				{
					val2.result.itemCost = itemCost;
				}
			}
		}
		Instance.terminal.terminalNodes.allKeywords = list2.ToArray();
	}

	public static void SyncData(byte[] bytes = null)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		if (bytes == null)
		{
			bytes = Serialize();
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(FastBufferWriter.GetWriteSize<byte>(bytes, -1, 0), (Allocator)2, -1);
		CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
		FastBufferWriter val2 = val;
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<byte>(bytes, default(ForPrimitives));
			if (IsServer())
			{
				customMessagingManager.SendNamedMessageToAll("PM_SyncData", val, (NetworkDelivery)3);
			}
			else
			{
				customMessagingManager.SendNamedMessage("PM_SyncData", 0uL, val, (NetworkDelivery)3);
			}
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
		}
	}

	private static void RetrieveDataHandler(ulong senderId, FastBufferReader reader)
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: 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)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		byte[] array = default(byte[]);
		if (IsServerAndSenderIsClient(senderId))
		{
			array = Serialize();
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(FastBufferWriter.GetWriteSize<byte>(array, -1, 0), (Allocator)2, -1);
			FastBufferWriter val2 = val;
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<byte>(array, default(ForPrimitives));
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("PM_RetrieveData", senderId, val, (NetworkDelivery)3);
				return;
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
			}
		}
		((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref array, default(ForPrimitives));
		SyncData(array);
	}

	private static byte[] Serialize()
	{
		using MemoryStream memoryStream = new MemoryStream();
		using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
		binaryWriter.Write(Instance.quotaNum);
		binaryWriter.Write(Instance.unlockedMoons.Count);
		foreach (string unlockedMoon in Instance.unlockedMoons)
		{
			binaryWriter.Write(unlockedMoon);
		}
		binaryWriter.Write(Instance.originalPrices.Count);
		foreach (KeyValuePair<string, int> originalPrice in Instance.originalPrices)
		{
			binaryWriter.Write(originalPrice.Key);
			binaryWriter.Write(originalPrice.Value);
		}
		return memoryStream.ToArray();
	}

	public static Dictionary<string, object> Deserialize(byte[] bytes)
	{
		Dictionary<string, object> dictionary = new Dictionary<string, object>();
		using MemoryStream input = new MemoryStream(bytes);
		using BinaryReader binaryReader = new BinaryReader(input);
		dictionary.Add("MoonQuotaNum", binaryReader.ReadInt32());
		int num = binaryReader.ReadInt32();
		for (int i = 0; i < num; i++)
		{
			if (!dictionary.ContainsKey("UnlockedMoons"))
			{
				dictionary.Add("UnlockedMoons", new List<string>());
			}
			((List<string>)dictionary["UnlockedMoons"]).Add(binaryReader.ReadString());
		}
		int num2 = binaryReader.ReadInt32();
		for (int j = 0; j < num2; j++)
		{
			if (!dictionary.ContainsKey("OriginalMoonPrices"))
			{
				dictionary.Add("OriginalMoonPrices", new Dictionary<string, int>());
			}
			((Dictionary<string, int>)dictionary["OriginalMoonPrices"]).Add(binaryReader.ReadString(), binaryReader.ReadInt32());
		}
		return dictionary;
	}
}