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;
using LabFusion.Downloading.ModIO;
using LabFusion.Entities;
using LabFusion.Marrow;
using LabFusion.Marrow.Pool;
using LabFusion.Network;
using LabFusion.Network.Serialization;
using LabFusion.Player;
using LabFusion.RPC;
using LabFusion.SDK.Modules;
using LabFusion.Scene;
using LabFusion.Senders;
using LabFusion.UI.Popups;
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 Newtonsoft.Json.Linq;
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.8.0", "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.8.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("2.8.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
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, ignoreTag: true);
			}
			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.8.0";
	}
	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() ? HelperMethods.LoadEmbeddedAssetBundle(Assembly.GetExecutingAssembly(), "ModioModNetworker.Resources.networkermenu.android.networker") : HelperMethods.LoadEmbeddedAssetBundle(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.OnPlayerJoined += new PlayerUpdate(OnPlayerJoin);
			MultiplayerHooking.OnDisconnected += new ServerEvent(OnDisconnect);
			MultiplayerHooking.OnStartedServer += new ServerEvent(OnStartServer);
			NetworkPlayer.OnNetworkRigCreated += OnPlayerRepCreated;
			AssetWarehouse.OnReady(Action.op_Implicit((Action)delegate
			{
				AssetWarehouse instance = AssetWarehouse.Instance;
				instance.OnCrateAdded += Action<Barcode>.op_Implicit((Action<Barcode>)delegate(Barcode s)
				{
					palletLock = false;
					LevelHoldQueue.CheckValid(s._id);
					SpawnableHoldQueue.CheckValid(s._id);
					foreach (NetworkPlayer allNetworkPlayer in NetworkPlayerUtilities.GetAllNetworkPlayers())
					{
						FieldInfo field = ((object)allNetworkPlayer.AvatarSetter).GetType().GetField("_isAvatarDirty", BindingFlags.Instance | BindingFlags.NonPublic);
						field.SetValue(allNetworkPlayer.AvatarSetter, true);
					}
				});
				assetWarehouseLoaded = true;
				DeleteAllTempMods();
			}));
			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")
					{
						Notifier.Send(new Notification
						{
							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
					{
						Notifier.Send(new Notification
						{
							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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: 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 (subsRefreshing && subscribedModIoNumericalIds.Count >= desiredSubs)
			{
				foreach (string toRemoveSubscribedModIoId in toRemoveSubscribedModIoIds)
				{
					subscribedModIoNumericalIds.Remove(toRemoveSubscribedModIoId);
				}
				toRemoveSubscribedModIoIds.Clear();
				ModlistMenu.Refresh(openMenu: true);
				subsRefreshing = false;
				handlingSubscribed = false;
				Notifier.Send(new Notification
				{
					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)
					{
						Notifier.Send(new Notification
						{
							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.IsHost)
				{
					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
			}, ignoreTag);
			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)
					{
						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.IsHost)
			{
				SendAllMods();
				SendAllAvatars();
			}
		}

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

		private void SendAllAvatars()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<PlayerID, ModInfo> avatarMod in ModlistMessage.avatarMods)
			{
				ModlistData modlistData = ModlistData.Create(avatarMod.Key, avatarMod.Value, ModlistData.ModType.AVATAR);
				NetWriter val = NetWriter.Create();
				try
				{
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					try
					{
						MessageSender.BroadcastMessageExcept(PlayerID.op_Implicit(avatarMod.Key), (NetworkChannel)0, val2, true);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}

		private void SendAllMods()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (ModInfo subscribedMod in subscribedMods)
			{
				bool final = num == subscribedMods.Count - 1;
				ModlistData modlistData = ModlistData.Create(final, subscribedMod);
				NetWriter val = NetWriter.Create();
				try
				{
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					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<object>)onCompleted2)?.Invoke(val2);
					}
					else
					{
						((Action<object>)onCompleted2)?.Invoke(val2);
					}
				});
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Error when fetching raw mod info for " + mod + ": ");
				MelonLogger.Error((object)ex);
			}
		}
	}
	public class ModlistMenu
	{
		[HarmonyPatch(typeof(GUIMenu), "OnPageOpened")]
		public class CategoryUpdatePatch
		{
			public static void Postfix(GUIMenu __instance, Page page)
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				if (page == mainCategory)
				{
					if (!Object.op_Implicit((Object)(object)customMenuObject))
					{
						GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.uiMenuPrefab);
						((Component)val.transform.Find("MenuBase")).gameObject.AddComponent<NetworkerMenuController>();
						val.transform.parent = ((Component)__instance).gameObject.transform;
						val.transform.localPosition = Vector3.forward;
						val.transform.localRotation = Quaternion.identity;
						val.transform.localScale = Vector3.one;
						customMenuObject = val;
					}
					else
					{
						customMenuObject.SetActive(true);
					}
				}
				else if (page == Page.Root && Object.op_Implicit((Object)(object)customMenuObject))
				{
					customMenuObject.SetActive(false);
					NetworkerMenuController.instance.Reset();
				}
			}
		}

		public static Page mainCategory;

		private static string lastSelectedCategory;

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

		public static int installPage = 0;

		public static int hostPage = 0;

		private static int installPageCount = 0;

		private static int hostPageCount = 0;

		private static int modsPerPage = 4;

		public static ModInfo activeDownloadModInfo;

		public static GameObject customMenuObject;

		public static void Initialize()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			mainCategory = Page.Root.CreatePage("ModIo Mod Networker", Color.cyan, 0, true);
			NetworkerMenuController.AddCheckboxSetting("Override Fusion DL", MainClass.overrideFusionDL, delegate(bool b)
			{
				MainClass.overrideFusionDL = b;
				MainClass.overrideFusionDLConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddCheckboxSetting("Auto Delete Lobby Mods", MainClass.tempLobbyMods, delegate(bool b)
			{
				MainClass.tempLobbyMods = b;
				MainClass.tempLobbyModsConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddCheckboxSetting("Auto Download Avatars", MainClass.autoDownloadAvatars, delegate(bool b)
			{
				MainClass.autoDownloadAvatars = b;
				MainClass.autoDownloadAvatarsConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddCheckboxSetting("Auto Download Spawnables", MainClass.autoDownloadSpawnables, delegate(bool b)
			{
				MainClass.autoDownloadSpawnables = b;
				MainClass.autoDownloadSpawnablesConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddCheckboxSetting("Auto Download Levels", MainClass.autoDownloadLevels, delegate(bool b)
			{
				MainClass.autoDownloadLevels = b;
				MainClass.autoDownloadLevelsConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddNumericalSetting("(Spawnable/Avatar) Auto Download Max MB", (int)MainClass.maxAutoDownloadMb, 200, 2000, 100, delegate(int num)
			{
				MainClass.maxAutoDownloadMb = num;
				MainClass.maxAutoDownloadMbConfig.Value = num;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddNumericalSetting("(Level) Auto Download Max GB", (int)MainClass.levelMaxGb, 1, 10, 1, delegate(int num)
			{
				MainClass.levelMaxGb = num;
				MainClass.maxLevelAutoDownloadGbConfig.Value = num;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			NetworkerMenuController.AddCheckboxSetting("Download Mature Content", MainClass.downloadMatureContent, delegate(bool b)
			{
				MainClass.downloadMatureContent = b;
				MainClass.downloadMatureContentConfig.Value = b;
				MainClass.melonPreferencesCategory.SaveToFile(true);
			});
			MainClass.menuRefreshRequested = true;
		}

		public static void PopulateModInfos(List<ModInfo> modInfos)
		{
			hostPage = 0;
			_modInfos.Clear();
			_modInfos.AddRange(modInfos);
			MainClass.confirmedHostHasIt = true;
			Refresh(openMenu: false);
		}

		public static void Clear()
		{
			_modInfos.Clear();
			Refresh(openMenu: false);
		}

		public static void Refresh(bool openMenu)
		{
			installPageCount = Mathf.CeilToInt((float)MainClass.installedMods.Count / (float)modsPerPage);
			hostPageCount = Mathf.CeilToInt((float)_modInfos.Count / (float)modsPerPage);
		}

		private static void CreateSettingsSection()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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)
			Color green = Color.green;
			if (!MainClass.autoDownloadAvatars)
			{
				green = Color.yellow;
			}
			Color green2 = Color.green;
			if (!MainClass.autoDownloadSpawnables)
			{
				green2 = Color.yellow;
			}
			Color green3 = Color.green;
			if (!MainClass.autoDownloadLevels)
			{
				green3 = Color.yellow;
			}
		}
	}
	public class ModlistModule : Module
	{
		public override string Name => "ModIoModNetworkerModule";

		public override string Author => "notnotnotswipez";

		public override Version Version => new Version("2.8.0");

		public override ConsoleColor Color => ConsoleColor.Cyan;

		protected override void OnModuleRegistered()
		{
			ModuleMessageManager.RegisterHandler<ModlistMessage>();
		}

		protected override void OnModuleUnregistered()
		{
		}
	}
	public class ModlistData : INetSerializable
	{
		public enum ModType
		{
			LIST = 1,
			AVATAR,
			SPAWNABLE,
			LEVEL
		}

		public PlayerID playerId;

		public bool isFinal = false;

		public ModType modType = ModType.LIST;

		public SerializedModInfo serializedModInfo;

		public void Dispose()
		{
			GC.SuppressFinalize(this);
		}

		public static ModlistData Create(bool final, ModInfo info)
		{
			return new ModlistData
			{
				isFinal = final,
				playerId = PlayerIDManager.LocalID,
				modType = ModType.LIST,
				serializedModInfo = SerializedModInfo.Create(info)
			};
		}

		public static ModlistData Create(PlayerID playerId, ModInfo info, ModType infoType)
		{
			return new ModlistData
			{
				isFinal = false,
				modType = infoType,
				playerId = playerId,
				serializedModInfo = SerializedModInfo.Create(info)
			};
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref isFinal);
			serializer.SerializeValue<ModType>(ref modType);
			NetSerializerExtensions.SerializeValue<PlayerID>(serializer, ref playerId);
			NetSerializerExtensions.SerializeValue<SerializedModInfo>(serializer, ref serializedModInfo);
		}
	}
	public class ModlistMessage : ModuleMessageHandler
	{
		private static List<ModInfo> modlist = new List<ModInfo>();

		public static Dictionary<PlayerID, ModInfo> avatarMods = new Dictionary<PlayerID, ModInfo>();

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

		protected override void OnHandleMessage(ReceivedMessage message)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Invalid comparison between Unknown and I4
			ModlistData modlistData = ((ReceivedMessage)(ref message)).ReadData<ModlistData>();
			if (NetworkInfo.IsHost && ((ReceivedMessage)(ref message)).IsServerHandled)
			{
				if (modlistData.modType == ModlistData.ModType.LIST)
				{
					return;
				}
				NetMessage val = NetMessage.ModuleCreate<ModlistMessage>(((ReceivedMessage)(ref message)).Bytes, CommonMessageRoutes.ReliableToClients, (byte?)null);
				try
				{
					MessageSender.BroadcastMessageExcept(PlayerID.op_Implicit(modlistData.playerId), (NetworkChannel)0, val, true);
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			if (modlistData == null)
			{
				return;
			}
			ModInfo modInfo = modlistData.serializedModInfo.modInfo;
			if (modlistData.modType != ModlistData.ModType.LIST)
			{
				bool flag = true;
				switch (modlistData.modType)
				{
				case ModlistData.ModType.AVATAR:
				{
					if (!MainClass.overrideFusionDL)
					{
						break;
					}
					if (!avatarMods.ContainsKey(modlistData.playerId))
					{
						avatarMods.Add(modlistData.playerId, modInfo);
					}
					else
					{
						avatarMods[modlistData.playerId] = modInfo;
					}
					if (SceneStreamer._session != null && (int)SceneStreamer._session.Status == 1)
					{
						waitAndQueue.Add(modInfo);
						break;
					}
					float num4 = modInfo.fileSizeKB / 1000000f;
					if (num4 < MainClass.maxAutoDownloadMb && MainClass.autoDownloadAvatars && (MainClass.downloadMatureContent || !modInfo.mature) && !MainClass.modNumericalsDownloadedDuringLobbySession.Contains(modInfo.numericalId) && !modInfo.IsSubscribed())
					{
						if (MainClass.tempLobbyMods)
						{
							modInfo.temp = true;
						}
						if (ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = modlistData.playerId,
							info = modInfo,
							notify = true
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(modInfo.numericalId);
						}
					}
					break;
				}
				case ModlistData.ModType.SPAWNABLE:
				{
					if (!MainClass.overrideFusionDL)
					{
						break;
					}
					float num3 = modInfo.fileSizeKB / 1000000f;
					if (MainClass.autoDownloadSpawnables && num3 < MainClass.maxAutoDownloadMb && (MainClass.downloadMatureContent || !modInfo.mature) && !modInfo.IsSubscribed() && !MainClass.modNumericalsDownloadedDuringLobbySession.Contains(modInfo.numericalId))
					{
						if (MainClass.tempLobbyMods)
						{
							modInfo.temp = true;
						}
						if (ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = null,
							info = modInfo,
							notify = true
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(modInfo.numericalId);
						}
					}
					break;
				}
				case ModlistData.ModType.LEVEL:
				{
					if (!MainClass.overrideFusionDL || MainClass.useRepo)
					{
						break;
					}
					float num = modInfo.fileSizeKB / 1000000f;
					float num2 = num / 1000f;
					if (MainClass.autoDownloadLevels && num2 < MainClass.levelMaxGb && (MainClass.downloadMatureContent || !modInfo.mature) && !MainClass.modNumericalsDownloadedDuringLobbySession.Contains(modInfo.numericalId))
					{
						if (MainClass.tempLobbyMods)
						{
							modInfo.temp = true;
						}
						if (ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = null,
							info = modInfo,
							notify = true
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(modInfo.numericalId);
						}
					}
					break;
				}
				}
			}
			else
			{
				if (modInfo.isValidMod)
				{
					modlist.Add(modInfo);
				}
				if (modlistData.isFinal)
				{
					NetworkerMenuController.SetHostSubscribedMods(modlist);
					modlist.Clear();
				}
			}
		}
	}
}
namespace ModioModNetworker.Utilities
{
	public class ActionProcessor
	{
		private List<ModInfo> installedModInfoThreaded = new List<ModInfo>();
	}
	public enum ActionType
	{
		REFRESH_INSTALLED,
		REFRESH_SUBSCRIPTIONS
	}
	public class ModInfoUtilities
	{
		public static ModInfo GetModInfoForPoolee(Poolee assetPoolee)
		{
			string id = ((Scannable)((Crate)assetPoolee.SpawnableCrate)._pallet)._barcode._id;
			return GetModInfoForPalletBarcode(id);
		}

		public static ModInfo GetModInfoForLevelBarcode(string barcode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			LevelCrate crate = CrateFilterer.GetCrate<LevelCrate>(new Barcode(barcode));
			if ((Object)(object)crate == (Object)null)
			{
				return null;
			}
			string id = ((Scannable)((Crate)crate)._pallet)._barcode._id;
			return GetModInfoForPalletBarcode(id);
		}

		public static ModInfo GetModInfoForSpawnableBarcode(string barcode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObjectCrate crate = CrateFilterer.GetCrate<GameObjectCrate>(new Barcode(barcode));
			if ((Object)(object)crate == (Object)null)
			{
				return null;
			}
			string id = ((Scannable)((Crate)crate)._pallet)._barcode._id;
			return GetModInfoForPalletBarcode(id);
		}

		public static ModInfo GetModInfoForPalletBarcode(string barcode)
		{
			ModInfo modInfo = null;
			foreach (InstalledModInfo installedModInfo in MainClass.InstalledModInfos)
			{
				try
				{
					if (installedModInfo.palletBarcode == barcode)
					{
						modInfo = installedModInfo.ModInfo;
						break;
					}
				}
				catch (Exception)
				{
				}
			}
			if (modInfo != null)
			{
				return modInfo;
			}
			return null;
		}
	}
	public static class NetworkPlayerUtilities
	{
		public static List<NetworkPlayer> GetAllNetworkPlayers()
		{
			List<NetworkPlayer> list = new List<NetworkPlayer>();
			NetworkPlayer item = default(NetworkPlayer);
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (NetworkPlayerManager.TryGetPlayer(PlayerID.op_Implicit(playerID), ref item))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	public static class AssetBundleExtension
	{
		public static T LoadPersistentAsset<T>(this AssetBundle bundle, string name) where T : Object
		{
			Object val = bundle.LoadAsset(name);
			if (val != (Object)null)
			{
				val.hideFlags = (HideFlags)32;
				return ((Il2CppObjectBase)val).TryCast<T>();
			}
			return default(T);
		}
	}
	public class NetworkerAssets
	{
		public static GameObject avatarDownloadBarPrefab;

		public static GameObject uiMenuPrefab;

		public static GameObject modInfoDisplay;

		public static GameObject blacklistDisplayPrefab;

		public static GameObject checkboxSettingPrefab;

		public static GameObject numericalSettingPrefab;

		public static void LoadAssetsUI(AssetBundle bundle)
		{
			avatarDownloadBarPrefab = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/avatarprogressbar.prefab");
			uiMenuPrefab = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/rootmenu.prefab");
			modInfoDisplay = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/modinfodisplay.prefab");
			blacklistDisplayPrefab = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/blacklistelement.prefab");
			checkboxSettingPrefab = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/checkboxelement.prefab");
			numericalSettingPrefab = bundle.LoadPersistentAsset<GameObject>("assets/networkerassets/numberelement.prefab");
		}
	}
}
namespace ModioModNetworker.UI
{
	public class AvatarDownloadBar
	{
		private NetworkPlayer rep;

		private GameObject bar;

		private GameObject fill;

		private Animator animator;

		private RigManager manager;

		private TMP_Text modNameText;

		private TMP_Text percentageText;

		private float zeroPosition = 86f;

		private float completePosition = 0f;

		private bool previouslyStarted = false;

		public static Dictionary<PlayerID, AvatarDownloadBar> bars = new Dictionary<PlayerID, AvatarDownloadBar>();

		public AvatarDownloadBar(NetworkPlayer rep)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(NetworkerAssets.avatarDownloadBarPrefab);
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)32;
			bar = val;
			val.SetActive(false);
			if (bars.TryGetValue(rep.PlayerID, out AvatarDownloadBar value))
			{
				GameObject val2 = value.bar;
				Object.Destroy((Object)(object)val2);
				bars.Remove(rep.PlayerID);
			}
			bars.Add(rep.PlayerID, this);
			animator = val.GetComponent<Animator>();
			this.rep = rep;
			manager = rep.RigRefs.RigManager;
			modNameText = ((Component)val.transform.Find("Bar").Find("ModName")).GetComponent<TMP_Text>();
			percentageText = ((Component)val.transform.Find("Bar").Find("Percentage")).GetComponent<TMP_Text>();
			fill = ((Component)val.transform.Find("Bar").Find("Mask").Find("Fill")).gameObject;
			fill.transform.localPosition = new Vector3(zeroPosition, 0f, 0f);
		}

		private float GetBarOffset(RigManager rm)
		{
			float num = 0.3f;
			if (Object.op_Implicit((Object)(object)rm._avatar))
			{
				num *= rm._avatar.height;
			}
			return num;
		}

		public void Update()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)manager))
			{
				Transform head = ((Rig)manager.physicsRig).m_head;
				bar.transform.position = head.position + Vector3.up * GetBarOffset(manager);
				bar.transform.forward = -(Player.Head.position - bar.transform.position);
			}
		}

		public void SetModName(string name)
		{
			modNameText.text = name;
		}

		public void Finish()
		{
			animator.SetTrigger("completed");
			previouslyStarted = false;
		}

		public void SetPercentage(float percentage)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!previouslyStarted)
			{
				Show();
			}
			string text = percentage.ToString("0.0");
			percentageText.text = text + "%";
			float num = zeroPosition - percentage / 100f * (zeroPosition - completePosition);
			RectTransform component = fill.GetComponent<RectTransform>();
			((Transform)component).localPosition = new Vector3(num, 0f, 0f);
		}

		public void Show()
		{
			bar.SetActive(true);
			animator.SetTrigger("reset");
			previouslyStarted = true;
		}
	}
	public class CheckboxSetting : GenericSetting
	{
		private Button checkBox;

		public bool value;

		public Action<bool> onChecked;

		public CheckboxSetting(string title, bool startingValue, Action<bool> onChecked = null)
		{
			prefabObject = NetworkerAssets.checkboxSettingPrefab;
			base.title = title;
			value = startingValue;
			this.onChecked = onChecked;
		}

		public override void SpawnPrefab(Transform parent)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefabObject);
			checkBox = ((Component)val.transform.Find("Button")).GetComponent<Button>();
			((UnityEvent)checkBox.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnCheckMarkClicked();
			}));
			TMP_Text component = ((Component)val.transform.Find("Title")).GetComponent<TMP_Text>();
			component.text = title;
			val.transform.parent = parent;
			val.transform.localPosition = Vector3.forward;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			spawnedObject = val;
			UpdateDisplay();
		}

		private void OnCheckMarkClicked()
		{
			value = !value;
			UpdateDisplay();
			if (onChecked != null)
			{
				onChecked(value);
			}
		}

		private void UpdateDisplay()
		{
			GameObject gameObject = ((Component)spawnedObject.transform.Find("UnCheckedImage")).gameObject;
			GameObject gameObject2 = ((Component)spawnedObject.transform.Find("CheckedImage")).gameObject;
			if (value)
			{
				gameObject.SetActive(false);
				gameObject2.SetActive(true);
			}
			else
			{
				gameObject.SetActive(true);
				gameObject2.SetActive(false);
			}
		}
	}
	public abstract class GenericSetting
	{
		public GameObject prefabObject;

		public GameObject spawnedObject;

		public string title;

		public abstract void SpawnPrefab(Transform parent);
	}
	public class KeyboardManager
	{
		public static string typed = "";

		public static void Append(string character)
		{
			typed += character;
		}

		public static void Backspace()
		{
			if (typed.Length > 0)
			{
				typed = typed.Substring(0, typed.Length - 1);
			}
		}
	}
	public class MainThreadManager
	{
		private static ConcurrentQueue<GenericThreadingJob> genericThreadJobs = new ConcurrentQueue<GenericThreadingJob>();

		public static void HandleQueue()
		{
			if (genericThreadJobs.Count > 0 && genericThreadJobs.TryDequeue(out GenericThreadingJob result))
			{
				result.action();
			}
		}

		public static void QueueAction(Action action)
		{
			genericThreadJobs.Enqueue(new GenericThreadingJob
			{
				action = action
			});
		}
	}
	public class GenericThreadingJob
	{
		public Action action;
	}
	public class NumericalSetting : GenericSetting
	{
		private Button increaseButton;

		private Button decreaseButton;

		public int value;

		public Action<int> onModified;

		public int minValue;

		public int maxValue;

		public int increment;

		public NumericalSetting(string title, int startingValue, int minValue, int maxValue, int increment, Action<int> onModified = null)
		{
			prefabObject = NetworkerAssets.numericalSettingPrefab;
			base.title = title;
			value = startingValue;
			this.onModified = onModified;
			this.minValue = minValue;
			this.maxValue = maxValue;
			this.increment = increment;
		}

		public override void SpawnPrefab(Transform parent)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefabObject);
			increaseButton = ((Component)val.transform.Find("IncreaseArrow").Find("Button")).GetComponent<Button>();
			decreaseButton = ((Component)val.transform.Find("DecreaseArrow").Find("Button")).GetComponent<Button>();
			((UnityEvent)increaseButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ModifyValue(increase: true);
			}));
			((UnityEvent)decreaseButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				ModifyValue(increase: false);
			}));
			TMP_Text component = ((Component)val.transform.Find("Title")).GetComponent<TMP_Text>();
			component.text = title;
			val.transform.parent = parent;
			val.transform.localPosition = Vector3.forward;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			spawnedObject = val;
			UpdateDisplay();
		}

		private void ModifyValue(bool increase)
		{
			if (increase)
			{
				value += increment;
			}
			else
			{
				value -= increment;
			}
			if (value < minValue)
			{
				value = minValue;
			}
			if (value > maxValue)
			{
				value = maxValue;
			}
			UpdateDisplay();
			if (onModified != null)
			{
				onModified(value);
			}
		}

		private void UpdateDisplay()
		{
			TMP_Text component = ((Component)spawnedObject.transform.Find("NumericalDisplay")).GetComponent<TMP_Text>();
			component.text = value.ToString();
		}
	}
	public class SpotlightOverride
	{
		public string manualDisplayId;

		public string descriptionOverride;

		public string titleOverride;

		public string subTitle;

		public ModInfo downloadedInfo;

		public Texture cachedThumbnail;

		public static void LoadFromRegularURL()
		{
			UnityWebRequest httpWebRequest = UnityWebRequest.Get("https://raw.githubusercontent.com/notnotnotswipez/ModioModNetworker/networker-spotlight/modSpotlight.txt");
			UnityWebRequestAsyncOperation val = httpWebRequest.SendWebRequest();
			((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
			{
				string text = httpWebRequest.downloadHandler.text;
				string[] array = text.Split('\n');
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					if (text2.StartsWith("manualDisplayMod: "))
					{
						NetworkerMenuController.spotlightOverride.manualDisplayId = GetSegmentOrNull(text2, "manualDisplayMod: ");
						if (NetworkerMenuController.spotlightOverride.manualDisplayId != null)
						{
							ModInfo.RequestModInfoNumerical(NetworkerMenuController.spotlightOverride.manualDisplayId, "spotlight");
						}
					}
					if (text2.StartsWith("subTitle: "))
					{
						NetworkerMenuController.spotlightOverride.subTitle = GetSegmentOrNull(text2, "subTitle: ");
					}
					if (text2.StartsWith("titleOverride: "))
					{
						NetworkerMenuController.spotlightOverride.titleOverride = GetSegmentOrNull(text2, "titleOverride: ");
					}
					if (text2.StartsWith("descriptionOverride: "))
					{
						NetworkerMenuController.spotlightOverride.descriptionOverride = GetSegmentOrNull(text2, "descriptionOverride: ");
					}
				}
			});
		}

		private static string GetSegmentOrNull(string line, string startWith)
		{
			string text = line.Replace(startWith, "");
			if (text != "null")
			{
				return text;
			}
			return null;
		}
	}
	public class ThumbnailThreader
	{
		private static ConcurrentQueue<ThumbnailCompletionJob> thumbnailCompletionJobs = new ConcurrentQueue<ThumbnailCompletionJob>();

		public static void HandleQueue()
		{
			if (thumbnailCompletionJobs.Count > 0 && thumbnailCompletionJobs.TryDequeue(out ThumbnailCompletionJob result))
			{
				result.callback();
			}
		}

		public static void DownloadThumbnail(string url, Action<Texture> action)
		{
			Action<Texture> action2 = action;
			UnityWebRequest webRequest = UnityWebRequestTexture.GetTexture(url);
			UnityWebRequestAsyncOperation val = webRequest.SendWebRequest();
			((AsyncOperation)val).m_completeCallback = ((AsyncOperation)val).m_completeCallback + Action<AsyncOperation>.op_Implicit((Action<AsyncOperation>)delegate
			{
				ThumbnailCompletionJob item = new ThumbnailCompletionJob
				{
					callback = delegate
					{
						//IL_0007: Unknown result type (might be due to invalid IL or missing references)
						//IL_000d: Invalid comparison between Unknown and I4
						if ((int)webRequest.result == 1)
						{
							DownloadHandlerTexture val2 = ((Il2CppObjectBase)webRequest.downloadHandler).Cast<DownloadHandlerTexture>();
							Texture texture = (Texture)(object)val2.texture;
							action2(texture);
						}
					}
				};
				thumbnailCompletionJobs.Enqueue(item);
			});
		}
	}
	public class ThumbnailCompletionJob
	{
		public Action callback;
	}
}
namespace ModioModNetworker.Queue
{
	public class LevelHoldQueue
	{
		public class LevelHoldQueueData
		{
			public string missingBarcode;

			public LevelLoadData _data;
		}

		private static LevelHoldQueueData queueData;

		public static bool waitingForLevel;

		public static bool waitingForLevelToLoad;

		public static bool finishedLoadingLevel;

		public static void ClearQueue()
		{
			queueData = null;
			waitingForLevel = false;
			waitingForLevelToLoad = false;
			finishedLoadingLevel = false;
		}

		public static bool LevelInQueue()
		{
			return queueData != null || waitingForLevel || waitingForLevelToLoad || finishedLoadingLevel;
		}

		public static void SetQueue(LevelHoldQueueData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = new NotificationText("The host tried loading a level you dont have. \"" + data.missingBarcode + "\""),
				Message = new NotificationText("Wait a bit, it may start downloading!"),
				PopupLength = 3f,
				SaveToMenu = false,
				ShowPopup = true
			});
			queueData = data;
		}

		public static void CheckValid(string barcode)
		{
			if (queueData != null && queueData.missingBarcode == barcode)
			{
				Handle(queueData._data);
				waitingForLevel = true;
				queueData = null;
			}
		}

		public static void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			if (waitingForLevel && SceneStreamer._session != null && (int)SceneStreamer._session.Status == 1)
			{
				waitingForLevelToLoad = true;
				waitingForLevel = false;
			}
			if (waitingForLevelToLoad && SceneStreamer._session != null && (int)SceneStreamer._session.Status != 1)
			{
				waitingForLevelToLoad = false;
				finishedLoadingLevel = true;
			}
			if (finishedLoadingLevel)
			{
				SpawnableHoldQueue.HandleAllSpawnResponseDatas();
				finishedLoadingLevel = false;
			}
			if (SceneStreamer._session != null && !LevelInQueue() && (int)SceneStreamer._session.Status == 2)
			{
				SpawnableHoldQueue.ClearSpawnResponseDatas();
			}
		}

		private static void Handle(LevelLoadData data)
		{
			FusionSceneManager.SetTargetScene(data.LevelBarcode, data.LoadingScreenBarcode);
			NetworkSceneManager.Purgatory = false;
		}
	}
	public class SpawnableHoldQueue
	{
		private static List<SpawnableHoldQueueData> queueDatas = new List<SpawnableHoldQueueData>();

		private static List<SpawnResponseData> spawnResponseDatas = new List<SpawnResponseData>();

		public static void ClearSpawnResponseDatas()
		{
			spawnResponseDatas.Clear();
		}

		public static void HandleAllSpawnResponseDatas()
		{
			foreach (SpawnResponseData spawnResponseData in spawnResponseDatas)
			{
				Handle(spawnResponseData);
			}
			spawnResponseDatas.Clear();
		}

		public static void AddToQueue(SpawnResponseData data)
		{
			spawnResponseDatas.Add(data);
		}

		public static void ClearQueue()
		{
			queueDatas.Clear();
		}

		public static void AddToQueue(SpawnableHoldQueueData data)
		{
			queueDatas.Add(data);
		}

		public static void CheckValid(string barcode)
		{
			List<SpawnableHoldQueueData> toRemove = new List<SpawnableHoldQueueData>();
			foreach (SpawnableHoldQueueData queueData in queueDatas)
			{
				if (queueData.missingBarcode == barcode)
				{
					Handle(queueData._data);
					toRemove.Add(queueData);
				}
			}
			queueDatas.RemoveAll((SpawnableHoldQueueData data) => toRemove.Contains(data));
		}

		private static void Handle(SpawnResponseData data)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			SpawnResponseData data2 = data;
			SpawnableCrateReference crateRef = new SpawnableCrateReference(data2.SpawnData.Barcode);
			Spawnable val = new Spawnable
			{
				crateRef = crateRef,
				policyData = null
			};
			LocalAssetSpawner.Register(val);
			LocalAssetSpawner.Spawn(val, data2.SpawnData.SerializedTransform.position, data2.SpawnData.SerializedTransform.rotation, (Action<Poolee>)delegate(Poolee go)
			{
				SpawnResponseMessage.OnSpawnFinished(data2, go);
			});
		}
	}
	public class SpawnableHoldQueueData
	{
		public string missingBarcode;

		public SpawnResponseData _data;
	}
}
namespace ModioModNetworker.Patches
{
	public class AvatarSwitchPatch
	{
		[HarmonyPatch(typeof(PlayerSender), "SendPlayerAvatar")]
		public static class PlayerSenderPatch
		{
			public static void Postfix()
			{
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkInfo.HasServer || !MainClass.confirmedHostHasIt)
				{
					return;
				}
				ModInfo modInfo = null;
				foreach (InstalledModInfo installedModInfo in MainClass.InstalledModInfos)
				{
					if (installedModInfo.palletBarcode == ((Scannable)((Crate)((CrateReferenceT<AvatarCrate>)(object)RigData.Refs.RigManager._avatarCrate).Crate)._pallet)._barcode._id)
					{
						modInfo = installedModInfo.ModInfo;
						break;
					}
				}
				if (!ModlistMessage.avatarMods.ContainsKey(PlayerIDManager.LocalID))
				{
					ModlistMessage.avatarMods.Add(PlayerIDManager.LocalID, modInfo);
				}
				else
				{
					ModlistMessage.avatarMods[PlayerIDManager.LocalID] = modInfo;
				}
				if (modInfo == null)
				{
					return;
				}
				NetWriter val = NetWriter.Create();
				try
				{
					ModlistData modlistData = ModlistData.Create(PlayerIDManager.LocalID, modInfo, ModlistData.ModType.AVATAR);
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					try
					{
						MessageSender.BroadcastMessageExceptSelf((NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class RigProgressBarPatchReport
	{
		public static void Prefix(RigProgressBar __instance, ref bool value)
		{
			if (MainClass.overrideFusionDL)
			{
				value = false;
			}
		}
	}
	[HarmonyPatch(typeof(LevelDownloaderManager), "LoadWaitingScene")]
	public class LevelDownloaderManagerPatch
	{
		public static bool Prefix()
		{
			if (MainClass.overrideFusionDL)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(NetworkModRequester), "RequestAndInstallMod")]
	public class NetworkModRequestPatch
	{
		public static void Prefix(ModInstallInfo installInfo)
		{
			if (MainClass.overrideFusionDL)
			{
				installInfo.BeginDownloadCallback = null;
			}
		}
	}
	[HarmonyPatch(typeof(ModIODownloader), "EnqueueDownload")]
	public class ModIoDownloaderEnqueuePatch
	{
		public static bool Prefix(ModTransaction transaction)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if (MainClass.overrideFusionDL)
			{
				ModIOFile modFile = transaction.ModFile;
				string item = ((ModIOFile)(ref modFile)).ModID.ToString();
				if (!MainClass.modNumericalsDownloadedDuringLobbySession.Contains(item))
				{
					DownloadCallback callback = transaction.Callback;
					bool flag = false;
					if (((Delegate)(object)callback).Method.DeclaringType == typeof(LevelDownloaderManager))
					{
						flag = true;
					}
					string destination = "install_spawnable";
					if (transaction.Reporter != null && transaction.Reporter.GetType() == typeof(RigProgressBar))
					{
						destination = "install_avatar;";
						PlayerID ownerOfProgressBar = GetOwnerOfProgressBar((RigProgressBar)transaction.Reporter);
						destination = ((ownerOfProgressBar == null) ? "install_spawnable" : (destination + ownerOfProgressBar.SmallID));
					}
					if (flag)
					{
						destination = "install_level";
					}
					modFile = transaction.ModFile;
					ModInfo.RequestModInfoNumerical(((ModIOFile)(ref modFile)).ModID.ToString(), destination);
				}
				return false;
			}
			return true;
		}

		private static PlayerID GetOwnerOfProgressBar(RigProgressBar bar)
		{
			NetworkPlayer val = default(NetworkPlayer);
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (NetworkPlayerManager.TryGetPlayer(PlayerID.op_Implicit(playerID), ref val) && val.AvatarSetter.ProgressBar == bar)
				{
					return playerID;
				}
			}
			return null;
		}
	}
	public class LevelLoadPatch
	{
		[HarmonyPatch(typeof(LevelLoadMessage), "OnHandleMessage", new Type[] { typeof(ReceivedMessage) })]
		public static class PatchClass
		{
			public static bool Prefix(ReceivedMessage received)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkInfo.IsHost && !((ReceivedMessage)(ref received)).IsServerHandled && MainClass.autoDownloadLevels)
				{
					LevelLoadData val = ((ReceivedMessage)(ref received)).ReadData<LevelLoadData>();
					if (!MainClass.overrideFusionDL)
					{
						return true;
					}
					LevelHoldQueue.ClearQueue();
					if (!CrateFilterer.HasCrate<LevelCrate>(new Barcode(val.LevelBarcode)))
					{
						LevelHoldQueue.SetQueue(new LevelHoldQueue.LevelHoldQueueData
						{
							missingBarcode = val.LevelBarcode,
							_data = val
						});
						if (!MainClass.confirmedHostHasIt)
						{
							LevelDownloadInfo val2 = default(LevelDownloadInfo);
							val2.LevelBarcode = val.LevelBarcode;
							val2.LevelHost = 0;
							LevelDownloaderManager.DownloadLevel(val2);
						}
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(LoadSender), "SendLevelLoad", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(ulong)
		})]
		private static class SendLevelPatchClass
		{
			public static void Prefix(string barcode, string loadBarcode, ulong userId)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkInfo.IsHost)
				{
					return;
				}
				ModInfo modInfoForLevelBarcode = ModInfoUtilities.GetModInfoForLevelBarcode(barcode);
				if (modInfoForLevelBarcode == null)
				{
					return;
				}
				NetWriter val = NetWriter.Create();
				try
				{
					ModlistData modlistData = ModlistData.Create(PlayerIDManager.LocalID, modInfoForLevelBarcode, ModlistData.ModType.LEVEL);
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					try
					{
						MessageSender.SendFromServer(userId, (NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}

		[HarmonyPatch(typeof(LoadSender), "SendLevelLoad", new Type[]
		{
			typeof(string),
			typeof(string)
		})]
		private static class SendLevelPatchClassGeneric
		{
			public static void Prefix(string barcode, string loadBarcode)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkInfo.IsHost)
				{
					return;
				}
				ModInfo modInfoForLevelBarcode = ModInfoUtilities.GetModInfoForLevelBarcode(barcode);
				if (modInfoForLevelBarcode == null)
				{
					return;
				}
				NetWriter val = NetWriter.Create();
				try
				{
					ModlistData modlistData = ModlistData.Create(PlayerIDManager.LocalID, modInfoForLevelBarcode, ModlistData.ModType.LEVEL);
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					try
					{
						MessageSender.BroadcastMessageExceptSelf((NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}
	}
	public class LobbyCreatePatch
	{
	}
	public class PooleeSpawnPatch
	{
		[HarmonyPatch(typeof(Poolee), "OnSpawn")]
		private static class SpawnPatchClass
		{
			public static void Prefix(Poolee __instance)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				if (!MainClass.confirmedHostHasIt || !NetworkInfo.HasServer)
				{
					return;
				}
				try
				{
					ModInfo modInfoForPoolee = ModInfoUtilities.GetModInfoForPoolee(__instance);
					if (modInfoForPoolee == null)
					{
						return;
					}
					NetWriter val = NetWriter.Create();
					try
					{
						ModlistData modlistData = ModlistData.Create(PlayerIDManager.LocalID, modInfoForPoolee, ModlistData.ModType.SPAWNABLE);
						modlistData.Serialize((INetSerializer)(object)val);
						NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
						try
						{
							MessageSender.BroadcastMessageExceptSelf((NetworkChannel)0, val2);
						}
						finally
						{
							((IDisposable)val2)?.Dispose();
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch (Exception)
				{
				}
			}
		}

		[HarmonyPatch(typeof(SpawnSender), "SendCatchupSpawn", new Type[]
		{
			typeof(byte),
			typeof(string),
			typeof(ushort),
			typeof(SerializedTransform),
			typeof(byte),
			typeof(EntitySource)
		})]
		private static class CatchupSpawnPatch
		{
			public static void Prefix(byte ownerID, string barcode, ushort entityID, SerializedTransform serializedTransform, byte playerID, EntitySource source)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if (!NetworkInfo.IsHost)
				{
					return;
				}
				ModInfo modInfoForSpawnableBarcode = ModInfoUtilities.GetModInfoForSpawnableBarcode(barcode);
				if (modInfoForSpawnableBarcode == null)
				{
					return;
				}
				NetWriter val = NetWriter.Create();
				try
				{
					ModlistData modlistData = ModlistData.Create(PlayerIDManager.LocalID, modInfoForSpawnableBarcode, ModlistData.ModType.SPAWNABLE);
					modlistData.Serialize((INetSerializer)(object)val);
					NetMessage val2 = NetMessage.ModuleCreate<ModlistMessage>(val, CommonMessageRoutes.ReliableToClients, (byte?)null);
					try
					{
						MessageSender.BroadcastMessageExceptSelf((NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}
	}
	public class SpawnableResponsePatch
	{
		[HarmonyPatch(typeof(SpawnResponseMessage), "OnHandleMessage", new Type[] { typeof(ReceivedMessage) })]
		public static class PatchClass
		{
			public static bool Prefix(ReceivedMessage received)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				if (!((ReceivedMessage)(ref received)).IsServerHandled && MainClass.autoDownloadSpawnables)
				{
					SpawnResponseData val = ((ReceivedMessage)(ref received)).ReadData<SpawnResponseData>();
					if (!MainClass.overrideFusionDL)
					{
						return true;
					}
					if (!CrateFilterer.HasCrate<GameObjectCrate>(new Barcode(val.SpawnData.Barcode)))
					{
						SpawnableHoldQueue.AddToQueue(new SpawnableHoldQueueData
						{
							missingBarcode = val.SpawnData.Barcode,
							_data = val
						});
						return false;
					}
					if (LevelHoldQueue.LevelInQueue())
					{
						SpawnableHoldQueue.AddToQueue(val);
						return false;
					}
				}
				return true;
			}
		}
	}
	public class SyncableCleanupPatch
	{
		[HarmonyPatch(typeof(NetworkEntityManager), "OnCleanupEntities")]
		private static class CleanupPatchClass
		{
			public static void Prefix()
			{
				SpawnableHoldQueue.ClearQueue();
			}
		}
	}
}
namespace ModioModNetworker.Data
{
	public class InstalledModInfo
	{
		public string manifestPath;

		public string palletBarcode;

		public string palletPath;

		public string catalogPath;

		public ModInfo ModInfo;
	}
	public class ModInfoThreadRequest
	{
		public string modId;

		public string json;

		public string destination;

		public Action<ModInfo> onInfo;

		public bool mature = false;

		public dynamic originalModInfo;
	}
	public class ModInfo
	{
		public bool isValidMod;

		public bool downloading;

		public bool mature;

		public bool isTracked = true;

		public string modId;

		public float fileSizeKB;

		public string thumbnailLink;

		public string modName;

		public string modSummary;

		public string fileName;

		public string windowsDownloadLink = "nothing";

		public string androidDownloadLink = "nothing";

		public string directDownloadLink = "nothing";

		public double modDownloadPercentage;

		public string numericalId;

		public string version = "0.0.0";

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

		public string author = "Networker";

		public int structureVersion = 0;

		public bool temp = false;

		private static Action onFinished;

		public static int globalStructureVersion = 4;

		public static float requestSize = 0f;

		public static ConcurrentQueue<ModInfoThreadRequest> modInfoThreadRequests = new ConcurrentQueue<ModInfoThreadRequest>();

		public bool Download()
		{
			if (isValidMod && !downloading && !ModFileManager.isDownloading)
			{
				ModFileManager.isDownloading = true;
				ModlistMenu.activeDownloadModInfo = this;
				ModFileManager.downloadingModId = modId;
				if (!HelperMethods.IsAndroid())
				{
					ModFileManager.DownloadFile(windowsDownloadLink, MelonUtils.GameDirectory + "\\temp.zip");
				}
				else
				{
					ModFileManager.DownloadFile(androidDownloadLink, Path.Combine(Application.persistentDataPath, "temp.zip"));
				}
				return true;
			}
			return false;
		}

		public bool IsTracked()
		{
			return isTracked;
		}

		public bool IsBlacklisted()
		{
			if (MainClass.blacklistedModIoIds.Contains(modId) || MainClass.blacklistedModIoIds.Contains(numericalId))
			{
				return true;
			}
			return false;
		}

		public static void HandleQueue()
		{
			if (modInfoThreadRequests.Count > 0 && modInfoThreadRequests.TryDequeue(out ModInfoThreadRequest result))
			{
				requestSize -= 1f;
				ModInfo.Make(result.modId, result.json, result.destination, result.originalModInfo, result.mature);
				if (requestSize == 0f)
				{
					onFinished?.Invoke();
					onFinished = null;
				}
			}
		}

		public bool IsSubscribed()
		{
			return MainClass.subscribedModIoNumericalIds.Contains(numericalId);
		}

		public bool IsInstalled()
		{
			bool result = false;
			foreach (ModInfo installedMod in MainClass.installedMods)
			{
				if (installedMod.numericalId == numericalId)
				{
					result = true;
					break;
				}
			}
			return result;
		}

		public ModListing ToModListing()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			ModListing val = new ModListing();
			try
			{
				val.Author = "ModIoModNetworker";
				val.Title = modId;
				val.Description = modSummary;
				val.ThumbnailUrl = thumbnailLink;
				val.Version = version;
				val.Targets = new StringModTargetListingDictionary();
				ModIOModTarget val2 = new ModIOModTarget();
				((ModTarget)val2).ThumbnailOverride = null;
				val2.GameId = 3809L;
				val2.ModId = long.Parse(numericalId);
				try
				{
					if (windowsDownloadLink != null)
					{
						val2.ModfileId = long.Parse(windowsDownloadLink.Split("/files/")[1].Replace("/download", ""));
					}
				}
				catch (Exception)
				{
				}
				((Dictionary<string, ModTarget>)(object)val.Targets).Add("pc", (ModTarget)(object)val2);
				ModIOModTarget val3 = new ModIOModTarget();
				((ModTarget)val3).ThumbnailOverride = null;
				val3.GameId = 3809L;
				val3.ModId = long.Parse(numericalId);
				try
				{
					if (androidDownloadLink != null)
					{
						val3.ModfileId = long.Parse(androidDownloadLink.Split("/files/")[1].Replace("/download", ""));
					}
				}
				catch (Exception)
				{
				}
				((Dictionary<string, ModTarget>)(object)val.Targets).Add("android", (ModTarget)(object)val3);
				string text = ToInfoString();
				((Dictionary<string, ModTarget>)(object)val.Targets).Add(text, (ModTarget)(object)val2);
			}
			catch (Exception ex3)
			{
				MelonLogger.Error((object)ex3);
			}
			return val;
		}

		public string ToInfoString()
		{
			string text = $"networker;{mature};{temp};{fileSizeKB};{fileName};{structureVersion};{ToSafeString(modName).Replace(";", "")};{tags.Count}";
			foreach (string tag in tags)
			{
				text = text + ";" + tag;
			}
			return text;
		}

		public string ToSafeString(string initial)
		{
			return initial.Replace("&amp;", "&");
		}

		public void PopulateFromInfoString(string targetString)
		{
			string[] array = ToSafeString(targetString).Split(";");
			mature = bool.Parse(array[1]);
			temp = bool.Parse(array[2]);
			fileSizeKB = float.Parse(array[3]);
			fileName = array[4];
			structureVersion = int.Parse(array[5]);
			modName = array[6];
			int num = int.Parse(array[7]);
			int num2 = 8;
			for (int i = 0; i < num; i++)
			{
				tags.Add(array[i + num2]);
			}
			isValidMod = true;
		}

		public static void SetFinishedAction(Action action)
		{
			onFinished = action;
		}

		public static void RequestModInfo(string modId, string destination)
		{
			string modId2 = modId;
			string destination2 = destination;
			ModFileManager.GetJson("@" + modId2, delegate(string json)
			{
				modInfoThreadRequests.Enqueue(new ModInfoThreadRequest
				{
					modId = modId2,
					json = json,
					destination = destination2
				});
			});
		}

		public static void RequestModInfoNumerical(string modIdNumerical, string destination)
		{
			string destination2 = destination;
			if (modIdNumerical == null)
			{
				MelonLogger.Msg("Mod ID Numerical was null, skipping");
				return;
			}
			ModFileManager.GetRawModInfoJson(modIdNumerical, delegate(dynamic totalModInfo)
			{
				dynamic totalModInfo2 = totalModInfo;
				if ((object)totalModInfo2 != null)
				{
					string modId = (string)totalModInfo2["name_id"];
					bool mature = (int)totalModInfo2["maturity_option"] > 0;
					ModFileManager.GetJson("@" + modId, delegate(string json)
					{
						modInfoThreadRequests.Enqueue(new ModInfoThreadRequest
						{
							modId = modId,
							json = json,
							destination = destination2,
							mature = mature,
							originalModInfo = totalModInfo2
						});
					});
				}
			});
		}

		public static ModInfo MakeFromDynamic(dynamic mod, string modId)
		{
			ModInfo modInfo = new ModInfo();
			modInfo.structureVersion = globalStructureVersion;
			modInfo.modId = modId;
			modInfo.isValidMod = true;
			modInfo.downloading = false;
			modInfo.fileSizeKB = (float)mod["filesize"];
			modInfo.fileName = (string)mod["filename"];
			modInfo.windowsDownloadLink = (string)mod["download"]["binary_url"];
			modInfo.version = (string)mod["version"];
			return modInfo;
		}

		public static void Make(string modId, string json, string destination, dynamic originalModInfo, bool mature = false)
		{
			ModInfo modInfo = new ModInfo();
			modInfo.structureVersion = globalStructureVersion;
			modInfo.modId = modId;
			modInfo.mature = mature;
			Action<ModInfo> action = delegate
			{
			};
			switch (destination)
			{
			case "menuinfos":
				action = delegate(ModInfo info)
				{
					ModlistMenu._modInfos.Add(info);
				};
				break;
			case "spotlight":
				action = delegate(ModInfo info)
				{
					NetworkerMenuController.spotlightOverride.downloadedInfo = info;
					if (Object.op_Implicit((Object)(object)NetworkerMenuController.spotlightOverride.cachedThumbnail))
					{
						Object.Destroy((Object)(object)NetworkerMenuController.spotlightOverride.cachedThumbnail);
					}
					NetworkerMenuController.spotlightOverride.cachedThumbnail = null;
				};
				break;
			case "install_level":
				action = delegate(ModInfo info)
				{
					if (!MainClass.modNumericalsDownloadedDuringLobbySession.Contains(info.numericalId) && !info.IsSubscribed())
					{
						if (MainClass.tempLobbyMods)
						{
							info.temp = true;
						}
						float num2 = modInfo.fileSizeKB / 1000000f;
						float num3 = num2 / 1000f;
						if (num3 < MainClass.levelMaxGb && ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = null,
							info = info,
							notify = true
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(info.numericalId);
						}
					}
				};
				break;
			case "install_spawnable":
				action = delegate(ModInfo info)
				{
					if (!info.IsSubscribed() && !MainClass.modNumericalsDownloadedDuringLobbySession.Contains(info.numericalId))
					{
						if (MainClass.tempLobbyMods)
						{
							info.temp = true;
						}
						float num4 = modInfo.fileSizeKB / 1000000f;
						if (num4 < MainClass.maxAutoDownloadMb && ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = null,
							info = info,
							notify = true
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(info.numericalId);
						}
					}
				};
				break;
			case "install_native":
				action = delegate(ModInfo info)
				{
					ModFileManager.AddToQueue(new DownloadQueueElement
					{
						associatedPlayer = null,
						info = info,
						notify = true
					});
				};
				break;
			default:
			{
				if (!destination.StartsWith("install_avatar"))
				{
					break;
				}
				string s = destination.Split(';')[1];
				byte b = byte.Parse(s);
				PlayerID playerId = PlayerIDManager.GetPlayerID(b);
				if (playerId == null)
				{
					break;
				}
				action = delegate(ModInfo info)
				{
					if (!info.IsSubscribed() && !MainClass.modNumericalsDownloadedDuringLobbySession.Contains(info.numericalId))
					{
						if (MainClass.tempLobbyMods)
						{
							info.temp = true;
						}
						float num5 = modInfo.fileSizeKB / 1000000f;
						if (num5 < MainClass.maxAutoDownloadMb && ModFileManager.AddToQueue(new DownloadQueueElement
						{
							associatedPlayer = playerId,
							info = info,
							notify = false
						}))
						{
							MainClass.modNumericalsDownloadedDuringLobbySession.Add(info.numericalId);
						}
					}
				};
				break;
			}
			}
			try
			{
				dynamic val = JsonConvert.DeserializeObject<object>(json);
				JArray val2 = (JArray)val["data"];
				int count = ((JContainer)val2).Count;
				if (val2 == null)
				{
					modInfo.isValidMod = false;
					action(modInfo);
					return;
				}
				modInfo.isValidMod = true;
				modInfo.downloading = false;
				dynamic val3 = null;
				dynamic val4 = null;
				string text = "0.0.0";
				string text2 = "0.0.0";
				int num = count - 1;
				while (num >= 0 && !((val3 != null && val4 != null) ? true : false))
				{
					JToken val5 = val2[num];
					dynamic val6 = val5[(object)"platforms"];
					bool flag = false;
					bool flag2 = false;
					foreach (dynamic item in val6)
					{
						bool flag3 = HelperMethods.IsAndroid();
						string text3 = (flag3 ? "android" : "windows");
						string text4 = (flag3 ? "windows" : "android");
						if ((string)item["platform"] == text3)
						{
							flag = true;
						}
						else if ((string)item["platform"] == text4)
						{
							flag = false;
							break;
						}
					}
					foreach (dynamic item2 in val6)
					{
						bool flag4 = HelperMethods.IsAndroid();
						string text5 = (flag4 ? "android" : "windows");
						string text6 = (flag4 ? "windows" : "android");
						if ((string)item2["platform"] == text6)
						{
							flag2 = true;
						}
						else if ((string)item2["platform"] == text5)
						{
							flag2 = false;
							break;
						}
					}
					if (flag || flag2)
					{
						if (flag)
						{
							string text7 = ((string)val5[(object)"version"]) ?? "";
							if (val3 == null)
							{
								val3 = val5;
								text = text7;
							}
						}
						if (flag2)
						{
							string text8 = ((string)val5[(object)"version"]) ?? "";
							if (val4 == null)
							{
								val4 = val5;
								text2 = text8;
							}
						}
					}
					num--;
				}
				if (val3 != null)
				{
					if (originalModInfo != null)
					{
						string text9 = (string)originalModInfo["profile_url"];
						string text10 = ((string)originalModInfo["id"]) ?? "";
						string text11 = (string)originalModInfo["name"];
						string text12 = (string)originalModInfo["summary"];
						string text13 = (string)originalModInfo["logo"]["thumb_640x360"];
						modInfo.modName = text11;
						modInfo.thumbnailLink = text13;
						modInfo.modSummary = text12;
						modInfo.numericalId = text10;
						modInfo.author = (string)originalModInfo["submitted_by"]["username"];
						foreach (dynamic item3 in originalModInfo["tags"])
						{
							modInfo.tags.Add((string)item3["name"]);
						}
					}
					modInfo.fileSizeKB = (float)val3["filesize"];
					if (!HelperMethods.IsAndroid())
					{
						modInfo.windowsDownloadLink = (string)val3["download"]["binary_url"];
						if (val4 != null)
						{
							modInfo.androidDownloadLink = (string)val4["download"]["binary_url"];
						}
					}
					else
					{
						modInfo.androidDownloadLink = (string)val3["download"]["binary_url"];
						if (val4 != null)
						{
							modInfo.windowsDownloadLink = (string)val4["download"]["binary_url"];
						}
					}
					modInfo.fileName = (string)val3["filename"];
					modInfo.version = ((string)val3["version"]) ?? "";
					if (HelperMethods.IsAndroid() && ((val4 != null) ? true : false))
					{
						modInfo.version = ((string)val4["version"]) ?? "";
					}
					if (modInfo.version == null)
					{
						modInfo.version = "0.0.0";
					}
				}
				else
				{
					modInfo.isValidMod = false;
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
				modInfo.isValidMod = false;
				action(modInfo);
				return;
			}
			action(modInfo);
		}
	}
	public class SerializedModInfo : INetSerializable
	{
		public bool valid = false;

		public bool mature = false;

		public ModInfo modInfo;

		private float fileSize;

		private string windowsDownloadLink;

		private string androidDownloadLink;

		private string thumbnailUrl;

		private string summary;

		private string modName;

		private string numericalId;

		private string versionNumber;

		private string modId;

		private List<string> tags;

		public static SerializedModInfo Create(ModInfo info)
		{
			return new SerializedModInfo
			{
				valid = info.isValidMod,
				mature = info.mature,
				modId = info.modId,
				fileSize = info.fileSizeKB,
				windowsDownloadLink = info.windowsDownloadLink,
				androidDownloadLink = info.androidDownloadLink,
				numericalId = info.numericalId,
				versionNumber = info.version,
				tags = info.tags,
				modName = info.modName,
				thumbnailUrl = info.thumbnailLink,
				summary = info.modSummary
			};
		}

		public void Serialize(INetSerializer serializer)
		{
			if (serializer.IsReader)
			{
				serializer.SerializeValue(ref valid);
				serializer.SerializeValue(ref mature);
				serializer.SerializeValue(ref fileSize);
				serializer.SerializeValue(ref numericalId);
				string text = "";
				serializer.SerializeValue(ref text);
				string[] array = text.Split('¬');
				versionNumber = array[0];
				windowsDownloadLink = array[1];
				androidDownloadLink = array[2];
				modId = array[3];
				thumbnailUrl = array[4];
				summary = array[5];
				modName = array[6];
				int num = int.Parse(array[7]);
				List<string> list = new List<string>();
				int num2 = 8;
				for (int i = 0; i < num; i++)
				{
					list.Add(array[i + num2]);
				}
				modInfo = new ModInfo
				{
					structureVersion = ModInfo.globalStructureVersion,
					isValidMod = valid,
					numericalId = numericalId,
					modId = modId,
					mature = mature,
					version = versionNumber,
					windowsDownloadLink = windowsDownloadLink,
					androidDownloadLink = androidDownloadLink,
					fileSizeKB = fileSize,
					fileName = modId + ".zip",
					modSummary = summary,
					thumbnailLink = thumbnailUrl,
					modName = modName,
					tags = list
				};
				return;
			}
			serializer.SerializeValue(ref valid);
			serializer.SerializeValue(ref mature);
			serializer.SerializeValue(ref fileSize);
			serializer.SerializeValue(ref numericalId);
			string text2 = "";
			text2 = text2 + versionNumber + "¬";
			text2 = text2 + windowsDownloadLink + "¬";
			text2 = text2 + androidDownloadLink + "¬";
			text2 = text2 + modId + "¬";
			text2 = text2 + thumbnailUrl + "¬";
			text2 = text2 + summary + "¬";
			text2 = text2 + modName + "¬";
			text2 += tags.Count;
			foreach (string tag in tags)
			{
				text2 = text2 + "¬" + tag;
			}
			serializer.SerializeValue(ref text2);
		}

		public string ToDebugString()
		{
			string text = "";
			text = text + versionNumber + "¬";
			text = text + windowsDownloadLink + "¬";
			text = text + androidDownloadLink + "¬";
			text = text + modId + "¬";
			text = text + thumbnailUrl + "¬";
			text = text + summary + "¬";
			text = text + modName + "¬";
			text += tags.Count;
			foreach (string tag in tags)
			{
				text = text + "¬" + tag;
			}
			return $"Serialized mod: {text} is valid {valid}, mature {mature}, numerical {numericalId}";
		}
	}
}