using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AdventureGuide.Config;
using AdventureGuide.Core;
using AdventureGuide.Data;
using AdventureGuide.Diagnostics;
using AdventureGuide.Navigation;
using AdventureGuide.Patches;
using AdventureGuide.Rendering;
using AdventureGuide.State;
using AdventureGuide.UI;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ErenshorMods.Input;
using HarmonyLib;
using ImGuiNET;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("AdventureGuide.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AdventureGuide")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1ae4ed0ca70f6324f2e309090088871672eec1aa")]
[assembly: AssemblyProduct("AdventureGuide")]
[assembly: AssemblyTitle("AdventureGuide")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 ErenshorMods.Input
{
	public interface IKeyboardInput
	{
		bool IsHeld(KeyCode key);

		bool WasPressed(KeyCode key);
	}
	public sealed class UnityKeyboardInput : IKeyboardInput
	{
		public static UnityKeyboardInput Instance { get; } = new UnityKeyboardInput();

		private UnityKeyboardInput()
		{
		}

		public bool IsHeld(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKey(key);
		}

		public bool WasPressed(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKeyDown(key);
		}
	}
	public static class KeyboardShortcuts
	{
		public static bool WasPressed(KeyCode key, IKeyboardInput keyboard)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return (int)key != 0 && keyboard.WasPressed(key);
		}

		public static bool IsHeld(KeyCode key, IKeyboardInput keyboard)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return (int)key != 0 && keyboard.IsHeld(key);
		}

		public static bool IsHeld(IReadOnlyList<KeyCode> keys, IKeyboardInput keyboard)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (keys.Count == 0)
			{
				return false;
			}
			for (int i = 0; i < keys.Count; i++)
			{
				if ((int)keys[i] == 0 || !keyboard.IsHeld(keys[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static bool IsHeld(KeyCode mainKey, IReadOnlyList<KeyCode> modifiers, IKeyboardInput keyboard)
		{
			//IL_0001: 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_0020: 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)
			if ((int)mainKey == 0 || !keyboard.IsHeld(mainKey))
			{
				return false;
			}
			for (int i = 0; i < modifiers.Count; i++)
			{
				if ((int)modifiers[i] == 0 || !keyboard.IsHeld(modifiers[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
}
namespace AdventureGuide
{
	public sealed class AdventureGuideRuntime : IRuntimeLifecycleEffects
	{
		private readonly IModLogger _logger;

		private readonly IGuideConfigBackend _backend;

		private readonly string _iniPath;

		private readonly IKeyboardInput _keyboard;

		private readonly RuntimeLifecycleCoordinator _lifecycle;

		private readonly RuntimeResourceOwnership _resources;

		private Harmony? _harmony;

		private GuideConfig? _config;

		private GuideData? _data;

		private QuestStateTracker? _state;

		private EntityRegistry? _entities;

		private NavigationController? _nav;

		private ArrowRenderer? _arrow;

		private GroundPathRenderer? _groundPath;

		private WorldMarkerSystem? _markers;

		private SpawnTimerTracker? _timers;

		private MiningNodeTracker? _miningTracker;

		private LootScanner? _lootScanner;

		private GuideWindow? _window;

		private TrackerState? _trackerState;

		private TrackerWindow? _tracker;

		private ImGuiRenderer? _imgui;

		private bool _wasTextInputActive;

		private bool _gameUIVisible = true;

		private bool _inGameplay;

		private bool _discoveryDone;

		private bool _wasEditUIMode;

		private bool _wantsMouseCapture;

		private bool _wantsTextInput;

		internal static IModLogger Log { get; private set; } = NullModLogger.Instance;

		public AdventureGuideRuntime(IModLogger logger, IGuideConfigBackend config, string iniPath, IKeyboardInput keyboard)
		{
			_logger = logger;
			_backend = config;
			_iniPath = iniPath;
			_keyboard = keyboard;
			_lifecycle = new RuntimeLifecycleCoordinator(this);
			_resources = new RuntimeResourceOwnership(config);
		}

		public bool Start()
		{
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Expected O, but got Unknown
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			switch (_lifecycle.BeginStart())
			{
			case RuntimeStartDecision.RejectedAfterStop:
				return false;
			case RuntimeStartDecision.AlreadyStarted:
				return true;
			default:
				Log = _logger;
				AdventureGuideLog.Current = _logger;
				try
				{
					try
					{
						_config = new GuideConfig(_backend);
						_resources.AdoptConfiguration(_config);
					}
					catch
					{
						_resources.Dispose();
						throw;
					}
					_data = GuideData.Load(_logger);
					_entities = new EntityRegistry();
					_state = new QuestStateTracker(_data, _entities);
					_state.LoadFromConfig(_config);
					_trackerState = new TrackerState();
					_trackerState.LoadFromConfig(_config);
					float num = UiScalePolicy.Resolve(_config.UiScale.Value, Screen.height);
					_config.ResolvedUiScale = num;
					_imgui = new ImGuiRenderer(_logger)
					{
						UiScale = num,
						IniPath = _iniPath
					};
					if (!_imgui.Init())
					{
						throw new InvalidOperationException("Adventure Guide ImGui renderer init failed.");
					}
					_config.UiScale.SettingChanged += OnUiScaleChanged;
					_config.ResetWindowLayout.SettingChanged += OnResetWindowLayout;
					_timers = new SpawnTimerTracker();
					_miningTracker = new MiningNodeTracker();
					SpawnPointBridge bridge = new SpawnPointBridge();
					_lootScanner = new LootScanner();
					_nav = new NavigationController(_data, _entities, _state, _timers, _miningTracker, _lootScanner);
					_state.WorkflowChanged += OnWorkflowChanged;
					_state.WorkflowCycleReset += OnWorkflowCycleReset;
					_state.FurnishingsChanged += OnFurnishingsChanged;
					_state.TreasureHuntChanged += OnTreasureHuntChanged;
					_arrow = new ArrowRenderer(_nav)
					{
						Enabled = _config.ShowArrow.Value
					};
					_config.ShowArrow.SettingChanged += OnShowArrowChanged;
					_groundPath = new GroundPathRenderer(_nav)
					{
						Enabled = _config.ShowGroundPath.Value
					};
					_config.ShowGroundPath.SettingChanged += OnShowGroundPathChanged;
					_markers = new WorldMarkerSystem(_data, _state, bridge, _lootScanner, _config)
					{
						Enabled = _config.ShowWorldMarkers.Value
					};
					_config.ShowWorldMarkers.SettingChanged += OnShowWorldMarkersChanged;
					_config.TrackerEnabled.SettingChanged += OnTrackerEnabledChanged;
					_config.ReplaceQuestLog.SettingChanged += OnReplaceQuestLogChanged;
					NavigationHistory history = new NavigationHistory(_config.HistoryMaxSize.Value);
					_config.HistoryMaxSize.SettingChanged += delegate
					{
						history.MaxSize = _config.HistoryMaxSize.Value;
					};
					_window = new GuideWindow(_data, _state, _nav, history, _trackerState, _config);
					_state.SetHistory(history);
					_window.Filter.LoadFrom(_config);
					_tracker = new TrackerWindow(_data, _state, _nav, _trackerState, _window, _config);
					Action guideDraw = _window.Draw;
					Action trackerDraw = delegate
					{
						_tracker.Draw(_inGameplay);
					};
					Action arrowDraw = _arrow.Draw;
					_imgui.OnLayout = delegate
					{
						_imgui.DrawIsolated(guideDraw);
						_imgui.DrawIsolated(trackerDraw);
						_imgui.DrawIsolated(arrowDraw);
					};
					DebugAPI.Data = _data;
					DebugAPI.State = _state;
					DebugAPI.Filter = _window.Filter;
					DebugAPI.Nav = _nav;
					DebugAPI.Entities = _entities;
					DebugAPI.GroundPath = _groundPath;
					DebugAPI.Markers = _markers;
					QuestAssignPatch.Tracker = _state;
					QuestAssignPatch.Nav = _nav;
					QuestAssignPatch.Loot = _lootScanner;
					QuestAssignPatch.TrackerPins = _trackerState;
					QuestFinishPatch.Tracker = _state;
					QuestFinishPatch.Nav = _nav;
					QuestFinishPatch.Loot = _lootScanner;
					QuestFinishPatch.TrackerPins = _trackerState;
					InventoryPatch.Tracker = _state;
					InventoryPatch.Nav = _nav;
					InventoryPatch.Loot = _lootScanner;
					SpawnPatch.Registry = _entities;
					SpawnPatch.Timers = _timers;
					SpawnPatch.Markers = _markers;
					SpawnPatch.Loot = _lootScanner;
					SpawnResetPatch.Markers = _markers;
					NpcStartPatch.Markers = _markers;
					NpcStartPatch.Entities = _entities;
					ScriptedEntityStartPatch.Tracker = _state;
					ScriptedRewardConsumedPatch.Tracker = _state;
					DeathPatch.Registry = _entities;
					DeathPatch.Timers = _timers;
					DeathPatch.Markers = _markers;
					DeathPatch.Loot = _lootScanner;
					DeathPatch.Tracker = _state;
					DeathPatch.Nav = _nav;
					QuestMarkerPatch.SetSuppression(_config.ShowWorldMarkers.Value);
					PointerOverUIPatch.WantsMouse = () => _wantsMouseCapture;
					PlayerTypingPatch.WantsTextInput = () => _gameUIVisible && _wantsTextInput;
					QuestLogPatch.ReplaceQuestLog = _config.ReplaceQuestLog;
					CharacterCreatePatch.Config = _config;
					CharacterDeletePatch.Config = _config;
					SceneManager.sceneLoaded += OnSceneLoaded;
					_harmony = new Harmony("wow-much.adventure-guide");
					_harmony.PatchAll();
					QuestStateTracker? state = _state;
					Scene activeScene = SceneManager.GetActiveScene();
					state.OnSceneChanged(((Scene)(ref activeScene)).name);
					_entities.SyncFromLiveNPCs();
					_miningTracker.Rescan();
					_lootScanner.OnSceneLoaded();
					activeScene = SceneManager.GetActiveScene();
					LoadCharacterState(((Scene)(ref activeScene)).name);
					activeScene = SceneManager.GetActiveScene();
					string name = ((Scene)(ref activeScene)).name;
					_inGameplay = name != "Menu" && name != "LoadScene";
					int num2 = 0;
					foreach (QuestEntry item in _data.All)
					{
						if (item.HasSteps)
						{
							num2++;
						}
					}
					_logger.LogInfo("Adventure Guide v2026.1008.0\n" + $"  Quests: {_data.Count} in guide, {num2} with step data\n" + $"  Controls: {_config.ToggleKey.Value} = guide, {_config.TrackerToggleKey.Value} = tracker, {_config.GroundPathToggleKey.Value} = ground path");
					return true;
				}
				catch (Exception exception)
				{
					_logger.LogError("Adventure Guide failed to start; unwinding partial initialization.", exception);
					Stop();
					return false;
				}
			}
		}

		public void Tick()
		{
			_lifecycle.Tick();
		}

		void IRuntimeLifecycleEffects.TickActive()
		{
			_tracker?.Update();
			bool isVisible = GameUIVisibility.IsVisible;
			if (isVisible != _gameUIVisible)
			{
				_gameUIVisible = isVisible;
				SyncVisibility();
				if (!isVisible)
				{
					ClearImGuiCaptureState();
					if (_wasTextInputActive)
					{
						if (!ChatInputActive())
						{
							GameData.PlayerTyping = false;
						}
						_wasTextInputActive = false;
					}
				}
			}
			bool editUIMode = GameData.EditUIMode;
			if (_wasEditUIMode && !editUIMode)
			{
				GameWindowOverlap.InvalidateRects();
			}
			_wasEditUIMode = editUIMode;
			if (_gameUIVisible)
			{
				CaptureImGuiState();
			}
			if (_gameUIVisible)
			{
				bool wantsTextInput = _wantsTextInput;
				bool? flag = TypingFlagSync.Next(wantsTextInput, _wasTextInputActive, ChatInputActive());
				if (flag.HasValue)
				{
					GameData.PlayerTyping = flag.Value;
				}
				_wasTextInputActive = wantsTextInput;
			}
			if (!_discoveryDone)
			{
				TryMergeUnknownQuests();
			}
			string currentScene = _state?.CurrentZone ?? "";
			_state?.Update(Time.deltaTime);
			if (_data != null && _state != null)
			{
				_lootScanner?.Update(_data, _state);
			}
			_nav?.Update(currentScene);
			_groundPath?.Update(currentScene);
			_markers?.Update(currentScene);
			if (_config != null && _window != null && _inGameplay)
			{
				HandleKeyboardShortcuts();
				if (!_wantsMouseCapture && !GameData.PlayerTyping)
				{
				}
			}
		}

		public void Draw()
		{
			_lifecycle.Draw(_gameUIVisible);
		}

		void IRuntimeLifecycleEffects.DrawActive()
		{
			_imgui?.OnGUI();
		}

		public void Stop()
		{
			_lifecycle.Stop();
		}

		void IRuntimeLifecycleEffects.StopActive()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if (_wasTextInputActive && !ChatInputActive())
			{
				GameData.PlayerTyping = false;
			}
			ClearImGuiCaptureState();
			if (_config != null)
			{
				_config.ShowArrow.SettingChanged -= OnShowArrowChanged;
				_config.ShowGroundPath.SettingChanged -= OnShowGroundPathChanged;
				_config.ShowWorldMarkers.SettingChanged -= OnShowWorldMarkersChanged;
				_config.TrackerEnabled.SettingChanged -= OnTrackerEnabledChanged;
				_config.ReplaceQuestLog.SettingChanged -= OnReplaceQuestLogChanged;
				_config.UiScale.SettingChanged -= OnUiScaleChanged;
				_config.ResetWindowLayout.SettingChanged -= OnResetWindowLayout;
			}
			if (_state != null)
			{
				_state.WorkflowChanged -= OnWorkflowChanged;
				_state.WorkflowCycleReset -= OnWorkflowCycleReset;
				_state.FurnishingsChanged -= OnFurnishingsChanged;
				_state.TreasureHuntChanged -= OnTreasureHuntChanged;
			}
			QuestMarkerPatch.SetSuppression(suppressed: false);
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			_tracker?.Dispose();
			_state?.SaveToConfig();
			_nav?.SavePerCharacter();
			_nav?.SuspendForMenu();
			_state?.TreasureHunt.Clear();
			_imgui?.Dispose();
			_imgui = null;
			_arrow?.Dispose();
			_groundPath?.Destroy();
			_markers?.Destroy();
			_timers?.Clear();
			_entities?.Clear();
			_miningTracker?.Clear();
			MarkerFonts.Destroy();
			CameraCache.Invalidate();
			GameWindowOverlap.Reset();
			_config = null;
			_resources.Dispose();
			ClearPatchStatics();
			ClearDebugApi();
			AdventureGuideLog.Reset();
			Log = NullModLogger.Instance;
		}

		private void TryMergeUnknownQuests()
		{
			if (!_discoveryDone && _data != null)
			{
				int num = _data.MergeUnknownQuests();
				if (num >= 0)
				{
					_discoveryDone = true;
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (_config.UiScale.Value < 0f && ((Scene)(ref scene)).name != "Menu" && ((Scene)(ref scene)).name != "LoadScene")
			{
				OnUiScaleChanged(this, EventArgs.Empty);
			}
			CameraCache.Invalidate();
			GameWindowOverlap.Reset();
			_inGameplay = ((Scene)(ref scene)).name != "Menu" && ((Scene)(ref scene)).name != "LoadScene";
			if (!_inGameplay)
			{
				_window?.Hide();
				_nav?.SuspendForMenu();
				_trackerState?.SuspendForMenu();
				_state?.SuspendForMenu();
				_config?.SuspendCharacter();
				ClearImGuiCaptureState();
			}
			_markers?.OnSceneLoaded();
			_entities?.Clear();
			_timers?.Clear();
			_miningTracker?.Rescan();
			_lootScanner?.OnSceneLoaded();
			_state?.OnSceneChanged(((Scene)(ref scene)).name);
			LoadCharacterState(((Scene)(ref scene)).name);
			_nav?.OnGameStateChanged(((Scene)(ref scene)).name);
		}

		private void LoadCharacterState(string scene)
		{
			if (scene == "Menu" || scene == "LoadScene")
			{
				return;
			}
			SaveGameData currentCharacterSlot = GameData.CurrentCharacterSlot;
			if (currentCharacterSlot != null && !string.IsNullOrEmpty(currentCharacterSlot.CharName))
			{
				_config.PrepareCharacter(currentCharacterSlot.index, currentCharacterSlot.CharName);
				_trackerState?.OnCharacterLoaded();
				_state?.OnCharacterLoaded();
				if (_trackerState != null && _state != null && _data != null)
				{
					_trackerState.PruneCompleted(_state, _data);
				}
				_nav?.LoadPerCharacter(_config, scene);
			}
		}

		private void OnShowArrowChanged(object sender, EventArgs e)
		{
			SyncVisibility();
		}

		private void OnShowGroundPathChanged(object sender, EventArgs e)
		{
			SyncVisibility();
		}

		private void OnUiScaleChanged(object sender, EventArgs e)
		{
			float num = UiScalePolicy.Resolve(_config.UiScale.Value, Screen.height);
			if (num != _config.ResolvedUiScale)
			{
				_config.ResolvedUiScale = num;
				_config.LayoutResetGeneration++;
				_imgui?.SetScale(num);
			}
		}

		private void OnResetWindowLayout(object sender, EventArgs e)
		{
			if (_config.ResetWindowLayout.Value)
			{
				_config.LayoutResetGeneration++;
				_imgui?.ClearWindowState();
				_config.ResetWindowLayout.Value = false;
			}
		}

		private void OnShowWorldMarkersChanged(object sender, EventArgs e)
		{
			SyncVisibility();
			QuestMarkerPatch.SetSuppression(_config.ShowWorldMarkers.Value);
		}

		private void OnTrackerEnabledChanged(object sender, EventArgs e)
		{
			_trackerState.Enabled = _config.TrackerEnabled.Value;
		}

		private void OnReplaceQuestLogChanged(object sender, EventArgs e)
		{
			if (_config.ReplaceQuestLog.Value)
			{
				QuestLog questLog = GameData.QuestLog;
				if ((Object)(object)questLog != (Object)null && (Object)(object)questLog.QuestWindow != (Object)null && questLog.QuestWindow.activeSelf)
				{
					questLog.QuestWindow.SetActive(false);
					_window?.Show();
				}
			}
		}

		private void OnWorkflowChanged(QuestEntry quest)
		{
			_nav?.OnGameStateChanged(_state?.CurrentZone ?? "");
			_lootScanner?.MarkDirty();
		}

		private void OnWorkflowCycleReset(QuestEntry quest)
		{
			_trackerState?.OnQuestCompleted(quest.RuntimeKey);
		}

		private void OnFurnishingsChanged()
		{
			_nav?.OnFurnishingsChanged(_state?.CurrentZone ?? "");
		}

		private void OnTreasureHuntChanged(TreasureHuntChange change)
		{
			_nav?.OnTreasureHuntChanged(change);
		}

		private void SyncVisibility()
		{
			bool gameUIVisible = _gameUIVisible;
			if (_arrow != null && _config != null)
			{
				_arrow.Enabled = gameUIVisible && _config.ShowArrow.Value;
			}
			if (_groundPath != null && _config != null)
			{
				_groundPath.Enabled = gameUIVisible && _config.ShowGroundPath.Value;
			}
			if (_markers != null && _config != null)
			{
				_markers.Enabled = gameUIVisible && _config.ShowWorldMarkers.Value;
			}
		}

		private void HandleKeyboardShortcuts()
		{
			//IL_002f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (_config != null && _window != null)
			{
				ShortcutAction shortcutAction = ShortcutCoordinator.Sample(_keyboard, _config.ToggleKey.Value, InputManager.Journal, _config.TrackerToggleKey.Value, _config.GroundPathToggleKey.Value, GameData.PlayerTyping, _wantsTextInput, _config.ReplaceQuestLog.Value, _config.TrackerEnabled.Value);
				if ((shortcutAction & ShortcutAction.ToggleGuide) != ShortcutAction.None)
				{
					_window.Toggle();
				}
				if ((shortcutAction & ShortcutAction.ToggleReplacementJournal) != ShortcutAction.None)
				{
					_window.Toggle();
				}
				if ((shortcutAction & ShortcutAction.ToggleTracker) != ShortcutAction.None)
				{
					_tracker?.Toggle();
				}
				if ((shortcutAction & ShortcutAction.ToggleGroundPath) != ShortcutAction.None)
				{
					_config.ShowGroundPath.Value = !_config.ShowGroundPath.Value;
				}
			}
		}

		private static bool ChatInputActive()
		{
			return (Object)(object)GameData.TextInput != (Object)null && (Object)(object)GameData.TextInput.InputBox != (Object)null && GameData.TextInput.InputBox.activeSelf;
		}

		private void CaptureImGuiState()
		{
			_wantsMouseCapture = _imgui?.WantCaptureMouse ?? false;
			_wantsTextInput = _imgui?.WantTextInput ?? false;
		}

		private void ClearImGuiCaptureState()
		{
			_wantsMouseCapture = false;
			_wantsTextInput = false;
		}

		private static void ClearPatchStatics()
		{
			QuestAssignPatch.Tracker = null;
			QuestAssignPatch.Nav = null;
			QuestAssignPatch.Loot = null;
			QuestAssignPatch.TrackerPins = null;
			QuestFinishPatch.Tracker = null;
			QuestFinishPatch.Nav = null;
			QuestFinishPatch.Loot = null;
			QuestFinishPatch.TrackerPins = null;
			InventoryPatch.Tracker = null;
			InventoryPatch.Nav = null;
			InventoryPatch.Loot = null;
			SpawnPatch.Registry = null;
			SpawnPatch.Timers = null;
			SpawnPatch.Markers = null;
			SpawnPatch.Loot = null;
			SpawnResetPatch.Markers = null;
			NpcStartPatch.Markers = null;
			NpcStartPatch.Entities = null;
			ScriptedEntityStartPatch.Tracker = null;
			ScriptedRewardConsumedPatch.Tracker = null;
			DeathPatch.Registry = null;
			DeathPatch.Timers = null;
			DeathPatch.Markers = null;
			DeathPatch.Loot = null;
			DeathPatch.Tracker = null;
			DeathPatch.Nav = null;
			QuestMarkerPatch.SuppressGameMarkers = false;
			PointerOverUIPatch.WantsMouse = null;
			QuestLogPatch.ReplaceQuestLog = null;
			PlayerTypingPatch.WantsTextInput = null;
			CharacterCreatePatch.Config = null;
			CharacterDeletePatch.Config = null;
		}

		private static void ClearDebugApi()
		{
			DebugAPI.Data = null;
			DebugAPI.State = null;
			DebugAPI.Filter = null;
			DebugAPI.Nav = null;
			DebugAPI.Entities = null;
			DebugAPI.GroundPath = null;
			DebugAPI.Markers = null;
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "wow-much.adventure-guide";

		public const string Name = "Adventure Guide";

		public const string Version = "2026.1008.0";
	}
	[BepInPlugin("wow-much.adventure-guide", "Adventure Guide", "2026.1008.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		private AdventureGuideRuntime? _runtime;

		private void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			((MonoBehaviour)this).useGUILayout = false;
			BepInExLogger logger = new BepInExLogger(((BaseUnityPlugin)this).Logger);
			BepInExConfigBackend config = new BepInExConfigBackend(((BaseUnityPlugin)this).Config);
			string iniPath = Path.Combine(Paths.ConfigPath, "adventureguide", "imgui.ini");
			_runtime = new AdventureGuideRuntime(logger, config, iniPath, UnityKeyboardInput.Instance);
			_runtime.Start();
		}

		private void Update()
		{
			_runtime?.Tick();
		}

		private void OnGUI()
		{
			_runtime?.Draw();
		}

		private void OnDestroy()
		{
			_runtime?.Stop();
		}
	}
	internal sealed class BepInExLogger : IModLogger
	{
		private readonly ManualLogSource _log;

		internal BepInExLogger(ManualLogSource log)
		{
			_log = log;
		}

		public void LogDebug(string message)
		{
			_log.LogDebug((object)message);
		}

		public void LogInfo(string message)
		{
			_log.LogInfo((object)message);
		}

		public void LogWarning(string message)
		{
			_log.LogWarning((object)message);
		}

		public void LogError(string message)
		{
			_log.LogError((object)message);
		}

		public void LogError(string message, Exception exception)
		{
			_log.LogError((object)$"{message}: {exception}");
		}
	}
	internal sealed class BepInExConfigBackend : IGuideConfigBackend, IDisposable
	{
		private sealed class ConfigurationManagerAttributes
		{
			public bool? Browsable { get; set; }
		}

		private readonly ConfigFile _config;

		private bool _disposed;

		internal BepInExConfigBackend(ConfigFile config)
		{
			_config = config;
		}

		public IConfigValue<T> Bind<T>(string section, string key, T defaultValue, string description, bool hidden = false, float? min = null, float? max = null)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (_disposed)
			{
				throw new ObjectDisposedException("BepInExConfigBackend");
			}
			AcceptableValueBase val = CreateRange<T>(min, max);
			ConfigurationManagerAttributes configurationManagerAttributes = (hidden ? new ConfigurationManagerAttributes
			{
				Browsable = false
			} : null);
			ConfigEntry<T> entry = _config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, val, new object[1] { configurationManagerAttributes }));
			return new BepInExConfigValue<T>(entry);
		}

		public void Dispose()
		{
			_disposed = true;
		}

		private static AcceptableValueBase? CreateRange<T>(float? min, float? max)
		{
			if (!min.HasValue || !max.HasValue)
			{
				return null;
			}
			if (typeof(T) == typeof(int))
			{
				return (AcceptableValueBase?)(object)new AcceptableValueRange<int>((int)min.Value, (int)max.Value);
			}
			if (typeof(T) == typeof(float))
			{
				return (AcceptableValueBase?)(object)new AcceptableValueRange<float>(min.Value, max.Value);
			}
			return null;
		}
	}
	internal sealed class BepInExConfigValue<T> : IConfigValue<T>, IDisposable
	{
		private readonly ConfigEntry<T> _entry;

		private bool _disposed;

		public T Value
		{
			get
			{
				return _entry.Value;
			}
			set
			{
				_entry.Value = value;
			}
		}

		public string Key => ((ConfigEntryBase)_entry).Definition.Section + "." + ((ConfigEntryBase)_entry).Definition.Key;

		public event EventHandler? SettingChanged;

		internal BepInExConfigValue(ConfigEntry<T> entry)
		{
			_entry = entry;
			_entry.SettingChanged += OnChanged;
		}

		public void SetSerializedValue(string value)
		{
			Value = Deserialize(value);
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				_entry.SettingChanged -= OnChanged;
				this.SettingChanged = null;
			}
		}

		private void OnChanged(object sender, EventArgs args)
		{
			if (!_disposed)
			{
				this.SettingChanged?.Invoke(this, args);
			}
		}

		private static T Deserialize(string value)
		{
			if (typeof(T).IsEnum)
			{
				return (T)Enum.Parse(typeof(T), value);
			}
			return (T)Convert.ChangeType(value, typeof(T), CultureInfo.InvariantCulture);
		}
	}
}
namespace AdventureGuide.UI
{
	internal struct DisplayCacheRevision
	{
		private bool _valid;

		private string? _questKey;

		private int _version;

		public readonly bool IsCurrent(string? questKey, int version)
		{
			return _valid && _questKey == questKey && _version == version;
		}

		public void Invalidate()
		{
			_valid = false;
		}

		public void Commit(string? questKey, int version)
		{
			_questKey = questKey;
			_version = version;
			_valid = true;
		}
	}
	public enum QuestFilterMode
	{
		Active,
		Available,
		Completed,
		All
	}
	public enum QuestSortMode
	{
		Alphabetical,
		ByZone,
		ByLevel
	}
	public class FilterState
	{
		private GuideConfig? _config;

		private QuestFilterMode _filterMode = QuestFilterMode.Active;

		private string _searchText = string.Empty;

		private string? _zoneFilter;

		private QuestSortMode _sortMode = QuestSortMode.Alphabetical;

		public int Version { get; private set; }

		public QuestFilterMode FilterMode
		{
			get
			{
				return _filterMode;
			}
			set
			{
				if (_filterMode != value)
				{
					_filterMode = value;
					Version++;
					_config?.FilterMode.SetSerializedValue(value.ToString());
				}
			}
		}

		public string SearchText
		{
			get
			{
				return _searchText;
			}
			set
			{
				if (_searchText != value)
				{
					_searchText = value;
					Version++;
				}
			}
		}

		public string? ZoneFilter
		{
			get
			{
				return _zoneFilter;
			}
			set
			{
				if (_zoneFilter != value)
				{
					_zoneFilter = value;
					Version++;
					_config?.ZoneFilter.SetSerializedValue(value ?? "");
				}
			}
		}

		public QuestSortMode SortMode
		{
			get
			{
				return _sortMode;
			}
			set
			{
				if (_sortMode != value)
				{
					_sortMode = value;
					Version++;
					_config?.SortMode.SetSerializedValue(value.ToString());
				}
			}
		}

		public void LoadFrom(GuideConfig config)
		{
			_config = config;
			_filterMode = config.FilterMode.Value;
			_sortMode = config.SortMode.Value;
			string value = config.ZoneFilter.Value;
			_zoneFilter = (string.IsNullOrEmpty(value) ? null : value);
			Version++;
		}
	}
	public sealed class GuideWindow
	{
		private readonly GuideData _data;

		private readonly QuestStateTracker _state;

		private readonly FilterState _filter = new FilterState();

		private readonly QuestListPanel _listPanel;

		private readonly QuestDetailPanel _detailPanel;

		private readonly NavigationHistory _history;

		private readonly GuideConfig _config;

		private bool _visible;

		private LayoutResetState _layoutReset;

		public bool Visible => _visible;

		public FilterState Filter => _filter;

		public GuideWindow(GuideData data, QuestStateTracker state, NavigationController nav, NavigationHistory history, TrackerState tracker, GuideConfig config)
		{
			_data = data;
			_state = state;
			_history = history;
			_config = config;
			_listPanel = new QuestListPanel(data, state, _filter, tracker);
			_detailPanel = new QuestDetailPanel(data, state, nav, tracker, config);
		}

		public void Toggle()
		{
			_visible = !_visible;
		}

		public void Show()
		{
			_visible = true;
		}

		public void Hide()
		{
			_visible = false;
		}

		public void Draw()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			long layoutResetGeneration = _config.LayoutResetGeneration;
			ImGuiCond val = (ImGuiCond)(_layoutReset.IsPending(layoutResetGeneration) ? 1 : 4);
			float resolvedUiScale = _config.ResolvedUiScale;
			Vector2 vector = Theme.DisplaySize();
			ImGui.SetNextWindowSize(new Vector2(780f * resolvedUiScale, 530f * resolvedUiScale), val);
			ImGui.SetNextWindowPos(new Vector2(vector.X * 0.5f, vector.Y * 0.5f), val, new Vector2(0.5f, 0.5f));
			using (Theme.WindowStyleScope(resolvedUiScale))
			{
				bool flag = false;
				try
				{
					bool flag2 = ImGui.Begin("Adventure Guide", ref _visible, (ImGuiWindowFlags)32);
					flag = true;
					_layoutReset.Applied(layoutResetGeneration);
					if (flag2)
					{
						DrawTabBar();
					}
					Theme.ClampWindowPosition();
				}
				finally
				{
					if (flag)
					{
						ImGui.End();
					}
				}
			}
		}

		private void DrawTabBar()
		{
			if (!ImGui.BeginTabBar("##GuideTabs"))
			{
				return;
			}
			try
			{
				if (ImGui.BeginTabItem("Quests"))
				{
					try
					{
						DrawQuestsTab();
					}
					finally
					{
						ImGui.EndTabItem();
					}
				}
				if (ImGui.TabItemButton("<"))
				{
					NavigationHistory.PageRef? pageRef = _history.Back();
					if (pageRef.HasValue && pageRef.Value.Type == NavigationHistory.PageType.Quest)
					{
						_state.SelectedQuestKey = pageRef.Value.Key;
					}
				}
				if (ImGui.TabItemButton(">"))
				{
					NavigationHistory.PageRef? pageRef2 = _history.Forward();
					if (pageRef2.HasValue && pageRef2.Value.Type == NavigationHistory.PageType.Quest)
					{
						_state.SelectedQuestKey = pageRef2.Value.Key;
					}
				}
			}
			finally
			{
				ImGui.EndTabBar();
			}
		}

		private void DrawQuestsTab()
		{
			float num = ImGui.GetContentRegionAvail().X * 0.32f;
			ImGui.BeginChild("##LeftPanel", new Vector2(num, 0f), true);
			try
			{
				_listPanel.Draw(num);
			}
			finally
			{
				ImGui.EndChild();
			}
			ImGui.SameLine();
			ImGui.BeginChild("##RightPanel", Vector2.Zero, true);
			try
			{
				_detailPanel.Draw();
			}
			finally
			{
				ImGui.EndChild();
			}
		}
	}
	internal struct LayoutResetState
	{
		private long _appliedGeneration;

		public readonly bool IsPending(long generation)
		{
			return generation != _appliedGeneration;
		}

		public void Applied(long generation)
		{
			_appliedGeneration = generation;
		}
	}
	public sealed class QuestDetailPanel
	{
		private enum StepState
		{
			Completed,
			Current,
			Future
		}

		private sealed class QuestDisplayCache
		{
			public int CurrentStepIndex;

			public readonly Dictionary<QuestStep, StepDisplayCache> Steps = new Dictionary<QuestStep, StepDisplayCache>();
		}

		private sealed class StepDisplayCache
		{
			public string Text = "";

			public string NavLabel = "";

			public string TipsLabel = "";

			public string? MoreSourcesLabel;

			public string? SubQuestLabel;

			public string? Requirement;

			public bool HasRequiredQuantity;

			public bool Navigable;

			public readonly List<ItemSource> VisibleSources = new List<ItemSource>();

			public readonly Dictionary<(ItemSource Source, int Depth), SourceDisplayCache> Sources = new Dictionary<(ItemSource, int), SourceDisplayCache>();
		}

		private sealed class SourceDisplayCache
		{
			public string Label = "";

			public string ChildrenLabel = "";

			public string? SourceId;

			public string? SelectableLabel;

			public string? QuestTreeLabel;

			public string? OpenQuestLabel;

			public string AddTooltip = "";

			public string RemoveTooltip = "";
		}

		private readonly GuideData _data;

		private readonly QuestStateTracker _state;

		private readonly NavigationController _nav;

		private readonly TrackerState _tracker;

		private readonly GuideConfig _config;

		private readonly Dictionary<QuestEntry, QuestDisplayCache> _questDisplay = new Dictionary<QuestEntry, QuestDisplayCache>();

		private readonly HashSet<string> _visited = new HashSet<string>();

		private readonly List<string> _acquisitionLines = new List<string>();

		private readonly List<string> _completionLines = new List<string>();

		private readonly List<(string Text, bool Secondary)> _rewardLines = new List<(string, bool)>();

		private readonly List<(Prerequisite Prerequisite, string Label)> _prerequisites = new List<(Prerequisite, string)>();

		private readonly Dictionary<QuestStep, ZoneLineAlternativeLabels> _zoneLineLabels = new Dictionary<QuestStep, ZoneLineAlternativeLabels>();

		private HashSet<string>? _stepTreeQuestKeys;

		private DisplayCacheRevision _displayCacheRevision;

		private string? _levelZoneLine;

		private const int MaxSubQuestDepth = 5;

		private bool IsNavigationEnabled => _config.ShowArrow.Value || _config.ShowGroundPath.Value;

		public QuestDetailPanel(GuideData data, QuestStateTracker state, NavigationController nav, TrackerState tracker, GuideConfig config)
		{
			_data = data;
			_state = state;
			_nav = nav;
			_tracker = tracker;
			_config = config;
		}

		public void Draw()
		{
			string selectedQuestKey = _state.SelectedQuestKey;
			int version = _state.Version;
			if (!_displayCacheRevision.IsCurrent(selectedQuestKey, version))
			{
				_displayCacheRevision.Invalidate();
				RebuildDisplayCache(selectedQuestKey);
				_displayCacheRevision.Commit(selectedQuestKey, version);
			}
			if (_state.SelectedQuestKey == null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.TextWrapped("Select a quest from the list.");
				ImGui.PopStyleColor();
				return;
			}
			QuestEntry byRuntimeKey = _data.GetByRuntimeKey(_state.SelectedQuestKey);
			if (byRuntimeKey == null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.TextWrapped("Quest not found in guide data.");
				ImGui.PopStyleColor();
			}
			else
			{
				DrawHeader(byRuntimeKey);
				DrawObjectives(byRuntimeKey);
				DrawRewards(byRuntimeKey);
				DrawPrerequisites(byRuntimeKey);
			}
		}

		private void DrawHeader(QuestEntry quest)
		{
			if (_tracker.Enabled)
			{
				bool flag = _tracker.IsTracked(quest.RuntimeKey);
				bool flag2 = _state.IsCompleted(quest);
				if (!flag2 || flag)
				{
					if (flag)
					{
						ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
					}
					if (ImGui.SmallButton(flag ? "[Untrack]" : "[Track]"))
					{
						if (flag)
						{
							_tracker.Untrack(quest.RuntimeKey);
						}
						else
						{
							_tracker.Track(quest.RuntimeKey);
						}
					}
					if (flag)
					{
						ImGui.PopStyleColor();
					}
					ImGui.SameLine();
				}
			}
			ImGui.PushStyleColor((ImGuiCol)0, Theme.Header);
			ImGui.TextWrapped(quest.DisplayName);
			ImGui.PopStyleColor();
			DrawLevelZoneLine(quest);
			foreach (string acquisitionLine in _acquisitionLines)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.Text(acquisitionLine);
				ImGui.PopStyleColor();
			}
			foreach (string completionLine in _completionLines)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.Text(completionLine);
				ImGui.PopStyleColor();
			}
			if (quest.Description != null)
			{
				ImGui.Spacing();
				ImGui.TextWrapped(quest.Description);
			}
			ImGui.Spacing();
			ImGui.Separator();
			ImGui.Spacing();
		}

		private void DrawLevelZoneLine(QuestEntry quest)
		{
			if (_levelZoneLine == null)
			{
				return;
			}
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			ImGui.Text(_levelZoneLine);
			if (ImGui.IsItemHovered())
			{
				List<QuestStep> steps = quest.Steps;
				if (steps != null && steps.Count > 0)
				{
					ImGui.BeginTooltip();
					ImGui.Text("Quest level: hardest step");
					ImGui.Separator();
					int? num = quest.LevelEstimate?.Recommended;
					foreach (QuestStep step in quest.Steps)
					{
						int? num2 = step.LevelEstimate?.Recommended;
						string text = (num2.HasValue ? $"Lv {num2,2}" : "    ");
						bool flag = num.HasValue && num2 == num;
						string text2 = (flag ? " <" : "");
						uint num3 = (flag ? Theme.TextPrimary : Theme.TextSecondary);
						ImGui.PushStyleColor((ImGuiCol)0, num3);
						ImGui.Text($"  {step.Order}. {step.Description}  {text}{text2}");
						ImGui.PopStyleColor();
					}
					ImGui.EndTooltip();
				}
			}
			ImGui.PopStyleColor();
		}

		private void DrawObjectives(QuestEntry quest)
		{
			if (!quest.HasSteps)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.TextWrapped("No guide data available for this quest.");
				ImGui.PopStyleColor();
				return;
			}
			if (_state.Workflows.IsUnverifiable(quest))
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.Warning);
				ImGui.TextWrapped("Workflow state is ambiguous after reload. Re-enter the trigger area with the required item.");
				ImGui.PopStyleColor();
			}
			if (ImGui.CollapsingHeader("Objectives", (ImGuiTreeNodeFlags)32))
			{
				_visited.Clear();
				_visited.Add(quest.StableKey);
				ImGui.Indent();
				DrawSteps(quest, _visited);
				ImGui.Unindent();
			}
		}

		private void DrawSteps(QuestEntry quest, HashSet<string> visited)
		{
			if (quest.Steps == null || quest.Steps.Count == 0)
			{
				return;
			}
			ImGui.PushID(quest.RuntimeKey);
			int currentStepIndex = _questDisplay[quest].CurrentStepIndex;
			string text = null;
			for (int i = 0; i < quest.Steps.Count; i++)
			{
				QuestStep questStep = quest.Steps[i];
				if (questStep.OrGroup != null && questStep.OrGroup == text)
				{
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
					ImGui.Text("  -- OR --");
					ImGui.PopStyleColor();
				}
				StepState state = ((i >= currentStepIndex) ? ((i == currentStepIndex) ? StepState.Current : StepState.Future) : StepState.Completed);
				DrawStep(questStep, state, quest, visited);
				text = questStep.OrGroup;
			}
			ImGui.PopID();
		}

		private void DrawStep(QuestStep step, StepState state, QuestEntry quest, HashSet<string> visited)
		{
			if (1 == 0)
			{
			}
			uint num = state switch
			{
				StepState.Completed => Theme.QuestCompleted, 
				StepState.Current => Theme.QuestActive, 
				_ => Theme.TextPrimary, 
			};
			if (1 == 0)
			{
			}
			uint num2 = num;
			StepDisplayCache stepDisplayCache = _questDisplay[quest].Steps[step];
			string action = step.Action;
			bool flag = ((action == "collect" || action == "obtain") ? true : false);
			if (flag && step.TargetKey != null && step.Quantity.HasValue && stepDisplayCache.HasRequiredQuantity)
			{
				num2 = Theme.QuestCompleted;
			}
			if (step.Action == "complete_quest" && step.TargetKey != null)
			{
				QuestEntry byStableKey = _data.GetByStableKey(step.TargetKey);
				if (byStableKey != null && _state.IsCompleted(byStableKey))
				{
					num2 = Theme.QuestCompleted;
				}
			}
			DrawNavButton(step, quest);
			ImGui.PushStyleColor((ImGuiCol)0, num2);
			ImGui.Text(stepDisplayCache.Text);
			ImGui.PopStyleColor();
			if (stepDisplayCache.Requirement != null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.Text(stepDisplayCache.Requirement);
				ImGui.PopStyleColor();
			}
			DrawStepSources(step, quest, visited);
			DrawSubQuestSteps(step, quest, visited);
			if (_nav.IsNavigating(quest.RuntimeKey, step.Order))
			{
				List<(ZoneLineEntry, float, bool, bool)> alternativeZoneLines = _nav.GetAlternativeZoneLines(_state.CurrentZone);
				if (alternativeZoneLines.Count > 1)
				{
					DrawZoneLineAlternatives(alternativeZoneLines, step);
				}
			}
		}

		private void DrawNavButton(QuestStep step, QuestEntry quest)
		{
			if (!IsNavigationEnabled || step.TargetKey == null)
			{
				return;
			}
			StepDisplayCache stepDisplayCache = _questDisplay[quest].Steps[step];
			bool navigable = stepDisplayCache.Navigable;
			bool flag = _nav.IsNavigating(quest.RuntimeKey, step.Order);
			if (!navigable)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.PushStyleVar((ImGuiStyleVar)0, 0.4f);
				ImGui.SmallButton(stepDisplayCache.NavLabel);
				ImGui.PopStyleVar();
				ImGui.PopStyleColor();
				if (ImGui.IsItemHovered((ImGuiHoveredFlags)512))
				{
					ImGui.BeginTooltip();
					ImGui.Text("No known source");
					ImGui.EndTooltip();
				}
				ImGui.SameLine();
				return;
			}
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.QuestActive);
			}
			if (ImGui.SmallButton(stepDisplayCache.NavLabel))
			{
				if (flag)
				{
					_nav.Clear();
				}
				else
				{
					_nav.NavigateTo(step, quest, _state.CurrentZone);
				}
			}
			if (flag)
			{
				ImGui.PopStyleColor();
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				if (flag)
				{
					ImGui.Text("Click to stop navigating");
				}
				else
				{
					ImGui.Text("Navigate to " + (step.TargetName ?? step.Description));
				}
				ImGui.EndTooltip();
			}
			ImGui.SameLine();
		}

		private void DrawStepSources(QuestStep step, QuestEntry quest, HashSet<string> visited)
		{
			switch (step.Action)
			{
			case "collect":
			case "obtain":
			case "read":
				if (step.TargetName != null)
				{
					StepDisplayCache stepDisplayCache = _questDisplay[quest].Steps[step];
					List<ItemSource> visibleSources = stepDisplayCache.VisibleSources;
					if (visibleSources.Count == 0)
					{
						DrawTips(step, quest);
						break;
					}
					ImGui.Indent();
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
					int num = Math.Min(visibleSources.Count, 4);
					for (int i = 0; i < num; i++)
					{
						DrawSource(visibleSources[i], quest, step, visited);
					}
					if (visibleSources.Count > 4 && ImGui.TreeNode(stepDisplayCache.MoreSourcesLabel))
					{
						for (int j = 4; j < visibleSources.Count; j++)
						{
							DrawSource(visibleSources[j], quest, step, visited);
						}
						ImGui.TreePop();
					}
					ImGui.PopStyleColor();
					ImGui.Unindent();
					DrawTips(step, quest);
					break;
				}
				goto default;
			default:
				DrawTips(step, quest);
				break;
			}
		}

		private void DrawZoneLineAlternatives(List<(ZoneLineEntry line, float distance, bool isSelected, bool isAccessible)> alternatives, QuestStep step)
		{
			ImGui.Indent();
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			if (!_zoneLineLabels.TryGetValue(step, out ZoneLineAlternativeLabels value))
			{
				value = new ZoneLineAlternativeLabels(step.Order);
				_zoneLineLabels.Add(step, value);
			}
			if (ImGui.TreeNode(value.Header(alternatives.Count)))
			{
				for (int i = 0; i < alternatives.Count; i++)
				{
					(ZoneLineEntry line, float distance, bool isSelected, bool isAccessible) tuple = alternatives[i];
					ZoneLineEntry item = tuple.line;
					float item2 = tuple.distance;
					bool item3 = tuple.isSelected;
					bool item4 = tuple.isAccessible;
					ZoneLineAlternativeLabels.RowLabels rowLabels = value.Row(i, item.DestinationDisplay, item2);
					if (!item4)
					{
						ImGui.PushStyleVar((ImGuiStyleVar)0, 0.3f);
						ImGui.TextUnformatted(rowLabels.Text);
						ImGui.PopStyleVar();
						if (item.RequiredQuestGroups == null)
						{
							continue;
						}
						using List<List<string>>.Enumerator enumerator = item.RequiredQuestGroups.GetEnumerator();
						if (!enumerator.MoveNext())
						{
							continue;
						}
						List<string> current = enumerator.Current;
						foreach (string item5 in current)
						{
							if (_state.IsGameQuestCompleted(item5))
							{
								continue;
							}
							QuestEntry byDBName = _data.GetByDBName(item5);
							if (byDBName != null)
							{
								ImGui.Indent();
								if (ImGui.Selectable(rowLabels.Requirement(byDBName.DisplayName, item5)))
								{
									_state.SelectQuest(byDBName);
								}
								ImGui.Unindent();
							}
						}
					}
					else
					{
						if (item3)
						{
							ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
						}
						if (ImGui.Selectable(rowLabels.Selectable))
						{
							_nav.PinZoneLine(item);
						}
						if (item3)
						{
							ImGui.PopStyleColor();
						}
						if (ImGui.IsItemHovered())
						{
							ImGui.BeginTooltip();
							ImGui.TextUnformatted(rowLabels.Tooltip);
							ImGui.EndTooltip();
						}
					}
				}
				ImGui.TreePop();
			}
			ImGui.PopStyleColor();
			ImGui.Unindent();
		}

		private void DrawSource(ItemSource src, QuestEntry quest, QuestStep step, HashSet<string> visited, int depth = 0, bool allowNavigation = true)
		{
			if (!IsSourceAvailable(src))
			{
				return;
			}
			SourceDisplayCache sourceDisplayCache = _questDisplay[quest].Steps[step].Sources[(src, depth)];
			string label = sourceDisplayCache.Label;
			if (allowNavigation && src.Type == "quest_reward" && src.QuestKey != null)
			{
				QuestEntry byStableKey = _data.GetByStableKey(src.QuestKey);
				List<QuestStep> list = byStableKey?.Steps;
				if (list != null && list.Count > 0 && visited.Count <= 5 && !visited.Contains(byStableKey.StableKey))
				{
					DrawQuestRewardTree(byStableKey, sourceDisplayCache, visited);
					return;
				}
			}
			List<ItemSource> children = src.Children;
			if (children != null && children.Count > 0 && depth < 3)
			{
				if (ImGui.TreeNode(sourceDisplayCache.ChildrenLabel))
				{
					if (src.Type == "quest_reward" && src.QuestKey != null)
					{
						QuestEntry byStableKey2 = _data.GetByStableKey(src.QuestKey);
						if (byStableKey2 != null)
						{
							ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
							if (ImGui.Selectable(sourceDisplayCache.OpenQuestLabel))
							{
								_state.SelectQuest(byStableKey2);
							}
							ImGui.PopStyleColor();
						}
					}
					foreach (ItemSource child in src.Children)
					{
						DrawSource(child, quest, step, visited, depth + 1, allowNavigation && ItemSourcePolicy.NeedsUsedItem(src, _state.CountItemDelegate));
					}
					ImGui.TreePop();
				}
			}
			else
			{
				if (allowNavigation)
				{
					string sourceId = sourceDisplayCache.SourceId;
					if (sourceId != null)
					{
						bool flag = _nav.IsSourceActive(sourceId);
						if (flag)
						{
							uint num = (_nav.IsManualSourceOverride ? Theme.NavManualOverride : Theme.QuestActive);
							ImGui.PushStyleColor((ImGuiCol)0, num);
						}
						if (ImGui.Selectable(sourceDisplayCache.SelectableLabel))
						{
							if (src.Type == "treasure_chest")
							{
								_nav.NavigateToTreasureHunt(quest.RuntimeKey, step.Order);
							}
							else
							{
								_nav.ToggleSource(sourceId, _state.CurrentZone);
							}
						}
						if (flag)
						{
							ImGui.PopStyleColor();
						}
						if (ImGui.IsItemHovered())
						{
							ImGui.BeginTooltip();
							ImGui.TextUnformatted(flag ? sourceDisplayCache.RemoveTooltip : sourceDisplayCache.AddTooltip);
							ImGui.EndTooltip();
						}
						goto IL_030b;
					}
				}
				ImGui.PushStyleColor((ImGuiCol)0, Theme.SourceDimmed);
				ImGui.TextUnformatted(label);
				ImGui.PopStyleColor();
			}
			goto IL_030b;
			IL_030b:
			if (src.Type != "vendor" && src.Instruction != null)
			{
				ImGui.Indent();
				ImGui.TextWrapped(src.Instruction);
				ImGui.Unindent();
			}
		}

		private void DrawSubQuestSteps(QuestStep step, QuestEntry quest, HashSet<string> visited)
		{
			if (step.Action != "complete_quest" || step.TargetKey == null)
			{
				return;
			}
			QuestEntry byStableKey = _data.GetByStableKey(step.TargetKey);
			if (byStableKey?.Steps != null && byStableKey.Steps.Count != 0 && visited.Count <= 5 && !visited.Contains(byStableKey.StableKey))
			{
				ImGui.Indent();
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
				if (ImGui.Selectable(_questDisplay[quest].Steps[step].SubQuestLabel))
				{
					_state.SelectQuest(byStableKey);
				}
				ImGui.PopStyleColor();
				visited.Add(byStableKey.StableKey);
				DrawSteps(byStableKey, visited);
				visited.Remove(byStableKey.StableKey);
				ImGui.Unindent();
			}
		}

		private void DrawQuestRewardTree(QuestEntry subQuest, SourceDisplayCache display, HashSet<string> visited)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _state.IsCompleted(subQuest);
			ImGuiTreeNodeFlags val = (ImGuiTreeNodeFlags)((!flag) ? 32 : 0);
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestCompleted);
			}
			bool flag2 = ImGui.TreeNodeEx(display.QuestTreeLabel, val);
			if (flag)
			{
				ImGui.PopStyleColor();
			}
			if (flag2)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
				if (ImGui.Selectable(display.OpenQuestLabel))
				{
					_state.SelectQuest(subQuest);
				}
				ImGui.PopStyleColor();
				visited.Add(subQuest.StableKey);
				DrawSteps(subQuest, visited);
				visited.Remove(subQuest.StableKey);
				ImGui.TreePop();
			}
		}

		private void DrawTips(QuestStep step, QuestEntry quest)
		{
			if (step.Tips == null || step.Tips.Count == 0)
			{
				return;
			}
			ImGui.Indent();
			if (ImGui.TreeNode(_questDisplay[quest].Steps[step].TipsLabel))
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				foreach (string tip in step.Tips)
				{
					ImGui.TextWrapped(tip);
				}
				ImGui.PopStyleColor();
				ImGui.TreePop();
			}
			ImGui.Unindent();
		}

		private void DrawRewards(QuestEntry quest)
		{
			RewardInfo rewards = quest.Rewards;
			if (rewards == null || !HasAnyRewards(rewards) || !ImGui.CollapsingHeader("Rewards", (ImGuiTreeNodeFlags)32))
			{
				return;
			}
			ImGui.Indent();
			foreach (var rewardLine in _rewardLines)
			{
				if (rewardLine.Secondary)
				{
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				}
				ImGui.Text(rewardLine.Text);
				if (rewardLine.Secondary)
				{
					ImGui.PopStyleColor();
				}
			}
			ImGui.Unindent();
		}

		private static bool HasAnyRewards(RewardInfo r)
		{
			int result;
			if (r.XP <= 0 && r.Gold <= 0 && r.ItemName == null && r.VendorUnlock == null)
			{
				List<UnlockedZoneLine> unlockedZoneLines = r.UnlockedZoneLines;
				if (unlockedZoneLines == null || unlockedZoneLines.Count <= 0)
				{
					List<UnlockedCharacter> unlockedCharacters = r.UnlockedCharacters;
					if ((unlockedCharacters == null || unlockedCharacters.Count <= 0) && r.NextQuestName == null)
					{
						List<FactionEffect> factionEffects = r.FactionEffects;
						if (factionEffects == null || factionEffects.Count <= 0)
						{
							List<string> alsoCompletes = r.AlsoCompletes;
							result = ((alsoCompletes != null && alsoCompletes.Count > 0) ? 1 : 0);
							goto IL_007c;
						}
					}
				}
			}
			result = 1;
			goto IL_007c;
			IL_007c:
			return (byte)result != 0;
		}

		private void DrawPrerequisites(QuestEntry quest)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			List<(Prerequisite, string)> prerequisites = _prerequisites;
			if (prerequisites.Count == 0)
			{
				return;
			}
			bool flag = false;
			foreach (var item in prerequisites)
			{
				if (!IsPrerequisiteCompleted(item.Item1))
				{
					flag = true;
					break;
				}
			}
			ImGuiTreeNodeFlags val = (ImGuiTreeNodeFlags)(flag ? 32 : 0);
			if (!ImGui.CollapsingHeader("Prerequisites", val))
			{
				return;
			}
			ImGui.Indent();
			foreach (var item2 in prerequisites)
			{
				uint num = (IsPrerequisiteCompleted(item2.Item1) ? Theme.QuestCompleted : Theme.TextPrimary);
				ImGui.PushStyleColor((ImGuiCol)0, num);
				if (ImGui.Selectable(item2.Item2))
				{
					QuestEntry byStableKey = _data.GetByStableKey(item2.Item1.QuestKey);
					if (byStableKey != null)
					{
						_state.SelectQuest(byStableKey);
					}
				}
				ImGui.PopStyleColor();
			}
			ImGui.Unindent();
		}

		private static HashSet<string> CollectStepTreeQuestKeys(QuestEntry quest)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (quest.Steps != null)
			{
				foreach (QuestStep step in quest.Steps)
				{
					if (step.Action == "complete_quest" && step.TargetKey != null)
					{
						hashSet.Add(step.TargetKey);
					}
					if (step.Sources != null)
					{
						CollectQuestRewardKeys(step.Sources, hashSet);
					}
				}
			}
			if (quest.RequiredItems != null)
			{
				foreach (RequiredItemInfo requiredItem in quest.RequiredItems)
				{
					if (requiredItem.Sources != null)
					{
						CollectQuestRewardKeys(requiredItem.Sources, hashSet);
					}
				}
			}
			return hashSet;
		}

		private static void CollectQuestRewardKeys(List<ItemSource> sources, HashSet<string> keys)
		{
			foreach (ItemSource source in sources)
			{
				if (source.Type == "quest_reward" && source.QuestKey != null)
				{
					keys.Add(source.QuestKey);
				}
				if (source.Children != null)
				{
					CollectQuestRewardKeys(source.Children, keys);
				}
			}
		}

		private bool IsPrerequisiteCompleted(Prerequisite prereq)
		{
			QuestEntry byStableKey = _data.GetByStableKey(prereq.QuestKey);
			return byStableKey != null && _state.IsCompleted(byStableKey);
		}

		private void RebuildDisplayCache(string? questKey)
		{
			_questDisplay.Clear();
			_zoneLineLabels.Clear();
			_visited.Clear();
			_acquisitionLines.Clear();
			_completionLines.Clear();
			_rewardLines.Clear();
			_prerequisites.Clear();
			_stepTreeQuestKeys = null;
			_levelZoneLine = null;
			QuestEntry questEntry = ((questKey == null) ? null : _data.GetByRuntimeKey(questKey));
			if (questEntry == null)
			{
				return;
			}
			CacheHeader(questEntry);
			CacheRewards(questEntry.Rewards);
			_stepTreeQuestKeys = CollectStepTreeQuestKeys(questEntry);
			if (questEntry.Prerequisites != null)
			{
				foreach (Prerequisite prerequisite in questEntry.Prerequisites)
				{
					if (!_stepTreeQuestKeys.Contains(prerequisite.QuestKey))
					{
						string text = ((prerequisite.Item != null) ? (prerequisite.QuestName + " (" + prerequisite.Item + ")") : prerequisite.QuestName);
						_prerequisites.Add((prerequisite, text + "##prereq_" + prerequisite.QuestKey));
					}
				}
			}
			_visited.Add(questEntry.StableKey);
			CacheStepTree(questEntry, _visited);
			_visited.Clear();
		}

		private void CacheHeader(QuestEntry quest)
		{
			int? num = quest.LevelEstimate?.Recommended;
			string zoneContext = quest.ZoneContext;
			bool flag = quest.Flags?.Repeatable ?? false;
			if (num.HasValue || zoneContext != null || flag)
			{
				string text = (num.HasValue ? $"Lv {num}" : "");
				if (zoneContext != null)
				{
					if (text.Length > 0)
					{
						text += "  ·  ";
					}
					text += zoneContext;
				}
				if (flag)
				{
					if (text.Length > 0)
					{
						text += "  ·  ";
					}
					text += "Repeatable";
				}
				_levelZoneLine = text;
			}
			if (quest.Acquisition != null)
			{
				foreach (AcquisitionSource item in quest.Acquisition)
				{
					string method = item.Method;
					if (1 == 0)
					{
					}
					string text2;
					switch (method)
					{
					case "dialog":
						if (item.SourceName == null)
						{
							goto default;
						}
						text2 = "Given by: " + item.SourceName;
						break;
					case "item_read":
						if (item.SourceName == null)
						{
							goto default;
						}
						text2 = "Read: " + item.SourceName;
						break;
					case "zone_entry":
						if (item.SourceName == null)
						{
							goto default;
						}
						text2 = "Enter: " + item.SourceName;
						break;
					case "quest_chain":
						if (item.SourceName == null)
						{
							goto default;
						}
						text2 = "Chain from: " + item.SourceName;
						break;
					default:
						text2 = ((item.SourceName != null) ? ("From: " + item.SourceName) : null);
						break;
					}
					if (1 == 0)
					{
					}
					string text3 = text2;
					if (text3 != null)
					{
						if (item.ZoneName != null && item.Method == "dialog")
						{
							text3 = text3 + " (" + item.ZoneName + ")";
						}
						_acquisitionLines.Add(text3);
					}
				}
			}
			if (quest.Completion == null)
			{
				return;
			}
			foreach (CompletionSource item2 in quest.Completion)
			{
				string method2 = item2.Method;
				if (1 == 0)
				{
				}
				string text2;
				switch (method2)
				{
				case "item_turnin":
				case "dialog":
					if (item2.SourceName == null)
					{
						goto default;
					}
					text2 = "Turn in to: " + item2.SourceName;
					break;
				case "zone":
					if (item2.SourceName == null)
					{
						goto default;
					}
					text2 = "Complete at: " + item2.SourceName;
					break;
				default:
					text2 = ((item2.SourceName == null) ? null : ("Complete: " + item2.SourceName));
					break;
				}
				if (1 == 0)
				{
				}
				string text4 = text2;
				if (text4 != null)
				{
					bool flag2 = item2.ZoneName != null;
					bool flag3 = flag2;
					if (flag3)
					{
						text2 = item2.Method;
						bool flag4 = ((text2 == "item_turnin" || text2 == "dialog") ? true : false);
						flag3 = flag4;
					}
					if (flag3)
					{
						text4 = text4 + " (" + item2.ZoneName + ")";
					}
					_completionLines.Add(text4);
				}
			}
		}

		private void CacheRewards(RewardInfo? r)
		{
			if (r == null)
			{
				return;
			}
			if (r.XP > 0)
			{
				_rewardLines.Add(($"{r.XP} XP", false));
			}
			if (r.Gold > 0)
			{
				_rewardLines.Add(($"{r.Gold} Gold", false));
			}
			if (r.ItemName != null)
			{
				_rewardLines.Add((r.ItemName, false));
			}
			if (r.VendorUnlock != null)
			{
				_rewardLines.Add(("Unlocks " + r.VendorUnlock.ItemName + " at " + r.VendorUnlock.VendorName, false));
			}
			List<string> coRequirements;
			if (r.UnlockedZoneLines != null)
			{
				foreach (UnlockedZoneLine unlockedZoneLine in r.UnlockedZoneLines)
				{
					string text = "Opens path from " + unlockedZoneLine.FromZone + " to " + unlockedZoneLine.ToZone;
					coRequirements = unlockedZoneLine.CoRequirements;
					if (coRequirements != null && coRequirements.Count > 0)
					{
						text = text + " (also requires " + string.Join(", ", unlockedZoneLine.CoRequirements) + ")";
					}
					_rewardLines.Add((text, false));
				}
			}
			if (r.UnlockedCharacters != null)
			{
				foreach (UnlockedCharacter unlockedCharacter in r.UnlockedCharacters)
				{
					string item = ((unlockedCharacter.Zone != null) ? ("Enables " + unlockedCharacter.Name + " in " + unlockedCharacter.Zone) : ("Enables " + unlockedCharacter.Name));
					_rewardLines.Add((item, false));
				}
			}
			if (r.NextQuestName != null)
			{
				_rewardLines.Add(("Next: " + r.NextQuestName, true));
			}
			if (r.FactionEffects != null)
			{
				foreach (FactionEffect factionEffect in r.FactionEffects)
				{
					string arg = ((factionEffect.Amount >= 0) ? "+" : "");
					_rewardLines.Add(($"{factionEffect.FactionName}: {arg}{factionEffect.Amount}", false));
				}
			}
			coRequirements = r.AlsoCompletes;
			if (coRequirements != null && coRequirements.Count > 0)
			{
				_rewardLines.Add(("Also completes: " + string.Join(", ", r.AlsoCompletes), true));
			}
		}

		private void CacheStepTree(QuestEntry quest, HashSet<string> visited)
		{
			if (!_questDisplay.TryGetValue(quest, out QuestDisplayCache value))
			{
				value = new QuestDisplayCache
				{
					CurrentStepIndex = StepProgress.GetCurrentStepIndex(quest, _state, _data)
				};
				_questDisplay.Add(quest, value);
				if (quest.Steps != null)
				{
					foreach (QuestStep step in quest.Steps)
					{
						value.Steps.Add(step, CacheStep(quest, step));
					}
				}
			}
			if (quest.Steps == null)
			{
				return;
			}
			foreach (QuestStep step2 in quest.Steps)
			{
				foreach (ItemSource visibleSource in value.Steps[step2].VisibleSources)
				{
					CacheSourceQuestTree(visibleSource, visited);
				}
				if (step2.Action == "complete_quest" && step2.TargetKey != null)
				{
					CacheInlineQuest(_data.GetByStableKey(step2.TargetKey), visited);
				}
			}
		}

		private void CacheInlineQuest(QuestEntry? quest, HashSet<string> visited)
		{
			List<QuestStep> list = quest?.Steps;
			if (list != null && list.Count > 0 && visited.Count <= 5 && !visited.Contains(quest.StableKey))
			{
				visited.Add(quest.StableKey);
				CacheStepTree(quest, visited);
				visited.Remove(quest.StableKey);
			}
		}

		private void CacheSourceQuestTree(ItemSource src, HashSet<string> visited, int depth = 0)
		{
			if (!IsSourceAvailable(src))
			{
				return;
			}
			if (src.Type == "quest_reward" && src.QuestKey != null)
			{
				QuestEntry byStableKey = _data.GetByStableKey(src.QuestKey);
				List<QuestStep> list = byStableKey?.Steps;
				if (list != null && list.Count > 0 && visited.Count <= 5 && !visited.Contains(byStableKey.StableKey))
				{
					CacheInlineQuest(byStableKey, visited);
					return;
				}
			}
			if (src.Children == null || depth >= 3)
			{
				return;
			}
			foreach (ItemSource child in src.Children)
			{
				CacheSourceQuestTree(child, visited, depth + 1);
			}
		}

		private StepDisplayCache CacheStep(QuestEntry quest, QuestStep step)
		{
			StepDisplayCache stepDisplayCache = new StepDisplayCache
			{
				Text = $"{step.Order}. {step.Description}",
				NavLabel = $"[NAV]##{step.Order}",
				TipsLabel = $"Tips##{step.Order}"
			};
			if (StepCountPolicy.ShowsInventoryCount(step))
			{
				int num = _state.CountItem(step.TargetKey);
				stepDisplayCache.Text += $" ({num}/{step.Quantity})";
				stepDisplayCache.HasRequiredQuantity = num >= step.Quantity.Value;
			}
			int? num2 = step.LevelEstimate?.Recommended;
			if (num2.HasValue)
			{
				int valueOrDefault = num2.GetValueOrDefault();
				if (true)
				{
					switch (step.Action)
					{
					default:
					{
						List<LevelFactor> factors = step.LevelEstimate.Factors;
						if (factors != null && factors.Count > 0)
						{
							stepDisplayCache.Text = stepDisplayCache.Text + "  ·  " + step.LevelEstimate.Factors[0].Name;
						}
						break;
					}
					case "collect":
					case "obtain":
					case "read":
						break;
					}
					stepDisplayCache.Text += $"  ·  Lv {valueOrDefault}";
					goto IL_023c;
				}
			}
			switch (step.Action)
			{
			default:
			{
				List<LevelFactor> factors = step.LevelEstimate?.Factors;
				if (factors != null && factors.Count > 0)
				{
					stepDisplayCache.Text = stepDisplayCache.Text + "  ·  " + step.LevelEstimate.Factors[0].Name;
				}
				break;
			}
			case "collect":
			case "obtain":
			case "read":
				break;
			}
			goto IL_023c;
			IL_023c:
			List<ItemSource> list = ItemSourcePolicy.SourcesFor(quest, step);
			if (step.TargetType == "item" && list != null)
			{
				foreach (ItemSource item in list)
				{
					if (HasNavigableSource(item))
					{
						stepDisplayCache.Navigable = true;
						break;
					}
				}
			}
			else if (step.TargetType == "character")
			{
				stepDisplayCache.Navigable = step.TargetKey != null && _data.CharacterSpawns.ContainsKey(step.TargetKey);
				string text = _state.Furnishings.RequirementText(step.TargetKey);
				if (text != null)
				{
					stepDisplayCache.Requirement = "     " + text;
				}
			}
			else if (step.TargetType == "zone")
			{
				stepDisplayCache.Navigable = step.ZoneName != null || step.TargetKey != null;
			}
			bool flag;
			switch (step.Action)
			{
			case "collect":
			case "obtain":
			case "read":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag && step.TargetName != null && list != null)
			{
				foreach (ItemSource item2 in list)
				{
					if (IsSourceAvailable(item2))
					{
						stepDisplayCache.VisibleSources.Add(item2);
						CacheSourceLabels(item2, step, stepDisplayCache);
					}
				}
			}
			if (stepDisplayCache.VisibleSources.Count > 4)
			{
				stepDisplayCache.MoreSourcesLabel = SourceListText.MoreSources(stepDisplayCache.VisibleSources, 4) + "##" + step.Order;
			}
			if (step.Action == "complete_quest" && step.TargetKey != null)
			{
				QuestEntry byStableKey = _data.GetByStableKey(step.TargetKey);
				if (byStableKey != null)
				{
					stepDisplayCache.SubQuestLabel = $"Open quest: {byStableKey.DisplayName}##cq_{step.Order}_{step.TargetKey}";
				}
			}
			return stepDisplayCache;
		}

		private void CacheSourceLabels(ItemSource src, QuestStep step, StepDisplayCache stepDisplay, int depth = 0)
		{
			if (stepDisplay.Sources.ContainsKey((src, depth)))
			{
				return;
			}
			string text = SourceListText.Label(src);
			SourceDisplayCache sourceDisplayCache = new SourceDisplayCache();
			sourceDisplayCache.Label = text;
			sourceDisplayCache.ChildrenLabel = $"{text}##src_{step.Order}_{depth}_{src.Type}_{src.Name}";
			sourceDisplayCache.SourceId = ((src.Type == "treasure_chest" && !_state.TreasureHunt.State.Active) ? null : src.MakeSourceId());
			sourceDisplayCache.AddTooltip = ((src.Type == "treasure_chest") ? "Navigate to the active treasure dig site." : ("Add to navigation: " + (src.Name ?? src.Zone ?? src.Scene)));
			sourceDisplayCache.RemoveTooltip = ((src.Type == "treasure_chest") ? "Navigate to the active treasure dig site." : ("Remove from navigation: " + (src.Name ?? src.Zone ?? src.Scene)));
			SourceDisplayCache sourceDisplayCache2 = sourceDisplayCache;
			if (sourceDisplayCache2.SourceId != null)
			{
				sourceDisplayCache2.SelectableLabel = $"{text}##src_{step.Order}_{depth}_{sourceDisplayCache2.SourceId}_{src.Level}_{src.LevelMax}";
			}
			if (src.Type == "quest_reward" && src.QuestKey != null)
			{
				sourceDisplayCache2.QuestTreeLabel = $"{text}##sqt_{step.Order}_{src.QuestKey}";
				QuestEntry byStableKey = _data.GetByStableKey(src.QuestKey);
				if (byStableKey != null)
				{
					sourceDisplayCache2.OpenQuestLabel = $"Open quest: {byStableKey.DisplayName}##goto_{step.Order}_{src.QuestKey}";
				}
			}
			stepDisplay.Sources.Add((src, depth), sourceDisplayCache2);
			if (src.Children == null || depth >= 3)
			{
				return;
			}
			foreach (ItemSource child in src.Children)
			{
				CacheSourceLabels(child, step, stepDisplay, depth + 1);
			}
		}

		private bool IsSourceAvailable(ItemSource source)
		{
			if (source.RequiredQuestDBNames != null)
			{
				foreach (string requiredQuestDBName in source.RequiredQuestDBNames)
				{
					if (!_state.IsGameQuestCompleted(requiredQuestDBName))
					{
						return false;
					}
				}
			}
			return source.SourceKey == null || _state.Furnishings.IsAvailable(source.SourceKey);
		}

		private bool HasNavigableSource(ItemSource s)
		{
			if (!IsSourceAvailable(s))
			{
				return false;
			}
			if (s.Type == "treasure_chest")
			{
				return _state.TreasureHunt.State.Active;
			}
			if (ItemSourcePolicy.IsRandomSource(s) || !ItemSourcePolicy.NeedsUsedItem(s, _state.CountItemDelegate))
			{
				return false;
			}
			if (ItemSourcePolicy.IsStaticCandidate(s) && s.Scene != null)
			{
				return true;
			}
			if (ItemSourcePolicy.IsStaticCandidate(s) && s.SourceKey != null && _data.CharacterSpawns.TryGetValue(s.SourceKey, out List<SpawnPoint> value) && value.Count > 0)
			{
				return true;
			}
			if (s.Children != null)
			{
				foreach (ItemSource child in s.Children)
				{
					if (HasNavigableSource(child))
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public sealed class QuestListPanel
	{
		private readonly struct RowText
		{
			public readonly string Label;

			public readonly string Id;

			public RowText(string label, string id)
			{
				Label = label;
				Id = id;
			}
		}

		private readonly GuideData _data;

		private readonly QuestStateTracker _state;

		private readonly FilterState _filter;

		private readonly TrackerState _tracker;

		private string _searchBuf = string.Empty;

		private readonly List<QuestEntry> _sorted = new List<QuestEntry>();

		private readonly Dictionary<QuestEntry, RowText> _rowText = new Dictionary<QuestEntry, RowText>();

		private int _lastFilterVersion = -1;

		private int _lastStateVersion = -1;

		private static readonly string[] FilterNames = new string[4] { "Active", "Available", "Completed", "All" };

		private const string QuestTrackedMarker = "·";

		private int _filterIndex;

		private const string CurrentZoneSentinel = "\u001current";

		private readonly string[] _zoneNames;

		private int _zoneIndex;

		private static float QuestListMarkerStartX(float contentStartX)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ImGuiStylePtr style = ImGui.GetStyle();
			return contentStartX + ((ImGuiStylePtr)(ref style)).FramePadding.X;
		}

		private static float QuestListMarkerColumnWidth()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ImGuiStylePtr style = ImGui.GetStyle();
			return ImGui.CalcTextSize("·").X + ((ImGuiStylePtr)(ref style)).ItemInnerSpacing.X;
		}

		public QuestListPanel(GuideData data, QuestStateTracker state, FilterState filter, TrackerState tracker)
		{
			_data = data;
			_state = state;
			_filter = filter;
			_tracker = tracker;
			SortedSet<string> sortedSet = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (QuestEntry item in data.All)
			{
				if (item.ZoneContext != null)
				{
					sortedSet.Add(item.ZoneContext);
				}
			}
			_zoneNames = new string[sortedSet.Count + 2];
			_zoneNames[0] = "All Zones";
			_zoneNames[1] = "Current Zone";
			int num = 2;
			foreach (string item2 in sortedSet)
			{
				_zoneNames[num++] = item2;
			}
		}

		public void Draw(float width)
		{
			DrawFilterRow(width);
			DrawZoneFilter();
			DrawSearchBar();
			ImGui.Separator();
			ImGui.BeginChild("##QuestScroll");
			if (DrawQuestList() == 0)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				if (_data.Count == 0)
				{
					ImGui.TextWrapped("No quest data loaded.");
				}
				else if (!string.IsNullOrEmpty(_filter.SearchText))
				{
					ImGui.TextWrapped("No quests match your search.");
				}
				else
				{
					ImGui.TextWrapped("No quests in this category.");
				}
				ImGui.PopStyleColor();
			}
			ImGui.EndChild();
		}

		private void DrawFilterRow(float width)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			_filterIndex = (int)_filter.FilterMode;
			ImGui.SetNextItemWidth(width * 0.55f);
			if (ImGui.Combo("##Filter", ref _filterIndex, FilterNames, FilterNames.Length))
			{
				_filter.FilterMode = (QuestFilterMode)_filterIndex;
			}
			ImGui.SameLine();
			DrawSortButton("Az##sort", QuestSortMode.Alphabetical, "Sort alphabetically");
			ImGuiStylePtr style = ImGui.GetStyle();
			ImGui.SameLine(0f, ((ImGuiStylePtr)(ref style)).ItemSpacing.X * 0.25f);
			DrawSortButton("Lv##sort", QuestSortMode.ByLevel, "Sort by level");
			style = ImGui.GetStyle();
			ImGui.SameLine(0f, ((ImGuiStylePtr)(ref style)).ItemSpacing.X * 0.25f);
			DrawSortButton("Zn##sort", QuestSortMode.ByZone, "Sort by zone");
			ImGui.Spacing();
		}

		private void DrawSortButton(string label, QuestSortMode mode, string tooltip)
		{
			bool flag = _filter.SortMode == mode;
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
			}
			if (ImGui.SmallButton(label))
			{
				_filter.SortMode = mode;
			}
			if (flag)
			{
				ImGui.PopStyleColor();
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				ImGui.TextUnformatted(tooltip);
				ImGui.EndTooltip();
			}
		}

		private void DrawZoneFilter()
		{
			_zoneIndex = 0;
			if (_filter.ZoneFilter != null)
			{
				if (_filter.ZoneFilter == "\u001current")
				{
					_zoneIndex = 1;
				}
				else
				{
					for (int i = 2; i < _zoneNames.Length; i++)
					{
						if (string.Equals(_zoneNames[i], _filter.ZoneFilter, StringComparison.OrdinalIgnoreCase))
						{
							_zoneIndex = i;
							break;
						}
					}
				}
			}
			ImGui.SetNextItemWidth(-1f);
			if (ImGui.Combo("##Zone", ref _zoneIndex, _zoneNames, _zoneNames.Length))
			{
				FilterState filter = _filter;
				int zoneIndex = _zoneIndex;
				if (1 == 0)
				{
				}
				string zoneFilter = zoneIndex switch
				{
					0 => null, 
					1 => "\u001current", 
					_ => _zoneNames[_zoneIndex], 
				};
				if (1 == 0)
				{
				}
				filter.ZoneFilter = zoneFilter;
			}
			ImGui.Spacing();
		}

		private void DrawSearchBar()
		{
			if (_searchBuf != _filter.SearchText)
			{
				_searchBuf = _filter.SearchText;
			}
			ImGui.SetNextItemWidth(-1f);
			if (ImGui.InputTextWithHint("##QuestSearch", "Search quests...", ref _searchBuf, 256u))
			{
				_filter.SearchText = _searchBuf;
			}
			ImGui.Spacing();
		}

		private int DrawQuestList()
		{
			bool flag = _filter.Version != _lastFilterVersion;
			bool flag2 = _state.Version != _lastStateVersion;
			if (flag || flag2)
			{
				_lastFilterVersion = _filter.Version;
				_lastStateVersion = _state.Version;
				_sorted.Clear();
				IReadOnlyList<QuestEntry> all = _data.All;
				for (int i = 0; i < all.Count; i++)
				{
					QuestEntry questEntry = all[i];
					if (PassesFilter(questEntry) && PassesSearch(questEntry))
					{
						_sorted.Add(questEntry);
					}
				}
				_sorted.Sort(CompareQuests);
			}
			float markerWidth = QuestListMarkerColumnWidth();
			foreach (QuestEntry item in _sorted)
			{
				DrawQuestEntry(item, markerWidth);
			}
			return _sorted.Count;
		}

		private int CompareQuests(QuestEntry a, QuestEntry b)
		{
			QuestSortMode sortMode = _filter.SortMode;
			if (1 == 0)
			{
			}
			int result = sortMode switch
			{
				QuestSortMode.ByLevel => CompareLevels(a, b), 
				QuestSortMode.ByZone => CompareZones(a, b), 
				_ => string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static int CompareLevels(QuestEntry a, QuestEntry b)
		{
			int? num = a.LevelEstimate?.Recommended;
			int? num2 = b.LevelEstimate?.Recommended;
			if (!num.HasValue && !num2.HasValue)
			{
				return string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase);
			}
			if (!num.HasValue)
			{
				return 1;
			}
			if (!num2.HasValue)
			{
				return -1;
			}
			int num3 = num.Value.CompareTo(num2.Value);
			return (num3 != 0) ? num3 : string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase);
		}

		private static int CompareZones(QuestEntry a, QuestEntry b)
		{
			if (a.ZoneContext == null && b.ZoneContext == null)
			{
				return string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase);
			}
			if (a.ZoneContext == null)
			{
				return 1;
			}
			if (b.ZoneContext == null)
			{
				return -1;
			}
			int num = string.Compare(a.ZoneContext, b.ZoneContext, StringComparison.OrdinalIgnoreCase);
			return (num != 0) ? num : string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase);
		}

		private bool PassesFilter(QuestEntry quest)
		{
			QuestRuntimeStatus status = _state.GetStatus(quest);
			QuestFilterMode filterMode = _filter.FilterMode;
			if (1 == 0)
			{
			}
			bool flag;
			switch (filterMode)
			{
			case QuestFilterMode.Active:
			{
				bool flag2 = (uint)(status - 1) <= 1u;
				flag = flag2;
				break;
			}
			case QuestFilterMode.Available:
				flag = status == QuestRuntimeStatus.Available;
				break;
			case QuestFilterMode.Completed:
				flag = status == QuestRuntimeStatus.Completed;
				break;
			case QuestFilterMode.All:
				flag = true;
				break;
			default:
				flag = true;
				break;
			}
			if (1 == 0)
			{
			}
			if (!flag)
			{
				return false;
			}
			if (_filter.ZoneFilter != null)
			{
				string text = ((_filter.ZoneFilter == "\u001current") ? _data.GetZoneDisplayName(_state.CurrentZone) : _filter.ZoneFilter);
				if (text == null)
				{
					return true;
				}
				return string.Equals(quest.ZoneContext, text, StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private bool PassesSearch(QuestEntry quest)
		{
			if (string.IsNullOrEmpty(_filter.SearchText))
			{
				return true;
			}
			string searchText = _filter.SearchText;
			if (quest.DisplayName.Contains(searchText, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (quest.ZoneContext != null && quest.ZoneContext.Contains(searchText, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (quest.Acquisition != null)
			{
				foreach (AcquisitionSource item in quest.Acquisition)
				{
					if (item.SourceName != null && item.SourceName.Contains(searchText, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			if (quest.RequiredItems != null)
			{
				foreach (RequiredItemInfo requiredItem in quest.RequiredItems)
				{
					if (requiredItem.ItemName.Contains(searchText, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			if (quest.Steps != null)
			{
				foreach (QuestStep step in quest.Steps)
				{
					if (step.TargetName != null && step.TargetName.Contains(searchText, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void DrawQuestEntry(QuestEntry quest, float markerWidth)
		{
			bool flag = string.Equals(quest.RuntimeKey, _state.SelectedQuestKey, StringComparison.OrdinalIgnoreCase);
			uint questColor = GetQuestColor(quest);
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
			}
			bool flag2 = _tracker.Enabled && _tracker.IsTracked(quest.RuntimeKey);
			RowText rowText = GetRowText(quest);
			ImGui.PushStyleColor((ImGuiCol)0, questColor);
			Vector2 cursorPos = ImGui.GetCursorPos();
			Vector2 vector = cursorPos;
			Vector2 vector2 = new Vector2(ImGui.GetContentRegionAvail().X + cursorPos.X, ImGui.GetTextLineHeight());
			ImGui.SetCursorPos(new Vector2(0f, cursorPos.Y));
			bool flag3 = ImGui.Selectable(rowText.Id, flag, (ImGuiSelectableFlags)0, vector2);
			bool flag4 = ImGui.IsItemHovered();
			vector = ImGui.GetCursorPos();
			if (flag3)
			{
				_state.SelectQuest(quest);
			}
			float num = QuestListMarkerStartX(cursorPos.X);
			if (flag2)
			{
				ImGui.SetCursorPos(new Vector2(num, cursorPos.Y));
				ImGui.TextUnformatted("·");
			}
			ImGui.SetCursorPos(new Vector2(num + markerWidth, cursorPos.Y));
			ImGui.TextUnformatted(rowText.Label);
			ImGui.SetCursorPos(vector);
			if (flag4)
			{
				ImGui.BeginTooltip();
				if (quest.ZoneContext != null)
				{
					ImGui.Text(quest.ZoneContext);
				}
				string text;
				if (_state.Workflows.IsUnverifiable(quest))
				{
					text = "Workflow state unavailable";
				}
				else
				{
					QuestRuntimeStatus status = _state.GetStatus(quest);
					if (1 == 0)
					{
					}
					string text2 = status switch
					{
						QuestRuntimeStatus.Completed => "Completed", 
						QuestRuntimeStatus.ImplicitlyActive => "Completable here", 
						QuestRuntimeStatus.Active => "Active", 
						_ => "Available", 
					};
					if (1 == 0)
					{
					}
					text = text2;
				}
				string text3 = text;
				ImGui.Text(text3);
				int? num2 = quest.LevelEstimate?.Recommended;
				if (num2.HasValue)
				{
					int valueOrDefault = num2.GetValueOrDefault();
					if (true)
					{
						ImGui.Text($"Level {valueOrDefault}");
					}
				}
				ImGui.EndTooltip();
			}
			ImGui.PopStyleColor((!flag) ? 1 : 2);
		}

		private uint GetQuestColor(QuestEntry quest)
		{
			return Theme.GetQuestColor(_state, quest);
		}

		private RowText GetRowText(QuestEntry quest)
		{
			if (_rowText.TryGetValue(quest, out var value))
			{
				return value;
			}
			QuestFlags flags = quest.Flags;
			string text = ((flags != null && flags.Repeatable) ? " [R]" : "");
			int? num = quest.LevelEstimate?.Recommended;
			string text2;
			if (num.HasValue)
			{
				int valueOrDefault = num.GetValueOrDefault();
				text2 = $"{valueOrDefault,2}  {quest.DisplayName}{text}";
			}
			else
			{
				text2 = "    " + quest.DisplayName + text;
			}
			string label = text2;
			value = new RowText(label, "##" + quest.RuntimeKey);
			_rowText[quest] = value;
			return value;
		}
	}
	internal static class SourceListText
	{
		public static string Label(ItemSource source)
		{
			string type = source.Type;
			if (1 == 0)
			{
			}
			string text;
			switch (type)
			{
			case "world_drop":
				text = "Drops from: " + source.Name;
				break;
			case "fishing_bonus":
				text = "Fishing: " + source.Name;
				break;
			case "treasure_chest":
				text = $"Treasure map chest (dig at Lv {source.Level}-{source.LevelMax})";
				break;
			case "drop":
				text = "Drops from: " + source.Name;
				break;
			case "vendor":
				text = (string.IsNullOrWhiteSpace(source.Instruction) ? ("Buy from: " + source.Name) : (source.Instruction + "  ·  " + source.Name));
				break;
			case "dialog_give":
				text = "Given by: " + source.Name;
				break;
			case "fishing":
				text = "Fishing";
				break;
			case "mining":
				text = "Mining";
				break;
			case "pickup":
				text = ((source.Name == null) ? "Found in world" : ("Found in world: " + source.Name));
				break;
			case "crafting":
				text = "Crafted from: " + source.Name;
				break;
			case "quest_reward":
				text = "Quest reward: " + source.Name;
				break;
			case "ingredient":
			{
				string? name = source.Name;
				int? nodeCount = source.NodeCount;
				object obj;
				if (nodeCount.HasValue)
				{
					int valueOrDefault = nodeCount.GetValueOrDefault();
					obj = $" x{valueOrDefault}";
				}
				else
				{
					obj = "";
				}
				text = "Ingredient: " + name + (string?)obj;
				break;
			}
			case "item_use":
				text = "Use: " + source.Name;
				break;
			default:
				text = source.Name ?? source.Type;
				break;
			}
			if (1 == 0)
			{
			}
			string text2 = text;
			if (source.Zone != null)
			{
				text2 = text2 + "  ·  " + source.Zone;
			}
			if (!ItemSourcePolicy.IsRandomSource(source))
			{
				int? nodeCount = source.Level;
				if (nodeCount.HasValue)
				{
					int valueOrDefault2 = nodeCount.GetValueOrDefault();
					if (true)
					{
						text2 += $"  ·  Lv {valueOrDefault2}";
					}
				}
			}
			double? chance = source.Chance;
			if (chance.HasValue)
			{
				double valueOrDefault3 = chance.GetValueOrDefault();
				if (true)
				{
					text2 = text2 + "  ·  " + valueOrDefault3.ToString((source.Type == "treasure_chest") ? "0" : "0.###", CultureInfo.InvariantCulture) + "%";
				}
			}
			return text2;
		}

		public static string MoreSources(IReadOnlyList<ItemSource> sources, int start)
		{
			int? num = null;
			int? num2 = null;
			int valueOrDefault = default(int);
			for (int i = start; i < sources.Count; i++)
			{
				if (ItemSourcePolicy.IsRandomSource(sources[i]))
				{
					continue;
				}
				int? level = sources[i].Level;
				int num3;
				if (level.HasValue)
				{
					valueOrDefault = level.GetValueOrDefault();
					num3 = 1;
				}
				else
				{
					num3 = 0;
				}
				if (num3 != 0)
				{
					if (!num.HasValue || valueOrDefault < num)
					{
						num = valueOrDefault;
					}
					if (!num2.HasValue || valueOrDefault > num2)
					{
						num2 = valueOrDefault;
					}
				}
			}
			int num4 = sources.Count - start;
			if (!num.HasValue)
			{
				return $"{num4} more sources";
			}
			return (num == num2) ? $"{num4} more sources (Lv {num})" : $"{num4} more sources (Lv {num}-{num2})";
		}
	}
	internal static class StepCountPolicy
	{
		public static bool ShowsInventoryCount(QuestStep step)
		{
			string action = step.Action;
			bool flag = ((action == "collect" || action == "obtain") ? true : false);
			return flag && step.TargetKey != null && step.Quantity.HasValue;
		}
	}
	public readonly struct StepDistance
	{
		public readonly bool InCurrentZone;

		public readonly float Meters;

		public readonly string? Label;

		public bool HasDistance => Meters < float.MaxValue;

		public bool HasLabel => Label != null;

		public StepDistance(bool inCurrentZone, float meters, string? label = null)
		{
			InCurrentZone = inCurrentZone;
			Meters = meters;
			Label = label;
		}
	}
	public static class Theme
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		internal readonly struct WindowStyleScopeToken : IDisposable
		{
			public void Dispose()
			{
				PopWindowStyle();
			}
		}

		public static readonly uint Background = Rgba(0.1f, 0.1f, 0.12f, 0.95f);

		public static readonly uint Surface = Rgba(0.15f, 0.15f, 0.18f, 1f);

		public static readonly uint TextPrimary = Rgba(1f, 1f, 1f, 1f);

		public static readonly uint TextSecondary = Rgba(0.6f, 0.6f, 0.6f, 1f);

		public static readonly uint Accent = Rgba(0.2f, 0.35f, 0.55f, 1f);

		public static readonly uint Success = Rgba(0.4f, 0.8f, 0.4f, 1f);

		public static readonly uint Warning = Rgba(1f, 0.5f, 0.3f, 1f);

		public static readonly uint Error = Rgba(1f, 0.3f, 0.3f, 1f);

		public static readonly uint QuestActive = Rgba(1f, 0.9f, 0.3f, 1f);

		public static readonly uint QuestImplicit = Rgba(0.55f, 0.8f, 0.75f, 1f);

		public static readonly uint QuestCompleted = Rgba(0.4f, 0.7f, 0.4f, 1f);

		public static readonly uint QuestAvailable = Rgba(0.5f, 0.7f, 0.9f, 1f);

		public static readonly uint NavManualOverride = Rgba(0.45f, 0.85f, 0.9f, 1f);

		public static readonly uint SourceDimmed = Rgba(0.5f, 0.5f, 0.5f, 1f);

		public static readonly uint Header = Rgba(0.9f, 0.85f, 0.6f, 1f);

		public static readonly uint LevelSafe = Rgba(0.4f, 0.8f, 0.4f, 1f);

		public static readonly uint LevelCaution = Rgba(1f, 0.9f, 0.3f, 1f);

		public static readonly uint LevelDanger = Rgba(1f, 0.3f, 0.3f, 1f);

		public static readonly uint TrackerFlashGreen = Rgba(0.2f, 0.8f, 0.2f, 0.3f);

		public static readonly uint TrackerFlashYellow = Rgba(0.8f, 0.7f, 0.1f, 0.2f);

		public const float WindowPadding = 8f;

		public const float ItemSpacing = 4f;

		public const float SectionGap = 8f;

		public const float IndentWidth = 16f;

		public const float LeftPanelRatio = 0.32f;

		private const int WindowStyleColorCount = 15;

		private const int WindowStyleVarCount = 13;

		internal static WindowStyleScopeToken WindowStyleScope(float scale)
		{
			PushWindowStyle(scale);
			return default(WindowStyleScopeToken);
		}

		public static void PushWindowStyle(float scale)
		{
			ThemeMetrics themeMetrics = ThemeMetrics.For(scale);
			ImGui.PushStyleColor((ImGuiCol)2, Background);
			ImGui.PushStyleColor((ImGuiCol)3, Surface);
			ImGui.PushStyleColor((ImGuiCol)21, Rgba(0.26f, 0.59f, 0.98f, 0.4f));
			ImGui.PushStyleColor((ImGuiCol)22, Rgba(0.26f, 0.59f, 0.98f, 1f));
			ImGui.PushStyleColor((ImGuiCol)23, Rgba(0.06f, 0.53f, 0.98f, 1f));
			ImGui.PushStyleColor((ImGuiCol)7, Rgba(0.16f, 0.29f, 0.48f, 0.54f));
			ImGui.PushStyleColor((ImGuiCol)8, Rgba(0.26f, 0.59f, 0.98f, 0.4f));
			ImGui.PushStyleColor((ImGuiCol)9, Rgba(0.26f, 0.59f, 0.98f, 0.67f));
			ImGui.PushStyleColor((ImGuiCol)5, Rgba(0.43f, 0.43f, 0.5f, 0.5f));
			ImGui.PushStyleColor((ImGuiCol)10, Rgba(0.04f, 0.04f, 0.04f, 1f));
			ImGui.PushStyleColor((ImGuiCol)11, Rgba(0.16f, 0.29f, 0.48f, 1f));
			ImGui.PushStyleColor((ImGuiCol)12, Rgba(0f, 0f, 0f, 0.51f));
			ImGui.PushStyleColor((ImGuiCol)24, Rgba(0.26f, 0.59f, 0.98f, 0.31f));
			ImGui.PushStyleColor((ImGuiCol)25, Rgba(0.26f, 0.59f, 0.98f, 0.8f));
			ImGui.PushStyleColor((ImGuiCol)26, Rgba(0.26f, 0.59f, 0.98f, 1f));
			ImGui.PushStyleVar((ImGuiStyleVar)3, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)7, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)12, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)9, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)19, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)21, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)22, themeMetrics.TabRounding);
			ImGui.PushStyleVar((ImGuiStyleVar)8, themeMetrics.ChildBorderSize);
			ImGui.PushStyleVar((ImGuiStyleVar)13, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)11, new Vector2(themeMetrics.FramePaddingX, themeMetrics.FramePaddingY));
			ImGui.PushStyleVar((ImGuiStyleVar)14, new Vector2(themeMetrics.ItemSpacingX, themeMetrics.ItemSpacingY));
			ImGui.PushStyleVar((ImGuiStyleVar)16, themeMetrics.IndentSpacing);
			ImGui.PushStyleVar((ImGuiStyleVar)24, new Vector2(0f, 0f));
		}

		public static void PopWindowStyle()
		{
			ImGui.PopStyleVar(13);
			ImGui.PopStyleColor(15);
		}

		public static uint Rgba(float r, float g, float b, float a)
		{
			byte b2 = (byte)(r * 255f + 0.5f);
			byte b3 = (byte)(g * 255f + 0.5f);
			byte b4 = (byte)(b * 255f + 0.5f);
			byte b5 = (byte)(a * 255f + 0.5f);
			return (uint)(b2 | (b3 << 8) | (b4 << 16) | (b5 << 24));
		}

		public static Vector2 DisplaySize()
		{
			return new Vector2(Screen.width, Screen.height);
		}

		public static void ClampWindowPosition()
		{
			Vector2 windowPos = ImGui.GetWindowPos();
			Vector2 windowSize = ImGui.GetWindowSize();
			Vector2 vector = DisplaySize();
			float num = windowPos.X;
			float num2 = windowPos.Y;
			if (num + windowSize.X < 40f)
			{
				num = 40f - windowSize.X;
			}
			if (num > vector.X - 40f)
			{
				num = vector.X - 40f;
			}
			if (num2 > vector.Y - 40f)
			{
				num2 = vector.Y - 40f;
			}
			if (num2 < 0f)
			{
				num2 = 0f;
			}
			if (num != windowPos.X || num2 != windowPos.Y)
			{
				ImGui.SetWindowPos(new Vector2(num, num2));
			}
		}

		public static uint GetQuestColor(QuestStateTracker state, QuestEntry quest)
		{
			QuestRuntimeStatus status = state.GetStatus(quest);
			if (1 == 0)
			{
			}
			uint result = status switch
			{
				QuestRuntimeStatus.ImplicitlyActive => QuestImplicit, 
				QuestRuntimeStatus.Active => QuestActive, 
				QuestRuntimeStatus.Completed => QuestCompleted, 
				_ => QuestAvailable, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	internal readonly struct ThemeMetrics
	{
		private readonly float _scale;

		public float FramePaddingX => 4f * _scale;

		public float FramePaddingY => 3f * _scale;

		public float ItemSpacingX => 8f * _scale;

		public float ItemSpacingY => 4f * _scale;

		public float IndentSpacing => 16f * _scale;

		public float TabRounding => 4f * _scale;

		public float ChildBorderSize => _scale;

		private ThemeMetrics(float scale)
		{
			_scale = scale;
		}

		public static ThemeMetrics For(float scale)
		{
			return new ThemeMetrics(scale);
		}
	}
	internal static class TrackerSorter
	{
		private readonly struct SourceDistance
		{
			public readonly float Meters;

			public readonly string? Label;

			public static SourceDistance None => new SourceDistance(float.MaxValue);

			public SourceDistance(float meters, string? label = null)
			{
				Meters = meters;
				Label = label;
			}

			public static SourceDistance Best(SourceDistance a, SourceDistance b)
			{
				if (a.Label != null && b.Label == null)
				{
					return a;
				}
				if (b.Label != null && a.Label == null)
				{
					return b;
				}
				return (a.Meters <= b.Meters) ? a : b;
			}
		}

		public static void ComputeDistances(IReadOnlyList<string> quests, GuideData data, QuestStateTracker state, NavigationTarget? navigationTarget, float navigationDistance, Vector3 playerPos, Dictionary<string, StepDistance> output)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			output.Clear();
			string currentZone = state.CurrentZone;
			for (int i = 0; i < quests.Count; i++)
			{
				string text = quests[i];
				QuestEntry byRuntimeKey = data.GetByRuntimeKey(text);
				if (byRuntimeKey == null)
				{
					output[text] = new StepDistance(inCurrentZone: false, float.MaxValue);
				}
				else if (navigationTarget != null && string.Equals(navigationTarget.QuestKey, text, StringComparison.OrdinalIgnoreCase))
				{
					bool flag = !navigationTarget.IsCrossZone(currentZone);
					if (flag && navigationTarget.TargetKind == NavigationTarget.Kind.Zone)
					{
						output[text] = new StepDistance(inCurrentZone: true, float.MaxValue);
						continue;
					}
					float meters = (flag ? navigationDistance : float.MaxValue);
					output[text] = new StepDistance(flag, meters);
				}
				else if (!IsCurrentStepInZone(byRuntimeKey, state, data, currentZone))
				{
					output[text] = new StepDistance(inCurrentZone: false, float.MaxValue);
				}
				else
				{
					SourceDistance sourceDistance = ComputeStepDistance(byRuntimeKey, state, data, currentZone, playerPos);
					output[text] = new StepDistance(inCurrentZone: true, sourceDistance.Meters, sourceDistance.Label);
				}
			}
		}

		public static void Sort(List<string> quests, TrackerSortMode mode, GuideData data, IReadOnlyDictionary<string, StepDistance>? distances)
		{
			switch (mode)
			{
			case TrackerSortMode.Proximity:
				if (distances == null)
				{
					break;
				}
				SortByProximity(quests, data, distances);
				return;
			case TrackerSortMode.Level:
				SortByLevel(quests, data);
				return;
			}
			SortAlphabetical(quests, data);
		}

		private static void SortByProximity(List<string> quests, GuideData data, IReadOnlyDictionary<string, StepDistance> distances)
		{
			quests.Sort(delegate(string a, string b)
			{
				StepDistance value;
				StepDistance stepDistance = (distances.TryGetValue(a, out value) ? value : new StepDistance(inCurrentZone: false, float.MaxValue));
				StepDistance value2;
				StepDistance stepDistance2 = (distances.TryGetValue(b, out value2) ? value2 : new StepDistance(inCurrentZone: false, float.MaxValue));
				if (stepDistance.InCurrentZone != stepDistance2.InCurrentZone)
				{
					return (!stepDistance.InCurrentZone) ? 1 : (-1);
				}
				if (stepDistance.InCurrentZone)
				{
					float num = (stepDistance.HasDistance ? stepDistance.Meters : 0f);
					float value3 = (stepDistance2.HasDistance ? stepDistance2.Meters : 0f);
					int num2 = num.CompareTo(value3);
					if (num2 != 0)
					{
						return num2;
					}
				}
				QuestEntry byRuntimeKey = data.GetByRuntimeKey(a);
				QuestEntry byRuntimeKey2 = data.GetByRuntimeKey(b);
				return string.Compare(byRuntimeKey?.DisplayName, byRuntimeKey2?.DisplayName, StringComparison.OrdinalIgnoreCase);
			});
		}

		private static void SortByLevel(List<string> quests, GuideData data)
		{
			quests.Sort(delegate(string a, string b)
			{
				QuestEntry byRuntimeKey = data.GetByRuntimeKey(a);
				QuestEntry byRuntimeKey2 = data.GetByRuntimeKey(b);
				int num = byRuntimeKey?.LevelEstimate?.Recommended ?? int.MaxValue;
				int value = byRuntimeKey2?.LevelEstimate?.Recommended ?? int.MaxValue;
				int num2 = num.CompareTo(value);
				return (num2 != 0) ? num2 : string.Compare(byRuntimeKey?.DisplayName, byRuntimeKey2?.DisplayName, StringComparison.OrdinalIgnoreCase);
			});
		}

		private static void SortAlphabetical(List<string> quests, GuideData data)
		{
			quests.Sort(delegate(string a, string b)
			{
				QuestEntry byRuntimeKey = data.GetByRuntimeKey(a);
				QuestEntry byRuntimeKey2 = data.GetByRuntimeKey(b);
				return string.Compare(byRuntimeKey?.DisplayName ?? a, byRuntimeKey2?.DisplayName ?? b, StringComparison.OrdinalIgnoreCase);
			});
		}

		public static string? GetStepZoneName(QuestEntry quest, QuestStateTracker state, GuideData data)
		{
			QuestStep currentStep = GetCurrentStep(quest, state, data);
			if (currentStep == null)
			{
				return null;
			}
			var (questStep, questEntry) = StepProgress.ResolveActiveStep(currentStep, quest, state, data);
			if (questStep == null)
			{
				return null;
			}
			string text = StepSceneResolver.ResolveScene(questEntry ?? quest, questStep, data, state.IsGameQuestCompleted, state.Furnishings.IsAvailablePredicate, state.CountItemDelegate);
			return (text != null) ? data.GetZoneDisplayName(text) : null;
		}

		private static bool IsCurrentStepInZone(QuestEntry quest, QuestStateTracker state, GuideData data, string currentScene)
		{
			QuestStep currentStep = GetCurrentStep(quest, state, data);
			if (currentStep == null)
			{
				return false;
			}
			var (questStep, questEntry) = StepProgress.ResolveActiveStep(currentStep, quest, state, data);
			if (questStep == null)
			{
				return false;
			}
			return StepSceneResolver.HasSourceInScene(questEntry ?? quest, questStep, data, currentScene, state.IsGameQuestCompleted, state.Furnishings.IsAvailablePredicate, state.CountItemDelegate);
		}

		private static SourceDistance ComputeStepDistance(QuestEntry quest, QuestStateTracker state, GuideData data, string currentScene, Vector3 playerPos)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			QuestStep currentStep = GetCurrentStep(quest, state, data);
			if (currentStep == null)
			{
				return SourceDistance.None;
			}
			var (questStep, questEntry) = StepProgress.ResolveActiveStep(currentStep, quest, state, data);
			if (questStep == null)
			{
				return SourceDistance.None;
			}
			QuestEntry quest2 = questEntry ?? quest;
			if (questStep.Location != null)
			{
				string text = StepSceneResolver.ResolveScene(quest2, questStep, data, state.IsGameQuestCompleted, state.Furnishings.IsAvailablePredicate, state.CountItemDelegate);
				if (text != null && string.Equals(text, currentScene, StringComparison.OrdinalIgnoreCase))
				{
					return new SourceDistance(NavigationPolicy.EuclideanDistance(playerPos.x, playerPos.y, playerPos.z, questStep.Location.X, questStep.Location.Y, questStep.Location.Z));
				}
			}
			string targetKey = ques