using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AngleSharp.Dom;
using AngleSharp.Html.Dom;
using AngleSharp.Html.Parser;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.manghomagnet")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.26.0")]
[assembly: AssemblyInformationalVersion("1.0.26+423286e242150378842c28a5fdbad0160505ed8f")]
[assembly: AssemblyProduct("com.github.manghomagnet")]
[assembly: AssemblyTitle("MangHoMagnet")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.26.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace MangHoMagnet
{
	[BepInPlugin("com.github.manghomagnet", "MangHoMagnet", "1.0.26")]
	public class Plugin : BaseUnityPlugin
	{
		private enum LobbyCheckStatus
		{
			Unknown,
			Checking,
			Timeout,
			Valid,
			Full,
			Invalid,
			SteamUnavailable
		}

		private enum ValidationMode
		{
			None,
			FormatOnly,
			Steam
		}

		private sealed class PostInfo
		{
			public string Id { get; }

			public string Url { get; }

			public string Title { get; }

			public string Author { get; }

			public string Date { get; }

			public string Views { get; }

			public PostInfo(string id, string title, string author, string date, string views, string url)
			{
				Id = id;
				Url = url;
				Title = title;
				Author = author;
				Date = date;
				Views = views;
			}

			public PostInfo WithDate(string date)
			{
				if (string.IsNullOrWhiteSpace(date) || date == Date)
				{
					return this;
				}
				return new PostInfo(Id, Title, Author, date, Views, Url);
			}
		}

		private sealed class PostSource
		{
			public string Id { get; private set; }

			public string Title { get; private set; }

			public string Author { get; private set; }

			public string Date { get; private set; }

			public string Views { get; private set; }

			public string Url { get; private set; }

			public DateTime AddedUtc { get; private set; }

			public PostSource(PostInfo postInfo)
			{
				Id = postInfo.Id;
				Title = postInfo.Title;
				Author = postInfo.Author;
				Date = postInfo.Date;
				Views = postInfo.Views;
				Url = postInfo.Url;
				AddedUtc = DateTime.UtcNow;
			}

			public void UpdateFrom(PostInfo postInfo)
			{
				Id = postInfo.Id;
				Title = postInfo.Title;
				Author = postInfo.Author;
				Date = postInfo.Date;
				Views = postInfo.Views;
				Url = postInfo.Url;
				AddedUtc = DateTime.UtcNow;
			}
		}

		private sealed class LobbyEntry
		{
			public string Link { get; }

			public uint AppId { get; private set; }

			public ulong LobbyId { get; private set; }

			public ulong HostId { get; private set; }

			public DateTime FirstSeenUtc { get; }

			public DateTime LastSeenUtc { get; private set; }

			public DateTime LastCheckUtc { get; set; } = DateTime.MinValue;


			public DateTime CheckStartedUtc { get; set; } = DateTime.MinValue;


			public bool IsCheckPending { get; set; }

			public LobbyCheckStatus Status { get; set; }

			public bool AutoJoinAttempted { get; set; }

			public int MemberCount { get; set; } = -1;


			public int MemberLimit { get; set; } = -1;


			public List<PostSource> Sources { get; } = new List<PostSource>();


			public bool HasLobbyId => LobbyId != 0;

			public LobbyEntry(string link)
			{
				Link = link;
				FirstSeenUtc = DateTime.UtcNow;
				LastSeenUtc = FirstSeenUtc;
				Status = LobbyCheckStatus.Unknown;
			}

			public void Touch()
			{
				LastSeenUtc = DateTime.UtcNow;
			}

			public void SetLobbyInfo(uint appId, ulong lobbyId, ulong hostId)
			{
				AppId = appId;
				LobbyId = lobbyId;
				HostId = hostId;
			}

			public void AddOrUpdateSource(PostInfo postInfo)
			{
				PostInfo postInfo2 = postInfo;
				PostSource postSource = Sources.FirstOrDefault((PostSource source) => source.Url.Equals(postInfo2.Url, StringComparison.OrdinalIgnoreCase));
				if (postSource != null)
				{
					postSource.UpdateFrom(postInfo2);
				}
				else
				{
					Sources.Add(new PostSource(postInfo2));
				}
			}
		}

		private sealed class LobbyEntryView
		{
			public string Link { get; set; } = string.Empty;


			public string PostId { get; set; } = string.Empty;


			public string PostTitle { get; set; } = string.Empty;


			public string Author { get; set; } = string.Empty;


			public string PostDate { get; set; } = string.Empty;


			public string Views { get; set; } = string.Empty;


			public string PostUrl { get; set; } = string.Empty;


			public int MemberCount { get; set; } = -1;


			public int MemberLimit { get; set; } = -1;


			public int SourceCount { get; set; }

			public DateTime LastSeenUtc { get; set; }

			public LobbyCheckStatus Status { get; set; }
		}

		private sealed class ListParseDiagnostics
		{
			public string Title { get; set; } = string.Empty;


			public int RowCount { get; set; }

			public int SubjectMatchCount { get; set; }

			public int MissingTitleCount { get; set; }

			public int MissingHrefCount { get; set; }

			public int PostInfoCount { get; set; }
		}

		[CompilerGenerated]
		private sealed class <ExtractSteamLinks>d__160 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string html;

			public string <>3__html;

			private IEnumerator <>7__wrap1;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ExtractSteamLinks>d__160(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = SteamLinkRegex.Matches(html).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						Match match = (Match)<>7__wrap1.Current;
						<>2__current = match.Value;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<ExtractSteamLinks>d__160 <ExtractSteamLinks>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ExtractSteamLinks>d__ = this;
				}
				else
				{
					<ExtractSteamLinks>d__ = new <ExtractSteamLinks>d__160(0);
				}
				<ExtractSteamLinks>d__.html = <>3__html;
				return <ExtractSteamLinks>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		private static readonly Regex SteamLinkRegex = new Regex("steam://joinlobby/\\d+/\\d+/\\d+", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex SteamLinkParseRegex = new Regex("steam://joinlobby/(?<app>\\d+)/(?<lobby>\\d+)/(?<host>\\d+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex TagRegex = new Regex("<.*?>", RegexOptions.Compiled | RegexOptions.Singleline);

		private readonly HashSet<string> _seenPostUrls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, LobbyEntry> _lobbyByLink = new Dictionary<string, LobbyEntry>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<ulong, LobbyEntry> _lobbyById = new Dictionary<ulong, LobbyEntry>();

		private readonly List<LobbyEntry> _lobbyEntries = new List<LobbyEntry>();

		private readonly object _lobbyLock = new object();

		private readonly SemaphoreSlim _pollGate = new SemaphoreSlim(1, 1);

		private readonly Queue<ulong> _pendingLobbyChecks = new Queue<ulong>();

		private readonly Dictionary<string, PostInfo> _postInfoByUrl = new Dictionary<string, PostInfo>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, DateTime> _postLastFetchUtc = new Dictionary<string, DateTime>(StringComparer.OrdinalIgnoreCase);

		private readonly object _pendingLobbyLock = new object();

		private const int MaxLobbyChecksPerFrame = 2;

		private const float LobbyCheckTimeoutSeconds = 2f;

		private const float LobbyCheckIntervalSeconds = 0.25f;

		private const float InGameCheckIntervalSeconds = 1f;

		private const float ColIdWidth = 80f;

		private const float ColAuthorWidth = 170f;

		private const float ColDateWidth = 200f;

		private const float ColViewsWidth = 70f;

		private const float MaxTitleWidth = 520f;

		private const float MinTitleWidth = 160f;

		private const float OpenPostWidth = 110f;

		private const float JoinButtonWidth = 260f;

		private const float ActionGapWidth = 10f;

		private const float ActionButtonSpacing = 6f;

		private const float ActionButtonHeight = 24f;

		private const float TableRightPadding = 12f;

		private HttpClient? _http;

		private Harmony? _harmony;

		private CancellationTokenSource? _cts;

		private DateTime _lastJoinUtc = DateTime.MinValue;

		private DateTime _lastPollUtc = DateTime.MinValue;

		private DateTime _nextPollUtc = DateTime.MinValue;

		private ConfigEntry<bool> _enabled;

		private ConfigEntry<string> _galleryListUrl;

		private ConfigEntry<string> _subjectKeyword;

		private ConfigEntry<bool> _pauseAutoPollInGame;

		private ConfigEntry<bool> _autoJoin;

		private ConfigEntry<int> _pollIntervalSeconds;

		private ConfigEntry<int> _maxPostsPerPoll;

		private ConfigEntry<int> _postRefetchCooldownSeconds;

		private ConfigEntry<int> _joinCooldownSeconds;

		private ConfigEntry<int> _maxLobbyEntries;

		private ConfigEntry<bool> _validateLobbies;

		private ConfigEntry<string> _validationMode;

		private ConfigEntry<int> _validationIntervalSeconds;

		private ConfigEntry<bool> _suppressLobbyPopups;

		private ConfigEntry<int> _expectedAppId;

		private ConfigEntry<string> _userAgent;

		private ConfigEntry<bool> _logFoundLinks;

		private ConfigEntry<KeyboardShortcut> _toggleKey;

		private ConfigEntry<bool> _showUiOnStart;

		private ConfigEntry<int> _uiWidth;

		private ConfigEntry<int> _uiHeight;

		private bool _showUi;

		private bool _inputBlockedByUs;

		private int _lobbyVersion;

		private int _uiVersion;

		private Vector2 _scrollPos;

		private Rect _windowRect = new Rect(20f, 20f, 1650f, 620f);

		private List<LobbyEntryView> _lobbySnapshot = new List<LobbyEntryView>();

		private bool _steamValidationEnabled;

		private Callback<LobbyDataUpdate_t>? _lobbyDataCallback;

		private bool _loggedListEmpty;

		private bool _loggedNoLinks;

		private DateTime _lastInGameCheckUtc = DateTime.MinValue;

		private float _nextLobbyCheckTime;

		private bool _autoPollingPaused;

		private bool _isInGame;

		private Type? _cachedConnectionServiceType;

		private MethodInfo? _cachedGetServiceMethod;

		private Type? _cachedInRoomStateType;

		private Type? _cachedHostStateType;

		private GUIStyle? _headerStyle;

		private GUIStyle? _cellStyle;

		private GUIStyle? _dateStyle;

		private GUIStyle? _linkStyle;

		private GUIStyle? _smallLabelStyle;

		private GUIStyle? _menuLabelStyle;

		private GUIStyle? _windowStyle;

		private GUIStyle? _headerBoxStyle;

		private GUIStyle? _rowBoxStyle;

		private GUIStyle? _buttonStyle;

		private GUIStyle? _joinButtonStyle;

		private GUIStyle? _joinButtonValidStyle;

		private GUIStyle? _joinButtonFullStyle;

		private GUIStyle? _joinButtonInvalidStyle;

		private GUIStyle? _joinButtonTimeoutStyle;

		private GUIStyle? _toggleStyle;

		private Texture2D? _windowBackgroundTex;

		private Texture2D? _headerBackgroundTex;

		public const string Id = "com.github.manghomagnet";

		internal static ManualLogSource Log { get; private set; } = null;


		internal static Plugin Instance { get; private set; } = null;


		public static string Name => "MangHoMagnet";

		public static string Version => "1.0.26";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			try
			{
				Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
			}
			catch
			{
			}
			BindConfig();
			ApplyHarmonyPatches();
			TryInitializeSteamValidation();
			_showUi = _showUiOnStart.Value;
			SetNextPollUtc();
			_http = CreateHttpClient(_userAgent.Value);
			_cts = new CancellationTokenSource();
			Task.Run(() => PollLoopAsync(_cts.Token));
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private void OnDestroy()
		{
			_cts?.Cancel();
			_http?.Dispose();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void UpdateInGameState()
		{
			if (!_pauseAutoPollInGame.Value || !_enabled.Value)
			{
				if (_autoPollingPaused)
				{
					_autoPollingPaused = false;
					_isInGame = false;
					SetNextPollUtc();
				}
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!((utcNow - _lastInGameCheckUtc).TotalSeconds < 1.0))
			{
				_lastInGameCheckUtc = utcNow;
				bool isInGame = IsInGame();
				bool autoPollingPaused = _autoPollingPaused;
				_isInGame = isInGame;
				_autoPollingPaused = _pauseAutoPollInGame.Value && _enabled.Value && _isInGame;
				if (autoPollingPaused && !_autoPollingPaused)
				{
					SetNextPollUtc();
				}
			}
		}

		private bool IsInGame()
		{
			if (TryGetPhotonInRoom(out var inRoom))
			{
				return inRoom;
			}
			if (TryGetConnectionState(out Type currentStateType))
			{
				if ((object)_cachedInRoomStateType == null)
				{
					_cachedInRoomStateType = AccessTools.TypeByName("InRoomState");
				}
				if ((object)_cachedHostStateType == null)
				{
					_cachedHostStateType = AccessTools.TypeByName("HostState");
				}
				if (_cachedInRoomStateType != null && currentStateType == _cachedInRoomStateType)
				{
					return true;
				}
				if (_cachedHostStateType != null && currentStateType == _cachedHostStateType)
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryGetPhotonInRoom(out bool inRoom)
		{
			inRoom = false;
			Type type = AccessTools.TypeByName("Photon.Pun.PhotonNetwork");
			if (type == null)
			{
				return false;
			}
			PropertyInfo property = type.GetProperty("InRoom", BindingFlags.Static | BindingFlags.Public);
			if (property == null)
			{
				return false;
			}
			if (property.GetValue(null) is bool flag)
			{
				inRoom = flag;
				return true;
			}
			return false;
		}

		private bool TryGetConnectionState(out Type? currentStateType)
		{
			currentStateType = null;
			Type type = AccessTools.TypeByName("GameHandler");
			if (type == null)
			{
				return false;
			}
			if ((object)_cachedConnectionServiceType == null)
			{
				_cachedConnectionServiceType = AccessTools.TypeByName("ConnectionService");
			}
			if (_cachedConnectionServiceType == null)
			{
				return false;
			}
			if ((object)_cachedGetServiceMethod == null)
			{
				_cachedGetServiceMethod = type.GetMethods(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((MethodInfo method) => method.Name == "GetService" && method.IsGenericMethodDefinition);
			}
			if (_cachedGetServiceMethod == null)
			{
				return false;
			}
			object obj = null;
			try
			{
				MethodInfo methodInfo = _cachedGetServiceMethod.MakeGenericMethod(_cachedConnectionServiceType);
				obj = methodInfo.Invoke(null, null);
			}
			catch
			{
				return false;
			}
			if (obj == null)
			{
				return false;
			}
			object obj3 = null;
			try
			{
				obj3 = _cachedConnectionServiceType.GetField("StateMachine", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj);
				if (obj3 == null)
				{
					obj3 = _cachedConnectionServiceType.GetProperty("StateMachine", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj);
				}
			}
			catch
			{
				return false;
			}
			if (obj3 == null)
			{
				return false;
			}
			try
			{
				object obj5 = obj3.GetType().GetProperty("CurrentState", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj3);
				if (obj5 == null)
				{
					return false;
				}
				currentStateType = obj5.GetType();
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = _toggleKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				ToggleUi();
			}
			UpdateInGameState();
			if (_steamValidationEnabled)
			{
				try
				{
					SteamAPI.RunCallbacks();
				}
				catch
				{
				}
				float unscaledTime = Time.unscaledTime;
				if (unscaledTime >= _nextLobbyCheckTime)
				{
					_nextLobbyCheckTime = unscaledTime + 0.25f;
					ProcessLobbyChecks();
					UpdateCheckTimeouts();
				}
			}
		}

		private void OnGUI()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (_showUi)
			{
				EnsureGuiStyles();
				float maxWindowWidth = GetMaxWindowWidth();
				if ((float)_uiWidth.Value > maxWindowWidth)
				{
					_uiWidth.Value = Mathf.RoundToInt(maxWindowWidth);
				}
				if (((Rect)(ref _windowRect)).width != (float)_uiWidth.Value || ((Rect)(ref _windowRect)).height != (float)_uiHeight.Value)
				{
					((Rect)(ref _windowRect)).width = _uiWidth.Value;
					((Rect)(ref _windowRect)).height = _uiHeight.Value;
				}
				int num = Volatile.Read(ref _lobbyVersion);
				if (num != _uiVersion)
				{
					_lobbySnapshot = GetLobbySnapshot();
					_uiVersion = num;
				}
				_windowRect = GUILayout.Window(7813421, _windowRect, new WindowFunction(DrawWindowContents), "MangHoMagnet", _windowStyle ?? GUI.skin.window, Array.Empty<GUILayoutOption>());
			}
		}

		private void DrawWindowContents(int id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			Color contentColor = GUI.contentColor;
			GUI.contentColor = Color.white;
			if (_headerStyle == null || _cellStyle == null || _linkStyle == null || _smallLabelStyle == null)
			{
				GUI.contentColor = contentColor;
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Refresh Now", _buttonStyle ?? GUI.skin.button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(140f) }))
			{
				RequestManualPoll();
			}
			if (GUILayout.Button("Hide (F8)", _buttonStyle ?? GUI.skin.button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				ToggleUi();
			}
			GUILayout.Space(8f);
			_autoJoin.Value = GUILayout.Toggle(_autoJoin.Value, "Auto Join", _toggleStyle ?? GUI.skin.toggle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUIStyle val = _menuLabelStyle ?? _smallLabelStyle;
			GUILayout.Label("Last poll: " + ((_lastPollUtc == DateTime.MinValue) ? "-" : _lastPollUtc.ToLocalTime().ToString("HH:mm:ss")), val, Array.Empty<GUILayoutOption>());
			GUILayout.Space(16f);
			int remainingSeconds = GetRemainingSeconds();
			string text = ((!_enabled.Value) ? "Next refresh: paused" : (_autoPollingPaused ? "Next refresh: paused (in game)" : $"Next refresh: {remainingSeconds}s"));
			GUILayout.Label(text, val, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			if (_autoPollingPaused)
			{
				GUILayout.Label("Auto scan paused while in game", val, Array.Empty<GUILayoutOption>());
			}
			float scrollViewWidth = GetScrollViewWidth();
			float scrollViewContentWidth = GetScrollViewContentWidth(scrollViewWidth);
			GUIStyle val2 = _headerBoxStyle ?? GUI.skin.box;
			GUIStyle style = _rowBoxStyle ?? GUI.skin.box;
			float contentWidthForStyle = GetContentWidthForStyle(scrollViewContentWidth, val2);
			float contentWidthForStyle2 = GetContentWidthForStyle(scrollViewContentWidth, style);
			float num = Mathf.Min(contentWidthForStyle, contentWidthForStyle2);
			float num2 = 80f;
			float num3 = 170f;
			float num4 = 200f;
			float num5 = 70f;
			float num6 = 386f;
			float num7 = num2 + num3 + num4 + num5 + num6 + 520f;
			float num8 = Mathf.Min(num - 12f, num7);
			num8 = Mathf.Max(300f, num8);
			float num9 = num8 - (num2 + num3 + num4 + num5 + num6);
			float num10 = Mathf.Clamp(num9, 160f, 520f);
			if (num10 > num9)
			{
				num10 = Math.Max(80f, num9);
			}
			float num11 = num8 + (float)val2.padding.left + (float)val2.padding.right;
			GUILayout.BeginHorizontal(val2, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num11),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.Label("번호", _headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
			GUILayout.Label("제목", _headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num10) });
			GUILayout.Label("글쓴이", _headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num3) });
			GUILayout.Label("작성일", _headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num4) });
			GUILayout.Label("조회수", _headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num5) });
			GUILayout.Space(num6);
			GUILayout.EndHorizontal();
			_scrollPos.x = 0f;
			_scrollPos = GUILayout.BeginScrollView(_scrollPos, false, true, (GUILayoutOption[])(object)new GUILayoutOption[3]
			{
				GUILayout.ExpandHeight(true),
				GUILayout.Width(scrollViewWidth),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num8),
				GUILayout.ExpandWidth(false)
			});
			if (_lobbySnapshot.Count == 0)
			{
				GUILayout.Label("No lobby links yet.", Array.Empty<GUILayoutOption>());
			}
			else
			{
				foreach (LobbyEntryView item in _lobbySnapshot)
				{
					DrawLobbyEntry(item, num2, num10, num3, num4, num5, num8, num6);
				}
			}
			GUILayout.EndVertical();
			GUILayout.EndScrollView();
			GUI.DragWindow();
			GUI.contentColor = contentColor;
		}

		private void DrawLobbyEntry(LobbyEntryView entry, float colIdWidth, float titleWidth, float colAuthorWidth, float colDateWidth, float colViewsWidth, float rowContentWidth, float colActionsWidth)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (_cellStyle == null || _linkStyle == null)
			{
				return;
			}
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = GetStatusBackground(entry.Status);
			GUIStyle val = _rowBoxStyle ?? GUI.skin.box;
			float num = rowContentWidth + (float)val.padding.left + (float)val.padding.right;
			GUILayout.BeginVertical(val, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.ExpandWidth(false)
			});
			GUI.backgroundColor = backgroundColor;
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(rowContentWidth),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.Label(DisplayOrDash(entry.PostId), _cellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(colIdWidth) });
			GUILayout.Label(DisplayOrDash(entry.PostTitle), _cellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(titleWidth) });
			GUILayout.Label(DisplayOrDash(entry.Author), _cellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(colAuthorWidth) });
			GUIStyle val2 = _dateStyle ?? _cellStyle;
			if (val2 != null && _cellStyle != null)
			{
				val2.normal.textColor = GetDateHighlightColor(entry.PostDate, _cellStyle.normal.textColor);
			}
			GUILayout.Label(DisplayOrDash(entry.PostDate), val2 ?? _cellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(colDateWidth) });
			GUILayout.Label(DisplayOrDash(entry.Views), _cellStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(colViewsWidth) });
			GUILayout.EndHorizontal();
			float num2 = Math.Max(0f, rowContentWidth - colActionsWidth);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(rowContentWidth),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num2),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.Label(entry.Link, _linkStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
			GUILayout.EndVertical();
			GUILayout.Space(10f);
			float num3 = 24f;
			if (!string.IsNullOrWhiteSpace(entry.PostUrl))
			{
				if (GUILayout.Button("Open Post", _buttonStyle ?? GUI.skin.button, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(110f),
					GUILayout.Height(num3)
				}))
				{
					Application.OpenURL(entry.PostUrl);
				}
			}
			else
			{
				GUILayout.Space(110f);
			}
			GUILayout.Space(6f);
			string text = BuildJoinButtonLabel(entry);
			GUIStyle joinButtonStyle = GetJoinButtonStyle(entry);
			if (GUILayout.Button(text, joinButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(260f),
				GUILayout.Height(num3)
			}))
			{
				TryJoinLobby(entry.Link, force: true);
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private void ToggleUi()
		{
			_showUi = !_showUi;
			TrySetWindowBlockingInput(_showUi);
		}

		private static string DisplayOrDash(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			return "-";
		}

		private static Color GetStatusBackground(LobbyCheckStatus status)
		{
			//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)
			//IL_0090: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(status switch
			{
				LobbyCheckStatus.Valid => new Color(0.86f, 0.97f, 0.9f), 
				LobbyCheckStatus.Full => new Color(1f, 0.95f, 0.8f), 
				LobbyCheckStatus.Invalid => new Color(1f, 0.86f, 0.86f), 
				LobbyCheckStatus.Checking => new Color(0.86f, 0.93f, 1f), 
				LobbyCheckStatus.Timeout => new Color(0.93f, 0.93f, 0.96f), 
				LobbyCheckStatus.SteamUnavailable => new Color(0.94f, 0.94f, 0.95f), 
				_ => GUI.backgroundColor, 
			});
		}

		private void EnsureGuiStyles()
		{
			//IL_0019: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0083: 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)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Expected O, but got Unknown
			//IL_029e: Expected O, but got Unknown
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Expected O, but got Unknown
			//IL_039a: Expected O, but got Unknown
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Expected O, but got Unknown
			//IL_03f8: Expected O, but got Unknown
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Expected O, but got Unknown
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Unknown result type (might be due to invalid IL or missing references)
			//IL_050d: Expected O, but got Unknown
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Expected O, but got Unknown
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_06db: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Expected O, but got Unknown
			//IL_0721: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Expected O, but got Unknown
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Expected O, but got Unknown
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0753: Expected O, but got Unknown
			//IL_075d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0767: Expected O, but got Unknown
			//IL_0771: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Expected O, but got Unknown
			//IL_0785: Unknown result type (might be due to invalid IL or missing references)
			//IL_078f: Expected O, but got Unknown
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Expected O, but got Unknown
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b7: Expected O, but got Unknown
			//IL_07c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cb: Expected O, but got Unknown
			//IL_07d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Expected O, but got Unknown
			if (_headerStyle == null)
			{
				_windowBackgroundTex = CreateSolidTexture(new Color(0.97f, 0.97f, 0.98f));
				_headerBackgroundTex = CreateSolidTexture(new Color(0.9f, 0.92f, 0.95f));
				_headerStyle = new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)3,
					wordWrap = false,
					clipping = (TextClipping)1
				};
				_cellStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = false,
					clipping = (TextClipping)1
				};
				_dateStyle = new GUIStyle(_cellStyle);
				_linkStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = true,
					clipping = (TextClipping)1
				};
				_smallLabelStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = false
				};
				_menuLabelStyle = new GUIStyle(_smallLabelStyle);
				_headerStyle.fontSize = Math.Max(_headerStyle.fontSize, 15);
				_cellStyle.fontSize = Math.Max(_cellStyle.fontSize, 14);
				_linkStyle.fontSize = Math.Max(_linkStyle.fontSize, 13);
				_smallLabelStyle.fontSize = Math.Max(_smallLabelStyle.fontSize + 1, 12);
				_menuLabelStyle.fontSize = Math.Max(_menuLabelStyle.fontSize + 4, 16);
				_headerStyle.normal.textColor = new Color(0.1f, 0.1f, 0.12f);
				_cellStyle.normal.textColor = new Color(0.12f, 0.12f, 0.14f);
				_dateStyle.normal.textColor = _cellStyle.normal.textColor;
				_linkStyle.normal.textColor = new Color(0.1f, 0.33f, 0.74f);
				_smallLabelStyle.normal.textColor = new Color(0.18f, 0.18f, 0.2f);
				_menuLabelStyle.normal.textColor = _cellStyle.normal.textColor;
				_windowStyle = new GUIStyle(GUI.skin.window)
				{
					padding = new RectOffset(12, 12, 22, 12)
				};
				if ((Object)(object)_windowBackgroundTex != (Object)null)
				{
					_windowStyle.normal.background = _windowBackgroundTex;
					_windowStyle.onNormal.background = _windowBackgroundTex;
				}
				Color textColor = default(Color);
				((Color)(ref textColor))..ctor(0.1f, 0.1f, 0.12f);
				_windowStyle.normal.textColor = textColor;
				_windowStyle.hover.textColor = textColor;
				_windowStyle.active.textColor = textColor;
				_windowStyle.focused.textColor = textColor;
				_windowStyle.onNormal.textColor = textColor;
				_windowStyle.onHover.textColor = textColor;
				_windowStyle.onActive.textColor = textColor;
				_windowStyle.onFocused.textColor = textColor;
				_headerBoxStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(6, 6, 4, 4)
				};
				if ((Object)(object)_headerBackgroundTex != (Object)null)
				{
					_headerBoxStyle.normal.background = _headerBackgroundTex;
					_headerBoxStyle.onNormal.background = _headerBackgroundTex;
				}
				_rowBoxStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(6, 6, 4, 4)
				};
				_buttonStyle = new GUIStyle(GUI.skin.button);
				Color textColor2 = default(Color);
				((Color)(ref textColor2))..ctor(0.1f, 0.1f, 0.12f);
				_buttonStyle.fontSize = Math.Max(_buttonStyle.fontSize, 15);
				_buttonStyle.wordWrap = false;
				_buttonStyle.clipping = (TextClipping)1;
				_buttonStyle.fixedHeight = 24f;
				_buttonStyle.stretchHeight = false;
				_buttonStyle.normal.textColor = textColor2;
				_buttonStyle.hover.textColor = textColor2;
				_buttonStyle.active.textColor = textColor2;
				_buttonStyle.focused.textColor = textColor2;
				_buttonStyle.onNormal.textColor = textColor2;
				_buttonStyle.onHover.textColor = textColor2;
				_buttonStyle.onActive.textColor = textColor2;
				_buttonStyle.onFocused.textColor = textColor2;
				_joinButtonStyle = new GUIStyle(_buttonStyle);
				_joinButtonStyle.normal.textColor = Color.white;
				_joinButtonStyle.hover.textColor = Color.white;
				_joinButtonStyle.active.textColor = Color.white;
				_joinButtonStyle.focused.textColor = Color.white;
				_joinButtonStyle.onNormal.textColor = Color.white;
				_joinButtonStyle.onHover.textColor = Color.white;
				_joinButtonStyle.onActive.textColor = Color.white;
				_joinButtonStyle.onFocused.textColor = Color.white;
				_joinButtonValidStyle = CreateJoinStateStyle(_joinButtonStyle, new Color(0.1f, 0.55f, 0.24f));
				_joinButtonFullStyle = CreateJoinStateStyle(_joinButtonStyle, new Color(0.78f, 0.42f, 0.05f));
				_joinButtonInvalidStyle = CreateJoinStateStyle(_joinButtonStyle, new Color(0.8f, 0.12f, 0.12f));
				_joinButtonTimeoutStyle = CreateJoinStateStyle(_joinButtonStyle, new Color(0.45f, 0.45f, 0.5f));
				_toggleStyle = new GUIStyle(GUI.skin.toggle);
				_toggleStyle.fontSize = Math.Max(_toggleStyle.fontSize, 15);
				_toggleStyle.normal.textColor = textColor2;
				_toggleStyle.hover.textColor = textColor2;
				_toggleStyle.active.textColor = textColor2;
				_toggleStyle.focused.textColor = textColor2;
				_toggleStyle.onNormal.textColor = textColor2;
				_toggleStyle.onHover.textColor = textColor2;
				_toggleStyle.onActive.textColor = textColor2;
				_toggleStyle.onFocused.textColor = textColor2;
				_headerStyle.margin = new RectOffset(0, 0, 0, 0);
				_cellStyle.margin = new RectOffset(0, 0, 0, 0);
				_dateStyle.margin = new RectOffset(0, 0, 0, 0);
				_linkStyle.margin = new RectOffset(0, 0, 0, 0);
				_smallLabelStyle.margin = new RectOffset(0, 0, 0, 0);
				_menuLabelStyle.margin = new RectOffset(0, 0, 0, 0);
				_headerBoxStyle.margin = new RectOffset(0, 0, 0, 0);
				_rowBoxStyle.margin = new RectOffset(0, 0, 0, 0);
				_buttonStyle.margin = new RectOffset(0, 0, 0, 0);
				_joinButtonStyle.margin = new RectOffset(0, 0, 0, 0);
				_toggleStyle.margin = new RectOffset(0, 0, 0, 0);
				if (_joinButtonValidStyle != null)
				{
					_joinButtonValidStyle.margin = _joinButtonStyle.margin;
					_joinButtonValidStyle.fixedHeight = _joinButtonStyle.fixedHeight;
					_joinButtonValidStyle.stretchHeight = _joinButtonStyle.stretchHeight;
				}
				if (_joinButtonFullStyle != null)
				{
					_joinButtonFullStyle.margin = _joinButtonStyle.margin;
					_joinButtonFullStyle.fixedHeight = _joinButtonStyle.fixedHeight;
					_joinButtonFullStyle.stretchHeight = _joinButtonStyle.stretchHeight;
				}
				if (_joinButtonInvalidStyle != null)
				{
					_joinButtonInvalidStyle.margin = _joinButtonStyle.margin;
					_joinButtonInvalidStyle.fixedHeight = _joinButtonStyle.fixedHeight;
					_joinButtonInvalidStyle.stretchHeight = _joinButtonStyle.stretchHeight;
				}
				if (_joinButtonTimeoutStyle != null)
				{
					_joinButtonTimeoutStyle.margin = _joinButtonStyle.margin;
					_joinButtonTimeoutStyle.fixedHeight = _joinButtonStyle.fixedHeight;
					_joinButtonTimeoutStyle.stretchHeight = _joinButtonStyle.stretchHeight;
				}
			}
		}

		private void BindConfig()
		{
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			_enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable MangHoMagnet.");
			_galleryListUrl = ((BaseUnityPlugin)this).Config.Bind<string>("General", "GalleryListUrl", "https://gall.dcinside.com/mgallery/board/lists?id=bingbong", "DCInside gallery list URL to scan.");
			_subjectKeyword = ((BaseUnityPlugin)this).Config.Bind<string>("Filter", "SubjectKeyword", string.Empty, "Ignored (no subject filtering; scans for Steam links in posts).");
			_pollIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("General", "PollIntervalSeconds", 10, "Seconds between list scans.");
			_pauseAutoPollInGame = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PauseAutoPollInGame", true, "Pause automatic polling while in game (manual refresh still works).");
			_maxPostsPerPoll = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxPostsPerPoll", 50, "Maximum number of posts to scan per poll (minimum 50 to cover the first page).");
			_postRefetchCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("General", "PostRefetchCooldownSeconds", 60, "Minimum seconds between re-fetching the same post when metadata changes.");
			_maxLobbyEntries = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxLobbyEntries", 200, "Maximum number of lobby links kept in memory.");
			_validateLobbies = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ValidateLobbies", true, "Enable lobby validation and highlight entries in the UI.");
			_validationMode = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ValidationMode", "FormatOnly", "Validation mode: None, FormatOnly, Steam. Steam mode can trigger in-game dialogs.");
			_suppressLobbyPopups = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SuppressLobbyPopups", true, "Auto-dismiss in-game lobby error dialogs while validating Steam lobbies.");
			_validationIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("General", "ValidationIntervalSeconds", 60, "Minimum seconds between Steam lobby validation checks per link.");
			_expectedAppId = ((BaseUnityPlugin)this).Config.Bind<int>("General", "ExpectedAppId", 3527290, "Expected Steam App ID for lobby links.");
			_autoJoin = ((BaseUnityPlugin)this).Config.Bind<bool>("Join", "AutoJoin", false, "Automatically open valid Steam join links when found.");
			_joinCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("Join", "JoinCooldownSeconds", 10, "Minimum seconds between automatic joins.");
			_userAgent = ((BaseUnityPlugin)this).Config.Bind<string>("Network", "UserAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", "User-Agent header used for requests.");
			_logFoundLinks = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "LogFoundLinks", true, "Log newly discovered Steam join links.");
			_toggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("UI", "ToggleKey", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "Toggle the lobby list window.");
			_showUiOnStart = ((BaseUnityPlugin)this).Config.Bind<bool>("UI", "ShowOnStart", false, "Show the lobby list window on startup.");
			_uiWidth = ((BaseUnityPlugin)this).Config.Bind<int>("UI", "WindowWidth", 1650, "Lobby list window width in pixels.");
			_uiHeight = ((BaseUnityPlugin)this).Config.Bind<int>("UI", "WindowHeight", 620, "Lobby list window height in pixels.");
		}

		private int GetRemainingSeconds()
		{
			if (_nextPollUtc == DateTime.MinValue)
			{
				return 0;
			}
			if (_autoPollingPaused || !_enabled.Value)
			{
				return 0;
			}
			return Math.Max(0, (int)Math.Ceiling((_nextPollUtc - DateTime.UtcNow).TotalSeconds));
		}

		private void SetNextPollUtc()
		{
			int num = Math.Max(_pollIntervalSeconds.Value, 1);
			_nextPollUtc = DateTime.UtcNow.AddSeconds(num);
		}

		private float GetScrollViewWidth()
		{
			GUIStyle verticalScrollbar = GUI.skin.verticalScrollbar;
			float num = ((verticalScrollbar != null) ? verticalScrollbar.fixedWidth : 0f);
			if (num <= 0f)
			{
				num = 16f;
			}
			GUIStyle? windowStyle = _windowStyle;
			RectOffset val = ((windowStyle != null) ? windowStyle.padding : null) ?? GUI.skin.window.padding;
			int num2 = val.left + val.right;
			return Mathf.Max(((Rect)(ref _windowRect)).width - (float)num2 - 8f, 720f);
		}

		private float GetMaxWindowWidth()
		{
			GUIStyle verticalScrollbar = GUI.skin.verticalScrollbar;
			float num = ((verticalScrollbar != null) ? verticalScrollbar.fixedWidth : 0f);
			if (num <= 0f)
			{
				num = 16f;
			}
			GUIStyle? windowStyle = _windowStyle;
			RectOffset val = ((windowStyle != null) ? windowStyle.padding : null) ?? GUI.skin.window.padding;
			int num2 = val.left + val.right;
			float num3 = 1426f;
			float num4 = 720f + (float)num2 + 8f;
			float num5 = num3 + 12f + num + (float)num2 + 8f;
			return Mathf.Max(num4, num5);
		}

		private float GetScrollViewContentWidth(float viewWidth)
		{
			GUIStyle verticalScrollbar = GUI.skin.verticalScrollbar;
			float num = ((verticalScrollbar != null) ? verticalScrollbar.fixedWidth : 0f);
			if (num <= 0f)
			{
				num = 16f;
			}
			return Mathf.Max(viewWidth - num - 2f, 300f);
		}

		private static float GetContentWidthForStyle(float width, GUIStyle style)
		{
			if (style == null)
			{
				return width;
			}
			int num = style.padding.left + style.padding.right;
			return Mathf.Max(width - (float)num, 300f);
		}

		private void TryInitializeSteamValidation()
		{
			if (!_validateLobbies.Value)
			{
				_steamValidationEnabled = false;
				return;
			}
			if (GetValidationMode() != ValidationMode.Steam)
			{
				_steamValidationEnabled = false;
				return;
			}
			try
			{
				_lobbyDataCallback = Callback<LobbyDataUpdate_t>.Create((DispatchDelegate<LobbyDataUpdate_t>)OnLobbyDataUpdated);
				_steamValidationEnabled = true;
			}
			catch (Exception ex)
			{
				_steamValidationEnabled = false;
				Log.LogWarning((object)("Steam lobby validation disabled: " + ex.Message));
			}
		}

		private void ApplyHarmonyPatches()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (_harmony != null)
			{
				return;
			}
			try
			{
				_harmony = new Harmony("com.github.manghomagnet");
				Type type = AccessTools.TypeByName("SteamLobbyHandler");
				if (type == null)
				{
					Log.LogWarning((object)"Failed to find SteamLobbyHandler type for popup suppression.");
					return;
				}
				MethodInfo methodInfo = AccessTools.Method(type, "OnLobbyDataUpdate", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Log.LogWarning((object)"Failed to find SteamLobbyHandler.OnLobbyDataUpdate for popup suppression.");
					return;
				}
				HarmonyMethod val = new HarmonyMethod(typeof(Plugin), "SteamLobbyHandler_OnLobbyDataUpdate_Prefix", (Type[])null);
				_harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to apply Harmony patches: " + ex.Message));
			}
		}

		private static void SteamLobbyHandler_OnLobbyDataUpdate_Prefix(object __instance, ref LobbyDataUpdate_t param)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Instance;
			if (!((Object)(object)instance == (Object)null) && instance.ShouldSuppressLobbyPopup(__instance, param))
			{
				param.m_bSuccess = 1;
			}
		}

		private bool ShouldSuppressLobbyPopup(object handler, LobbyDataUpdate_t param)
		{
			//IL_0027: 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)
			if (!_suppressLobbyPopups.Value)
			{
				return false;
			}
			if (!_validateLobbies.Value || GetValidationMode() != ValidationMode.Steam)
			{
				return false;
			}
			if (param.m_bSuccess == 1)
			{
				return false;
			}
			if (handler == null)
			{
				return false;
			}
			return TryIsGameLobbyRequestActive(handler, param) == false;
		}

		private static bool? TryIsGameLobbyRequestActive(object handler, LobbyDataUpdate_t param)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(handler.GetType(), "m_currentlyFetchingGameVersion");
				if (fieldInfo == null)
				{
					return null;
				}
				object value = fieldInfo.GetValue(handler);
				if (value == null)
				{
					return null;
				}
				Type type = value.GetType();
				PropertyInfo property = type.GetProperty("IsSome", BindingFlags.Instance | BindingFlags.Public);
				if (property == null)
				{
					return null;
				}
				object value2 = property.GetValue(value);
				if (!(value2 is bool))
				{
					return null;
				}
				if (!(bool)value2)
				{
					return false;
				}
				PropertyInfo property2 = type.GetProperty("Value", BindingFlags.Instance | BindingFlags.Public);
				if (property2 == null)
				{
					return true;
				}
				object value3 = property2.GetValue(value);
				if (value3 is CSteamID val)
				{
					return val.m_SteamID == param.m_ulSteamIDLobby;
				}
				FieldInfo fieldInfo2 = value3?.GetType().GetField("m_SteamID", BindingFlags.Instance | BindingFlags.Public);
				if (fieldInfo2 != null && value3 != null && fieldInfo2.GetValue(value3) is ulong num)
				{
					return num == param.m_ulSteamIDLobby;
				}
				return true;
			}
			catch
			{
				return null;
			}
		}

		private static HttpClient CreateHttpClient(string userAgent)
		{
			HttpClientHandler handler = new HttpClientHandler
			{
				AutomaticDecompression = (DecompressionMethods.GZip | DecompressionMethods.Deflate)
			};
			HttpClient httpClient = new HttpClient(handler)
			{
				Timeout = TimeSpan.FromSeconds(10.0)
			};
			if (!string.IsNullOrWhiteSpace(userAgent))
			{
				httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
			}
			httpClient.DefaultRequestHeaders.Accept.ParseAdd("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
			return httpClient;
		}

		private async Task<string?> FetchStringAsync(string url, CancellationToken token, string context)
		{
			if (_http == null)
			{
				return null;
			}
			try
			{
				using HttpResponseMessage response = await _http.GetAsync(url, token);
				if (!response.IsSuccessStatusCode)
				{
					Log.LogWarning((object)$"Failed to fetch {context}: {url} (status {(int)response.StatusCode} {response.ReasonPhrase})");
					return null;
				}
				return await response.Content.ReadAsStringAsync();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to fetch " + context + ": " + url + " (" + ex.Message + ")"));
				return null;
			}
		}

		private async Task PollLoopAsync(CancellationToken token)
		{
			while (!token.IsCancellationRequested)
			{
				try
				{
					if (_enabled.Value && !_autoPollingPaused)
					{
						await PollOnceAsync(token);
					}
				}
				catch (OperationCanceledException)
				{
				}
				catch (Exception arg)
				{
					Log.LogWarning((object)$"Poll loop error: {arg}");
				}
				int num = Math.Max(_pollIntervalSeconds.Value, 1);
				try
				{
					await Task.Delay(TimeSpan.FromSeconds(num), token);
				}
				catch (OperationCanceledException)
				{
				}
			}
		}

		private void RequestManualPoll()
		{
			if (_cts != null && !_cts.IsCancellationRequested)
			{
				Task.Run(() => PollOnceAsync(_cts.Token));
			}
		}

		private async Task PollOnceAsync(CancellationToken token)
		{
			await _pollGate.WaitAsync(token);
			try
			{
				if (_http == null)
				{
					return;
				}
				string listUrl = (_galleryListUrl.Value ?? string.Empty).Trim();
				if (listUrl.Length == 0)
				{
					return;
				}
				string text = await FetchStringAsync(listUrl, token, "list page");
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				_lastPollUtc = DateTime.UtcNow;
				string subjectKeyword = (_subjectKeyword.Value ?? string.Empty).Trim();
				int maxPosts = Math.Max(_maxPostsPerPoll.Value, 50);
				ListParseDiagnostics diagnostics;
				List<PostInfo> list = ExtractPostInfos(text, subjectKeyword, maxPosts, out diagnostics);
				if (list.Count == 0)
				{
					if (!_loggedListEmpty)
					{
						LogListDiagnostics(diagnostics, listUrl);
						_loggedListEmpty = true;
					}
					return;
				}
				_loggedListEmpty = false;
				int scannedPosts = 0;
				int foundLinks = 0;
				foreach (PostInfo postInfo in list)
				{
					if (token.IsCancellationRequested)
					{
						return;
					}
					bool flag = _seenPostUrls.Add(postInfo.Url);
					bool flag2 = flag;
					if (!flag && _postInfoByUrl.TryGetValue(postInfo.Url, out PostInfo value) && HasListMetadataChanged(value, postInfo))
					{
						flag2 = true;
					}
					_postInfoByUrl[postInfo.Url] = postInfo;
					if (!flag2 || (!flag && ShouldThrottlePostFetch(postInfo.Url)))
					{
						continue;
					}
					string text2 = await FetchStringAsync(postInfo.Url, token, "post");
					if (string.IsNullOrWhiteSpace(text2))
					{
						continue;
					}
					scannedPosts++;
					string text3 = ExtractExactPostDate(text2);
					PostInfo postInfo2 = (string.IsNullOrWhiteSpace(text3) ? postInfo : postInfo.WithDate(text3));
					TrackPostFetch(postInfo.Url);
					foreach (string item in ExtractSteamLinks(text2))
					{
						if (_logFoundLinks.Value)
						{
							Log.LogInfo((object)("Found lobby link: " + item + " (post: " + postInfo2.Url + ")"));
						}
						AddLobbyEntry(item, postInfo2);
						TryJoinLobby(item, force: false);
						foundLinks++;
					}
				}
				if (foundLinks == 0)
				{
					if (!_loggedNoLinks)
					{
						Log.LogWarning((object)$"No lobby links found this poll. ScannedPosts={scannedPosts}, Rows={diagnostics.RowCount}, SubjectMatches={diagnostics.SubjectMatchCount}, Title='{diagnostics.Title}'.");
						_loggedNoLinks = true;
					}
				}
				else
				{
					_loggedNoLinks = false;
				}
			}
			finally
			{
				SetNextPollUtc();
				_pollGate.Release();
			}
		}

		private bool ShouldThrottlePostFetch(string url)
		{
			if (string.IsNullOrWhiteSpace(url))
			{
				return false;
			}
			int num = Math.Max(_postRefetchCooldownSeconds.Value, 0);
			if (num <= 0)
			{
				return false;
			}
			if (_postLastFetchUtc.TryGetValue(url, out var value) && DateTime.UtcNow - value < TimeSpan.FromSeconds(num))
			{
				return true;
			}
			return false;
		}

		private void TrackPostFetch(string url)
		{
			if (!string.IsNullOrWhiteSpace(url))
			{
				_postLastFetchUtc[url] = DateTime.UtcNow;
			}
		}

		private List<PostInfo> ExtractPostInfos(string html, string subjectKeyword, int maxPosts, out ListParseDiagnostics diagnostics)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			diagnostics = new ListParseDiagnostics();
			if (string.IsNullOrWhiteSpace(html))
			{
				return new List<PostInfo>();
			}
			HtmlParser val = new HtmlParser();
			IHtmlDocument val2 = val.ParseDocument(html);
			diagnostics.Title = ((IDocument)val2).Title ?? string.Empty;
			IHtmlCollection<IElement> val3 = ((IParentNode)val2).QuerySelectorAll("tr.ub-content");
			diagnostics.RowCount = val3.Length;
			List<PostInfo> list = new List<PostInfo>();
			foreach (IElement item in (IEnumerable<IElement>)val3)
			{
				if (maxPosts <= 0)
				{
					break;
				}
				PostInfo postInfo = TryExtractPostInfo(item, subjectKeyword, diagnostics);
				if (postInfo != null)
				{
					list.Add(postInfo);
					maxPosts--;
				}
			}
			diagnostics.PostInfoCount = list.Count;
			return list;
		}

		private static PostInfo? TryExtractPostInfo(IElement row, string subjectKeyword, ListParseDiagnostics diagnostics)
		{
			if (!SubjectMatches(row, subjectKeyword))
			{
				return null;
			}
			diagnostics.SubjectMatchCount++;
			IElement val = ((IParentNode)row).QuerySelector("td.gall_tit a");
			if (val == null)
			{
				diagnostics.MissingTitleCount++;
				return null;
			}
			string attribute = val.GetAttribute("href");
			if (string.IsNullOrWhiteSpace(attribute))
			{
				diagnostics.MissingHrefCount++;
				return null;
			}
			if (!attribute.Contains("board/view", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			string text = CleanText(((INode)val).TextContent);
			int num = ExtractReplyCount(row);
			if (num > 0 && !text.Contains($"[{num}]", StringComparison.Ordinal))
			{
				text = $"{text} [{num}]";
			}
			string id = ExtractPostId(row);
			string author = ExtractAuthor(row);
			string date = ExtractPostDate(row);
			string views = ExtractViewCount(row);
			string url = NormalizeUrl(WebUtility.HtmlDecode(attribute));
			return new PostInfo(id, text, author, date, views, url);
		}

		private static bool SubjectMatches(IElement row, string subjectKeyword)
		{
			return true;
		}

		private static string ExtractPostId(IElement row)
		{
			string text = row.GetAttribute("data-no");
			if (string.IsNullOrWhiteSpace(text))
			{
				IElement obj = ((IParentNode)row).QuerySelector("td.gall_num");
				text = CleanText(((obj != null) ? ((INode)obj).TextContent : null) ?? string.Empty);
			}
			return text ?? string.Empty;
		}

		private static string ExtractAuthor(IElement row)
		{
			IElement obj = ((IParentNode)row).QuerySelector("td.gall_writer");
			return CleanText(((obj != null) ? ((INode)obj).TextContent : null) ?? string.Empty);
		}

		private static string ExtractPostDate(IElement row)
		{
			IElement val = ((IParentNode)row).QuerySelector("td.gall_date");
			if (val == null)
			{
				return string.Empty;
			}
			string full = val.GetAttribute("title") ?? string.Empty;
			string shortText = ((INode)val).TextContent ?? string.Empty;
			return FormatDate(full, shortText);
		}

		private static string ExtractExactPostDate(string html)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(html))
			{
				return string.Empty;
			}
			HtmlParser val = new HtmlParser();
			IHtmlDocument val2 = val.ParseDocument(html);
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)val2).QuerySelectorAll(".gall_date"))
			{
				string text = item.GetAttribute("title");
				if (string.IsNullOrWhiteSpace(text))
				{
					text = ((INode)item).TextContent;
				}
				string value = CleanText(text ?? string.Empty);
				if (!string.IsNullOrWhiteSpace(value))
				{
					if (TryParseExactDate(value, out var parsed))
					{
						return parsed.ToString("yyyy.MM.dd HH:mm:ss", CultureInfo.InvariantCulture);
					}
					string text2 = NormalizeExactDateText(value);
					if (!string.IsNullOrWhiteSpace(text2))
					{
						return text2;
					}
				}
			}
			return string.Empty;
		}

		private static string ExtractViewCount(IElement row)
		{
			IElement obj = ((IParentNode)row).QuerySelector("td.gall_count");
			string text = CleanText(((obj != null) ? ((INode)obj).TextContent : null) ?? string.Empty);
			if (string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			string text2 = Regex.Replace(text, "\\D", string.Empty);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			return text;
		}

		private static int ExtractReplyCount(IElement row)
		{
			IElement obj = ((IParentNode)row).QuerySelector("span.reply_num");
			return ParseIntFromText((obj != null) ? ((INode)obj).TextContent : null);
		}

		private static int ParseIntFromText(string? text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return 0;
			}
			Match match = Regex.Match(text, "\\d+");
			if (!match.Success || !int.TryParse(match.Value, out var result))
			{
				return 0;
			}
			return result;
		}

		private static string FormatDate(string full, string shortText)
		{
			string s = (full ?? string.Empty).Trim();
			if (DateTime.TryParseExact(s, new string[2] { "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm" }, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var result) || DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out result) || DateTime.TryParse(s, out result))
			{
				return result.ToString("MM-dd HH:mm");
			}
			return CleanText(shortText);
		}

		private static bool TryParseExactDate(string value, out DateTime parsed)
		{
			if (!DateTime.TryParseExact(value, new string[6] { "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm" }, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out parsed))
			{
				return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out parsed);
			}
			return true;
		}

		private static string NormalizeExactDateText(string value)
		{
			Match match = Regex.Match(value, "(?<date>\\d{4}[./-]\\d{2}[./-]\\d{2})\\s+(?<time>\\d{2}:\\d{2}(?::\\d{2})?)");
			if (!match.Success)
			{
				return value;
			}
			string text = match.Groups["date"].Value.Replace('-', '.').Replace('/', '.');
			string text2 = match.Groups["time"].Value;
			if (text2.Length == 5)
			{
				text2 += ":00";
			}
			return text + " " + text2;
		}

		private static bool HasListMetadataChanged(PostInfo previous, PostInfo current)
		{
			if (!string.Equals(previous.Title, current.Title, StringComparison.Ordinal))
			{
				return true;
			}
			if (!string.Equals(previous.Author, current.Author, StringComparison.Ordinal))
			{
				return true;
			}
			if (!string.Equals(previous.Date, current.Date, StringComparison.Ordinal))
			{
				return true;
			}
			if (!string.Equals(previous.Views, current.Views, StringComparison.Ordinal))
			{
				if (TryParseViewCount(previous.Views, out var count) && TryParseViewCount(current.Views, out var count2))
				{
					return count2 - count >= 2;
				}
				return true;
			}
			return false;
		}

		private ValidationMode GetValidationMode()
		{
			string value = (_validationMode.Value ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(value))
			{
				return ValidationMode.FormatOnly;
			}
			if (Enum.TryParse<ValidationMode>(value, ignoreCase: true, out var result))
			{
				return result;
			}
			return ValidationMode.FormatOnly;
		}

		private static string NormalizeUrl(string href)
		{
			if (href.StartsWith("http", StringComparison.OrdinalIgnoreCase))
			{
				return href;
			}
			if (href.StartsWith("//", StringComparison.OrdinalIgnoreCase))
			{
				return "https:" + href;
			}
			if (href.StartsWith("/", StringComparison.OrdinalIgnoreCase))
			{
				return "https://gall.dcinside.com" + href;
			}
			return "https://gall.dcinside.com/" + href;
		}

		private static string CleanText(string html)
		{
			if (string.IsNullOrWhiteSpace(html))
			{
				return string.Empty;
			}
			string value = TagRegex.Replace(html, string.Empty);
			return WebUtility.HtmlDecode(value).Trim();
		}

		private static Color GetDateHighlightColor(string? dateText, Color baseColor)
		{
			//IL_0008: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(dateText))
			{
				return baseColor;
			}
			if (!TryParseExactDate(dateText, out var parsed))
			{
				return baseColor;
			}
			TimeSpan timeSpan = DateTime.Now - parsed;
			if (timeSpan < TimeSpan.Zero)
			{
				timeSpan = TimeSpan.Zero;
			}
			if (timeSpan <= TimeSpan.FromMinutes(10.0))
			{
				return new Color(0.12f, 0.7f, 0.18f);
			}
			if (timeSpan <= TimeSpan.FromHours(1.0))
			{
				return new Color(0.22f, 0.62f, 0.2f);
			}
			if (timeSpan <= TimeSpan.FromHours(3.0))
			{
				return new Color(0.92f, 0.78f, 0.22f);
			}
			if (timeSpan <= TimeSpan.FromHours(12.0))
			{
				return new Color(0.95f, 0.55f, 0.15f);
			}
			if (timeSpan <= TimeSpan.FromHours(24.0))
			{
				return new Color(0.6f, 0.6f, 0.6f);
			}
			return baseColor;
		}

		private string BuildLinkInfoText(LobbyEntryView entry)
		{
			string statusLabel = GetStatusLabel(entry);
			string membersLabel = GetMembersLabel(entry);
			if (string.IsNullOrWhiteSpace(membersLabel))
			{
				return statusLabel;
			}
			return statusLabel + " | " + membersLabel;
		}

		private string BuildJoinButtonLabel(LobbyEntryView entry)
		{
			bool flag = entry.MemberCount >= 0 && entry.MemberLimit > 0;
			if (flag && entry.MemberCount >= entry.MemberLimit)
			{
				return $"Join (Full | Members {entry.MemberCount}/{entry.MemberLimit})";
			}
			return entry.Status switch
			{
				LobbyCheckStatus.Invalid => "Join (Invalid)", 
				LobbyCheckStatus.Timeout => "Join (Timeout)", 
				LobbyCheckStatus.Full => flag ? $"Join (Full | Members {entry.MemberCount}/{entry.MemberLimit})" : "Join (Full)", 
				LobbyCheckStatus.Valid => flag ? $"Join (Members {entry.MemberCount}/{entry.MemberLimit})" : "Join (Valid)", 
				LobbyCheckStatus.Checking => "Join (Checking)", 
				LobbyCheckStatus.SteamUnavailable => "Join (Steam offline)", 
				_ => "Join", 
			};
		}

		private GUIStyle GetJoinButtonStyle(LobbyEntryView entry)
		{
			GUIStyle val = _joinButtonStyle ?? _buttonStyle ?? GUI.skin.button;
			bool flag = entry.MemberCount >= 0 && entry.MemberLimit > 0 && entry.MemberCount >= entry.MemberLimit;
			if (entry.Status == LobbyCheckStatus.Invalid)
			{
				return _joinButtonInvalidStyle ?? val;
			}
			if (entry.Status == LobbyCheckStatus.Timeout)
			{
				return _joinButtonTimeoutStyle ?? val;
			}
			if (flag || entry.Status == LobbyCheckStatus.Full)
			{
				return _joinButtonFullStyle ?? val;
			}
			if (entry.Status == LobbyCheckStatus.Valid)
			{
				return _joinButtonValidStyle ?? val;
			}
			return val;
		}

		private static GUIStyle CreateJoinStateStyle(GUIStyle baseStyle, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000d: 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_0025: 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_003d: 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_0055: 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)
			GUIStyle val = new GUIStyle(baseStyle);
			val.normal.textColor = color;
			val.hover.textColor = color;
			val.active.textColor = color;
			val.focused.textColor = color;
			val.onNormal.textColor = color;
			val.onHover.textColor = color;
			val.onActive.textColor = color;
			val.onFocused.textColor = color;
			return val;
		}

		private string GetStatusLabel(LobbyEntryView entry)
		{
			return entry.Status switch
			{
				LobbyCheckStatus.Unknown => "Not checked", 
				LobbyCheckStatus.Checking => "Checking", 
				LobbyCheckStatus.Timeout => "Timeout", 
				LobbyCheckStatus.Valid => (GetValidationMode() == ValidationMode.FormatOnly) ? "Valid (format)" : "Valid", 
				LobbyCheckStatus.Full => "Full", 
				LobbyCheckStatus.Invalid => "Invalid", 
				LobbyCheckStatus.SteamUnavailable => "Steam unavailable", 
				_ => "Unknown", 
			};
		}

		private static string GetMembersLabel(LobbyEntryView entry)
		{
			if (entry.MemberLimit > 0 && entry.MemberCount >= 0)
			{
				return $"Members {entry.MemberCount}/{entry.MemberLimit}";
			}
			if (entry.MemberCount >= 0)
			{
				return $"Members {entry.MemberCount}";
			}
			return string.Empty;
		}

		private static Texture2D CreateSolidTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			val.Apply();
			return val;
		}

		private void LogListDiagnostics(ListParseDiagnostics diagnostics, string listUrl)
		{
			Log.LogWarning((object)$"List parse returned 0 posts. Rows={diagnostics.RowCount}, SubjectMatches={diagnostics.SubjectMatchCount}, MissingTitle={diagnostics.MissingTitleCount}, MissingHref={diagnostics.MissingHrefCount}, Title='{diagnostics.Title}', Url={listUrl}");
		}

		[IteratorStateMachine(typeof(<ExtractSteamLinks>d__160))]
		private IEnumerable<string> ExtractSteamLinks(string html)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ExtractSteamLinks>d__160(-2)
			{
				<>3__html = html
			};
		}

		private static bool TryParseLobbyLink(string link, out uint appId, out ulong lobbyId, out ulong hostId)
		{
			appId = 0u;
			lobbyId = 0uL;
			hostId = 0uL;
			Match match = SteamLinkParseRegex.Match(link);
			if (!match.Success)
			{
				return false;
			}
			if (uint.TryParse(match.Groups["app"].Value, out appId) && ulong.TryParse(match.Groups["lobby"].Value, out lobbyId))
			{
				return ulong.TryParse(match.Groups["host"].Value, out hostId);
			}
			return false;
		}

		private void OnLobbyDataUpdated(LobbyDataUpdate_t callback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			ulong ulSteamIDLobby = callback.m_ulSteamIDLobby;
			LobbyEntry value;
			lock (_lobbyLock)
			{
				if (!_lobbyById.TryGetValue(ulSteamIDLobby, out value))
				{
					return;
				}
				value.IsCheckPending = false;
				value.CheckStartedUtc = DateTime.MinValue;
			}
			if (callback.m_bSuccess == 0)
			{
				lock (_lobbyLock)
				{
					value.Status = LobbyCheckStatus.Invalid;
					value.MemberCount = -1;
					value.MemberLimit = -1;
				}
			}
			else
			{
				try
				{
					CSteamID val = default(CSteamID);
					((CSteamID)(ref val))..ctor(ulSteamIDLobby);
					int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
					int lobbyMemberLimit = SteamMatchmaking.GetLobbyMemberLimit(val);
					LobbyCheckStatus lobbyCheckStatus = LobbyCheckStatus.Valid;
					if (lobbyMemberLimit > 0 && numLobbyMembers >= lobbyMemberLimit)
					{
						lobbyCheckStatus = LobbyCheckStatus.Full;
					}
					lock (_lobbyLock)
					{
						value.Status = lobbyCheckStatus;
						value.MemberCount = numLobbyMembers;
						value.MemberLimit = lobbyMemberLimit;
					}
					if (lobbyCheckStatus == LobbyCheckStatus.Valid)
					{
						TryJoinLobby(value.Link, force: false);
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Steam lobby validation error: " + ex.Message));
					lock (_lobbyLock)
					{
						value.Status = LobbyCheckStatus.SteamUnavailable;
						value.MemberCount = -1;
						value.MemberLimit = -1;
					}
				}
			}
			Interlocked.Increment(ref _lobbyVersion);
		}

		private void ProcessLobbyChecks()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			while (num < 2)
			{
				ulong num2;
				lock (_pendingLobbyLock)
				{
					if (_pendingLobbyChecks.Count == 0)
					{
						break;
					}
					num2 = _pendingLobbyChecks.Dequeue();
				}
				LobbyEntry value;
				lock (_lobbyLock)
				{
					if (!_lobbyById.TryGetValue(num2, out value) || !value.IsCheckPending)
					{
						continue;
					}
					value.CheckStartedUtc = DateTime.UtcNow;
					goto IL_0091;
				}
				IL_0091:
				bool flag = false;
				try
				{
					flag = SteamMatchmaking.RequestLobbyData(new CSteamID(num2));
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Steam lobby validation failed: " + ex.Message));
				}
				if (!flag)
				{
					lock (_lobbyLock)
					{
						if (_lobbyById.TryGetValue(num2, out value))
						{
							value.IsCheckPending = false;
							value.CheckStartedUtc = DateTime.MinValue;
							value.Status = LobbyCheckStatus.SteamUnavailable;
						}
					}
					Interlocked.Increment(ref _lobbyVersion);
				}
				num++;
			}
		}

		private void UpdateCheckTimeouts()
		{
			DateTime utcNow = DateTime.UtcNow;
			bool flag = false;
			lock (_lobbyLock)
			{
				foreach (LobbyEntry lobbyEntry in _lobbyEntries)
				{
					if (lobbyEntry.IsCheckPending && !(lobbyEntry.CheckStartedUtc == DateTime.MinValue) && !(utcNow - lobbyEntry.CheckStartedUtc < TimeSpan.FromSeconds(2.0)))
					{
						lobbyEntry.IsCheckPending = false;
						lobbyEntry.CheckStartedUtc = DateTime.MinValue;
						lobbyEntry.Status = LobbyCheckStatus.Timeout;
						lobbyEntry.MemberCount = -1;
						lobbyEntry.MemberLimit = -1;
						flag = true;
					}
				}
			}
			if (flag)
			{
				Interlocked.Increment(ref _lobbyVersion);
			}
		}

		private void AddLobbyEntry(string link, PostInfo postInfo)
		{
			if (string.IsNullOrWhiteSpace(link))
			{
				return;
			}
			bool flag = false;
			ulong num = 0uL;
			lock (_lobbyLock)
			{
				if (!_lobbyByLink.TryGetValue(link, out LobbyEntry value))
				{
					value = new LobbyEntry(link);
					_lobbyByLink[link] = value;
					_lobbyEntries.Add(value);
				}
				value.AddOrUpdateSource(postInfo);
				value.Touch();
				TrimLobbyEntries();
				if (!value.HasLobbyId)
				{
					if (TryParseLobbyLink(link, out var appId, out var lobbyId, out var hostId))
					{
						value.SetLobbyInfo(appId, lobbyId, hostId);
						_lobbyById[lobbyId] = value;
					}
					else
					{
						value.Status = LobbyCheckStatus.Invalid;
						value.IsCheckPending = false;
						value.CheckStartedUtc = DateTime.MinValue;
					}
				}
				if (value.HasLobbyId)
				{
					uint num2 = (uint)Math.Max(_expectedAppId.Value, 0);
					if (num2 != 0 && value.AppId != num2)
					{
						value.Status = LobbyCheckStatus.Invalid;
						value.MemberCount = -1;
						value.MemberLimit = -1;
						value.IsCheckPending = false;
						value.CheckStartedUtc = DateTime.MinValue;
					}
					else
					{
						ValidationMode validationMode = GetValidationMode();
						if (_validateLobbies.Value)
						{
							switch (validationMode)
							{
							case ValidationMode.None:
								break;
							case ValidationMode.FormatOnly:
								value.Status = LobbyCheckStatus.Valid;
								value.MemberCount = -1;
								value.MemberLimit = -1;
								value.IsCheckPending = false;
								value.CheckStartedUtc = DateTime.MinValue;
								goto end_IL_0018;
							default:
								if (_steamValidationEnabled && !value.IsCheckPending)
								{
									int num3 = Math.Max(_validationIntervalSeconds.Value, 5);
									if (value.LastCheckUtc == DateTime.MinValue || DateTime.UtcNow - value.LastCheckUtc >= TimeSpan.FromSeconds(num3))
									{
										value.LastCheckUtc = DateTime.UtcNow;
										value.IsCheckPending = true;
										value.Status = LobbyCheckStatus.Checking;
										value.MemberCount = -1;
										value.MemberLimit = -1;
										value.CheckStartedUtc = DateTime.UtcNow;
										flag = true;
										num = value.LobbyId;
									}
								}
								else if (_steamValidationEnabled)
								{
									value.Status = LobbyCheckStatus.Checking;
									value.MemberCount = -1;
									value.MemberLimit = -1;
								}
								else
								{
									value.Status = LobbyCheckStatus.SteamUnavailable;
									value.MemberCount = -1;
									value.MemberLimit = -1;
									value.IsCheckPending = false;
									value.CheckStartedUtc = DateTime.MinValue;
								}
								goto end_IL_0018;
							}
						}
						value.Status = LobbyCheckStatus.Unknown;
						value.MemberCount = -1;
						value.MemberLimit = -1;
						value.IsCheckPending = false;
						value.CheckStartedUtc = DateTime.MinValue;
					}
				}
				end_IL_0018:;
			}
			if (flag && num != 0L)
			{
				lock (_pendingLobbyLock)
				{
					_pendingLobbyChecks.Enqueue(num);
				}
			}
			Interlocked.Increment(ref _lobbyVersion);
		}

		private void TrimLobbyEntries()
		{
			int num = Math.Max(_maxLobbyEntries.Value, 10);
			while (_lobbyEntries.Count > num)
			{
				LobbyEntry lobbyEntry = _lobbyEntries.OrderBy((LobbyEntry e) => e.FirstSeenUtc).First();
				_lobbyEntries.Remove(lobbyEntry);
				_lobbyByLink.Remove(lobbyEntry.Link);
			}
		}

		private List<LobbyEntryView> GetLobbySnapshot()
		{
			lock (_lobbyLock)
			{
				return (from @group in _lobbyEntries.Select(delegate(LobbyEntry entry)
					{
						PostSource source = entry.Sources.OrderByDescending((PostSource item) => item.AddedUtc).FirstOrDefault();
						long sortPostId = entry.Sources.Select((PostSource item) => ParsePostId(item.Id)).DefaultIfEmpty(0L).Max();
						return new
						{
							Entry = entry,
							Source = source,
							SortPostId = sortPostId
						};
					}).GroupBy(item => (!string.IsNullOrWhiteSpace(item.Source?.Id)) ? item.Source.Id : item.Entry.Link, StringComparer.OrdinalIgnoreCase)
					select (from item in @group
						orderby GetStatusSortRank(item.Entry.Status) descending, item.Entry.LastSeenUtc descending
						select item).First() into item
					orderby item.SortPostId descending, item.Entry.LastSeenUtc descending
					select new LobbyEntryView
					{
						Link = item.Entry.Link,
						SourceCount = item.Entry.Sources.Count,
						LastSeenUtc = item.Entry.LastSeenUtc,
						PostUrl = (item.Source?.Url ?? string.Empty),
						PostId = (item.Source?.Id ?? string.Empty),
						PostTitle = (item.Source?.Title ?? string.Empty),
						Author = (item.Source?.Author ?? string.Empty),
						PostDate = (item.Source?.Date ?? string.Empty),
						Views = (item.Source?.Views ?? string.Empty),
						MemberCount = item.Entry.MemberCount,
						MemberLimit = item.Entry.MemberLimit,
						Status = item.Entry.Status
					}).ToList();
			}
		}

		private static int GetStatusSortRank(LobbyCheckStatus status)
		{
			return status switch
			{
				LobbyCheckStatus.Valid => 5, 
				LobbyCheckStatus.Full => 4, 
				LobbyCheckStatus.Checking => 3, 
				LobbyCheckStatus.Unknown => 2, 
				LobbyCheckStatus.Timeout => 1, 
				LobbyCheckStatus.SteamUnavailable => 1, 
				LobbyCheckStatus.Invalid => 0, 
				_ => 0, 
			};
		}

		private static long ParsePostId(string id)
		{
			if (long.TryParse(id, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return 0L;
		}

		private static bool TryParseViewCount(string value, out int count)
		{
			count = 0;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string text = new string(value.Where(char.IsDigit).ToArray());
			if (text.Length == 0)
			{
				return false;
			}
			return int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out count);
		}

		private void TryJoinLobby(string link, bool force)
		{
			if (!force && !_autoJoin.Value)
			{
				return;
			}
			int num = Math.Max(_joinCooldownSeconds.Value, 0);
			if (!force && num > 0 && DateTime.UtcNow - _lastJoinUtc < TimeSpan.FromSeconds(num))
			{
				return;
			}
			if (!force)
			{
				if (!TryMarkAutoJoin(link))
				{
					return;
				}
			}
			else
			{
				MarkAutoJoinAttempted(link);
			}
			try
			{
				ProcessStartInfo startInfo = new ProcessStartInfo(link)
				{
					UseShellExecute = true
				};
				Process.Start(startInfo);
				_lastJoinUtc = DateTime.UtcNow;
				Log.LogInfo((object)("Joining lobby: " + link));
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to open lobby link: " + ex.Message));
			}
		}

		private bool TryMarkAutoJoin(string link)
		{
			if (string.IsNullOrWhiteSpace(link))
			{
				return false;
			}
			lock (_lobbyLock)
			{
				if (!_lobbyByLink.TryGetValue(link, out LobbyEntry value))
				{
					return false;
				}
				if (value.Status != LobbyCheckStatus.Valid)
				{
					return false;
				}
				if (value.AutoJoinAttempted)
				{
					return false;
				}
				value.AutoJoinAttempted = true;
				return true;
			}
		}

		private void MarkAutoJoinAttempted(string link)
		{
			if (string.IsNullOrWhiteSpace(link))
			{
				return;
			}
			lock (_lobbyLock)
			{
				if (_lobbyByLink.TryGetValue(link, out LobbyEntry value))
				{
					value.AutoJoinAttempted = true;
				}
			}
		}

		private void TrySetWindowBlockingInput(bool block)
		{
			try
			{
				Type type = Type.GetType("GUIManager, Assembly-CSharp");
				if (type == null)
				{
					return;
				}
				object obj = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj == null)
				{
					return;
				}
				object obj2 = null;
				FieldInfo field = type.GetField("windowBlockingInput", BindingFlags.Instance | BindingFlags.Public);
				obj2 = ((!(field != null)) ? type.GetProperty("windowBlockingInput", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) : field.GetValue(obj));
				bool flag = default(bool);
				int num;
				if (obj2 is bool)
				{
					flag = (bool)obj2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				if (block)
				{
					if (!flag2)
					{
						SetWindowBlocking(obj, type, value: true);
						_inputBlockedByUs = true;
					}
				}
				else if (_inputBlockedByUs)
				{
					SetWindowBlocking(obj, type, value: false);
					_inputBlockedByUs = false;
				}
			}
			catch
			{
			}
		}

		private static void SetWindowBlocking(object instance, Type type, bool value)
		{
			FieldInfo field = type.GetField("windowBlockingInput", BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				field.SetValue(instance, value);
			}
			else
			{
				type.GetProperty("windowBlockingInput", BindingFlags.Instance | BindingFlags.Public)?.SetValue(instance, value);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}