using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Security;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.BoneMenu.UI;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Forklift.Model;
using Il2CppSLZ.Marrow.Pool;
using Il2CppSLZ.Marrow.SceneStreaming;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using LabFusion.Data;
using LabFusion.Downloading.ModIO;
using LabFusion.Entities;
using LabFusion.Extensions;
using LabFusion.Marrow;
using LabFusion.Network;
using LabFusion.Player;
using LabFusion.RPC;
using LabFusion.SDK.Modules;
using LabFusion.Scene;
using LabFusion.Senders;
using LabFusion.Utilities;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using ModIoModNetworker.Ui;
using ModioModNetworker;
using ModioModNetworker.Data;
using ModioModNetworker.Queue;
using ModioModNetworker.UI;
using ModioModNetworker.Utilities;
using Newtonsoft.Json;
using ThunderstoreModAssistant.Utilities;
using UnityEngine;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(MainClass), "ModioModNetworker", "2.5.1", "notnotnotswipez", null)]
[assembly: AssemblyTitle("ModioModNetworker")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ModioModNetworker")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cdde6516-f286-4f2c-ad4b-d75164eb3e75")]
[assembly: AssemblyFileVersion("2.5.1")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("2.5.1.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;
		}
	}
}
public class DownloadQueueElement
{
	public PlayerId associatedPlayer;

	public ModInfo info;

	public bool notify = true;

	public bool lobby = false;
}
public class DownloadAction
{
	public int delayFrames;

	public DownloadAction(int delayFrames)
	{
		this.delayFrames = delayFrames;
	}

	public bool Check()
	{
		if (delayFrames > 0)
		{
			delayFrames--;
			return false;
		}
		return true;
	}

	public void Handle()
	{
		Thread thread = new Thread((ThreadStart)delegate
		{
			try
			{
				string text = Path.Combine(ModFileManager.MOD_FOLDER_PATH, "tempfolder");
				if (Directory.Exists(text))
				{
					Directory.Delete(text, recursive: true);
				}
				Directory.CreateDirectory(text);
				MelonLogger.Msg("Extracting " + ModFileManager.downloadPath + " to " + text);
				using (ZipArchive zipArchive = ZipFile.OpenRead(ModFileManager.downloadPath))
				{
					foreach (ZipArchiveEntry entry in zipArchive.Entries)
					{
						string text2 = Path.Combine(text, entry.FullName);
						if (entry.FullName.EndsWith("/"))
						{
							text2 = text2.Substring(0, text2.Length - 1);
							Directory.CreateDirectory(text2);
						}
						else
						{
							Directory.CreateDirectory(Path.GetDirectoryName(text2));
							string fileName = Path.GetFileName(text2);
							string text3 = Path.Combine(Path.GetDirectoryName(text2), "tempExtractedFile.temp");
							entry.ExtractToFile(text3, overwrite: true);
							File.Move(text3, Path.Combine(Path.GetDirectoryName(text3), fileName));
						}
					}
					zipArchive.Dispose();
				}
				MelonLogger.Msg("Extracted " + ModFileManager.downloadPath + " to " + text);
				string text4 = ModFileManager.FindFile(text, "pallet.json");
				while (text4 != "")
				{
					string fullName = Directory.GetParent(text4).FullName;
					MelonLogger.Msg("Mod folder is: " + fullName);
					string text5 = (HelperMethods.IsAndroid() ? fullName.Split('/') : fullName.Split('\\'))[^1];
					string text6 = ModFileManager.MOD_FOLDER_PATH + "/" + text5;
					bool flag = false;
					MelonLogger.Msg("Checking directory if it exists: " + text6);
					if (Directory.Exists(text6))
					{
						MelonLogger.Msg("Directory exists: " + text6);
						flag = true;
						string text7 = ModFileManager.FindFile(text6, "pallet.json");
						if (text7 != "")
						{
							string text8 = File.ReadAllText(text7);
							dynamic val = JsonConvert.DeserializeObject<object>(text8);
							string item = (string)val["objects"]["1"]["barcode"];
							MainClass.warehousePalletReloadTargets.Add(item);
						}
						else
						{
							flag = false;
						}
						Directory.Delete(text6, recursive: true);
					}
					Directory.Move(fullName, text6);
					string path = text6 + "/modinfo.json";
					string contents = JsonConvert.SerializeObject((object)ModlistMenu.activeDownloadModInfo);
					File.WriteAllText(path, contents);
					if (!flag)
					{
						MainClass.warehouseReloadFolders.Add(ModFileManager.FindFile(text6, "pallet.json"));
					}
					text4 = ModFileManager.FindFile(text, "pallet.json");
					MelonLogger.Msg(fullName + " Downloaded and extracted!");
				}
				File.Delete(ModFileManager.downloadPath);
				Directory.Delete(text, recursive: true);
				MainClass.warehouseReloadRequested = true;
				MainClass.RequestInstallCheck();
				MainClass.subsChanged = true;
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Error while downloading mod " + ModlistMenu.activeDownloadModInfo.modId + ": " + ex);
				ModFileManager.isDownloading = false;
				ModFileManager.activeDownloadQueueElement = null;
				ModFileManager.activeDownloadWebRequest = null;
				ModlistMenu.activeDownloadModInfo = null;
			}
		});
		thread.Start();
	}
}
public class StalledAction
{
	public int frameCount;

	public Action action;
}
namespace ThunderstoreModAssistant.Utilities
{
	public class TimerManager
	{
		private static List<TimerDelayedAction> timerDelayedJobs = new List<TimerDelayedAction>();

		public static void Update()
		{
			foreach (TimerDelayedAction timerDelayedJob in timerDelayedJobs)
			{
				timerDelayedJob.time -= Time.deltaTime;
				if (timerDelayedJob.time <= 0f)
				{
					timerDelayedJob.onTimeOver();
					timerDelayedJob.completed = true;
				}
			}
			timerDelayedJobs.RemoveAll((TimerDelayedAction x) => x.completed);
		}

		public static void DelayAction(float time, Action onCompleted)
		{
			timerDelayedJobs.Add(new TimerDelayedAction
			{
				time = time,
				onTimeOver = onCompleted
			});
		}
	}
	public class TimerDelayedAction
	{
		public float time;

		public Action onTimeOver;

		public bool completed = false;
	}
}
namespace ModIoModNetworker.Ui
{
	[RegisterTypeInIl2Cpp]
	public class ModInfoDisplay : MonoBehaviour
	{
		public TMP_Text title;

		private RawImage thumbnailImage;

		public RawImage borderImage;

		public ModInfo modInfo;

		public Button button;

		public NetworkerMenuController controller;

		public GameObject subscriptionButton;

		private bool hasAddedThumbnail = false;

		public ModInfoDisplay(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			thumbnailImage = ((Component)((Component)this).transform.Find("Thumbnail")).GetComponent<RawImage>();
			title = ((Component)((Component)this).transform.Find("Text (TMP)")).GetComponent<TMP_Text>();
			borderImage = ((Component)((Component)this).transform.Find("BaseOverlay")).GetComponent<RawImage>();
			button = ((Component)((Component)this).transform.Find("Button")).GetComponent<Button>();
			subscriptionButton = ((Component)((Component)this).transform.Find("SubscribedIndicator")).gameObject;
			((UnityEvent)button.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnModInfoPressed();
			}));
		}

		public void OnModInfoPressed()
		{
			controller.TriggerModInfoPopup(show: true, modInfo);
		}

		public void SetModInfo(ModInfo modInfo)
		{
			this.modInfo = modInfo;
			title.text = modInfo.modName;
			if (!modInfo.IsSubscribed())
			{
				subscriptionButton.SetActive(false);
			}
			else
			{
				subscriptionButton.SetActive(true);
			}
			ThumbnailThreader.DownloadThumbnail(modInfo.thumbnailLink, delegate(Texture texture)
			{
				if (Object.op_Implicit((Object)(object)thumbnailImage))
				{
					thumbnailImage.texture = texture;
					hasAddedThumbnail = true;
				}
			});
		}

		public void DestroyThumbnail()
		{
			if (hasAddedThumbnail)
			{
				Object.DestroyImmediate((Object)(object)thumbnailImage.texture);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class NetworkerMenuController : MonoBehaviour
	{
		public enum Panels
		{
			MODIO,
			FILES,
			SETTINGS,
			MULTIPLAYER,
			NONE
		}

		public enum InstalledSort
		{
			INSTALLED,
			SUBSCRIBED,
			BLACKLIST
		}

		private Panels selectedPanel = Panels.NONE;

		private InstalledSort chosenSort = InstalledSort.INSTALLED;

		private GameObject modIoTab;

		private GameObject filesTab;

		private GameObject settingsTab;

		private GameObject multiplayerTab;

		private GameObject modProgressDisplay;

		private GameObject keyboardPopup;

		private Button upArrowButton;

		private Button downArrowButton;

		private TMP_Text typeBarText;

		private GameObject typeBarTextObject;

		private GameObject typeBarEmptyTextObject;

		private GameObject typeBarObject;

		private Transform selector;

		private Transform desired;

		private float speed = 10f;

		private Button modIoTabButton;

		private Button filesTabButton;

		private Button settingsTabButton;

		private Button multiplayerTabButton;

		private GameObject modInfoPopup;

		private int pageNumber = 0;

		private int maxPages = 0;

		private int maxDisplayPerPage = 8;

		private int trendingOffset = 0;

		private bool searching = false;

		private Animator rootAnimator;

		public string lastDownloadedTitle = "nothing";

		public static List<ModInfo> totalInstalled = new List<ModInfo>();

		public static List<ModInfo> modIoRetrieved = new List<ModInfo>();

		public static List<ModInfo> host = new List<ModInfo>();

		private static List<GenericSetting> settings = new List<GenericSetting>();

		private static List<StalledAction> stalledActions = new List<StalledAction>();

		private ModInfo viewedInfo;

		public static NetworkerMenuController instance;

		public static SpotlightOverride spotlightOverride = new SpotlightOverride();

		public NetworkerMenuController(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			instance = this;
			selector = ((Component)this).transform.Find("Selector");
			modIoTab = ((Component)((Component)this).transform.Find("ModIoTab")).gameObject;
			filesTab = ((Component)((Component)this).transform.Find("FilesTab")).gameObject;
			settingsTab = ((Component)((Component)this).transform.Find("SettingsTab")).gameObject;
			multiplayerTab = ((Component)((Component)this).transform.Find("MultiplayerTab")).gameObject;
			Button component = ((Component)((Component)this).transform.Find("BackButton")).GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				Menu.OpenPage(Page.Root);
			}));
			Button component2 = ((Component)filesTab.transform.Find("Confirmer").Find("Confirm").Find("Button")).GetComponent<Button>();
			((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				foreach (ModInfo item in totalInstalled)
				{
					if (!item.IsSubscribed() && item.IsTracked())
					{
						ModFileManager.UnInstallMainThread(item.numericalId);
					}
				}
			}));
			Button component3 = ((Component)multiplayerTab.transform.Find("Confirmer").Find("Confirm").Find("Button")).GetComponent<Button>();
			((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				foreach (ModInfo item2 in host)
				{
					ModFileManager.AddToQueue(new DownloadQueueElement
					{
						associatedPlayer = null,
						info = item2
					});
				}
			}));
			Button component4 = ((Component)modIoTab.transform.Find("RefreshSubscribedButton").Find("Button")).GetComponent<Button>();
			((UnityEvent)component4.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				MainClass.PopulateSubscriptions();
			}));
			Button component5 = ((Component)modIoTab.transform.Find("TrendingFirstPage").Find("BigBanner").Find("ThumbnailMaskMovedSlight")
				.Find("Button")).GetComponent<Button>();
			((UnityEvent)component5.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				if (spotlightOverride.manualDisplayId != null)
				{
					TriggerModInfoPopup(show: true, spotlightOverride.downloadedInfo);
				}
				else
				{
					TriggerModInfoPopup(show: true, modIoRetrieved[0]);
				}
			}));
			Button component6 = ((Component)modIoTab.transform.Find("SearchIcon")).GetComponent<Button>();
			((UnityEvent)component6.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				PopupKeyboard();
			}));
			upArrowButton = ((Component)((Component)this).transform.Find("UpArrow").Find("Button")).GetComponent<Button>();
			downArrowButton = ((Component)((Component)this).transform.Find("DownArrow").Find("Button")).GetComponent<Button>();
			((UnityEvent)upArrowButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnArrowPress(up: true);
			}));
			((UnityEvent)downArrowButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnArrowPress(up: false);
			}));
			modIoTabButton = ((Component)((Component)this).transform.Find("SelectableTabs").Find("ModIoTab")).GetComponentInChildren<Button>();
			filesTabButton = ((Component)((Component)this).transform.Find("SelectableTabs").Find("FileManagementTab")).GetComponentInChildren<Button>();
			settingsTabButton = ((Component)((Component)this).transform.Find("SelectableTabs").Find("SettingsTab")).GetComponentInChildren<Button>();
			multiplayerTabButton = ((Component)((Component)this).transform.Find("SelectableTabs").Find("MultiplayerTab")).GetComponentInChildren<Button>();
			((UnityEvent)((Component)modIoTab.transform.Find("BackToTrending").Find("BackArrow").Find("Button")).gameObject.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ReturnToTrending();
			}));
			((UnityEvent)modIoTabButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ChangePanel(Panels.MODIO);
			}));
			((UnityEvent)filesTabButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ChangePanel(Panels.FILES);
			}));
			((UnityEvent)settingsTabButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ChangePanel(Panels.SETTINGS);
			}));
			((UnityEvent)multiplayerTabButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ChangePanel(Panels.MULTIPLAYER);
			}));
			modInfoPopup = ((Component)((Component)this).transform.parent.Find("ModInfoOverlay").Find("ModInfoPopup")).gameObject;
			modProgressDisplay = ((Component)((Component)this).transform.parent.Find("ModInstallingDisplay")).gameObject;
			keyboardPopup = ((Component)((Component)this).transform.parent.Find("KeyboardOverlay")).gameObject;
			typeBarObject = ((Component)keyboardPopup.transform.Find("TypeBar")).gameObject;
			typeBarTextObject = ((Component)typeBarObject.transform.Find("TypedOutText")).gameObject;
			typeBarEmptyTextObject = ((Component)typeBarObject.transform.Find("EmptyTextDisplay")).gameObject;
			typeBarText = typeBarTextObject.GetComponent<TMP_Text>();
			rootAnimator = ((Component)this).GetComponentInParent<Animator>();
			Button componentInChildren = ((Component)modInfoPopup.transform.Find("SubscribeUnselected")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren2 = ((Component)modInfoPopup.transform.Find("SubscribeSelected")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren3 = ((Component)modInfoPopup.transform.Find("BlacklistParted")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren4 = ((Component)modInfoPopup.transform.Find("BlacklistPartedSelected")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren5 = ((Component)modInfoPopup.transform.Find("UninstallParted")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren6 = ((Component)modInfoPopup.transform.Find("UninstallPartedSelected")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren7 = ((Component)modInfoPopup.transform.Find("BlacklistFull")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren8 = ((Component)modInfoPopup.transform.Find("BlacklistSelectedFull")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren9 = ((Component)modInfoPopup.transform.Find("ExitCatch")).gameObject.GetComponentInChildren<Button>();
			Button componentInChildren10 = ((Component)modInfoPopup.transform.Find("ExitCatch (1)")).gameObject.GetComponentInChildren<Button>();
			Button component7 = ((Component)filesTab.transform.Find("InstalledText")).GetComponent<Button>();
			Button component8 = ((Component)filesTab.transform.Find("SubscribedText")).GetComponent<Button>();
			Button component9 = ((Component)filesTab.transform.Find("BlacklistText")).GetComponent<Button>();
			RegisterWholeKeyboard();
			((UnityEvent)component7.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				SetFilterMode(InstalledSort.INSTALLED);
			}));
			((UnityEvent)component8.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				SetFilterMode(InstalledSort.SUBSCRIBED);
			}));
			((UnityEvent)component9.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				SetFilterMode(InstalledSort.BLACKLIST);
			}));
			((UnityEvent)componentInChildren9.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				TriggerModInfoPopup(show: false, null);
			}));
			((UnityEvent)componentInChildren10.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				TriggerModInfoPopup(show: false, null);
			}));
			((UnityEvent)componentInChildren.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnSubscribeButtonPressed(selected: false);
			}));
			((UnityEvent)componentInChildren2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnSubscribeButtonPressed(selected: true);
			}));
			((UnityEvent)componentInChildren3.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnBlacklistButtonPressed(selected: false);
			}));
			((UnityEvent)componentInChildren4.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnBlacklistButtonPressed(selected: true);
			}));
			((UnityEvent)componentInChildren5.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnInstallButtonPressed(selected: false);
			}));
			((UnityEvent)componentInChildren6.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnInstallButtonPressed(selected: true);
			}));
			((UnityEvent)componentInChildren7.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnBlacklistButtonPressed(selected: false);
			}));
			((UnityEvent)componentInChildren8.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnBlacklistButtonPressed(selected: true);
			}));
			ChangePanel(Panels.FILES);
		}

		public void Refresh()
		{
			if (selectedPanel == Panels.FILES)
			{
				SetFilterMode(chosenSort);
			}
		}

		public static void SetHostSubscribedMods(List<ModInfo> modInfos)
		{
			host.Clear();
			host.AddRange(modInfos);
			MainClass.confirmedHostHasIt = true;
		}

		public static void AddCheckboxSetting(string title, bool startingValue, Action<bool> onModified)
		{
			settings.Add(new CheckboxSetting(title, startingValue, onModified));
		}

		public static void AddNumericalSetting(string title, int startingValue, int minValue, int maxValue, int increment, Action<int> onModified)
		{
			settings.Add(new NumericalSetting(title, startingValue, minValue, maxValue, increment, onModified));
		}

		public void OnSubscribeButtonPressed(bool selected)
		{
			if (selected)
			{
				ModFileManager.UnSubscribe(viewedInfo.numericalId);
				if (viewedInfo.IsInstalled())
				{
					ModFileManager.UnInstall(viewedInfo.numericalId);
				}
				MainClass.subscribedModIoNumericalIds.Remove(viewedInfo.numericalId);
				return;
			}
			if (viewedInfo.windowsDownloadLink != "nothing" || viewedInfo.androidDownloadLink != "nothing")
			{
				MainClass.ReceiveSubModInfo(viewedInfo);
			}
			else
			{
				MainClass.PopulateSubscriptions();
			}
			if (!MainClass.subscribedModIoNumericalIds.Contains(viewedInfo.numericalId))
			{
				MainClass.subscribedModIoNumericalIds.Add(viewedInfo.numericalId);
			}
			ModFileManager.Subscribe(viewedInfo.numericalId);
		}

		private void Search(string query)
		{
			searching = true;
			modIoRetrieved.Clear();
			PopulateModIoTab(0);
			ResetPageNumber();
			trendingOffset = 0;
			UpdateArrowDisplays();
			ModFileManager.QueueTrending(0, query);
			rootAnimator.SetTrigger("keyboardpopup");
			SetMainCanvasColliderState(enabled: true);
			((Component)modIoTab.transform.Find("BackToTrending")).gameObject.SetActive(true);
			((Component)modIoTab.transform.Find("BonelabIcon")).gameObject.SetActive(false);
			((Component)modIoTab.transform.Find("SectionText")).GetComponent<TMP_Text>().text = "\"" + query + "\"";
		}

		private void ReturnToTrending()
		{
			searching = false;
			modIoRetrieved.Clear();
			PopulateModIoTab(0);
			ResetPageNumber();
			UpdateArrowDisplays();
			ModFileManager.QueueTrending(0);
			((Component)modIoTab.transform.Find("BackToTrending")).gameObject.SetActive(false);
			((Component)modIoTab.transform.Find("BonelabIcon")).gameObject.SetActive(true);
			((Component)modIoTab.transform.Find("SectionText")).GetComponent<TMP_Text>().text = "TRENDING";
		}

		public void OnBlacklistButtonPressed(bool selected)
		{
			if (selected)
			{
				if (viewedInfo.modId != null)
				{
					MainClass.blacklistedModIoIds.Remove(viewedInfo.modId);
					MainClass.RemoveLineFromBlacklist(viewedInfo.modId);
				}
				MainClass.blacklistedModIoIds.Remove(viewedInfo.numericalId);
				MainClass.RemoveLineFromBlacklist(viewedInfo.numericalId);
			}
			else
			{
				if (viewedInfo.modId != null)
				{
					MainClass.blacklistedModIoIds.Add(viewedInfo.modId);
					MainClass.WriteLineToBlacklist(viewedInfo.modId);
				}
				else
				{
					MainClass.blacklistedModIoIds.Add(viewedInfo.numericalId);
					MainClass.WriteLineToBlacklist(viewedInfo.numericalId);
				}
				if (viewedInfo.IsSubscribed())
				{
					ModFileManager.UnSubscribe(viewedInfo.numericalId);
					if (viewedInfo.IsInstalled())
					{
						ModFileManager.UnInstall(viewedInfo.numericalId);
					}
					MainClass.subscribedModIoNumericalIds.Remove(viewedInfo.numericalId);
				}
			}
			UpdateModPopupButtons();
		}

		public void OnInstallButtonPressed(bool selected)
		{
			if (selected)
			{
				ModFileManager.UnInstall(viewedInfo.numericalId);
				if (viewedInfo.IsSubscribed())
				{
					ModFileManager.UnSubscribe(viewedInfo.numericalId);
				}
				MainClass.subscribedModIoNumericalIds.Remove(viewedInfo.numericalId);
			}
			else if (viewedInfo.windowsDownloadLink != null)
			{
				ModFileManager.AddToQueue(new DownloadQueueElement
				{
					info = viewedInfo,
					associatedPlayer = null,
					notify = true
				});
			}
			else
			{
				ModInfo.RequestModInfoNumerical(viewedInfo.numericalId, "install_native");
			}
		}

		private void ResetPageNumber()
		{
			pageNumber = 0;
			maxDisplayPerPage = 8;
			maxPages = 0;
		}

		public void TriggerModInfoPopup(bool show, ModInfo modInfo)
		{
			rootAnimator = ((Component)this).GetComponentInParent<Animator>();
			rootAnimator.SetTrigger("triggerpopup");
			if (show)
			{
				SetMainCanvasColliderState(enabled: false);
				TMP_Text component = ((Component)modInfoPopup.transform.Find("ModTitle")).GetComponent<TMP_Text>();
				TMP_Text component2 = ((Component)modInfoPopup.transform.Find("Description")).GetComponent<TMP_Text>();
				TMP_Text component3 = ((Component)modInfoPopup.transform.Find("FileSizeDisplay")).GetComponent<TMP_Text>();
				RawImage thumbnail = ((Component)modInfoPopup.transform.Find("Thumbnail")).GetComponent<RawImage>();
				component.text = modInfo.modName;
				component2.text = modInfo.modSummary;
				float fileSizeKB = modInfo.fileSizeKB;
				float num = fileSizeKB / 1000000f;
				float num2 = num / 1000f;
				string value = "KB";
				float num3 = fileSizeKB;
				if (num > 1f)
				{
					num3 = num;
					value = "MB";
				}
				if (num2 > 1f)
				{
					num3 = num2;
					value = "GB";
				}
				num3 = Mathf.Round(num3 * 100f) / 100f;
				component3.text = $"({num3} {value})";
				ThumbnailThreader.DownloadThumbnail(modInfo.thumbnailLink, delegate(Texture texture)
				{
					if (Object.op_Implicit((Object)(object)thumbnail))
					{
						thumbnail.texture = texture;
					}
				});
				viewedInfo = modInfo;
				UpdateModPopupButtons();
			}
			else
			{
				SetMainCanvasColliderState(enabled: true);
			}
		}

		private void SetMainCanvasColliderState(bool enabled)
		{
			foreach (BoxCollider componentsInChild in ((Component)this).GetComponentsInChildren<BoxCollider>())
			{
				((Collider)componentsInChild).enabled = enabled;
			}
		}

		public void UpdateModPopupButtons()
		{
			if (viewedInfo == null)
			{
				return;
			}
			ModInfo modInfo = viewedInfo;
			GameObject gameObject = ((Component)modInfoPopup.transform.Find("SubscribeUnselected")).gameObject;
			GameObject gameObject2 = ((Component)modInfoPopup.transform.Find("SubscribeSelected")).gameObject;
			GameObject gameObject3 = ((Component)modInfoPopup.transform.Find("BlacklistParted")).gameObject;
			GameObject gameObject4 = ((Component)modInfoPopup.transform.Find("BlacklistPartedSelected")).gameObject;
			GameObject gameObject5 = ((Component)modInfoPopup.transform.Find("UninstallParted")).gameObject;
			GameObject gameObject6 = ((Component)modInfoPopup.transform.Find("UninstallPartedSelected")).gameObject;
			GameObject gameObject7 = ((Component)modInfoPopup.transform.Find("BlacklistFull")).gameObject;
			GameObject gameObject8 = ((Component)modInfoPopup.transform.Find("BlacklistSelectedFull")).gameObject;
			gameObject.SetActive(false);
			gameObject2.SetActive(false);
			gameObject3.SetActive(false);
			gameObject4.SetActive(false);
			gameObject5.SetActive(false);
			gameObject6.SetActive(false);
			gameObject7.SetActive(false);
			gameObject8.SetActive(false);
			bool flag = modInfo.IsInstalled();
			if (modInfo.IsSubscribed())
			{
				gameObject.SetActive(false);
				gameObject2.SetActive(true);
			}
			else
			{
				gameObject.SetActive(true);
				gameObject2.SetActive(false);
			}
			bool flag2 = false;
			if (flag)
			{
				flag2 = true;
				gameObject6.SetActive(true);
				gameObject5.SetActive(false);
			}
			if (flag2)
			{
				gameObject8.SetActive(false);
				gameObject7.SetActive(false);
				if (modInfo.IsBlacklisted())
				{
					gameObject4.SetActive(true);
					gameObject3.SetActive(false);
				}
				else
				{
					gameObject4.SetActive(false);
					gameObject3.SetActive(true);
				}
			}
			else if (modInfo.IsBlacklisted())
			{
				gameObject8.SetActive(true);
				gameObject7.SetActive(false);
			}
			else
			{
				gameObject8.SetActive(false);
				gameObject7.SetActive(true);
			}
		}

		public void SetFilterMode(InstalledSort installedSort)
		{
			chosenSort = installedSort;
			ResetPageNumber();
			switch (installedSort)
			{
			case InstalledSort.INSTALLED:
				((Component)filesTab.transform.Find("GridLayout")).gameObject.SetActive(true);
				((Component)filesTab.transform.Find("ListLayout")).gameObject.SetActive(false);
				((Component)filesTab.transform.Find("UninstallUnsubscribedModsButton")).gameObject.SetActive(true);
				maxPages = (int)Math.Ceiling((double)totalInstalled.Count / (double)maxDisplayPerPage);
				UpdateArrowDisplays();
				PopulateFiles(pageNumber);
				break;
			case InstalledSort.SUBSCRIBED:
			{
				((Component)filesTab.transform.Find("GridLayout")).gameObject.SetActive(true);
				((Component)filesTab.transform.Find("ListLayout")).gameObject.SetActive(false);
				((Component)filesTab.transform.Find("UninstallUnsubscribedModsButton")).gameObject.SetActive(false);
				List<ModInfo> list = new List<ModInfo>();
				foreach (ModInfo item in totalInstalled)
				{
					if (item.IsSubscribed())
					{
						list.Add(item);
					}
				}
				maxPages = (int)Math.Ceiling((double)list.Count / (double)maxDisplayPerPage);
				UpdateArrowDisplays();
				PopulateFiles(pageNumber);
				break;
			}
			case InstalledSort.BLACKLIST:
				((Component)filesTab.transform.Find("GridLayout")).gameObject.SetActive(false);
				((Component)filesTab.transform.Find("ListLayout")).gameObject.SetActive(true);
				((Component)filesTab.transform.Find("UninstallUnsubscribedModsButton")).gameObject.SetActive(false);
				maxPages = (int)Math.Ceiling((double)MainClass.blacklistedModIoIds.Count / 4.0);
				UpdateArrowDisplays();
				PopulateBlacklist(pageNumber);
				break;
			}
		}

		public void PopulateBlacklist(int page)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)filesTab.transform.Find("ListLayout")).gameObject;
			int childCount = gameObject.transform.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = gameObject.transform.GetChild(i);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			int num = 4 * page;
			for (int j = 0; j < 4; j++)
			{
				if (MainClass.blacklistedModIoIds.Count > num + j)
				{
					string original = MainClass.blacklistedModIoIds[num + j];
					string text = original;
					if (int.TryParse(text, out var result))
					{
						text = "Numeric Listing: " + result;
					}
					GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.blacklistDisplayPrefab);
					TMP_Text component = ((Component)val.transform.Find("BlacklistedMod")).gameObject.GetComponent<TMP_Text>();
					component.text = text;
					Button component2 = ((Component)val.transform.Find("XButton").Find("Button")).gameObject.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						MainClass.blacklistedModIoIds.Remove(original);
						maxPages = (int)Math.Ceiling((double)MainClass.blacklistedModIoIds.Count / 4.0);
						PopulateBlacklist(pageNumber);
						MainClass.RemoveLineFromBlacklist(original);
					}));
					val.transform.parent = gameObject.transform;
					val.transform.localPosition = Vector3.forward;
					val.transform.localRotation = Quaternion.identity;
					val.transform.localScale = Vector3.one;
				}
			}
		}

		public void OnNewTrendingRecieved()
		{
			if (selectedPanel == Panels.MODIO)
			{
				if (maxPages >= 1)
				{
					PopulateModIoTab(maxPages - 1);
				}
				else
				{
					PopulateModIoTab(0);
				}
				maxPages = (int)Math.Ceiling((double)modIoRetrieved.Count / (double)maxDisplayPerPage);
				UpdateArrowDisplays();
				SetMainCanvasColliderState(enabled: true);
			}
		}

		private void PopulateModIoTab(int page)
		{
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			if (page > 0 || searching)
			{
				GameObject gameObject = ((Component)modIoTab.transform.Find("GridLayout")).gameObject;
				GameObject gameObject2 = ((Component)modIoTab.transform.Find("TrendingFirstPage")).gameObject;
				gameObject2.SetActive(false);
				gameObject.SetActive(true);
				ClearAllChildren(gameObject.transform);
				int num = maxDisplayPerPage * page;
				if (!searching)
				{
					if (num > 0)
					{
						num -= 2;
					}
					if (spotlightOverride.manualDisplayId != null)
					{
						num--;
					}
				}
				for (int i = 0; i < maxDisplayPerPage; i++)
				{
					if (modIoRetrieved.Count > num + i)
					{
						ModInfo modInfo = modIoRetrieved[num + i];
						MakeModInfoObject(gameObject.transform, modInfo);
					}
				}
				return;
			}
			GameObject gameObject3 = ((Component)modIoTab.transform.Find("GridLayout")).gameObject;
			Transform val = modIoTab.transform.Find("TrendingFirstPage");
			GameObject gameObject4 = ((Component)val).gameObject;
			Transform val2 = val.Find("BigBanner");
			gameObject4.SetActive(true);
			gameObject3.SetActive(false);
			Transform parent = val.Find("GridLayoutTrending");
			Transform val3 = val.Find("ModInfoSpawnPoint");
			ClearAllChildren(parent);
			ClearAllChildren(val3);
			int num2 = 1;
			if (spotlightOverride.manualDisplayId != null)
			{
				num2--;
			}
			if (modIoRetrieved.Count == 0)
			{
				((Component)val2).gameObject.SetActive(false);
				return;
			}
			((Component)val2).gameObject.SetActive(true);
			GameObject val4 = MakeModInfoObject(val3, modIoRetrieved[num2]);
			RectTransform component = val4.GetComponent<RectTransform>();
			RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
			((Transform)component).position = ((Transform)component2).position;
			num2++;
			for (int j = 0; j < 4; j++)
			{
				if (modIoRetrieved.Count > num2 + j)
				{
					ModInfo modInfo2 = modIoRetrieved[num2 + j];
					MakeModInfoObject(parent, modInfo2);
				}
			}
			TMP_Text component3 = ((Component)val2.Find("ModTitleText")).GetComponent<TMP_Text>();
			TMP_Text component4 = ((Component)val2.Find("Description")).GetComponent<TMP_Text>();
			Transform val5 = val2.Find("ThumbnailMaskMovedSlight");
			RawImage thumbNail = ((Component)val5.Find("LargeThumbnail")).GetComponent<RawImage>();
			ModInfo modInfo3 = modIoRetrieved[0];
			if (spotlightOverride.downloadedInfo != null)
			{
				modInfo3 = spotlightOverride.downloadedInfo;
			}
			ThumbnailThreader.DownloadThumbnail(modInfo3.thumbnailLink, delegate(Texture texture)
			{
				if (Object.op_Implicit((Object)(object)thumbNail))
				{
					thumbNail.texture = texture;
				}
				spotlightOverride.cachedThumbnail = texture;
			});
			GameObject gameObject5 = ((Component)((Component)val5).transform.Find("BottomBar")).gameObject;
			if (spotlightOverride.subTitle != null)
			{
				gameObject5.SetActive(true);
				TMP_Text component5 = ((Component)gameObject5.transform.Find("OptionalTitle")).GetComponent<TMP_Text>();
				component5.text = spotlightOverride.subTitle;
			}
			else
			{
				gameObject5.SetActive(false);
			}
			if (spotlightOverride.titleOverride != null)
			{
				component3.text = spotlightOverride.titleOverride;
			}
			else
			{
				component3.text = modInfo3.modName;
			}
			if (spotlightOverride.descriptionOverride != null)
			{
				component4.text = spotlightOverride.descriptionOverride;
			}
			else
			{
				component4.text = modInfo3.modSummary;
			}
		}

		private void ClearAllChildren(Transform parent)
		{
			int childCount = parent.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = parent.GetChild(i);
				ModInfoDisplay componentInChildren = ((Component)child).GetComponentInChildren<ModInfoDisplay>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.DestroyThumbnail();
				}
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
		}

		private GameObject MakeModInfoObject(Transform parent, ModInfo modInfo, bool zeroPosition = true)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.modInfoDisplay);
			ModInfoDisplay modInfoDisplay = val.AddComponent<ModInfoDisplay>();
			modInfoDisplay.SetModInfo(modInfo);
			modInfoDisplay.controller = this;
			val.transform.parent = ((Component)parent).transform;
			if (zeroPosition)
			{
				val.transform.localPosition = Vector3.forward;
				val.transform.localRotation = Quaternion.identity;
			}
			val.transform.localScale = Vector3.one;
			return val;
		}

		private void PopulateFiles(int page)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)filesTab.transform.Find("GridLayout")).gameObject;
			int childCount = gameObject.transform.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = gameObject.transform.GetChild(i);
				ModInfoDisplay componentInChildren = ((Component)child).GetComponentInChildren<ModInfoDisplay>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.DestroyThumbnail();
				}
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			int num = 0;
			int num2 = 0;
			int num3 = page * maxDisplayPerPage;
			foreach (ModInfo item in totalInstalled)
			{
				num2++;
				if (num2 >= num3 && (chosenSort != InstalledSort.SUBSCRIBED || item.IsSubscribed()))
				{
					GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.modInfoDisplay);
					ModInfoDisplay modInfoDisplay = val.AddComponent<ModInfoDisplay>();
					modInfoDisplay.SetModInfo(item);
					modInfoDisplay.controller = this;
					val.transform.parent = gameObject.transform;
					val.transform.localPosition = Vector3.forward;
					val.transform.localRotation = Quaternion.identity;
					val.transform.localScale = Vector3.one;
					num++;
					if (num >= maxDisplayPerPage)
					{
						break;
					}
				}
			}
		}

		private void PopulateHostMods(int page)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)multiplayerTab.transform.Find("GridLayout")).gameObject;
			int childCount = gameObject.transform.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = gameObject.transform.GetChild(i);
				ModInfoDisplay componentInChildren = ((Component)child).GetComponentInChildren<ModInfoDisplay>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.DestroyThumbnail();
				}
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			int num = 0;
			int num2 = 0;
			int num3 = page * maxDisplayPerPage;
			foreach (ModInfo item in host)
			{
				num2++;
				if (num2 >= num3)
				{
					GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.modInfoDisplay);
					ModInfoDisplay modInfoDisplay = val.AddComponent<ModInfoDisplay>();
					modInfoDisplay.SetModInfo(item);
					modInfoDisplay.controller = this;
					val.transform.parent = gameObject.transform;
					val.transform.localPosition = Vector3.forward;
					val.transform.localRotation = Quaternion.identity;
					val.transform.localScale = Vector3.one;
					num++;
					if (num >= maxDisplayPerPage)
					{
						break;
					}
				}
			}
		}

		private void PopulateSettings(int page)
		{
			GameObject gameObject = ((Component)settingsTab.transform.Find("SettingsHolder")).gameObject;
			int childCount = gameObject.transform.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = gameObject.transform.GetChild(i);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			int num = 3 * page;
			for (int j = 0; j < 3; j++)
			{
				if (settings.Count > num + j)
				{
					GenericSetting genericSetting = settings[num + j];
					genericSetting.SpawnPrefab(gameObject.transform);
				}
			}
		}

		private void ChangePanel(Panels panel)
		{
			ResetPageNumber();
			selectedPanel = panel;
			switch (panel)
			{
			case Panels.FILES:
				SetSelectorDesired(((Component)filesTabButton).transform.parent.Find("SelectorDesiredPos"));
				SetFilterMode(chosenSort);
				break;
			case Panels.MODIO:
				maxPages = (int)Math.Ceiling((double)modIoRetrieved.Count / (double)maxDisplayPerPage);
				UpdateArrowDisplays();
				SetSelectorDesired(((Component)modIoTabButton).transform.parent.Find("SelectorDesiredPos"));
				PopulateModIoTab(pageNumber);
				break;
			case Panels.SETTINGS:
				maxPages = (int)Math.Ceiling((double)settings.Count / 3.0);
				UpdateArrowDisplays();
				SetSelectorDesired(((Component)settingsTabButton).transform.parent.Find("SelectorDesiredPos"));
				PopulateSettings(pageNumber);
				break;
			case Panels.MULTIPLAYER:
			{
				maxPages = (int)Math.Ceiling((double)host.Count / (double)maxDisplayPerPage);
				UpdateArrowDisplays();
				SetSelectorDesired(((Component)multiplayerTabButton).transform.parent.Find("SelectorDesiredPos"));
				PopulateHostMods(pageNumber);
				TMP_Text component = ((Component)multiplayerTab.transform.Find("InstallAllHostModsButton").Find("Text (TMP)")).GetComponent<TMP_Text>();
				float num = 0f;
				int num2 = 0;
				foreach (ModInfo item in host)
				{
					if (!item.IsInstalled())
					{
						num2++;
						num += item.fileSizeKB;
					}
				}
				float num3 = num;
				float num4 = num3 / 1000000f;
				float num5 = num4 / 1000f;
				string value = "KB";
				float num6 = num3;
				if (num4 > 1f)
				{
					num6 = num4;
					value = "MB";
				}
				if (num5 > 1f)
				{
					num6 = num5;
					value = "GB";
				}
				num6 = Mathf.Round(num6 * 100f) / 100f;
				component.text = $"Install Host Mods ({num2}) ({num6} {value})";
				break;
			}
			}
		}

		private void UpdateArrowDisplays()
		{
			GameObject gameObject = ((Component)((Component)upArrowButton).transform.parent).gameObject;
			GameObject gameObject2 = ((Component)((Component)downArrowButton).transform.parent).gameObject;
			gameObject.SetActive(pageNumber > 0);
			gameObject2.SetActive(pageNumber < maxPages - 1);
			if (selectedPanel == Panels.MODIO && modIoRetrieved.Count > 80)
			{
				gameObject2.SetActive(true);
			}
		}

		private void OnArrowPress(bool up)
		{
			if (!up)
			{
				pageNumber++;
			}
			else
			{
				pageNumber--;
			}
			if (pageNumber < 0)
			{
				pageNumber = 0;
			}
			if (selectedPanel == Panels.MODIO && pageNumber == maxPages - 1 && modIoRetrieved.Count > 80)
			{
				trendingOffset++;
				if (searching)
				{
					ModFileManager.QueueTrending(trendingOffset * 100, KeyboardManager.typed);
				}
				else
				{
					ModFileManager.QueueTrending(trendingOffset * 100);
				}
			}
			if (pageNumber > maxPages)
			{
				pageNumber = maxPages;
			}
			if (selectedPanel == Panels.MULTIPLAYER)
			{
				PopulateHostMods(pageNumber);
			}
			if (selectedPanel == Panels.FILES)
			{
				if (chosenSort != InstalledSort.BLACKLIST)
				{
					PopulateFiles(pageNumber);
				}
				else
				{
					PopulateBlacklist(pageNumber);
				}
			}
			if (selectedPanel == Panels.MODIO)
			{
				PopulateModIoTab(pageNumber);
			}
			if (selectedPanel == Panels.SETTINGS)
			{
				PopulateSettings(pageNumber);
			}
			UpdateArrowDisplays();
		}

		private void RegisterWholeKeyboard()
		{
			RegisterKey("Q");
			RegisterKey("W");
			RegisterKey("E");
			RegisterKey("R");
			RegisterKey("T");
			RegisterKey("Y");
			RegisterKey("U");
			RegisterKey("I");
			RegisterKey("O");
			RegisterKey("P");
			RegisterKey("A");
			RegisterKey("S");
			RegisterKey("D");
			RegisterKey("F");
			RegisterKey("G");
			RegisterKey("H");
			RegisterKey("J");
			RegisterKey("K");
			RegisterKey("L");
			RegisterKey("Z");
			RegisterKey("X");
			RegisterKey("C");
			RegisterKey("V");
			RegisterKey("B");
			RegisterKey("N");
			RegisterKey("M");
			RegisterKey("1");
			RegisterKey("2");
			RegisterKey("3");
			RegisterKey("4");
			RegisterKey("5");
			RegisterKey("6");
			RegisterKey("7");
			RegisterKey("8");
			RegisterKey("9");
			RegisterKey("0");
			RegisterKey(".");
			RegisterKey(",");
			RegisterKey("'");
			RegisterKey("-");
			RegisterKey("=");
			SetKeyAction("Backspace", delegate
			{
				KeyboardManager.Backspace();
			});
			SetKeyAction("Space", delegate
			{
				KeyboardManager.Append(" ");
			});
			SetKeyAction("Enter", delegate
			{
				Search(KeyboardManager.typed);
			});
			SetKeyAction("Exit", delegate
			{
				rootAnimator.SetTrigger("keyboardpopup");
				SetMainCanvasColliderState(enabled: true);
			});
		}

		public void Reset()
		{
			((Component)((Component)this).transform.parent.Find("ModInfoOverlay")).gameObject.SetActive(false);
			keyboardPopup.gameObject.SetActive(false);
			((Component)this).GetComponent<CanvasGroup>().interactable = true;
			SetMainCanvasColliderState(enabled: true);
		}

		private void RegisterKey(string keyName)
		{
			string keyName2 = keyName;
			SetKeyAction(keyName2, delegate
			{
				KeyboardManager.Append(keyName2);
			});
		}

		private void PopupKeyboard()
		{
			rootAnimator.SetTrigger("keyboardpopup");
			SetMainCanvasColliderState(enabled: false);
		}

		private void SetKeyAction(string keyName, Action action)
		{
			GameObject gameObject = ((Component)keyboardPopup.transform.Find("Keyboard").Find(keyName)).gameObject;
			Button component = gameObject.GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit(action));
		}

		private void Update()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			List<StalledAction> toRemove = new List<StalledAction>();
			foreach (StalledAction stalledAction in stalledActions)
			{
				stalledAction.frameCount--;
				if (stalledAction.frameCount == 0)
				{
					stalledAction.action();
					toRemove.Add(stalledAction);
				}
			}
			stalledActions.RemoveAll((StalledAction stall) => toRemove.Contains(stall));
			if ((Object)(object)desired != (Object)null && (Object)(object)selector != (Object)null)
			{
				selector.position = Vector3.Lerp(selector.position, desired.position, speed * Time.deltaTime);
			}
			if (ModFileManager.activeDownloadQueueElement != null)
			{
				modProgressDisplay.SetActive(true);
				RawImage thumbnail = ((Component)modProgressDisplay.transform.Find("Thumbnail")).gameObject.GetComponent<RawImage>();
				if (lastDownloadedTitle != ModFileManager.activeDownloadQueueElement.info.modName)
				{
					lastDownloadedTitle = ModFileManager.activeDownloadQueueElement.info.modName;
					ThumbnailThreader.DownloadThumbnail(ModFileManager.activeDownloadQueueElement.info.thumbnailLink, delegate(Texture thumb)
					{
						thumbnail.texture = thumb;
					});
				}
				TMP_Text component = ((Component)modProgressDisplay.transform.Find("Title")).gameObject.GetComponent<TMP_Text>();
				component.text = ModFileManager.activeDownloadQueueElement.info.modName;
				TMP_Text component2 = ((Component)modProgressDisplay.transform.Find("Percentage")).gameObject.GetComponent<TMP_Text>();
				component2.text = (int)Math.Round(ModlistMenu.activeDownloadModInfo.modDownloadPercentage) + "%";
			}
			else
			{
				lastDownloadedTitle = "nothing";
				modProgressDisplay.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)multiplayerTabButton))
			{
				((Component)((Component)multiplayerTabButton).transform.parent).gameObject.SetActive(NetworkInfo.HasServer);
			}
			if (Object.op_Implicit((Object)(object)keyboardPopup))
			{
				typeBarText.text = KeyboardManager.typed;
				if (KeyboardManager.typed == "")
				{
					typeBarTextObject.SetActive(false);
					typeBarEmptyTextObject.SetActive(true);
				}
				else
				{
					typeBarTextObject.SetActive(true);
					typeBarEmptyTextObject.SetActive(false);
				}
			}
		}

		public void SetSelectorDesired(Transform transform)
		{
			desired = transform;
		}
	}
}
namespace ModioModNetworker
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct ModioModNetworkerUpdaterVersion
	{
		public const string versionString = "2.5.1";
	}
	public class MainClass : MelonMod
	{
		private static string MODIO_MODNETWORKER_DIRECTORY = MelonUtils.GameDirectory + "/ModIoModNetworker";

		private static string MODIO_AUTH_TXT_DIRECTORY = MODIO_MODNETWORKER_DIRECTORY + "/auth.txt";

		private static string MODIO_BLACKLIST_TXT_DIRECTORY = MODIO_MODNETWORKER_DIRECTORY + "/blacklist.txt";

		public static List<string> subscribedModIoNumericalIds = new List<string>();

		public static List<string> blacklistedModIoIds = new List<string>();

		private static List<string> toRemoveSubscribedModIoIds = new List<string>();

		public static List<ModInfo> subscribedMods = new List<ModInfo>();

		public static List<ModInfo> installedMods = new List<ModInfo>();

		public static List<InstalledModInfo> InstalledModInfos = new List<InstalledModInfo>();

		private static List<InstalledModInfo> outOfDateModInfos = new List<InstalledModInfo>();

		public static bool warehouseReloadRequested = false;

		public static List<string> warehousePalletReloadTargets = new List<string>();

		public static List<string> warehouseReloadFolders = new List<string>();

		public static bool subsChanged = false;

		public static bool refreshInstalledModsRequested = false;

		public static bool refreshSubscribedModsRequested = false;

		public static bool menuRefreshRequested = false;

		public static string subscriptionThreadString = "";

		public static string trendingThreadString = "";

		public static bool subsRefreshing = false;

		private static int desiredSubs = 0;

		private bool addedCallback = false;

		public static MelonPreferences_Category melonPreferencesCategory;

		private static MelonPreferences_Entry<string> modsDirectory;

		public static MelonPreferences_Entry<bool> autoDownloadAvatarsConfig;

		public static MelonPreferences_Entry<bool> autoDownloadSpawnablesConfig;

		public static MelonPreferences_Entry<bool> autoDownloadLevelsConfig;

		public static MelonPreferences_Entry<bool> downloadMatureContentConfig;

		public static MelonPreferences_Entry<bool> tempLobbyModsConfig;

		public static MelonPreferences_Entry<bool> overrideFusionDLConfig;

		public static MelonPreferences_Entry<float> maxAutoDownloadMbConfig;

		public static MelonPreferences_Entry<float> maxLevelAutoDownloadGbConfig;

		public static float maxAutoDownloadMb = 500f;

		public static bool autoDownloadAvatars = true;

		public static bool autoDownloadSpawnables = true;

		public static bool autoDownloadLevels = false;

		public static float levelMaxGb = 1f;

		public static bool downloadMatureContent = false;

		public static bool tempLobbyMods = false;

		public static bool useRepo = false;

		public static bool overrideFusionDL = false;

		public static List<string> modNumericalsDownloadedDuringLobbySession = new List<string>();

		private static int subsShown = 0;

		private static int subTotal = 0;

		public bool palletLock = false;

		public static bool confirmedHostHasIt = false;

		private static bool loadedInstalled = false;

		public static bool handlingInstalled = false;

		public static bool handlingSubscribed = false;

		private bool assetWarehouseLoaded = false;

		public override void OnInitializeMelon()
		{
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			melonPreferencesCategory = MelonPreferences.CreateCategory("ModioModNetworker");
			melonPreferencesCategory.SetFilePath(MelonUtils.UserDataDirectory + "/ModioModNetworker.cfg");
			modsDirectory = melonPreferencesCategory.CreateEntry<string>("ModDirectoryPath", Application.persistentDataPath + "/Mods", (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			autoDownloadAvatarsConfig = melonPreferencesCategory.CreateEntry<bool>("AutoDownloadAvatars", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			autoDownloadSpawnablesConfig = melonPreferencesCategory.CreateEntry<bool>("AutoDownloadSpawnables", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			autoDownloadLevelsConfig = melonPreferencesCategory.CreateEntry<bool>("AutoDownloadLevels", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			maxLevelAutoDownloadGbConfig = melonPreferencesCategory.CreateEntry<float>("MaxLevelAutoDownloadGb", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			tempLobbyModsConfig = melonPreferencesCategory.CreateEntry<bool>("TemporaryLobbyMods", false, (string)null, "If set to true, lobby mods like (avatars/spawnables/levels) that got auto downloaded will be deleted when you leave the lobby.", false, false, (ValueValidator)null, (string)null);
			maxAutoDownloadMbConfig = melonPreferencesCategory.CreateEntry<float>("MaxAutoDownloadMb", 500f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			downloadMatureContentConfig = melonPreferencesCategory.CreateEntry<bool>("DownloadMatureContent", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			overrideFusionDLConfig = melonPreferencesCategory.CreateEntry<bool>("OverrideFusionDL", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			maxAutoDownloadMb = maxAutoDownloadMbConfig.Value;
			autoDownloadAvatars = autoDownloadAvatarsConfig.Value;
			downloadMatureContent = downloadMatureContentConfig.Value;
			autoDownloadSpawnables = autoDownloadSpawnablesConfig.Value;
			autoDownloadLevels = autoDownloadLevelsConfig.Value;
			tempLobbyMods = tempLobbyModsConfig.Value;
			levelMaxGb = maxLevelAutoDownloadGbConfig.Value;
			useRepo = false;
			overrideFusionDL = overrideFusionDLConfig.Value;
			ModFileManager.MOD_FOLDER_PATH = modsDirectory.Value;
			SpotlightOverride.LoadFromRegularURL();
			AssetBundle bundle = (HelperMethods.IsAndroid() ? EmbeddedAssetBundle.LoadFromAssembly(Assembly.GetExecutingAssembly(), "ModioModNetworker.Resources.networkermenu.android.networker") : EmbeddedAssetBundle.LoadFromAssembly(Assembly.GetExecutingAssembly(), "ModioModNetworker.Resources.networkermenu.networker"));
			NetworkerAssets.LoadAssetsUI(bundle);
			PrepareModFiles();
			string text = ReadAuthKey();
			blacklistedModIoIds = ReadBlacklist();
			MelonLogger.Msg("Loaded blacklist with " + blacklistedModIoIds.Count + " entries.");
			ModIOSettings.LoadToken((Action<string>)OnLoadToken);
			MelonLogger.Msg("Loading internal module...");
			ModuleManager.RegisterModule<ModlistModule>();
			ModFileManager.Initialize();
			ModlistMenu.Initialize();
			MultiplayerHooking.OnPlayerJoin += new PlayerUpdate(OnPlayerJoin);
			MultiplayerHooking.OnDisconnect += new ServerEvent(OnDisconnect);
			MultiplayerHooking.OnStartServer += new ServerEvent(OnStartServer);
			NetworkPlayer.OnNetworkRigCreated += OnPlayerRepCreated;
			void OnLoadToken(string loadedToken)
			{
				ModFileManager.OAUTH_KEY = loadedToken;
				MelonLogger.Msg("Populating currently installed mods via this mod.");
				installedMods.Clear();
				InstalledModInfos.Clear();
				PopulateInstalledMods(ModFileManager.MOD_FOLDER_PATH);
				loadedInstalled = true;
				MelonLogger.Msg("Checking mod.io account subscriptions");
				PopulateSubscriptions();
				ModFileManager.QueueTrending(0);
				MelonLogger.Msg("Registered on mod.io with auth key!");
			}
		}

		private void OnLobbyCategoryMade(Page category, INetworkLobby lobby)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			INetworkLobby lobby2 = lobby;
			string text = default(string);
			if (lobby2.TryGetMetadata("modionetworker", ref text))
			{
				category.CreateFunction("ModioModNetworker Active On Server", Color.cyan, (Action)delegate
				{
				});
			}
			string text2 = default(string);
			if (!lobby2.TryGetMetadata("LevelBarcode", ref text2) || CrateFilterer.HasCrate<LevelCrate>(new Barcode(text2)))
			{
				return;
			}
			category.CreateFunction("Download Level", Color.cyan, (Action)delegate
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: 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: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				string text3 = default(string);
				if (lobby2.TryGetMetadata("networkermap", ref text3))
				{
					if (text3 != "null")
					{
						FusionNotifier.Send(new FusionNotification
						{
							Title = new NotificationText("Installing lobby level...", Color.cyan, true),
							ShowPopup = true,
							PopupLength = 1f,
							Message = NotificationText.op_Implicit("Please wait"),
							SaveToMenu = false
						});
						ModInfo.RequestModInfoNumerical(text3, "install_native");
					}
					else
					{
						FusionNotifier.Send(new FusionNotification
						{
							Title = new NotificationText("Cannot install this map!", Color.cyan, true),
							ShowPopup = true,
							PopupLength = 1f,
							Message = NotificationText.op_Implicit("Probably not a networked map!"),
							SaveToMenu = false
						});
					}
				}
			});
		}

		private void DeleteAllTempMods()
		{
			foreach (ModInfo installedMod in installedMods)
			{
				if (installedMod.temp)
				{
					ModFileManager.UnInstallMainThread(installedMod.numericalId);
				}
			}
		}

		public override void OnUpdate()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			foreach (AvatarDownloadBar value3 in AvatarDownloadBar.bars.Values)
			{
				value3.Update();
			}
			ThumbnailThreader.HandleQueue();
			MainThreadManager.HandleQueue();
			LevelHoldQueue.Update();
			if (ModFileManager.activeDownloadQueueElement != null && ModFileManager.activeDownloadQueueElement.associatedPlayer != null && AvatarDownloadBar.bars.TryGetValue(ModFileManager.activeDownloadQueueElement.associatedPlayer, out AvatarDownloadBar value))
			{
				ModInfo activeDownloadModInfo = ModlistMenu.activeDownloadModInfo;
				value.SetModName(activeDownloadModInfo.modId);
				value.SetPercentage((float)activeDownloadModInfo.modDownloadPercentage);
			}
			bool flag = false;
			if (SceneStreamer._session != null && (int)SceneStreamer._session.Status == 1)
			{
				flag = true;
			}
			if (ModFileManager.activeDownloadAction != null && ModFileManager.activeDownloadAction.Check())
			{
				ModFileManager.activeDownloadAction.Handle();
				ModFileManager.activeDownloadAction = null;
			}
			if (!addedCallback && AssetWarehouse.Instance != null)
			{
				AssetWarehouse instance = AssetWarehouse.Instance;
				instance.OnCrateAdded += Action<Barcode>.op_Implicit((Action<Barcode>)delegate(Barcode s)
				{
					palletLock = false;
					foreach (NetworkPlayer allNetworkPlayer in NetworkPlayerUtilities.GetAllNetworkPlayers())
					{
						FieldInfo field = ((object)allNetworkPlayer.AvatarSetter).GetType().GetField("_isAvatarDirty", BindingFlags.Instance | BindingFlags.NonPublic);
						field.SetValue(allNetworkPlayer.AvatarSetter, true);
					}
					SpawnableHoldQueue.CheckValid(s._id);
					LevelHoldQueue.CheckValid(s._id);
				});
				addedCallback = true;
				assetWarehouseLoaded = true;
				DeleteAllTempMods();
			}
			if (subsRefreshing && subscribedModIoNumericalIds.Count >= desiredSubs)
			{
				foreach (string toRemoveSubscribedModIoId in toRemoveSubscribedModIoIds)
				{
					subscribedModIoNumericalIds.Remove(toRemoveSubscribedModIoId);
				}
				toRemoveSubscribedModIoIds.Clear();
				ModlistMenu.Refresh(openMenu: true);
				subsRefreshing = false;
				handlingSubscribed = false;
				FusionNotifier.Send(new FusionNotification
				{
					Title = new NotificationText("Mod.io Subscriptions Refreshed!", Color.cyan, true),
					ShowPopup = true,
					PopupLength = 2f
				});
				MelonLogger.Msg("Finished refreshing mod.io subscriptions!");
				outOfDateModInfos.Clear();
			}
			if (warehouseReloadRequested && assetWarehouseLoaded && AssetWarehouse.Instance._initialLoaded && !palletLock)
			{
				bool flag2 = false;
				if (warehousePalletReloadTargets.Count > 0)
				{
					ModFileManager.DeleteExistingModObjects(warehousePalletReloadTargets[0]);
					PalletManifest val = null;
					Enumerator<Barcode, PalletManifest> enumerator3 = AssetWarehouse.Instance.palletManifests.GetEnumerator();
					while (enumerator3.MoveNext())
					{
						KeyValuePair<Barcode, PalletManifest> current3 = enumerator3.Current;
						if (current3.key._id == warehousePalletReloadTargets[0])
						{
							val = current3.value;
							break;
						}
					}
					AssetWarehouse.Instance.LoadAndUpdatePalletManifest(val.Pallet, ModlistMenu.activeDownloadModInfo.ToModListing(), val.PalletPath, val.CatalogPath, (IResourceLocator)null);
					warehousePalletReloadTargets.RemoveAt(0);
					flag2 = true;
				}
				if (warehouseReloadFolders.Count > 0)
				{
					AssetWarehouse.Instance.LoadPalletFromFolderAsync(warehouseReloadFolders[0], true, (string)null, ModlistMenu.activeDownloadModInfo.ToModListing());
					warehouseReloadFolders.RemoveAt(0);
					palletLock = true;
				}
				if (warehouseReloadFolders.Count == 0 && warehousePalletReloadTargets.Count == 0)
				{
					string text = "Downloaded!";
					string text2 = "This mod has been loaded into the game.";
					if (flag2)
					{
						text = "Updated!";
						text2 = "This mod has been updated and reloaded.";
					}
					if (ModFileManager.activeDownloadQueueElement.notify)
					{
						FusionNotifier.Send(new FusionNotification
						{
							Title = new NotificationText(ModlistMenu.activeDownloadModInfo.modId + " " + text, Color.cyan, true),
							ShowPopup = true,
							Message = new NotificationText(text2),
							PopupLength = 3f,
							SaveToMenu = false
						});
					}
					if (ModFileManager.activeDownloadQueueElement != null && ModFileManager.activeDownloadQueueElement.associatedPlayer != null && AvatarDownloadBar.bars.TryGetValue(ModFileManager.activeDownloadQueueElement.associatedPlayer, out AvatarDownloadBar value2))
					{
						value2.Finish();
					}
					palletLock = false;
					warehouseReloadRequested = false;
					ModFileManager.isDownloading = false;
					ModFileManager.activeDownloadWebRequest = null;
					ModlistMenu.activeDownloadModInfo = null;
					ModFileManager.activeDownloadQueueElement = null;
				}
			}
			ModInfo.HandleQueue();
			ModFileManager.CheckQueue();
			TimerManager.Update();
			if (!flag && ModlistMessage.waitAndQueue.Count > 0)
			{
				foreach (ModInfo item in ModlistMessage.waitAndQueue)
				{
					float num = item.fileSizeKB / 1000000f;
					if (num < maxAutoDownloadMb && autoDownloadAvatars)
					{
						if (!downloadMatureContent && item.mature)
						{
							return;
						}
						ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = null,
							info = item,
							notify = false
						});
					}
				}
				ModlistMessage.waitAndQueue.Clear();
			}
			if (subsChanged)
			{
				subsChanged = false;
				if (NetworkInfo.HasServer && NetworkInfo.IsServer)
				{
					SendAllMods();
				}
			}
			if (menuRefreshRequested)
			{
				if (flag)
				{
					return;
				}
				ModlistMenu.Refresh(openMenu: true);
				menuRefreshRequested = false;
			}
			if (refreshSubscribedModsRequested && !handlingInstalled && !handlingSubscribed)
			{
				refreshSubscribedModsRequested = false;
				handlingSubscribed = true;
				subscribedMods.Clear();
				subscribedModIoNumericalIds.Clear();
				subTotal = 0;
				subsShown = 0;
				desiredSubs = 0;
				ModFileManager.QueueSubscriptions(subsShown);
			}
			if (refreshInstalledModsRequested && !handlingSubscribed && !handlingInstalled)
			{
				installedMods.Clear();
				InstalledModInfos.Clear();
				NetworkerMenuController.totalInstalled.Clear();
				ModlistMenu.installPage = 0;
				Thread thread = new Thread((ThreadStart)delegate
				{
					handlingInstalled = true;
					PopulateInstalledMods(ModFileManager.MOD_FOLDER_PATH);
					MainThreadManager.QueueAction(delegate
					{
						if (Object.op_Implicit((Object)(object)NetworkerMenuController.instance))
						{
							NetworkerMenuController.instance.Refresh();
						}
					});
					handlingInstalled = false;
				});
				thread.Start();
				loadedInstalled = true;
				ModlistMenu.Refresh(openMenu: true);
				refreshInstalledModsRequested = false;
				if (Object.op_Implicit((Object)(object)NetworkerMenuController.instance))
				{
					NetworkerMenuController.instance.UpdateModPopupButtons();
				}
			}
			if (subscriptionThreadString != "")
			{
				InternalPopulateSubscriptions();
			}
			if (trendingThreadString != "")
			{
				InternalPopulateTrending();
				if (Object.op_Implicit((Object)(object)NetworkerMenuController.instance))
				{
					NetworkerMenuController.instance.OnNewTrendingRecieved();
				}
			}
		}

		public static void RequestInstallCheck(float delay = 1f)
		{
			TimerManager.DelayAction(delay, delegate
			{
				refreshInstalledModsRequested = true;
			});
		}

		private static void UpdateModInfo(ModInfo subscribed, InstalledModInfo installed)
		{
			try
			{
				ModInfo modInfo = installed.ModInfo;
				modInfo.mature = subscribed.mature;
				modInfo.modSummary = subscribed.modSummary;
				modInfo.modName = subscribed.modName;
				modInfo.thumbnailLink = subscribed.thumbnailLink;
				modInfo.numericalId = subscribed.numericalId;
				modInfo.structureVersion = ModInfo.globalStructureVersion;
				modInfo.windowsDownloadLink = subscribed.windowsDownloadLink;
				modInfo.androidDownloadLink = subscribed.androidDownloadLink;
				if (modInfo.version == null)
				{
					modInfo.version = "0.0.0";
				}
				string path = Path.Combine(Directory.GetParent(installed.palletPath).Name, "modinfo.json");
				File.Delete(path);
				string contents = JsonConvert.SerializeObject((object)modInfo);
				File.WriteAllText(path, contents);
				MelonLogger.Msg($"Updated modinfo.json for {modInfo.modId} to version {modInfo.structureVersion}");
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Skipped updating modinfo.json for " + installed.ModInfo.modId + " because of an error: " + ex);
			}
		}

		public static void ReceiveSubModInfo(ModInfo modInfo, bool ignoreTag = false)
		{
			InstalledModInfo installedModInfo = null;
			if (modInfo.version == null)
			{
				modInfo.version = "0.0.0";
			}
			if (installedModInfo != null)
			{
				outOfDateModInfos.Remove(installedModInfo);
			}
			if (!modInfo.isValidMod)
			{
				toRemoveSubscribedModIoIds.Add(modInfo.numericalId);
			}
			ModFileManager.AddToQueue(new DownloadQueueElement
			{
				associatedPlayer = null,
				info = modInfo
			});
			subscribedModIoNumericalIds.Add(modInfo.numericalId);
			subscribedMods.Add(modInfo);
		}

		public static void PopulateSubscriptions()
		{
			refreshSubscribedModsRequested = true;
		}

		private static void InternalPopulateTrending()
		{
			string text = trendingThreadString;
			trendingThreadString = "";
			dynamic val = JsonConvert.DeserializeObject<object>(text);
			foreach (dynamic item in val["data"])
			{
				string text2 = (string)item["profile_url"];
				string numericalId = "" + item["id"];
				string text3 = (string)item["name"];
				string modSummary = (string)item["summary"];
				string thumbnailLink = (string)item["logo"]["thumb_640x360"];
				string text4 = text2.Split('/')[^1];
				bool flag = true;
				int num = 0;
				int num2 = 0;
				try
				{
					foreach (dynamic item2 in item["platforms"])
					{
						if ((string)item2["platform"] == "windows")
						{
							int num3 = (int)item2["modfile_live"];
							num = num3;
							break;
						}
					}
					foreach (dynamic item3 in item["platforms"])
					{
						if ((string)item3["platform"] == "android")
						{
							int num4 = (int)item3["modfile_live"];
							num2 = num4;
							break;
						}
					}
					if (num != 0 && num2 != 0 && num == num2)
					{
						flag = false;
					}
					if ((int)item["status"] == 3)
					{
						flag = false;
					}
					ModInfo modInfo = ModInfo.MakeFromDynamic(item["modfile"], text4);
					modInfo.isValidMod = false;
					modInfo.mature = (int)item["maturity_option"] > 0;
					modInfo.modName = text3;
					modInfo.thumbnailLink = thumbnailLink;
					modInfo.modSummary = modSummary;
					modInfo.numericalId = numericalId;
					foreach (dynamic item4 in item["tags"])
					{
						modInfo.tags.Add((string)item4["name"]);
					}
					if (flag)
					{
						modInfo.androidDownloadLink = $"https://api.mod.io/v1/games/3809/mods/{(string)item["id"]}/files/{num2}/download";
						modInfo.windowsDownloadLink = $"https://api.mod.io/v1/games/3809/mods/{(string)item["id"]}/files/{num}/download";
						modInfo.isValidMod = true;
					}
					if (modInfo.version == null)
					{
						modInfo.version = "0.0.0";
					}
					if (modInfo.mature && !downloadMatureContent)
					{
						break;
					}
					NetworkerMenuController.modIoRetrieved.Add(modInfo);
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Failed to parse trending mod " + text3 + ": " + ex);
				}
			}
		}

		private static void InternalPopulateSubscriptions()
		{
			string text = subscriptionThreadString;
			subscriptionThreadString = "";
			dynamic val = JsonConvert.DeserializeObject<object>(text);
			int num = 0;
			int num2 = (int)val["result_total"];
			if (subTotal == 0)
			{
				MelonLogger.Msg("Total subscriptions: " + num2);
				subTotal = num2;
				desiredSubs = 0;
			}
			int num3 = (int)val["result_count"];
			if (num3 == 0)
			{
				MelonLogger.Msg("No subscriptions found!");
				return;
			}
			foreach (dynamic item in val["data"])
			{
				if ((int)item["game_id"] == 3809)
				{
					num++;
				}
			}
			desiredSubs += num;
			ModInfoThreadRequest result;
			while (ModInfo.modInfoThreadRequests.TryDequeue(out result))
			{
			}
			ModInfo.requestSize = num;
			foreach (dynamic item2 in val["data"])
			{
				if ((int)item2["game_id"] != 3809)
				{
					continue;
				}
				string text2 = (string)item2["profile_url"];
				string numericalId = ((string)item2["id"]) ?? "";
				string modName = (string)item2["name"];
				string modSummary = (string)item2["summary"];
				string author = (string)item2["submitted_by"]["username"];
				string thumbnailLink = (string)item2["logo"]["thumb_640x360"];
				string text3 = text2.Split('/')[^1];
				bool flag = true;
				int num4 = 0;
				int num5 = 0;
				foreach (dynamic item3 in item2["platforms"])
				{
					if ((string)item3["platform"] == "windows")
					{
						int num6 = (int)item3["modfile_live"];
						num4 = num6;
						break;
					}
				}
				foreach (dynamic item4 in item2["platforms"])
				{
					if ((string)item4["platform"] == "android")
					{
						int num7 = (int)item4["modfile_live"];
						num5 = num7;
						break;
					}
				}
				if (num4 != 0 && num5 != 0 && num4 == num5)
				{
					flag = false;
				}
				if ((int)item2["status"] == 3)
				{
					flag = false;
				}
				ModInfo modInfo = ModInfo.MakeFromDynamic(item2["modfile"], text3);
				modInfo.isValidMod = false;
				modInfo.mature = (int)item2["maturity_option"] > 0;
				modInfo.modName = modName;
				modInfo.thumbnailLink = thumbnailLink;
				modInfo.modSummary = modSummary;
				modInfo.numericalId = numericalId;
				modInfo.author = author;
				foreach (dynamic item5 in item2["tags"])
				{
					modInfo.tags.Add((string)item5["name"]);
				}
				if (flag)
				{
					modInfo.androidDownloadLink = string.Format("https://api.mod.io/v1/games/3809/mods/{0}/files/{1}/download", (object?)item2["id"], num5);
					modInfo.windowsDownloadLink = string.Format("https://api.mod.io/v1/games/3809/mods/{0}/files/{1}/download", (object?)item2["id"], num4);
					modInfo.isValidMod = true;
				}
				ReceiveSubModInfo(modInfo);
			}
			subsShown += num3;
			if (subTotal - subsShown > 0)
			{
				ModFileManager.QueueSubscriptions(subsShown);
			}
			if (subsShown >= subTotal)
			{
				subsRefreshing = true;
			}
		}

		public void PopulateInstalledMods(string directory)
		{
			List<DirectoryInfo> list = new List<DirectoryInfo>();
			try
			{
				list = (from f in new DirectoryInfo(directory).GetDirectories()
					orderby f.LastWriteTime descending
					select f).ToList();
			}
			catch (Exception)
			{
			}
			if (1 == 0)
			{
				return;
			}
			string[] files = Directory.GetFiles(directory);
			foreach (string text in files)
			{
				if (!text.EndsWith(".manifest"))
				{
					continue;
				}
				dynamic val = JsonConvert.DeserializeObject<object>(File.ReadAllText(text));
				ModInfo modInfo = new ModInfo();
				try
				{
					string version = (string)val["objects"]["2"]["version"];
					string modId = (string)val["objects"]["2"]["title"];
					string modSummary = (string)val["objects"]["2"]["description"];
					string thumbnailLink = (string)val["objects"]["2"]["thumbnailUrl"];
					int num = -1;
					int num2 = -1;
					string text2 = "";
					int value = 0;
					foreach (dynamic item2 in val["objects"]["2"]["targets"])
					{
						string text3 = item2.ToString();
						if (text3.Contains("networker"))
						{
							string[] array = text3.Split("\": {");
							text2 = array[0].Replace("\"", "");
						}
					}
					string windowsDownloadLink = "";
					string androidDownloadLink = "";
					try
					{
						num2 = (int)val["objects"]["2"]["targets"]["android"]["ref"];
					}
					catch (Exception)
					{
					}
					try
					{
						num = (int)val["objects"]["2"]["targets"]["pc"]["ref"];
					}
					catch (Exception)
					{
					}
					if (num != -1)
					{
						int value2 = (int)val["objects"][num.ToString()]["modfileId"];
						value = (int)val["objects"][num.ToString()]["modId"];
						windowsDownloadLink = $"https://api.mod.io/v1/games/3809/mods/{value}/files/{value2}/download";
					}
					if (num2 != -1)
					{
						int value3 = val["objects"][num2.ToString()]["modfileId"];
						value = (int)val["objects"][num2.ToString()]["modId"];
						androidDownloadLink = $"https://api.mod.io/v1/games/3809/mods/{value}/files/{value3}/download";
					}
					modInfo.version = version;
					modInfo.thumbnailLink = thumbnailLink;
					modInfo.modSummary = modSummary;
					modInfo.androidDownloadLink = androidDownloadLink;
					modInfo.windowsDownloadLink = windowsDownloadLink;
					modInfo.modId = modId;
					modInfo.numericalId = value.ToString() ?? "";
					modInfo.structureVersion = ModInfo.globalStructureVersion;
					if (text2 != "")
					{
						modInfo.PopulateFromInfoString(text2);
					}
					NetworkerMenuController.totalInstalled.Add(modInfo);
					installedMods.Add(modInfo);
					InstalledModInfo installedModInfo = new InstalledModInfo();
					installedModInfo.manifestPath = text;
					installedModInfo.palletBarcode = (string)val["objects"]["1"]["palletBarcode"];
					installedModInfo.palletPath = (string)val["objects"]["1"]["palletPath"];
					installedModInfo.catalogPath = (string)val["objects"]["1"]["catalogPath"];
					installedModInfo.ModInfo = modInfo;
					InstalledModInfo item = installedModInfo;
					InstalledModInfos.Add(item);
				}
				catch (Exception)
				{
				}
			}
		}

		public void OnStartServer()
		{
			ModlistMenu.Refresh(openMenu: false);
			confirmedHostHasIt = true;
		}

		public void OnDisconnect()
		{
			ModlistMessage.avatarMods.Clear();
			ModlistMenu.Clear();
			confirmedHostHasIt = false;
			modNumericalsDownloadedDuringLobbySession.Clear();
			DeleteAllTempMods();
		}

		public override void OnApplicationQuit()
		{
			DeleteAllTempMods();
		}

		public void OnPlayerJoin(PlayerId playerId)
		{
			if (NetworkInfo.HasServer && NetworkInfo.IsServer)
			{
				SendAllMods();
				SendAllAvatars();
			}
		}

		public void OnPlayerRepCreated(NetworkPlayer networkPlayer, RigManager manager)
		{
			if (!networkPlayer.NetworkEntity.IsOwner)
			{
				new AvatarDownloadBar(networkPlayer);
			}
		}

		private void SendAllAvatars()
		{
			foreach (KeyValuePair<PlayerId, ModInfo> avatarMod in ModlistMessage.avatarMods)
			{
				ModlistData modlistData = ModlistData.Create(avatarMod.Key, avatarMod.Value, ModlistData.ModType.AVATAR);
				FusionWriter val = FusionWriter.Create();
				try
				{
					using ModlistData modlistData2 = modlistData;
					val.Write<ModlistData>(modlistData2);
					FusionMessage val2 = FusionMessage.ModuleCreate<ModlistMessage>(val);
					try
					{
						MessageSender.BroadcastMessageExcept(PlayerId.op_Implicit(avatarMod.Key), (NetworkChannel)0, val2, true);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}

		private void SendAllMods()
		{
			int num = 0;
			foreach (ModInfo subscribedMod in subscribedMods)
			{
				bool final = num == subscribedMods.Count - 1;
				ModlistData modlistData = ModlistData.Create(final, subscribedMod);
				FusionWriter val = FusionWriter.Create();
				try
				{
					using ModlistData modlistData2 = modlistData;
					val.Write<ModlistData>(modlistData2);
					FusionMessage val2 = FusionMessage.ModuleCreate<ModlistMessage>(val);
					try
					{
						MessageSender.BroadcastMessageExceptSelf((NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
				num++;
			}
		}

		private void PrepareModFiles()
		{
			if (!Directory.Exists(MODIO_MODNETWORKER_DIRECTORY))
			{
				Directory.CreateDirectory(MODIO_MODNETWORKER_DIRECTORY);
			}
			if (!File.Exists(MODIO_AUTH_TXT_DIRECTORY))
			{
				CreateDefaultAuthText(MODIO_AUTH_TXT_DIRECTORY);
			}
			if (!File.Exists(MODIO_BLACKLIST_TXT_DIRECTORY))
			{
				CreateDefaultBlacklistText(MODIO_BLACKLIST_TXT_DIRECTORY);
			}
		}

		private void CreateDefaultBlacklistText(string directory)
		{
			using StreamWriter streamWriter = File.CreateText(directory);
			streamWriter.WriteLine("#                       ----- WELCOME TO THE MOD.IO BLACKLIST TXT! -----");
			streamWriter.WriteLine("#");
			streamWriter.WriteLine("# This file is where you put mods that you DO NOT want to download under any circumstances.");
			streamWriter.WriteLine("# If you want to blacklist a mod, simply put the mod ID in this file, and it will not be downloaded.");
			streamWriter.WriteLine("# You can find the mod ID by going to the mod.io page for the mod, and looking at the URL.");
			streamWriter.WriteLine("# The mod ID is the name at the end of the URL.");
			streamWriter.WriteLine("# For example, if the URL is https://mod.io/g/bonelab/m/remove-bodylog-transform-vfx, the mod ID is remove-bodylog-transform-vfx");
			streamWriter.WriteLine("# To blacklist mods, simply put each mod ID on a new line. DO NOT START YOUR LINES WITH #, as this will comment out the line.");
			streamWriter.WriteLine("# Ex. ");
			streamWriter.WriteLine("# remove-bodylog-transform-vfx");
			streamWriter.WriteLine("# my-awesome-replacer");
			streamWriter.WriteLine("# annoying-mod");
		}

		private void CreateDefaultAuthText(string directory)
		{
			using StreamWriter streamWriter = File.CreateText(directory);
			streamWriter.WriteLine("#                       ----- WELCOME TO THE MOD.IO AUTH TXT! -----");
			streamWriter.WriteLine("#");
			streamWriter.WriteLine("# Put your mod.io OAuth token in this file, and it will be used to download mods from the mod.io network.");
			streamWriter.WriteLine("# Your OAuth token can be found here: https://mod.io/me/access");
			streamWriter.WriteLine("# At the bottom, you should see a section called 'OAuth Access'");
			streamWriter.WriteLine("# Create a key, then create a token using the + Icon. call it whatever you'd like, this doesnt matter.");
			streamWriter.WriteLine("# Then create a token, call it whatever you'd like, this doesnt matter.");
			streamWriter.WriteLine("# The token is pretty long, so make sure you copy the entire thing. Make sure you're copying the token, not the key.");
			streamWriter.WriteLine("# Once you've copied the token, paste it in this file, replacing the text labeled REPLACE_THIS_TEXT_WITH_YOUR_TOKEN.");
			streamWriter.WriteLine("AuthToken=REPLACE_THIS_TEXT_WITH_YOUR_TOKEN");
		}

		private List<string> ReadBlacklist()
		{
			string[] array = File.ReadAllLines(MODIO_BLACKLIST_TXT_DIRECTORY);
			List<string> list = new List<string>();
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!text.StartsWith("#") && text != "")
				{
					list.Add(text.Trim());
				}
			}
			return list;
		}

		public static void WriteLineToBlacklist(string line)
		{
			using StreamWriter streamWriter = new StreamWriter(MODIO_BLACKLIST_TXT_DIRECTORY, append: true);
			streamWriter.WriteLine(line);
		}

		public static void RemoveLineFromBlacklist(string line)
		{
			string tempFileName = Path.GetTempFileName();
			using (StreamReader streamReader = new StreamReader(MODIO_BLACKLIST_TXT_DIRECTORY))
			{
				using StreamWriter streamWriter = new StreamWriter(tempFileName);
				string text;
				while ((text = streamReader.ReadLine()) != null)
				{
					if (text != line)
					{
						streamWriter.WriteLine(text);
					}
				}
			}
			File.Delete(MODIO_BLACKLIST_TXT_DIRECTORY);
			File.Move(tempFileName, MODIO_BLACKLIST_TXT_DIRECTORY);
		}

		private string ReadAuthKey()
		{
			string[] array = File.ReadAllLines(MODIO_AUTH_TXT_DIRECTORY);
			string text = "";
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (!text2.StartsWith("#"))
				{
					text += text2;
				}
			}
			return text.Replace("AuthToken=", "").Replace("REPLACE_THIS_TEXT_WITH_YOUR_TOKEN", "").Trim();
		}
	}
	public class ModFileManager
	{
		public static string OAUTH_KEY = "";

		public static string API_PATH = "https://api.mod.io/v1/games/3809/mods/";

		public static string MOD_FOLDER_PATH = Application.persistentDataPath + "/Mods";

		public static string downloadingModId = "";

		public static string downloadPath = "";

		public static bool isDownloading = false;

		public static bool queueAvailable = false;

		private static List<DownloadQueueElement> queue = new List<DownloadQueueElement>();

		public static bool fetchingSubscriptions = false;

		public static bool fetchingTrending = false;

		public static DownloadAction activeDownloadAction = null;

		public static DownloadQueueElement activeDownloadQueueElement = null;

		public static UnityWebRequest activeDownloadWebRequest;

		public static string[] targetVersionStrings = new string[2] { "1.1", "1.2" };

		public static void Initialize()
		{
			ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
		}

		private static void OnDownloadFileCompleted()
		{
			activeDownloadAction = new DownloadAction(10);
		}

		public static string FindFile(string path, string fileName)
		{
			try
			{
				string[] files = Directory.GetFiles(path);
				foreach (string text in files)
				{
					string text2 = text.Split('\\')[^1];
					if (text2.EndsWith(fileName))
					{
						return text;
					}
				}
				string[] directories = Directory.GetDirectories(path);
				foreach (string path2 in directories)
				{
					string text3 = FindFile(path2, fileName);
					if (text3 != "")
					{
						return text3;
					}
				}
			}
			catch (Exception)
			{
				return "";
			}
			return "";
		}

		public static void OnDownloadProgressChanged(double progress)
		{
			if (ModlistMenu.activeDownloadModInfo != null)
			{
				ModlistMenu.activeDownloadModInfo.modDownloadPercentage = progress;
			}
		}

		public static void StopDownload()
		{
			if (isDownloading)
			{
				if (activeDownloadQueueElement != null && activeDownloadQueueElement.associatedPlayer != null && AvatarDownloadBar.bars.TryGetValue(activeDownloadQueueElement.associatedPlayer, out AvatarDownloadBar value))
				{
					value.Finish();
				}
				isDownloading = false;
				activeDownloadQueueElement = null;
				activeDownloadWebRequest = null;
				ModlistMenu.activeDownloadModInfo = null;
			}
		}

		public static void CheckQueue()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			if (isDownloading || AssetWarehouse.Instance == null || SceneStreamer._session == null || (int)SceneStreamer._session.Status == 1 || queue.Count <= 0)
			{
				return;
			}
			DownloadQueueElement downloadQueueElement = queue[0];
			if (downloadQueueElement.info.Download())
			{
				queue.RemoveAt(0);
				activeDownloadQueueElement = downloadQueueElement;
				MelonLogger.Msg("Downloading mod " + downloadQueueElement.info.modId);
				if (activeDownloadQueueElement.associatedPlayer != null && AvatarDownloadBar.bars.TryGetValue(activeDownloadQueueElement.associatedPlayer, out AvatarDownloadBar value))
				{
					value.Show();
				}
			}
			MainClass.menuRefreshRequested = true;
		}

		public static bool AddToQueue(DownloadQueueElement queueElement, bool ignoreTag = false)
		{
			ModInfo info = queueElement.info;
			if (!info.isValidMod)
			{
				return false;
			}
			if (MainClass.blacklistedModIoIds.Contains(info.modId) || MainClass.blacklistedModIoIds.Contains(info.numericalId))
			{
				return false;
			}
			if (info.IsSubscribed())
			{
				return false;
			}
			if (!ignoreTag)
			{
				bool flag = false;
				foreach (string tag in info.tags)
				{
					if (targetVersionStrings.Contains(tag))
					{
						flag = true;
					}
				}
				if (!flag)
				{
					return false;
				}
			}
			if (activeDownloadQueueElement != null && (activeDownloadQueueElement.info.modId == info.modId || activeDownloadQueueElement.info.numericalId == info.numericalId))
			{
				return false;
			}
			if (info.mature && !MainClass.downloadMatureContent)
			{
				return false;
			}
			if (info.version == null)
			{
				info.version = "0.0.0";
			}
			bool flag2 = false;
			bool flag3 = false;
			foreach (ModInfo installedMod in MainClass.installedMods)
			{
				if (installedMod.numericalId == info.numericalId || installedMod.modId == info.modId)
				{
					flag2 = true;
					if (installedMod.version != info.version)
					{
						flag3 = true;
					}
					break;
				}
			}
			if (flag2 && !flag3)
			{
				return false;
			}
			foreach (DownloadQueueElement item in queue)
			{
				if (item.info.modId == info.modId || item.info.numericalId == info.numericalId)
				{
					return false;
				}
			}
			queue.Add(queueElement);
			return true;
		}

		public static async void DownloadFileHttpClient(string url, string path)
		{
			using HttpClient client = new HttpClient(new HttpClientHandler
			{
				ClientCertificateOptions = ClientCertificateOption.Manual,
				ServerCertificateCustomValidationCallback = (HttpRequestMessage httpRequestMessage, X509Certificate2? cert, X509Chain? cetChain, SslPolicyErrors policyErrors) => true
			});
			client.DefaultRequestHeaders.Add("Authorization", "Bearer " + OAUTH_KEY);
			using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
			{
				using Stream streamToReadFrom = await response.Content.ReadAsStreamAsync();
				long totalBytes = response.Content.Headers.ContentLength.Value;
				long bytesRead = 0L;
				byte[] buffer = new byte[4096];
				using FileStream fs = new FileStream(path, FileMode.CreateNew);
				while (true)
				{
					int num;
					int bytesReceived = (num = await streamToReadFrom.ReadAsync(buffer, 0, buffer.Length));
					if (num <= 0)
					{
						break;
					}
					await fs.WriteAsync(buffer, 0, bytesReceived);
					bytesRead += bytesReceived;
					double percentage = (double)bytesRead / (double)totalBytes * 100.0;
					OnDownloadProgressChanged(percentage);
				}
			}
			OnDownloadFileCompleted();
		}

		public static async Task DownloadFileAsync(string url, string path)
		{
			DownloadFileHttpClient(url, path);
		}

		public static void DownloadFile(string url, string path)
		{
			downloadPath = path;
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			try
			{
				DownloadFileAsync(url, path);
			}
			catch (WebException ex)
			{
				isDownloading = false;
				ModlistMenu.activeDownloadModInfo = null;
				activeDownloadQueueElement = null;
				activeDownloadWebRequest = null;
				MelonLogger.Error("Failed to download file: " + ex.Message);
				throw;
			}
		}

		public static void QueueSubscriptions(int shown)
		{
			if (!fetchingSubscriptions)
			{
				fetchingSubscriptions = true;
				UnityWebRequest httpWebRequest = UnityWebRequest.Get("https://api.mod.io/v1/me/subscribed?_offset=" + shown + "&limit=400");
				httpWebRequest.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
				UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
				((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
				{
					MainClass.subscriptionThreadString = httpWebRequest.downloadHandler.text;
					fetchingSubscriptions = false;
				});
			}
		}

		public static void QueueTrending(int offset, string searchQuery = "")
		{
			if (!fetchingTrending)
			{
				fetchingTrending = true;
				string text = "&_q=" + searchQuery;
				if (searchQuery == "")
				{
					text = "";
				}
				SpotlightOverride.LoadFromRegularURL();
				UnityWebRequest httpWebRequest = UnityWebRequest.Get($"https://mod.io/v1/games/@bonelab/mods?_limit=100&_offset={offset}&_sort=-popular" + text);
				httpWebRequest.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
				UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
				((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
				{
					MainClass.trendingThreadString = httpWebRequest.downloadHandler.text;
					fetchingTrending = false;
				});
			}
		}

		public static bool Subscribe(string numericalid)
		{
			string text = "https://api.mod.io/v1/games/3809/mods/" + numericalid + "/subscribe";
			UnityWebRequest httpWebRequest = UnityWebRequest.Get(text);
			httpWebRequest.method = "POST";
			httpWebRequest.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
			httpWebRequest.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded");
			UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
			((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
			{
				if (httpWebRequest.responseCode == 201)
				{
					MainThreadManager.QueueAction(delegate
					{
						if (Object.op_Implicit((Object)(object)NetworkerMenuController.instance))
						{
							NetworkerMenuController.instance.UpdateModPopupButtons();
						}
					});
				}
			});
			return false;
		}

		public static void UninstallAndUnsubscribe(string modId)
		{
			UnInstall(modId);
			UnSubscribe(modId);
		}

		public static void UnSubscribe(string numericalId)
		{
			string numericalId2 = numericalId;
			string text = "https://api.mod.io/v1/games/3809/mods/" + numericalId2 + "/subscribe";
			UnityWebRequest val = UnityWebRequest.Get(text);
			val.method = "DELETE";
			val.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
			val.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded");
			UnityWebRequestAsyncOperation val2 = val.SendWebRequest();
			((AsyncOperation)val2).m_completeCallback = ((AsyncOperation)val2).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
			{
				MainThreadManager.QueueAction(delegate
				{
					if (Object.op_Implicit((Object)(object)NetworkerMenuController.instance))
					{
						MainClass.subscribedModIoNumericalIds.Remove(numericalId2);
						NetworkerMenuController.instance.UpdateModPopupButtons();
					}
				});
			});
		}

		public static void UnInstallMainThread(string numericalId)
		{
			InstalledModInfo installedModInfo = null;
			foreach (InstalledModInfo installedModInfo2 in MainClass.InstalledModInfos)
			{
				if (installedModInfo2.ModInfo.numericalId == numericalId)
				{
					installedModInfo = installedModInfo2;
				}
			}
			try
			{
				if (installedModInfo != null)
				{
					string palletBarcode = installedModInfo.palletBarcode;
					UnloadPallet(palletBarcode);
					File.Delete(installedModInfo.manifestPath);
					string fullName = Directory.GetParent(installedModInfo.catalogPath).FullName;
					Directory.Delete(fullName, recursive: true);
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Exception when uninstalling mod: " + ex);
			}
			MainClass.RequestInstallCheck();
		}

		private static void UnloadPallet(string palletBarcode)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			DeleteExistingModObjects(palletBarcode);
			try
			{
				AssetWarehouse.Instance.UnloadPallet(new Barcode(palletBarcode));
			}
			catch (Exception)
			{
			}
		}

		public static void DeleteExistingModObjects(string palletBarcode)
		{
			try
			{
				Enumerator<Pallet> enumerator = AssetWarehouse.Instance.GetPallets().GetEnumerator();
				while (enumerator.MoveNext())
				{
					Pallet current = enumerator.Current;
					if (((Scannable)current)._barcode._id != palletBarcode)
					{
						continue;
					}
					Enumerator<Crate> enumerator2 = current._crates.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						Crate current2 = enumerator2.Current;
						Enumerator<Pool> enumerator3 = AssetSpawner._instance._poolList.GetEnumerator();
						while (enumerator3.MoveNext())
						{
							Pool current3 = enumerator3.Current;
							if (!(((Scannable)current3._crate)._barcode != ((Scannable)current2)._barcode))
							{
								Enumerator<Poolee> enumerator4 = current3._spawned.GetEnumerator();
								while (enumerator4.MoveNext())
								{
									Poolee current4 = enumerator4.Current;
									Object.Destroy((Object)(object)((Component)current4).gameObject);
								}
							}
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}

		public static void UnInstall(string numericalId)
		{
			InstalledModInfo installedModInfo = null;
			foreach (InstalledModInfo installedModInfo2 in MainClass.InstalledModInfos)
			{
				if (installedModInfo2.ModInfo.numericalId == numericalId)
				{
					installedModInfo = installedModInfo2;
				}
			}
			Thread thread = new Thread((ThreadStart)delegate
			{
				try
				{
					if (installedModInfo != null)
					{
						string barcode = installedModInfo.palletBarcode;
						MainThreadManager.QueueAction(delegate
						{
							UnloadPallet(barcode);
						});
						File.Delete(installedModInfo.manifestPath);
						string fullName = Directory.GetParent(installedModInfo.catalogPath).FullName;
						Directory.Delete(fullName, recursive: true);
					}
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Exception when uninstalling mod: " + ex);
				}
				MainClass.RequestInstallCheck();
			});
			thread.Start();
		}

		public static void GetJson(string mod, Action<string> onCompleted)
		{
			Action<string> onCompleted2 = onCompleted;
			string text = API_PATH + mod + "/files";
			UnityWebRequest httpWebRequest = UnityWebRequest.Get(text);
			httpWebRequest.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
			UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
			((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Invalid comparison between Unknown and I4
				if ((int)httpWebRequest.result == 2 || (int)httpWebRequest.result == 3)
				{
					Debug.LogError(Object.op_Implicit(httpWebRequest.error));
					onCompleted2?.Invoke(null);
				}
				else
				{
					string text2 = httpWebRequest.downloadHandler.text;
					onCompleted2?.Invoke(text2);
				}
			});
		}

		public static void GetRawModInfoJson(string mod, Action<dynamic> onCompleted)
		{
			Action<dynamic> onCompleted2 = onCompleted;
			string json = "";
			try
			{
				string text = API_PATH + mod;
				UnityWebRequest httpWebRequest = UnityWebRequest.Get(text);
				httpWebRequest.SetRequestHeader("Authorization", "Bearer " + OAUTH_KEY);
				UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
				((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
				{
					//IL_0033: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Invalid comparison between Unknown and I4
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					//IL_0047: Invalid comparison between Unknown and I4
					json = httpWebRequest.downloadHandler.text;
					dynamic val2 = JsonConvert.DeserializeObject<object>(json);
					if ((int)httpWebRequest.result == 2 || (int)httpWebRequest.result == 3)
					{
						Debug.LogError(Object.op_Implicit(httpWebRequest.error));
						((Action<