using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GroupRecipesWithPopups.Core;
using GroupRecipesWithPopups.Game;
using GroupRecipesWithPopups.Net;
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("555maggot666")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 555maggot666")]
[assembly: AssemblyDescription("Shares recipe, material, piece and crafting-station discoveries with every player in a Valheim world and shows the original unlock popups.")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+06394aaec1ffe4f68c5d1db7696aa7bede0559f9")]
[assembly: AssemblyProduct("GroupRecipes with Popups")]
[assembly: AssemblyTitle("GroupRecipesWithPopups")]
[assembly: AssemblyVersion("1.0.2.0")]
namespace GroupRecipesWithPopups
{
	internal sealed class ModSettings
	{
		public ConfigEntry<bool> ShowNotifications { get; }

		public ConfigEntry<bool> SyncItems { get; }

		public ConfigEntry<bool> SyncRecipesAndPieces { get; }

		public ConfigEntry<bool> SyncCraftingStations { get; }

		public ConfigEntry<bool> EnablePopups { get; }

		public ConfigEntry<int> MaxPopupsOnJoin { get; }

		public ConfigEntry<float> PopupIntervalSeconds { get; }

		public ModSettings(ConfigFile config)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			ShowNotifications = config.Bind<bool>("General", "ShowNotifications", true, "Show the summary line (for example '12 more unlocks were synchronised') when entries were applied without a popup. The original Valheim unlock popups are not affected by this setting.");
			SyncItems = config.Bind<bool>("Sync", "Items", true, "Share discovered materials and items. Applies to sending and receiving.");
			SyncRecipesAndPieces = config.Bind<bool>("Sync", "RecipesAndPieces", true, "Share learned recipes and build pieces. Applies to sending and receiving.");
			SyncCraftingStations = config.Bind<bool>("Sync", "CraftingStations", true, "Share crafting station levels (only ever raised, never lowered). Applies to sending and receiving.");
			EnablePopups = config.Bind<bool>("Display", "EnablePopups", true, "Show the original Valheim unlock popup (icon plus 'New material' / 'Recipe learned' ...) for every entry received from other players. When disabled, received entries are still applied, just silently.");
			MaxPopupsOnJoin = config.Bind<int>("Display", "MaxPopupsOnJoin", 25, new ConfigDescription("Maximum number of popups when a large batch arrives (joining a world, or another player uploading their whole knowledge). Further entries are applied silently, nothing is lost.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 500), Array.Empty<object>()));
			PopupIntervalSeconds = config.Bind<float>("Display", "PopupIntervalSeconds", 0.3f, new ConfigDescription("Delay in seconds between two applied entries, so the popups appear one after another.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
		}

		public bool IsKindEnabled(KnowledgeKind kind)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			switch (kind - 1)
			{
			case 0:
				return SyncItems.Value;
			case 1:
			case 2:
				return SyncRecipesAndPieces.Value;
			case 3:
				return SyncCraftingStations.Value;
			default:
				return false;
			}
		}
	}
	[BepInPlugin("555maggot666.GroupRecipesWithPopups", "GroupRecipes with Popups", "1.0.2")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "555maggot666.GroupRecipesWithPopups";

		public const string PluginName = "GroupRecipes with Popups";

		public const string PluginVersion = "1.0.2";

		private static readonly HashSet<string> WarnedKeys = new HashSet<string>(StringComparer.Ordinal);

		internal static ManualLogSource Log { get; private set; }

		internal static ModSettings Settings { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = new ModSettings(((BaseUnityPlugin)this).Config);
			((Component)this).gameObject.AddComponent<SyncDriver>();
			Log.LogInfo((object)"GroupRecipes with Popups 1.0.2 loaded.");
		}

		internal static void WarnOnce(string key, string message)
		{
			if (WarnedKeys.Add(key))
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)message);
				}
			}
		}
	}
	internal sealed class SyncDriver : MonoBehaviour
	{
		private const float TickIntervalSeconds = 1f;

		private const int StableTicksBeforeFirstSync = 3;

		private GameCatalog _catalog;

		private PlayerKnowledgeBridge _bridge;

		private VanillaUnlocker _unlocker;

		private ZRoutedRpc _rpc;

		private ZNet _znet;

		private Ledger _ledger;

		private SyncHost _host;

		private SyncClient _client;

		private bool _helloDone;

		private float _tickTimer;

		private int _playerTicks;

		private void Awake()
		{
			_catalog = new GameCatalog();
			_bridge = new PlayerKnowledgeBridge();
			_unlocker = new VanillaUnlocker(_catalog, _bridge);
		}

		private void Update()
		{
			try
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				ZNet instance2 = ZNet.instance;
				if (instance == null || (Object)(object)instance2 == (Object)null)
				{
					if (_rpc != null)
					{
						EndSession();
					}
					return;
				}
				if (instance != _rpc || instance2 != _znet)
				{
					BeginSession(instance, instance2);
				}
				_host?.EnsureOpen(instance2);
				float unscaledDeltaTime = Time.unscaledDeltaTime;
				_client?.Update(unscaledDeltaTime);
				_tickTimer += unscaledDeltaTime;
				if (_tickTimer >= 1f)
				{
					_tickTimer = 0f;
					SyncTick();
				}
			}
			catch (Exception ex)
			{
				Failed("update", ex);
			}
		}

		private void BeginSession(ZRoutedRpc rpc, ZNet znet)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			EndSession();
			_rpc = rpc;
			_znet = znet;
			_ledger = new Ledger();
			_host = (znet.IsServer() ? new SyncHost(_ledger) : null);
			_client = (znet.IsDedicated() ? null : new SyncClient(_ledger, _catalog, _bridge, _unlocker, Plugin.Settings, SendNew));
			_helloDone = false;
			_tickTimer = 0f;
			_playerTicks = 0;
			try
			{
				rpc.Register<ZPackage>("GRWP_Hello", (Action<long, ZPackage>)OnHello);
				rpc.Register<ZPackage>("GRWP_New", (Action<long, ZPackage>)OnNew);
				rpc.Register<ZPackage>("GRWP_CatchUp", (Action<long, ZPackage>)OnCatchUp);
			}
			catch (Exception ex)
			{
				Failed("rpc registration", ex);
			}
			Plugin.Log.LogInfo((object)("Sync session started (" + ((_host != null) ? "server role" : "client role") + ((_client == null) ? ", no local player" : string.Empty) + ")."));
		}

		private void EndSession()
		{
			_client?.Reset();
			_client = null;
			_host = null;
			_ledger = null;
			_rpc = null;
			_znet = null;
			_helloDone = false;
		}

		private void SyncTick()
		{
			Player localPlayer = Player.m_localPlayer;
			if (_client == null || (Object)(object)localPlayer == (Object)null)
			{
				_playerTicks = 0;
			}
			else
			{
				if (++_playerTicks < 3 || !_catalog.Refresh())
				{
					return;
				}
				if (!_helloDone)
				{
					_helloDone = true;
					if (_host != null)
					{
						_host.EnsureOpen(_znet);
						_client.Receive(new List<KnowledgeEntry>(_ledger.Entries), ReceiveMode.CatchUp, final: true, 0L);
					}
					else
					{
						_rpc.InvokeRoutedRPC("GRWP_Hello", new object[1] { SyncProtocol.Encode(new List<KnowledgeEntry>(), 0, 0, 2) });
					}
				}
				_client.Tick(localPlayer);
			}
		}

		private void SendNew(List<KnowledgeEntry> changed, bool bulk)
		{
			if (_host != null)
			{
				_host.EnsureOpen(_znet);
				_host.Persist(changed);
			}
			foreach (ZPackage item in SyncProtocol.EncodeChunks(changed, bulk))
			{
				_rpc.InvokeRoutedRPC(0L, "GRWP_New", new object[1] { item });
			}
		}

		private void OnHello(long sender, ZPackage package)
		{
			try
			{
				if (_host != null && _rpc != null && sender != ZNet.GetUID())
				{
					_host.EnsureOpen(_znet);
					_host.SendCatchUp(_rpc, sender);
				}
			}
			catch (Exception ex)
			{
				Failed("HELLO handler", ex);
			}
		}

		private void OnNew(long sender, ZPackage package)
		{
			HandleEntries(sender, package, isCatchUp: false);
		}

		private void OnCatchUp(long sender, ZPackage package)
		{
			HandleEntries(sender, package, isCatchUp: true);
		}

		private void HandleEntries(long sender, ZPackage package, bool isCatchUp)
		{
			string text = (isCatchUp ? "CATCHUP handler" : "NEW handler");
			try
			{
				if (_ledger == null || sender == ZNet.GetUID() || (isCatchUp && _host != null))
				{
					return;
				}
				if (!SyncProtocol.TryDecode(package, out var entries, out var flags, out var error))
				{
					Plugin.WarnOnce(text + "-decode-" + error, text + ": ignoring bad package from " + sender + " (" + error + ")");
				}
				else
				{
					List<KnowledgeEntry> list = _ledger.AddRange((IEnumerable<KnowledgeEntry>)entries);
					if (_host != null)
					{
						_host.EnsureOpen(_znet);
						_host.Persist(list);
					}
					ReceiveMode mode = (isCatchUp ? ReceiveMode.CatchUp : (((flags & 1) != 0) ? ReceiveMode.Bulk : ReceiveMode.Live));
					_client?.Receive(list, mode, (flags & 2) != 0, sender);
				}
			}
			catch (Exception ex)
			{
				Failed(text, ex);
			}
		}

		private static void Failed(string where, Exception ex)
		{
			Plugin.WarnOnce("failure-" + where + "-" + ex.GetType().Name + "-" + ex.Message, "GroupRecipes with Popups: " + where + " failed: " + ex.GetType().Name + ": " + ex.Message);
		}
	}
}
namespace GroupRecipesWithPopups.Net
{
	internal sealed class LedgerStore
	{
		private readonly LedgerFile _file;

		public string Path => _file.Path;

		public LedgerStore(string worldName, long worldUid)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string text = System.IO.Path.Combine(Paths.ConfigPath, "GroupRecipesWithPopups", GrwpPaths.LedgerFileName(worldName, worldUid));
			_file = new LedgerFile(text);
		}

		public void LoadInto(Ledger ledger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			try
			{
				Ledger val = new Ledger();
				LedgerParseResult val2 = _file.Load(val);
				foreach (string warning in val2.Warnings)
				{
					Plugin.Log.LogWarning((object)("Ledger file " + _file.Path + ": " + warning));
				}
				if (!val2.IsSupported)
				{
					Plugin.Log.LogWarning((object)("Ledger file " + _file.Path + " has an unsupported version; it is left untouched and not used for persistence."));
				}
				List<KnowledgeEntry> list = val.AddRange((IEnumerable<KnowledgeEntry>)ledger.Entries);
				ledger.AddRange((IEnumerable<KnowledgeEntry>)val.Entries);
				if (list.Count > 0)
				{
					Append(list);
				}
				Plugin.Log.LogInfo((object)("Ledger " + _file.Path + " loaded: " + ledger.Count + " entries."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not read ledger file " + _file.Path + ": " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		public void Append(IReadOnlyCollection<KnowledgeEntry> entries)
		{
			if (entries.Count == 0)
			{
				return;
			}
			try
			{
				_file.Append((IEnumerable<KnowledgeEntry>)entries);
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
			{
				Plugin.WarnOnce("ledger-write-" + ex.GetType().Name, "Could not write ledger file " + _file.Path + ": " + ex.GetType().Name + ": " + ex.Message);
			}
			catch (Exception ex2)
			{
				Plugin.WarnOnce("ledger-write-other", "Unexpected error while writing " + _file.Path + ": " + ex2.GetType().Name + ": " + ex2.Message);
			}
		}
	}
	internal enum ReceiveMode
	{
		Live,
		Bulk,
		CatchUp
	}
	internal sealed class SyncClient
	{
		private readonly struct Pending
		{
			public List<KnowledgeEntry> Entries { get; }

			public ReceiveMode Mode { get; }

			public bool Final { get; }

			public long Sender { get; }

			public Pending(List<KnowledgeEntry> entries, ReceiveMode mode, bool final, long sender)
			{
				Entries = entries;
				Mode = mode;
				Final = final;
				Sender = sender;
			}
		}

		private readonly Ledger _ledger;

		private readonly GameCatalog _catalog;

		private readonly PlayerKnowledgeBridge _bridge;

		private readonly VanillaUnlocker _unlocker;

		private readonly ModSettings _settings;

		private readonly Action<List<KnowledgeEntry>, bool> _send;

		private readonly KnowledgeSnapshot _snapshot = new KnowledgeSnapshot();

		private readonly List<Pending> _backlog = new List<Pending>();

		private readonly Dictionary<long, int> _popupBudgets = new Dictionary<long, int>();

		private PopupPump _pump;

		private double _pumpInterval;

		private bool _uploadedOnce;

		private int _hiddenTotal;

		private bool _noticeReady;

		public SyncClient(Ledger ledger, GameCatalog catalog, PlayerKnowledgeBridge bridge, VanillaUnlocker unlocker, ModSettings settings, Action<List<KnowledgeEntry>, bool> send)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			_ledger = ledger;
			_catalog = catalog;
			_bridge = bridge;
			_unlocker = unlocker;
			_settings = settings;
			_send = send;
			_pumpInterval = settings.PopupIntervalSeconds.Value;
			_pump = new PopupPump(_pumpInterval);
		}

		public void Tick(Player player)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !_catalog.Refresh())
			{
				return;
			}
			DrainBacklog();
			List<KnowledgeEntry> list = new List<KnowledgeEntry>();
			if (!_bridge.TryRead(player, _catalog, list))
			{
				Plugin.WarnOnce("read-knowledge", "Could not read the player's knowledge; nothing is sent.");
				return;
			}
			List<KnowledgeEntry> list2 = new List<KnowledgeEntry>();
			foreach (KnowledgeEntry item in _snapshot.Diff((IEnumerable<KnowledgeEntry>)list))
			{
				KnowledgeEntry current = item;
				if (_settings.IsKindEnabled(((KnowledgeEntry)(ref current)).Kind))
				{
					list2.Add(current);
				}
			}
			bool flag = !_uploadedOnce;
			_uploadedOnce = true;
			if (list2.Count != 0)
			{
				_snapshot.RecordRange((IEnumerable<KnowledgeEntry>)list2);
				List<KnowledgeEntry> list3 = _ledger.AddRange((IEnumerable<KnowledgeEntry>)list2);
				if (list3.Count > 0)
				{
					bool arg = flag || list3.Count > _settings.MaxPopupsOnJoin.Value;
					_send(list3, arg);
				}
			}
		}

		public void Receive(List<KnowledgeEntry> entries, ReceiveMode mode, bool final, long sender)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_backlog.Add(new Pending(entries, mode, final, sender));
				return;
			}
			List<KnowledgeEntry> list = new List<KnowledgeEntry>();
			foreach (KnowledgeEntry entry in entries)
			{
				KnowledgeEntry current = entry;
				_snapshot.Record(current);
				if (_settings.IsKindEnabled(((KnowledgeEntry)(ref current)).Kind) && !_bridge.IsKnown(localPlayer, current))
				{
					list.Add(current);
				}
			}
			int num = int.MaxValue;
			if (!_settings.EnablePopups.Value)
			{
				num = 0;
			}
			else if (mode != ReceiveMode.Live)
			{
				if (!_popupBudgets.TryGetValue(sender, out var value))
				{
					value = Math.Max(0, _settings.MaxPopupsOnJoin.Value);
				}
				num = value;
			}
			PopupPlan val = PopupPlanner.BuildPlan((IEnumerable<KnowledgeEntry>)list, num);
			if (mode != ReceiveMode.Live && _settings.EnablePopups.Value)
			{
				if (final)
				{
					_popupBudgets.Remove(sender);
				}
				else
				{
					_popupBudgets[sender] = Math.Max(0, num - val.PopupCount);
				}
			}
			_pump.Enqueue(val);
			_hiddenTotal += val.HiddenCount;
			if (final && _hiddenTotal > 0)
			{
				_noticeReady = true;
			}
		}

		public void Update(float deltaSeconds)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (_pump.IsEmpty && Math.Abs(_pumpInterval - (double)_settings.PopupIntervalSeconds.Value) > 1E-06)
			{
				_pumpInterval = _settings.PopupIntervalSeconds.Value;
				_pump = new PopupPump(_pumpInterval);
			}
			_pump.Tick((double)deltaSeconds);
			_unlocker.Tick(localPlayer);
			int num = 0;
			KnowledgeEntry entry = default(KnowledgeEntry);
			for (int i = 0; i < 500; i++)
			{
				if (!_pump.TryDequeueSilent(ref entry))
				{
					break;
				}
				if (_unlocker.Apply(localPlayer, entry, showPopup: false))
				{
					num++;
				}
			}
			bool showPopup = default(bool);
			if (_pump.TryDequeue(ref entry, ref showPopup) && _unlocker.Apply(localPlayer, entry, showPopup))
			{
				num++;
			}
			if (num > 0)
			{
				_unlocker.Refresh(localPlayer);
			}
			if (_noticeReady && _pump.IsEmpty)
			{
				ShowNotice(localPlayer);
			}
		}

		public void Reset()
		{
			_snapshot.Clear();
			_backlog.Clear();
			_popupBudgets.Clear();
			_pump.Clear();
			_unlocker.Reset();
			_uploadedOnce = false;
			_hiddenTotal = 0;
			_noticeReady = false;
		}

		private void DrainBacklog()
		{
			if (_backlog.Count == 0 || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			List<Pending> list = new List<Pending>(_backlog);
			_backlog.Clear();
			foreach (Pending item in list)
			{
				Receive(item.Entries, item.Mode, item.Final, item.Sender);
			}
		}

		private void ShowNotice(Player player)
		{
			int hiddenTotal = _hiddenTotal;
			_hiddenTotal = 0;
			_noticeReady = false;
			if (hiddenTotal > 0 && _settings.ShowNotifications.Value)
			{
				string text = ((hiddenTotal == 1) ? "unlock was" : "unlocks were");
				((Character)player).Message((MessageType)1, "GroupRecipes: " + hiddenTotal + " more " + text + " synchronised without popup", 0, (Sprite)null, false);
			}
		}
	}
	internal sealed class SyncHost
	{
		private readonly Ledger _ledger;

		private LedgerStore _store;

		public bool IsOpen => _store != null;

		public SyncHost(Ledger ledger)
		{
			_ledger = ledger;
		}

		public void EnsureOpen(ZNet znet)
		{
			if (_store == null && !((Object)(object)znet == (Object)null))
			{
				string worldName = znet.GetWorldName();
				if (!string.IsNullOrEmpty(worldName))
				{
					_store = new LedgerStore(worldName, znet.GetWorldUID());
					_store.LoadInto(_ledger);
				}
			}
		}

		public void Persist(IReadOnlyCollection<KnowledgeEntry> changed)
		{
			if (_store != null && changed.Count > 0)
			{
				_store.Append(changed);
			}
		}

		public void SendCatchUp(ZRoutedRpc rpc, long target)
		{
			foreach (ZPackage item in SyncProtocol.EncodeChunks(new List<KnowledgeEntry>(_ledger.Entries), bulk: false))
			{
				rpc.InvokeRoutedRPC(target, "GRWP_CatchUp", new object[1] { item });
			}
		}
	}
	internal static class SyncProtocol
	{
		public const string RpcHello = "GRWP_Hello";

		public const string RpcNew = "GRWP_New";

		public const string RpcCatchUp = "GRWP_CatchUp";

		public const byte Version = 1;

		public const byte FlagBulk = 1;

		public const byte FlagFinal = 2;

		public const int MaxEntriesPerPackage = 500;

		private const int MaxAcceptedCount = 100000;

		public static List<ZPackage> EncodeChunks(IReadOnlyList<KnowledgeEntry> entries, bool bulk)
		{
			List<ZPackage> list = new List<ZPackage>();
			int num = 0;
			do
			{
				int num2 = Math.Min(500, entries.Count - num);
				bool flag = num + num2 >= entries.Count;
				byte flags = (byte)((bulk ? 1u : 0u) | (uint)(flag ? 2 : 0));
				list.Add(Encode(entries, num, num2, flags));
				num += num2;
			}
			while (num < entries.Count);
			return list;
		}

		public static ZPackage Encode(IReadOnlyList<KnowledgeEntry> entries, int start, int count, byte flags)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write((byte)1);
			val.Write(flags);
			val.Write(count);
			for (int i = start; i < start + count; i++)
			{
				KnowledgeEntry val2 = entries[i];
				val.Write((byte)((KnowledgeEntry)(ref val2)).Kind);
				val.Write(((KnowledgeEntry)(ref val2)).Key);
				val.Write(((KnowledgeEntry)(ref val2)).Level);
			}
			return val;
		}

		public static bool TryDecode(ZPackage package, out List<KnowledgeEntry> entries, out byte flags, out string error)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			entries = new List<KnowledgeEntry>();
			flags = 0;
			error = null;
			if (package == null)
			{
				error = "package is null";
				return false;
			}
			try
			{
				byte b = package.ReadByte();
				if (b != 1)
				{
					error = "unsupported protocol version " + b;
					return false;
				}
				flags = package.ReadByte();
				int num = package.ReadInt();
				if (num < 0 || num > 100000)
				{
					error = "implausible entry count " + num;
					return false;
				}
				for (int i = 0; i < num; i++)
				{
					byte b2 = package.ReadByte();
					string text = package.ReadString();
					int num2 = package.ReadInt();
					if (b2 < 1 || b2 > 4 || string.IsNullOrEmpty(text))
					{
						error = "invalid entry #" + i;
						entries.Clear();
						return false;
					}
					entries.Add(new KnowledgeEntry((KnowledgeKind)b2, text, num2));
				}
				return true;
			}
			catch (Exception ex)
			{
				entries.Clear();
				error = "malformed package: " + ex.GetType().Name + ": " + ex.Message;
				return false;
			}
		}
	}
}
namespace GroupRecipesWithPopups.Game
{
	internal sealed class GameCatalog
	{
		private readonly Dictionary<string, Recipe> _recipes = new Dictionary<string, Recipe>(StringComparer.Ordinal);

		private readonly Dictionary<string, Piece> _pieces = new Dictionary<string, Piece>(StringComparer.Ordinal);

		private readonly Dictionary<string, ItemData> _items = new Dictionary<string, ItemData>(StringComparer.Ordinal);

		private readonly Dictionary<string, CraftingStation> _stations = new Dictionary<string, CraftingStation>(StringComparer.Ordinal);

		private ObjectDB _db;

		private int _dbItemCount = -1;

		private int _dbRecipeCount = -1;

		private ZNetScene _scene;

		private int _sceneCount = -1;

		private float _lastForcedRebuild = float.NegativeInfinity;

		public bool TryRebuildAfterMiss()
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || instance.m_items == null || instance.m_recipes == null || instance.m_items.Count == 0)
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - _lastForcedRebuild < 2f)
			{
				return false;
			}
			_lastForcedRebuild = realtimeSinceStartup;
			RebuildObjectTables(instance);
			return true;
		}

		public bool Refresh()
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || instance.m_items == null || instance.m_recipes == null || instance.m_items.Count == 0 || instance.m_recipes.Count == 0)
			{
				return false;
			}
			if (instance != _db || instance.m_items.Count != _dbItemCount || instance.m_recipes.Count != _dbRecipeCount)
			{
				RebuildObjectTables(instance);
			}
			ZNetScene instance2 = ZNetScene.instance;
			if ((Object)(object)instance2 != (Object)null && instance2.m_prefabs != null && (instance2 != _scene || instance2.m_prefabs.Count != _sceneCount))
			{
				RebuildStationTable(instance2);
			}
			return true;
		}

		public bool TryGetRecipe(string key, out Recipe recipe)
		{
			if (_recipes.TryGetValue(key, out recipe))
			{
				return (Object)(object)recipe != (Object)null;
			}
			return false;
		}

		public bool TryGetPiece(string key, out Piece piece)
		{
			if (_pieces.TryGetValue(key, out piece))
			{
				return (Object)(object)piece != (Object)null;
			}
			return false;
		}

		public bool TryGetItem(string key, out ItemData item)
		{
			if (_items.TryGetValue(key, out item))
			{
				return item != null;
			}
			return false;
		}

		public bool TryGetStation(string key, out CraftingStation station)
		{
			if (_stations.TryGetValue(key, out station))
			{
				return (Object)(object)station != (Object)null;
			}
			return false;
		}

		public Sprite GetStationIcon(string key)
		{
			if (!TryGetStation(key, out var station))
			{
				return null;
			}
			return station.m_icon;
		}

		public KnowledgeKind ClassifyKnownRecipeKey(string key)
		{
			if (!_recipes.ContainsKey(key))
			{
				if (_pieces.ContainsKey(key))
				{
					return (KnowledgeKind)3;
				}
				return (KnowledgeKind)2;
			}
			return (KnowledgeKind)2;
		}

		private void RebuildObjectTables(ObjectDB db)
		{
			_items.Clear();
			_recipes.Clear();
			_pieces.Clear();
			foreach (GameObject item in db.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null) && component.m_itemData != null && component.m_itemData.m_shared != null)
				{
					string name = component.m_itemData.m_shared.m_name;
					if (!string.IsNullOrEmpty(name))
					{
						_items.TryAdd(name, component.m_itemData);
					}
				}
			}
			foreach (Recipe recipe in db.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null) && !((Object)(object)recipe.m_item == (Object)null) && recipe.m_item.m_itemData != null && recipe.m_item.m_itemData.m_shared != null)
				{
					string name2 = recipe.m_item.m_itemData.m_shared.m_name;
					if (!string.IsNullOrEmpty(name2))
					{
						_recipes.TryAdd(name2, recipe);
					}
				}
			}
			List<Piece> allBuildPieces = db.GetAllBuildPieces(true);
			if (allBuildPieces != null)
			{
				foreach (Piece item2 in allBuildPieces)
				{
					if ((Object)(object)item2 != (Object)null && !string.IsNullOrEmpty(item2.m_name))
					{
						_pieces.TryAdd(item2.m_name, item2);
					}
				}
			}
			_db = db;
			_dbItemCount = db.m_items.Count;
			_dbRecipeCount = db.m_recipes.Count;
		}

		private void RebuildStationTable(ZNetScene scene)
		{
			_stations.Clear();
			foreach (GameObject prefab in scene.m_prefabs)
			{
				if (!((Object)(object)prefab == (Object)null))
				{
					CraftingStation component = prefab.GetComponent<CraftingStation>();
					if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.m_name))
					{
						_stations.TryAdd(component.m_name, component);
					}
				}
			}
			_scene = scene;
			_sceneCount = scene.m_prefabs.Count;
		}
	}
	internal sealed class PlayerKnowledgeBridge
	{
		private const BindingFlags InstanceNonPublic = BindingFlags.Instance | BindingFlags.NonPublic;

		private readonly FieldInfo _knownMaterial;

		private readonly FieldInfo _knownRecipes;

		private readonly FieldInfo _knownStations;

		private readonly MethodInfo _addKnownRecipe;

		private readonly MethodInfo _addKnownPiece;

		private readonly MethodInfo _updateKnownRecipesList;

		private readonly MethodInfo _updateAvailablePiecesList;

		public bool CanAccessKnowledge
		{
			get
			{
				if (_knownMaterial != null && _knownRecipes != null)
				{
					return _knownStations != null;
				}
				return false;
			}
		}

		public bool HasAddKnownRecipe => _addKnownRecipe != null;

		public bool HasAddKnownPiece => _addKnownPiece != null;

		public PlayerKnowledgeBridge()
		{
			Type typeFromHandle = typeof(Player);
			_knownMaterial = FindField(typeFromHandle, "m_knownMaterial");
			_knownRecipes = FindField(typeFromHandle, "m_knownRecipes");
			_knownStations = FindField(typeFromHandle, "m_knownStations");
			_addKnownRecipe = FindMethod(typeFromHandle, "AddKnownRecipe", typeof(Recipe));
			_addKnownPiece = FindMethod(typeFromHandle, "AddKnownPiece", typeof(Piece));
			_updateKnownRecipesList = FindMethod(typeFromHandle, "UpdateKnownRecipesList");
			_updateAvailablePiecesList = FindMethod(typeFromHandle, "UpdateAvailablePiecesList");
		}

		public bool TryRead(Player player, GameCatalog catalog, List<KnowledgeEntry> sink)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !CanAccessKnowledge)
			{
				return false;
			}
			HashSet<string> hashSet = _knownMaterial.GetValue(player) as HashSet<string>;
			HashSet<string> hashSet2 = _knownRecipes.GetValue(player) as HashSet<string>;
			Dictionary<string, int> dictionary = _knownStations.GetValue(player) as Dictionary<string, int>;
			if (hashSet == null || hashSet2 == null || dictionary == null)
			{
				return false;
			}
			foreach (string item in hashSet)
			{
				if (!string.IsNullOrEmpty(item))
				{
					sink.Add(new KnowledgeEntry((KnowledgeKind)1, item, 0));
				}
			}
			foreach (string item2 in hashSet2)
			{
				if (!string.IsNullOrEmpty(item2))
				{
					sink.Add(new KnowledgeEntry(catalog.ClassifyKnownRecipeKey(item2), item2, 0));
				}
			}
			foreach (KeyValuePair<string, int> item3 in dictionary)
			{
				if (!string.IsNullOrEmpty(item3.Key))
				{
					sink.Add(new KnowledgeEntry((KnowledgeKind)4, item3.Key, item3.Value));
				}
			}
			return true;
		}

		public bool IsKnown(Player player, KnowledgeEntry entry)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected I4, but got Unknown
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			KnowledgeKind kind = ((KnowledgeEntry)(ref entry)).Kind;
			switch (kind - 1)
			{
			case 0:
				return player.IsMaterialKnown(((KnowledgeEntry)(ref entry)).Key);
			case 1:
			case 2:
				return player.IsRecipeKnown(((KnowledgeEntry)(ref entry)).Key);
			case 3:
			{
				if (TryGetStationLevel(player, ((KnowledgeEntry)(ref entry)).Key, out var level))
				{
					return level >= ((KnowledgeEntry)(ref entry)).Level;
				}
				return false;
			}
			default:
				return true;
			}
		}

		public bool TryGetStationLevel(Player player, string station, out int level)
		{
			level = 0;
			if (_knownStations?.GetValue(player) is Dictionary<string, int> dictionary)
			{
				return dictionary.TryGetValue(station, out level);
			}
			return false;
		}

		public bool TryWrite(Player player, KnowledgeEntry entry)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected I4, but got Unknown
			if ((Object)(object)player == (Object)null || !CanAccessKnowledge)
			{
				Plugin.WarnOnce("bridge-fields", "Player knowledge fields were not found in this game version; cannot apply entries.");
				return false;
			}
			KnowledgeKind kind = ((KnowledgeEntry)(ref entry)).Kind;
			switch (kind - 1)
			{
			case 0:
				return (_knownMaterial.GetValue(player) as HashSet<string>)?.Add(((KnowledgeEntry)(ref entry)).Key) ?? false;
			case 1:
			case 2:
				return (_knownRecipes.GetValue(player) as HashSet<string>)?.Add(((KnowledgeEntry)(ref entry)).Key) ?? false;
			case 3:
			{
				if (_knownStations.GetValue(player) is Dictionary<string, int> dictionary && (!dictionary.TryGetValue(((KnowledgeEntry)(ref entry)).Key, out var value) || value < ((KnowledgeEntry)(ref entry)).Level))
				{
					dictionary[((KnowledgeEntry)(ref entry)).Key] = ((KnowledgeEntry)(ref entry)).Level;
					return true;
				}
				return false;
			}
			default:
				return false;
			}
		}

		public bool TryInvokeAddKnownRecipe(Player player, Recipe recipe)
		{
			return TryInvoke(_addKnownRecipe, "AddKnownRecipe", player, recipe);
		}

		public bool TryInvokeAddKnownPiece(Player player, Piece piece)
		{
			return TryInvoke(_addKnownPiece, "AddKnownPiece", player, piece);
		}

		public void Refresh(Player player)
		{
			TryInvoke(_updateKnownRecipesList, "UpdateKnownRecipesList", player);
			TryInvoke(_updateAvailablePiecesList, "UpdateAvailablePiecesList", player);
		}

		public void RefreshKnownRecipes(Player player)
		{
			TryInvoke(_updateKnownRecipesList, "UpdateKnownRecipesList", player);
		}

		private static bool TryInvoke(MethodInfo method, string name, Player player, params object[] args)
		{
			if (method == null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				method.Invoke(player, args);
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = ((ex is TargetInvocationException && ex.InnerException != null) ? ex.InnerException : ex);
				Plugin.WarnOnce("invoke-" + name, "Player." + name + " failed: " + ex2.GetType().Name + ": " + ex2.Message);
				return false;
			}
		}

		private static FieldInfo FindField(Type type, string name)
		{
			FieldInfo? field = type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				Plugin.WarnOnce("field-" + name, "Player." + name + " was not found in this game version.");
			}
			return field;
		}

		private static MethodInfo FindMethod(Type type, string name, params Type[] parameters)
		{
			MethodInfo? method = type.GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic, null, parameters, null);
			if (method == null)
			{
				Plugin.WarnOnce("method-" + name, "Player." + name + " was not found in this game version; falling back to direct writes.");
			}
			return method;
		}
	}
	internal sealed class VanillaUnlocker
	{
		private const int MaxDeferred = 200;

		private readonly GameCatalog _catalog;

		private readonly PlayerKnowledgeBridge _bridge;

		private readonly List<KnowledgeEntry> _deferredPieces = new List<KnowledgeEntry>();

		private readonly HashSet<string> _deferredKeys = new HashSet<string>(StringComparer.Ordinal);

		public VanillaUnlocker(GameCatalog catalog, PlayerKnowledgeBridge bridge)
		{
			_catalog = catalog;
			_bridge = bridge;
		}

		private static bool IsBuildHudReady()
		{
			Hud instance = Hud.instance;
			if ((Object)(object)instance != (Object)null)
			{
				return (Object)(object)instance.m_buildUi != (Object)null;
			}
			return false;
		}

		private bool DeferPiece(KnowledgeEntry entry)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (_deferredPieces.Count >= 200)
			{
				return false;
			}
			if (_deferredKeys.Add(((KnowledgeEntry)(ref entry)).Key))
			{
				_deferredPieces.Add(entry);
			}
			return true;
		}

		public void Reset()
		{
			_deferredPieces.Clear();
			_deferredKeys.Clear();
		}

		public void Tick(Player player)
		{
			//IL_004d: 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)
			if ((Object)(object)player == (Object)null || _deferredPieces.Count == 0 || !IsBuildHudReady())
			{
				return;
			}
			KnowledgeEntry[] array = _deferredPieces.ToArray();
			_deferredPieces.Clear();
			_deferredKeys.Clear();
			for (int i = 0; i < array.Length; i++)
			{
				if (!_bridge.IsKnown(player, array[i]))
				{
					try
					{
						Apply(player, array[i], showPopup: true);
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Retrying the held back piece " + ((object)Unsafe.As<KnowledgeEntry, KnowledgeEntry>(ref array[i])/*cast due to .constrained prefix*/).ToString() + " failed: " + ex.GetType().Name));
					}
				}
			}
		}

		public unsafe bool Apply(Player player, KnowledgeEntry entry, bool showPopup)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected I4, but got Unknown
			//IL_0046: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				if (_bridge.IsKnown(player, entry))
				{
					return false;
				}
				KnowledgeKind kind = ((KnowledgeEntry)(ref entry)).Kind;
				return (kind - 1) switch
				{
					0 => ApplyMaterial(player, entry, showPopup), 
					1 => ApplyRecipe(player, entry, showPopup), 
					2 => ApplyPiece(player, entry, showPopup), 
					3 => ApplyStation(player, entry, showPopup), 
					_ => false, 
				};
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Applying " + ((object)(*(KnowledgeEntry*)(&entry))/*cast due to .constrained prefix*/).ToString() + " failed: " + ex.GetType().Name + ": " + ex.Message));
				return false;
			}
		}

		public void Refresh(Player player)
		{
			try
			{
				_bridge.Refresh(player);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Refreshing the player's known lists failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private bool ApplyMaterial(Player player, KnowledgeEntry entry, bool showPopup)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!_catalog.TryGetItem(((KnowledgeEntry)(ref entry)).Key, out var item))
			{
				Plugin.WarnOnce("missing-item-" + ((KnowledgeEntry)(ref entry)).Key, "Item '" + ((KnowledgeEntry)(ref entry)).Key + "' does not exist in this game; adding it to the known materials directly.");
				bool num = _bridge.TryWrite(player, entry);
				if (num && showPopup)
				{
					QueuePopup(null, "$msg_newmaterial", ((KnowledgeEntry)(ref entry)).Key);
				}
				return num;
			}
			if (showPopup)
			{
				player.AddKnownItem(item);
				return _bridge.IsKnown(player, entry);
			}
			return _bridge.TryWrite(player, entry);
		}

		private bool ApplyRecipe(Player player, KnowledgeEntry entry, bool showPopup)
		{
			//IL_0049: 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_0097: 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)
			if (!_catalog.TryGetRecipe(((KnowledgeEntry)(ref entry)).Key, out var recipe))
			{
				Plugin.WarnOnce("unmapped-recipe-" + ((KnowledgeEntry)(ref entry)).Key, "'" + ((KnowledgeEntry)(ref entry)).Key + "' matches no recipe or piece in this game; adding it to the known recipes silently.");
				return _bridge.TryWrite(player, entry);
			}
			if (!showPopup)
			{
				return _bridge.TryWrite(player, entry);
			}
			if (_bridge.TryInvokeAddKnownRecipe(player, recipe) && _bridge.IsKnown(player, entry))
			{
				return true;
			}
			Plugin.WarnOnce("fallback-recipe", "Vanilla AddKnownRecipe is unavailable; using the direct write plus manual popup fallback.");
			if (!_bridge.TryWrite(player, entry))
			{
				return false;
			}
			QueuePopup(((Object)(object)recipe.m_item != (Object)null && recipe.m_item.m_itemData != null) ? recipe.m_item.m_itemData.GetIcon() : null, "$msg_newrecipe", ((KnowledgeEntry)(ref entry)).Key);
			return true;
		}

		private unsafe bool ApplyPiece(Player player, KnowledgeEntry entry, bool showPopup)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Invalid comparison between Unknown and I4
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Invalid comparison between Unknown and I4
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Invalid comparison between Unknown and I4
			if (!_catalog.TryGetPiece(((KnowledgeEntry)(ref entry)).Key, out var piece) && _catalog.TryRebuildAfterMiss())
			{
				_catalog.TryGetPiece(((KnowledgeEntry)(ref entry)).Key, out piece);
			}
			if ((Object)(object)piece == (Object)null)
			{
				Plugin.WarnOnce("missing-piece-" + ((KnowledgeEntry)(ref entry)).Key, "Piece '" + ((KnowledgeEntry)(ref entry)).Key + "' does not exist in this game; adding it to the known recipes directly.");
				bool num = _bridge.TryWrite(player, entry);
				if (num && showPopup)
				{
					QueuePopup(null, "$msg_newpiece", ((KnowledgeEntry)(ref entry)).Key);
				}
				return num;
			}
			if (!showPopup)
			{
				return _bridge.TryWrite(player, entry);
			}
			if (!IsBuildHudReady())
			{
				if (DeferPiece(entry))
				{
					return false;
				}
				Plugin.Log.LogWarning((object)("Build ui is not ready yet and the hold back list is full; applying " + ((object)(*(KnowledgeEntry*)(&entry))/*cast due to .constrained prefix*/).ToString() + " without a popup."));
				return _bridge.TryWrite(player, entry);
			}
			if (_bridge.TryInvokeAddKnownPiece(player, piece) && _bridge.IsKnown(player, entry))
			{
				return true;
			}
			Plugin.WarnOnce("fallback-piece", "Vanilla AddKnownPiece is unavailable; using the direct write plus manual popup fallback.");
			if (!_bridge.TryWrite(player, entry))
			{
				return false;
			}
			bool flag = (int)piece.m_category == 6 || (int)piece.m_category == 7 || (int)piece.m_category == 8;
			QueuePopup(piece.m_icon, flag ? "$msg_newdish" : "$msg_newpiece", ((KnowledgeEntry)(ref entry)).Key);
			return true;
		}

		private bool ApplyStation(Player player, KnowledgeEntry entry, bool showPopup)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			int level;
			bool flag = _bridge.TryGetStationLevel(player, ((KnowledgeEntry)(ref entry)).Key, out level);
			if (flag && level >= ((KnowledgeEntry)(ref entry)).Level)
			{
				return false;
			}
			if (!_bridge.TryWrite(player, entry))
			{
				return false;
			}
			if (showPopup)
			{
				Sprite stationIcon = _catalog.GetStationIcon(((KnowledgeEntry)(ref entry)).Key);
				if (flag)
				{
					QueuePopup(stationIcon, "$msg_newstation_level", ((KnowledgeEntry)(ref entry)).Key + " $msg_level " + ((KnowledgeEntry)(ref entry)).Level);
				}
				else
				{
					QueuePopup(stationIcon, "$msg_newstation", ((KnowledgeEntry)(ref entry)).Key);
				}
			}
			_bridge.RefreshKnownRecipes(player);
			return true;
		}

		private static void QueuePopup(Sprite icon, string topic, string description)
		{
			MessageHud instance = MessageHud.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.QueueUnlockMsg(icon, topic, description);
			}
		}
	}
}