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.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+15433c013c25caa50b5fca80f4a7ee8f23dfdcee")]
[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;
		}
	}
}
public sealed class SpawnPointBridge
{
	public enum SpawnState
	{
		Alive,
		Dead,
		Mined,
		NightLocked,
		QuestGated,
		DirectlyPlacedDead,
		NotFound
	}

	public readonly struct SpawnInfo
	{
		public readonly SpawnState State;

		public readonly SpawnPoint? LiveSpawnPoint;

		public readonly NPC? LiveNPC;

		public readonly MiningNode? LiveMiningNode;

		public readonly float RespawnSeconds;

		public SpawnInfo(SpawnState state, SpawnPoint? liveSP = null, NPC? liveNPC = null, MiningNode? miningNode = null, float respawnSeconds = 0f)
		{
			State = state;
			LiveSpawnPoint = liveSP;
			LiveNPC = liveNPC;
			LiveMiningNode = miningNode;
			RespawnSeconds = respawnSeconds;
		}
	}

	private readonly struct PosKey : IEquatable<PosKey>
	{
		private readonly int _x;

		private readonly int _y;

		private readonly int _z;

		public PosKey(float x, float y, float z)
		{
			_x = Mathf.RoundToInt(x * 100f);
			_y = Mathf.RoundToInt(y * 100f);
			_z = Mathf.RoundToInt(z * 100f);
		}

		public bool Equals(PosKey other)
		{
			return _x == other._x && _y == other._y && _z == other._z;
		}

		public override bool Equals(object? obj)
		{
			return obj is PosKey other && Equals(other);
		}

		public override int GetHashCode()
		{
			return (_x * 397) ^ (_y * 17) ^ _z;
		}
	}

	private readonly Dictionary<PosKey, SpawnPoint> _index = new Dictionary<PosKey, SpawnPoint>();

	private readonly Dictionary<string, List<NPC>> _npcByName = new Dictionary<string, List<NPC>>();

	private const float MaxDriftSqr = 4f;

	public void Rebuild()
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		_index.Clear();
		_npcByName.Clear();
		if (SpawnPointManager.SpawnPointsInScene != null)
		{
			foreach (SpawnPoint item in SpawnPointManager.SpawnPointsInScene)
			{
				if (!((Object)(object)item == (Object)null))
				{
					Vector3 position = ((Component)item).transform.position;
					PosKey key = new PosKey(position.x, position.y, position.z);
					_index.TryAdd(key, item);
				}
			}
		}
		NPC[] array = Object.FindObjectsOfType<NPC>();
		foreach (NPC val in array)
		{
			if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(val.NPCName))
			{
				string key2 = val.NPCName.ToLowerInvariant();
				if (!_npcByName.TryGetValue(key2, out List<NPC> value))
				{
					value = new List<NPC>();
					_npcByName[key2] = value;
				}
				value.Add(val);
			}
		}
	}

	public SpawnInfo GetState(float x, float y, float z, string expectedNPCName)
	{
		PosKey key = new PosKey(x, y, z);
		if (_index.TryGetValue(key, out SpawnPoint value))
		{
			return ClassifySpawnPoint(value, expectedNPCName);
		}
		NPC val = FindDirectlyPlacedNPC(x, y, z, expectedNPCName);
		if ((Object)(object)val != (Object)null)
		{
			MiningNode component = ((Component)val).GetComponent<MiningNode>();
			if ((Object)(object)component != (Object)null)
			{
				if (IsMiningNodeMined(component))
				{
					float miningNodeRespawnSeconds = GetMiningNodeRespawnSeconds(component);
					return new SpawnInfo(SpawnState.Mined, null, val, component, miningNodeRespawnSeconds);
				}
				return new SpawnInfo(SpawnState.Alive, null, val, component);
			}
			return new SpawnInfo(SpawnState.Alive, null, val);
		}
		return new SpawnInfo(SpawnState.DirectlyPlacedDead);
	}

	public static bool IsExpectedNPCAlive(SpawnPoint sp, string expectedName)
	{
		return sp.MyNPCAlive && (Object)(object)sp.SpawnedNPC != (Object)null && string.Equals(sp.SpawnedNPC.NPCName, expectedName, StringComparison.OrdinalIgnoreCase);
	}

	private static SpawnInfo ClassifySpawnPoint(SpawnPoint sp, string expectedNPCName)
	{
		if (!sp.canSpawn)
		{
			return new SpawnInfo(SpawnState.QuestGated, sp);
		}
		if (sp.NightSpawn && !IsNightHours())
		{
			if (IsExpectedNPCAlive(sp, expectedNPCName))
			{
				return new SpawnInfo(SpawnState.Alive, sp, sp.SpawnedNPC);
			}
			return new SpawnInfo(SpawnState.NightLocked, sp);
		}
		if (IsExpectedNPCAlive(sp, expectedNPCName))
		{
			return new SpawnInfo(SpawnState.Alive, sp, sp.SpawnedNPC);
		}
		if (sp.MyNPCAlive && (Object)(object)sp.SpawnedNPC != (Object)null)
		{
			return new SpawnInfo(SpawnState.NotFound, sp);
		}
		float num = 60f * GetSpawnTimeMod();
		float respawnSeconds = ((num > 0f) ? (sp.actualSpawnDelay / num) : 0f);
		return new SpawnInfo(SpawnState.Dead, sp, null, null, respawnSeconds);
	}

	private static bool IsNightHours()
	{
		int hour = GameData.Time.GetHour();
		return hour > 22 || hour < 4;
	}

	private NPC? FindDirectlyPlacedNPC(float x, float y, float z, string expectedName)
	{
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		if (!_npcByName.TryGetValue(expectedName.ToLowerInvariant(), out List<NPC> value))
		{
			return null;
		}
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(x, y, z);
		foreach (NPC item in value)
		{
			if (!((Object)(object)item == (Object)null))
			{
				Vector3 val2 = ((Component)item).transform.position - val;
				if (((Vector3)(ref val2)).sqrMagnitude <= 4f)
				{
					return item;
				}
			}
		}
		return null;
	}

	private static float GetSpawnTimeMod()
	{
		GameManager gM = GameData.GM;
		return ((Object)(object)gM != (Object)null) ? gM.SpawnTimeMod : 1f;
	}

	public static bool IsMiningNodeMined(MiningNode node)
	{
		return MiningNodeTracker.IsMined(node);
	}

	public static float GetMiningNodeRespawnSeconds(MiningNode node)
	{
		return MiningNodeTracker.GetRemainingSeconds(node).GetValueOrDefault();
	}
}
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
	{
		private readonly IModLogger _logger;

		private readonly IGuideConfigBackend _backend;

		private readonly string _iniPath;

		private readonly IKeyboardInput _keyboard;

		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;

		private bool _started;

		private bool _stopped;

		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;
		}

		public bool Start()
		{
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Expected O, but got Unknown
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_070a: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			if (_started)
			{
				return true;
			}
			if (_stopped)
			{
				return false;
			}
			_started = true;
			Log = _logger;
			AdventureGuideLog.Current = _logger;
			try
			{
				_config = new GuideConfig(_backend);
				_data = GuideData.Load(_logger);
				_entities = new EntityRegistry();
				_state = new QuestStateTracker(_data, _entities);
				_state.LoadFromConfig(_config);
				_trackerState = new TrackerState();
				_trackerState.LoadFromConfig(_config);
				float num = ((_config.UiScale.Value >= 0f) ? _config.UiScale.Value : 1f);
				_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;
				_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);
				_imgui.OnLayout = delegate
				{
					_window.Draw();
					_tracker.Draw();
					_arrow.Draw();
					_config.LayoutResetRequested = false;
				};
				DebugAPI.Data = _data;
				DebugAPI.State = _state;
				DebugAPI.Filter = _window.Filter;
				DebugAPI.Nav = _nav;
				DebugAPI.Entities = _entities;
				DebugAPI.GroundPath = _groundPath;
				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;
				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.SuppressGameMarkers = _config.ShowWorldMarkers.Value;
				PointerOverUIPatch.WantsMouse = () => _wantsMouseCapture;
				QuestLogPatch.ReplaceQuestLog = _config.ReplaceQuestLog;
				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();
				_trackerState.OnCharacterLoaded();
				_state.OnCharacterLoaded();
				_trackerState.PruneCompleted(_state, _data);
				NavigationController? nav = _nav;
				GuideConfig? config = _config;
				activeScene = SceneManager.GetActiveScene();
				nav.LoadPerCharacter(config, ((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.718.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()
		{
			if (!_started || _stopped)
			{
				return;
			}
			_tracker?.Update();
			bool isVisible = GameUIVisibility.IsVisible;
			if (isVisible != _gameUIVisible)
			{
				_gameUIVisible = isVisible;
				SyncVisibility();
				if (!isVisible)
				{
					ClearImGuiCaptureState();
					if (_wasTextInputActive)
					{
						GameData.PlayerTyping = false;
						_wasTextInputActive = false;
					}
				}
			}
			bool editUIMode = GameData.EditUIMode;
			if (_wasEditUIMode && !editUIMode)
			{
				GameWindowOverlap.InvalidateRects();
			}
			_wasEditUIMode = editUIMode;
			if (_gameUIVisible)
			{
				CaptureImGuiState();
			}
			if (_gameUIVisible)
			{
				bool wantsTextInput = _wantsTextInput;
				if (wantsTextInput && !_wasTextInputActive)
				{
					GameData.PlayerTyping = true;
				}
				else if (!wantsTextInput && _wasTextInputActive)
				{
					GameData.PlayerTyping = false;
				}
				_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)
			{
				if (!GameData.PlayerTyping && !_wantsTextInput)
				{
					HandleKeyboardShortcuts();
				}
				if (!_wantsMouseCapture && !GameData.PlayerTyping)
				{
				}
			}
		}

		public void Draw()
		{
			if (_started && !_stopped && _gameUIVisible)
			{
				_imgui?.OnGUI();
			}
		}

		public void Stop()
		{
			if (!_stopped)
			{
				_stopped = true;
				_started = false;
				SceneManager.sceneLoaded -= OnSceneLoaded;
				if (_wasTextInputActive)
				{
					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;
				}
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
				_harmony = null;
				_tracker?.Dispose();
				_trackerState?.SaveToConfig();
				_state?.SaveToConfig();
				_nav?.SavePerCharacter();
				_imgui?.Dispose();
				_imgui = null;
				_arrow?.Dispose();
				_groundPath?.Destroy();
				_markers?.Destroy();
				_timers?.Clear();
				_entities?.Clear();
				_miningTracker?.Clear();
				MarkerFonts.Destroy();
				CameraCache.Invalidate();
				GameWindowOverlap.Reset();
				_config?.Dispose();
				_config = null;
				ClearPatchStatics();
				ClearDebugApi();
				_backend.Dispose();
				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")
			{
				_config.UiScale.Value = DetectUiScale();
			}
			CameraCache.Invalidate();
			GameWindowOverlap.Reset();
			_inGameplay = ((Scene)(ref scene)).name != "Menu" && ((Scene)(ref scene)).name != "LoadScene";
			if (!_inGameplay)
			{
				_window?.Hide();
				_tracker?.Hide();
				_nav?.Clear();
				ClearImGuiCaptureState();
			}
			_markers?.OnSceneLoaded();
			_entities?.Clear();
			_timers?.Clear();
			_miningTracker?.Rescan();
			_lootScanner?.OnSceneLoaded();
			_state?.OnSceneChanged(((Scene)(ref scene)).name);
			_trackerState?.OnCharacterLoaded();
			_state?.OnCharacterLoaded();
			if (_trackerState != null && _state != null && _data != null)
			{
				_trackerState.PruneCompleted(_state, _data);
			}
			_nav?.LoadPerCharacter(_config, ((Scene)(ref scene)).name);
			_nav?.OnGameStateChanged(((Scene)(ref scene)).name);
		}

		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 = _config.UiScale.Value;
			if (num < 0f)
			{
				num = DetectUiScale();
			}
			_config.ResolvedUiScale = num;
			_config.LayoutResetRequested = true;
			_imgui?.SetScale(num);
		}

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

		private void OnShowWorldMarkersChanged(object sender, EventArgs e)
		{
			SyncVisibility();
			QuestMarkerPatch.SuppressGameMarkers = _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 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (_config != null && _window != null)
			{
				if (KeyboardShortcuts.WasPressed(_config.ToggleKey.Value, _keyboard))
				{
					_window.Toggle();
				}
				if (_config.ReplaceQuestLog.Value && KeyboardShortcuts.WasPressed(InputManager.Journal, _keyboard))
				{
					_window.Toggle();
				}
				if (_config.TrackerEnabled.Value && KeyboardShortcuts.WasPressed(_config.TrackerToggleKey.Value, _keyboard))
				{
					_tracker?.Toggle();
				}
				if (KeyboardShortcuts.WasPressed(_config.GroundPathToggleKey.Value, _keyboard))
				{
					_config.ShowGroundPath.Value = !_config.ShowGroundPath.Value;
				}
			}
		}

		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;
			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;
		}

		private static void ClearDebugApi()
		{
			DebugAPI.Data = null;
			DebugAPI.State = null;
			DebugAPI.Filter = null;
			DebugAPI.Nav = null;
			DebugAPI.Entities = null;
			DebugAPI.GroundPath = null;
		}

		private static float DetectUiScale()
		{
			return Mathf.Clamp((float)Screen.height / 1080f, 0.5f, 4f);
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "wow-much.adventure-guide";

		public const string Name = "Adventure Guide";

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

		private void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			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
{
	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;

		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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			ImGuiCond val = (ImGuiCond)(_config.LayoutResetRequested ? 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())
			{
				bool flag = false;
				try
				{
					bool flag2 = ImGui.Begin("Adventure Guide", ref _visible, (ImGuiWindowFlags)32);
					flag = true;
					if (flag2)
					{
						DrawTabBar();
					}
					Theme.ClampWindowPosition();
				}
				finally
				{
					if (flag)
					{
						ImGui.End();
					}
				}
			}
		}

		private void DrawTabBar()
		{
			if (!ImGui.BeginTabBar("##GuideTabs"))
			{
				return;
			}
			if (ImGui.BeginTabItem("Quests"))
			{
				DrawQuestsTab();
				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;
				}
			}
			ImGui.EndTabBar();
		}

		private void DrawQuestsTab()
		{
			float num = ImGui.GetContentRegionAvail().X * 0.32f;
			ImGui.BeginChild("##LeftPanel", new Vector2(num, 0f), true);
			_listPanel.Draw(num);
			ImGui.EndChild();
			ImGui.SameLine();
			ImGui.BeginChild("##RightPanel", Vector2.Zero, true);
			_detailPanel.Draw();
			ImGui.EndChild();
		}
	}
	public sealed class QuestDetailPanel
	{
		private enum StepState
		{
			Completed,
			Current,
			Future
		}

		private readonly GuideData _data;

		private readonly QuestStateTracker _state;

		private readonly NavigationController _nav;

		private readonly TrackerState _tracker;

		private readonly GuideConfig _config;

		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()
		{
			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);
			if (quest.Acquisition != null)
			{
				foreach (AcquisitionSource item in quest.Acquisition)
				{
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
					string method = item.Method;
					if (1 == 0)
					{
					}
					string text;
					switch (method)
					{
					case "dialog":
						if (item.SourceName == null)
						{
							goto default;
						}
						text = "Given by: " + item.SourceName;
						break;
					case "item_read":
						if (item.SourceName == null)
						{
							goto default;
						}
						text = "Read: " + item.SourceName;
						break;
					case "zone_entry":
						if (item.SourceName == null)
						{
							goto default;
						}
						text = "Enter: " + item.SourceName;
						break;
					case "quest_chain":
						if (item.SourceName == null)
						{
							goto default;
						}
						text = "Chain from: " + item.SourceName;
						break;
					default:
						text = ((item.SourceName != null) ? ("From: " + item.SourceName) : null);
						break;
					}
					if (1 == 0)
					{
					}
					string text2 = text;
					if (text2 != null)
					{
						if (item.ZoneName != null && item.Method == "dialog")
						{
							text2 = text2 + " (" + item.ZoneName + ")";
						}
						ImGui.Text(text2);
					}
					ImGui.PopStyleColor();
				}
			}
			if (quest.Completion != null)
			{
				foreach (CompletionSource item2 in quest.Completion)
				{
					if (item2.SourceName == null && item2.ZoneName == null)
					{
						continue;
					}
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
					string method2 = item2.Method;
					if (1 == 0)
					{
					}
					string text;
					switch (method2)
					{
					case "item_turnin":
					case "dialog":
						if (item2.SourceName == null)
						{
							goto default;
						}
						text = "Turn in to: " + item2.SourceName;
						break;
					case "zone":
						if (item2.SourceName == null)
						{
							goto default;
						}
						text = "Complete at: " + item2.SourceName;
						break;
					default:
						text = ((item2.SourceName == null) ? null : ("Complete: " + item2.SourceName));
						break;
					}
					if (1 == 0)
					{
					}
					string text3 = text;
					if (text3 == null)
					{
						ImGui.PopStyleColor();
						continue;
					}
					bool flag3 = item2.ZoneName != null;
					bool flag4 = flag3;
					if (flag4)
					{
						text = item2.Method;
						bool flag5 = ((text == "item_turnin" || text == "dialog") ? true : false);
						flag4 = flag5;
					}
					if (flag4)
					{
						text3 = text3 + " (" + item2.ZoneName + ")";
					}
					ImGui.Text(text3);
					ImGui.PopStyleColor();
				}
			}
			if (quest.Description != null)
			{
				ImGui.Spacing();
				ImGui.TextWrapped(quest.Description);
			}
			ImGui.Spacing();
			ImGui.Separator();
			ImGui.Spacing();
		}

		private static void DrawLevelZoneLine(QuestEntry quest)
		{
			int? num = quest.LevelEstimate?.Recommended;
			string zoneContext = quest.ZoneContext;
			bool flag = quest.Flags?.Repeatable ?? false;
			if (!num.HasValue && zoneContext == null && !flag)
			{
				return;
			}
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			string text = "";
			if (num.HasValue)
			{
				text = $"Lv {num}";
			}
			if (zoneContext != null)
			{
				if (text.Length > 0)
				{
					text += "  ·  ";
				}
				text += zoneContext;
			}
			if (flag)
			{
				if (text.Length > 0)
				{
					text += "  ·  ";
				}
				text += "Repeatable";
			}
			ImGui.Text(text);
			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? num2 = quest.LevelEstimate?.Recommended;
					foreach (QuestStep step in quest.Steps)
					{
						int? num3 = step.LevelEstimate?.Recommended;
						string text2 = (num3.HasValue ? $"Lv {num3,2}" : "    ");
						bool flag2 = num2.HasValue && num3 == num2;
						string text3 = (flag2 ? " <" : "");
						uint num4 = (flag2 ? Theme.TextPrimary : Theme.TextSecondary);
						ImGui.PushStyleColor((ImGuiCol)0, num4);
						ImGui.Text($"  {step.Order}. {step.Description}  {text2}{text3}");
						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))
			{
				HashSet<string> visited = new HashSet<string> { quest.StableKey };
				ImGui.Indent(16f);
				DrawSteps(quest, visited);
				ImGui.Unindent(16f);
			}
		}

		private void DrawSteps(QuestEntry quest, HashSet<string> visited)
		{
			if (quest.Steps == null || quest.Steps.Count == 0)
			{
				return;
			}
			ImGui.PushID(quest.RuntimeKey);
			int currentStepIndex = StepProgress.GetCurrentStepIndex(quest, _state, _data);
			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;
			string text = $"{step.Order}. {step.Description}";
			string action = step.Action;
			bool flag = ((action == "collect" || action == "obtain") ? true : false);
			if (flag && step.TargetKey != null && step.Quantity.HasValue)
			{
				int num3 = _state.CountItem(step.TargetKey);
				text += $" ({num3}/{step.Quantity})";
				if (num3 >= step.Quantity.Value)
				{
					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;
				}
			}
			int? num4 = step.LevelEstimate?.Recommended;
			if (num4.HasValue)
			{
				int valueOrDefault = num4.GetValueOrDefault();
				if (true)
				{
					switch (step.Action)
					{
					default:
					{
						List<LevelFactor> factors = step.LevelEstimate.Factors;
						if (factors != null && factors.Count > 0)
						{
							text = text + "  ·  " + step.LevelEstimate.Factors[0].Name;
						}
						break;
					}
					case "collect":
					case "obtain":
					case "read":
						break;
					}
					text += $"  ·  Lv {valueOrDefault}";
					goto IL_02a7;
				}
			}
			switch (step.Action)
			{
			default:
			{
				List<LevelFactor> factors = step.LevelEstimate?.Factors;
				if (factors != null && factors.Count > 0)
				{
					text = text + "  ·  " + step.LevelEstimate.Factors[0].Name;
				}
				break;
			}
			case "collect":
			case "obtain":
			case "read":
				break;
			}
			goto IL_02a7;
			IL_02a7:
			DrawNavButton(step, quest);
			ImGui.PushStyleColor((ImGuiCol)0, num2);
			ImGui.Text(text);
			ImGui.PopStyleColor();
			DrawStepSources(step, quest, visited);
			DrawSubQuestSteps(step, 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;
			}
			bool flag;
			if (!(step.TargetType == "item"))
			{
				flag = ((step.TargetType == "character") ? (step.TargetKey != null && _data.CharacterSpawns.ContainsKey(step.TargetKey)) : (step.TargetType == "zone" && (step.ZoneName != null || step.TargetKey != null)));
			}
			else
			{
				RequiredItemInfo requiredItemInfo = FindRequiredItem(quest, step);
				flag = requiredItemInfo != null && requiredItemInfo.Sources?.Exists((ItemSource s) => HasNavigableSource(s)) == true;
			}
			bool flag2 = _nav.IsNavigating(quest.RuntimeKey, step.Order);
			if (!flag)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.PushStyleVar((ImGuiStyleVar)0, 0.4f);
				ImGui.SmallButton($"[NAV]##{step.Order}");
				ImGui.PopStyleVar();
				ImGui.PopStyleColor();
				if (ImGui.IsItemHovered((ImGuiHoveredFlags)512))
				{
					ImGui.BeginTooltip();
					ImGui.Text("No known source");
					ImGui.EndTooltip();
				}
				ImGui.SameLine();
				return;
			}
			if (flag2)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.QuestActive);
			}
			if (ImGui.SmallButton($"[NAV]##{step.Order}"))
			{
				if (flag2)
				{
					_nav.Clear();
				}
				else
				{
					_nav.NavigateTo(step, quest, _state.CurrentZone);
				}
			}
			if (flag2)
			{
				ImGui.PopStyleColor();
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				if (flag2)
				{
					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)
				{
					List<ItemSource> list = FindRequiredItem(quest, step)?.Sources?.FindAll(IsSourceAvailable);
					if (list == null || list.Count == 0)
					{
						DrawTips(step);
						break;
					}
					ImGui.Indent(16f);
					ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
					int num = Math.Min(list.Count, 4);
					for (int i = 0; i < num; i++)
					{
						DrawSource(list[i], quest, step, visited);
					}
					if (list.Count > 4)
					{
						int num2 = list.Count - 4;
						int valueOrDefault = list[4].Level.GetValueOrDefault();
						int num3 = list[list.Count - 1].Level ?? valueOrDefault;
						string arg = ((valueOrDefault == num3) ? $"Lv {valueOrDefault}" : $"Lv {valueOrDefault}-{num3}");
						if (ImGui.TreeNode($"{num2} more sources ({arg})##{step.Order}"))
						{
							for (int j = 4; j < list.Count; j++)
							{
								DrawSource(list[j], quest, step, visited);
							}
							ImGui.TreePop();
						}
					}
					ImGui.PopStyleColor();
					ImGui.Unindent(16f);
					DrawTips(step);
					break;
				}
				goto default;
			default:
				DrawTips(step);
				break;
			}
		}

		private void DrawZoneLineAlternatives(List<(ZoneLineEntry line, float distance, bool isSelected, bool isAccessible)> alternatives, QuestStep step)
		{
			ImGui.Indent(16f);
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			string arg = $"{alternatives.Count} zone connections";
			if (ImGui.TreeNode($"{arg}##zl_{step.Order}"))
			{
				for (int i = 0; i < alternatives.Count; i++)
				{
					(ZoneLineEntry line, float distance, bool isSelected, bool isAccessible) tuple = alternatives[i];
					var (zoneLineEntry, num, flag, _) = tuple;
					if (!tuple.isAccessible)
					{
						ImGui.PushStyleVar((ImGuiStyleVar)0, 0.3f);
						ImGui.Text($"To {zoneLineEntry.DestinationDisplay} ({num:F0}m)");
						ImGui.PopStyleVar();
						if (zoneLineEntry.RequiredQuestGroups == null)
						{
							continue;
						}
						using List<List<string>>.Enumerator enumerator = zoneLineEntry.RequiredQuestGroups.GetEnumerator();
						if (!enumerator.MoveNext())
						{
							continue;
						}
						List<string> current = enumerator.Current;
						foreach (string item in current)
						{
							if (_state.IsGameQuestCompleted(item))
							{
								continue;
							}
							QuestEntry byDBName = _data.GetByDBName(item);
							if (byDBName != null)
							{
								ImGui.Indent(16f);
								if (ImGui.Selectable($"Requires: \"{byDBName.DisplayName}\"##rq_{step.Order}_{i}_{item}"))
								{
									_state.SelectQuest(byDBName);
								}
								ImGui.Unindent(16f);
							}
						}
					}
					else
					{
						string arg2 = $"To {zoneLineEntry.DestinationDisplay} ({num:F0}m)";
						if (flag)
						{
							ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
						}
						if (ImGui.Selectable($"{arg2}##zl_{step.Order}_{i}"))
						{
							_nav.PinZoneLine(zoneLineEntry);
						}
						if (flag)
						{
							ImGui.PopStyleColor();
						}
						if (ImGui.IsItemHovered())
						{
							ImGui.BeginTooltip();
							ImGui.Text("Route via " + zoneLineEntry.DestinationDisplay);
							ImGui.EndTooltip();
						}
					}
				}
				ImGui.TreePop();
			}
			ImGui.PopStyleColor();
			ImGui.Unindent(16f);
		}

		private void DrawSource(ItemSource src, QuestEntry quest, QuestStep step, HashSet<string> visited, int depth = 0)
		{
			if (!IsSourceAvailable(src))
			{
				return;
			}
			string type = src.Type;
			if (1 == 0)
			{
			}
			string text;
			int? nodeCount;
			switch (type)
			{
			case "drop":
				text = "Drops from: " + src.Name;
				break;
			case "vendor":
				text = (string.IsNullOrWhiteSpace(src.Instruction) ? ("Buy from: " + src.Name) : (src.Instruction + "  ·  " + src.Name));
				break;
			case "dialog_give":
				text = "Given by: " + src.Name;
				break;
			case "fishing":
				text = "Fishing";
				break;
			case "mining":
				text = "Mining";
				break;
			case "pickup":
				text = "Found in world";
				break;
			case "crafting":
				text = "Crafted from: " + src.Name;
				break;
			case "quest_reward":
				text = "Quest reward: " + src.Name;
				break;
			case "ingredient":
			{
				string? name = src.Name;
				nodeCount = src.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: " + src.Name;
				break;
			default:
				text = src.Name ?? src.Type;
				break;
			}
			if (1 == 0)
			{
			}
			string text2 = text;
			string text3 = text2;
			if (src.Zone != null)
			{
				text3 = text3 + "  ·  " + src.Zone;
			}
			nodeCount = src.Level;
			if (nodeCount.HasValue)
			{
				int valueOrDefault2 = nodeCount.GetValueOrDefault();
				if (true)
				{
					text3 += $"  ·  Lv {valueOrDefault2}";
				}
			}
			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))
				{
					DrawQuestRewardTree(src, byStableKey, text3, step, visited);
					return;
				}
			}
			List<ItemSource> children = src.Children;
			if (children != null && children.Count > 0 && depth < 3)
			{
				if (!ImGui.TreeNode($"{text3}##src_{step.Order}_{depth}_{src.Type}_{src.Name}"))
				{
					return;
				}
				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($"Open quest: {byStableKey2.DisplayName}##goto_{step.Order}_{src.QuestKey}"))
						{
							_state.SelectQuest(byStableKey2);
						}
						ImGui.PopStyleColor();
					}
				}
				foreach (ItemSource child in src.Children)
				{
					DrawSource(child, quest, step, visited, depth + 1);
				}
				ImGui.TreePop();
				return;
			}
			string text4 = src.MakeSourceId();
			if (text4 != null)
			{
				bool flag = _nav.IsSourceActive(text4);
				if (flag)
				{
					uint num = (_nav.IsManualSourceOverride ? Theme.NavManualOverride : Theme.QuestActive);
					ImGui.PushStyleColor((ImGuiCol)0, num);
				}
				if (ImGui.Selectable($"{text3}##src_{step.Order}_{text4}"))
				{
					_nav.ToggleSource(text4, _state.CurrentZone);
				}
				if (flag)
				{
					ImGui.PopStyleColor();
				}
				if (ImGui.IsItemHovered())
				{
					ImGui.BeginTooltip();
					string text5 = (flag ? "Remove from" : "Add to");
					if (src.SourceKey != null)
					{
						ImGui.Text(text5 + " navigation: " + src.Name);
					}
					else
					{
						ImGui.Text(text5 + " navigation: " + (src.Zone ?? src.Scene));
					}
					ImGui.EndTooltip();
				}
			}
			else
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.SourceDimmed);
				ImGui.Text(text3);
				ImGui.PopStyleColor();
			}
		}

		private void DrawSubQuestSteps(QuestStep step, 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(16f);
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
				if (ImGui.Selectable($"Open quest: {byStableKey.DisplayName}##cq_{step.Order}_{step.TargetKey}"))
				{
					_state.SelectQuest(byStableKey);
				}
				ImGui.PopStyleColor();
				visited.Add(byStableKey.StableKey);
				DrawSteps(byStableKey, visited);
				visited.Remove(byStableKey.StableKey);
				ImGui.Unindent(16f);
			}
		}

		private void DrawQuestRewardTree(ItemSource src, QuestEntry subQuest, string label, QuestStep parentStep, HashSet<string> visited)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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($"{label}##sqt_{parentStep.Order}_{src.QuestKey}", val);
			if (flag)
			{
				ImGui.PopStyleColor();
			}
			if (flag2)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
				if (ImGui.Selectable($"Open quest: {subQuest.DisplayName}##goto_{parentStep.Order}_{src.QuestKey}"))
				{
					_state.SelectQuest(subQuest);
				}
				ImGui.PopStyleColor();
				visited.Add(subQuest.StableKey);
				DrawSteps(subQuest, visited);
				visited.Remove(subQuest.StableKey);
				ImGui.TreePop();
			}
		}

		private void DrawTips(QuestStep step)
		{
			if (step.Tips == null || step.Tips.Count == 0)
			{
				return;
			}
			ImGui.Indent(16f);
			if (ImGui.TreeNode($"Tips##{step.Order}"))
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				foreach (string tip in step.Tips)
				{
					ImGui.TextWrapped(tip);
				}
				ImGui.PopStyleColor();
				ImGui.TreePop();
			}
			ImGui.Unindent(16f);
		}

		private void DrawRewards(QuestEntry quest)
		{
			RewardInfo rewards = quest.Rewards;
			if (rewards == null || !HasAnyRewards(rewards) || !ImGui.CollapsingHeader("Rewards", (ImGuiTreeNodeFlags)32))
			{
				return;
			}
			ImGui.Indent(16f);
			if (rewards.XP > 0)
			{
				ImGui.Text($"{rewards.XP} XP");
			}
			if (rewards.Gold > 0)
			{
				ImGui.Text($"{rewards.Gold} Gold");
			}
			if (rewards.ItemName != null)
			{
				ImGui.Text(rewards.ItemName);
			}
			if (rewards.VendorUnlock != null)
			{
				ImGui.Text("Unlocks " + rewards.VendorUnlock.ItemName + " at " + rewards.VendorUnlock.VendorName);
			}
			if (rewards.UnlockedZoneLines != null)
			{
				foreach (UnlockedZoneLine unlockedZoneLine in rewards.UnlockedZoneLines)
				{
					string text = "Opens path from " + unlockedZoneLine.FromZone + " to " + unlockedZoneLine.ToZone;
					List<string> coRequirements = unlockedZoneLine.CoRequirements;
					if (coRequirements != null && coRequirements.Count > 0)
					{
						text = text + " (also requires " + string.Join(", ", unlockedZoneLine.CoRequirements) + ")";
					}
					ImGui.Text(text);
				}
			}
			if (rewards.UnlockedCharacters != null)
			{
				foreach (UnlockedCharacter unlockedCharacter in rewards.UnlockedCharacters)
				{
					string text2 = ((unlockedCharacter.Zone != null) ? ("Enables " + unlockedCharacter.Name + " in " + unlockedCharacter.Zone) : ("Enables " + unlockedCharacter.Name));
					ImGui.Text(text2);
				}
			}
			if (rewards.NextQuestName != null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.Text("Next: " + rewards.NextQuestName);
				ImGui.PopStyleColor();
			}
			if (rewards.FactionEffects != null)
			{
				foreach (FactionEffect factionEffect in rewards.FactionEffects)
				{
					string arg = ((factionEffect.Amount >= 0) ? "+" : "");
					ImGui.Text($"{factionEffect.FactionName}: {arg}{factionEffect.Amount}");
				}
			}
			if (rewards.AlsoCompletes != null && rewards.AlsoCompletes.Count > 0)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.Text("Also completes: " + string.Join(", ", rewards.AlsoCompletes));
				ImGui.PopStyleColor();
			}
			ImGui.Unindent(16f);
		}

		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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (quest.Prerequisites == null || quest.Prerequisites.Count == 0)
			{
				return;
			}
			HashSet<string> hashSet = CollectStepTreeQuestKeys(quest);
			List<Prerequisite> list = new List<Prerequisite>();
			foreach (Prerequisite prerequisite in quest.Prerequisites)
			{
				if (!hashSet.Contains(prerequisite.QuestKey))
				{
					list.Add(prerequisite);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			bool flag = false;
			foreach (Prerequisite item in list)
			{
				if (!IsPrerequisiteCompleted(item))
				{
					flag = true;
					break;
				}
			}
			ImGuiTreeNodeFlags val = (ImGuiTreeNodeFlags)(flag ? 32 : 0);
			if (!ImGui.CollapsingHeader("Prerequisites", val))
			{
				return;
			}
			ImGui.Indent(16f);
			foreach (Prerequisite item2 in list)
			{
				uint num = (IsPrerequisiteCompleted(item2) ? Theme.QuestCompleted : Theme.TextPrimary);
				string text = ((item2.Item != null) ? (item2.QuestName + " (" + item2.Item + ")") : item2.QuestName);
				ImGui.PushStyleColor((ImGuiCol)0, num);
				if (ImGui.Selectable(text + "##prereq_" + item2.QuestKey))
				{
					QuestEntry byStableKey = _data.GetByStableKey(item2.QuestKey);
					if (byStableKey != null)
					{
						_state.SelectQuest(byStableKey);
					}
				}
				ImGui.PopStyleColor();
			}
			ImGui.Unindent(16f);
		}

		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 (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 static RequiredItemInfo? FindRequiredItem(QuestEntry quest, QuestStep step)
		{
			return quest.RequiredItems?.Find((RequiredItemInfo ri) => string.Equals(ri.ItemName, step.TargetName, StringComparison.OrdinalIgnoreCase));
		}

		private bool IsSourceAvailable(ItemSource source)
		{
			return source.RequiredQuestDBNames == null || source.RequiredQuestDBNames.TrueForAll(_state.IsGameQuestCompleted);
		}

		private bool HasNavigableSource(ItemSource s)
		{
			if (!IsSourceAvailable(s))
			{
				return false;
			}
			if (s.Scene != null)
			{
				return true;
			}
			if (s.SourceKey != null && _data.CharacterSpawns.ContainsKey(s.SourceKey))
			{
				return true;
			}
			return s.Children?.Exists((ItemSource c) => HasNavigableSource(c)) ?? false;
		}
	}
	public sealed class QuestListPanel
	{
		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 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)
		{
			_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", QuestSortMode.Alphabetical, "Sort alphabetically");
			ImGui.SameLine(0f, 2f);
			DrawSortButton("Lv", QuestSortMode.ByLevel, "Sort by level");
			ImGui.SameLine(0f, 2f);
			DrawSortButton("Zn", 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 + "##sort"))
			{
				_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);
			}
			foreach (QuestEntry item in _sorted)
			{
				DrawQuestEntry(item);
			}
			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)
		{
			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);
			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 text3 = text2;
			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("##" + quest.RuntimeKey, flag, (ImGuiSelectableFlags)0, vector2);
			bool flag4 = ImGui.IsItemHovered();
			vector = ImGui.GetCursorPos();
			if (flag3)
			{
				_state.SelectQuest(quest);
			}
			float num2 = QuestListMarkerStartX(cursorPos.X);
			float num3 = QuestListMarkerColumnWidth();
			if (flag2)
			{
				ImGui.SetCursorPos(new Vector2(num2, cursorPos.Y));
				ImGui.TextUnformatted("·");
			}
			ImGui.SetCursorPos(new Vector2(num2 + num3, cursorPos.Y));
			ImGui.TextUnformatted(text3);
			ImGui.SetCursorPos(vector);
			if (flag4)
			{
				ImGui.BeginTooltip();
				if (quest.ZoneContext != null)
				{
					ImGui.Text(quest.ZoneContext);
				}
				string text4;
				if (_state.Workflows.IsUnverifiable(quest))
				{
					text4 = "Workflow state unavailable";
				}
				else
				{
					QuestRuntimeStatus status = _state.GetStatus(quest);
					if (1 == 0)
					{
					}
					string text5 = status switch
					{
						QuestRuntimeStatus.Completed => "Completed", 
						QuestRuntimeStatus.ImplicitlyActive => "Completable here", 
						QuestRuntimeStatus.Active => "Active", 
						_ => "Available", 
					};
					if (1 == 0)
					{
					}
					text4 = text5;
				}
				string text6 = text4;
				ImGui.Text(text6);
				num = quest.LevelEstimate?.Recommended;
				if (num.HasValue)
				{
					int valueOrDefault2 = num.GetValueOrDefault();
					if (true)
					{
						ImGui.Text($"Level {valueOrDefault2}");
					}
				}
				ImGui.EndTooltip();
			}
			ImGui.PopStyleColor((!flag) ? 1 : 2);
		}

		private uint GetQuestColor(QuestEntry quest)
		{
			return Theme.GetQuestColor(_state, quest);
		}
	}
	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()
		{
			PushWindowStyle();
			return default(WindowStyleScopeToken);
		}

		public static void PushWindowStyle()
		{
			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, 4f);
			ImGui.PushStyleVar((ImGuiStyleVar)8, 1f);
			ImGui.PushStyleVar((ImGuiStyleVar)13, 0f);
			ImGui.PushStyleVar((ImGuiStyleVar)11, new Vector2(4f, 3f));
			ImGui.PushStyleVar((ImGuiStyleVar)14, new Vector2(8f, 4f));
			ImGui.PushStyleVar((ImGuiStyleVar)16, 16f);
			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 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_0123: 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)
					{
						string label = ((navigationTarget.SourceId != null && navigationTarget.SourceId.StartsWith("fishing:", StringComparison.Ordinal)) ? "Fishing" : null);
						output[text] = new StepDistance(inCurrentZone: true, float.MaxValue, label);
					}
					else
					{
						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);
			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);
		}

		private static SourceDistance ComputeStepDistance(QuestEntry quest, QuestStateTracker state, GuideData data, string currentScene, Vector3 playerPos)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: 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 (step, questEntry) = StepProgress.ResolveActiveStep(currentStep, quest, state, data);
			if (step == null)
			{
				return SourceDistance.None;
			}
			QuestEntry questEntry2 = questEntry ?? quest;
			if (step.Location != null)
			{
				string text = StepSceneResolver.ResolveScene(questEntry2, step, data, state.IsGameQuestCompleted);
				if (text != null && string.Equals(text, currentScene, StringComparison.OrdinalIgnoreCase))
				{
					return new SourceDistance(Vector3.Distance(playerPos, new Vector3(step.Location.X, step.Location.Y, step.Location.Z)));
				}
			}
			string targetKey = step.TargetKey;
			if (targetKey != null && step.TargetType == "character" && data.CharacterSpawns.ContainsKey(targetKey))
			{
				return NearestSpawnDistance(data, targetKey, currentScene, playerPos);
			}
			if (step.TargetType == "item" && questEntry2.RequiredItems != null)
			{
				RequiredItemInfo requiredItemInfo = questEntry2.RequiredItems.Find((RequiredItemInfo ri) => string.Equals(ri.ItemName, step.TargetName, StringComparison.OrdinalIgnoreCase));
				if (requiredItemInfo?.Sources != null)
				{
					return NearestSourceDistance(requiredItemInfo.Sources, data, state, currentScene, playerPos);
				}
			}
			return SourceDistance.None;
		}

		private static SourceDistance NearestSourceDistance(List<ItemSource> sources, GuideData data, QuestStateTracker state, string currentScene, Vector3 playerPos)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			SourceDistance sourceDistance = SourceDistance.None;
			foreach (ItemSource source in sources)
			{
				if (source.RequiredQuestDBNames != null && !source.RequiredQuestDBNames.TrueForAll(state.IsGameQuestCompleted))
				{
					continue;
				}
				if (source.Type == "quest_reward")
				{
					List<ItemSource> children = source.Children;
					if (children != null && children.Count > 0)
					{
						sourceDistance = SourceDistance.Best(sourceDistance, NearestSourceDistance(source.Children, data, state, currentScene, playerPos));
						continue;
					}
				}
				if (source.SourceKey != null)
				{
					sourceDistance = SourceDistance.Best(sourceDistance, NearestSpawnDistance(data, source.SourceKey, currentScene, playerPos));
				}
				if (source.Children != null)
				{
					sourceDistance = SourceDistance.Best(sourceDistance, NearestSourceDistance(source.Children, data, state, currentScene, playerPos));
				}
			}
			return sourceDistance;
		}

		private static SourceDistance NearestSpawnDistance(GuideData data, string key, string currentScene, Vector3 playerPos)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (key.StartsWith("fishing:", StringComparison.Ordinal))
			{
				string a = key.Substring("fishing:".Length);
				return string.Equals(a, currentScene, StringComparison.OrdinalIgnoreCase) ? new SourceDistance(float.MaxValue, "Fishing") : SourceDistance.None;
			}
			if (!data.CharacterSpawns.TryGetValue(key, out List<SpawnPoint> value) || value.Count == 0)
			{
				return SourceDistance.None;
			}
			float num = float.MaxValue;
			foreach (SpawnPoint item in value)
			{
				if (string.Equals(item.Scene, currentScene, StringComparison.OrdinalIgnoreCase))
				{
					float num2 = Vector3.Distance(playerPos, new Vector3(item.X, item.Y, item.Z));
					if (num2 < num)
					{
						num = num2;
					}
				}
			}
			return new SourceDistance(num);
		}

		private static QuestStep? GetCurrentStep(QuestEntry quest, QuestStateTracker state, GuideData data)
		{
			if (quest.Steps == null || quest.Steps.Count == 0)
			{
				return null;
			}
			int currentStepIndex = StepProgress.GetCurrentStepIndex(quest, state, data);
			return (currentStepIndex >= 0 && currentStepIndex < quest.Steps.Count) ? quest.Steps[currentStepIndex] : null;
		}
	}
	public enum TrackerSortMode
	{
		Proximity,
		Level,
		Alphabetical
	}
	public sealed class TrackerWindow
	{
		private struct EntryAnimation
		{
			public float AddedAt;

			public float CompletedAt;

			public float StepAdvancedAt;
		}

		private const float DefaultWidth = 340f;

		private const float DefaultHeight = 260f;

		private const float FadeInDuration = 0.3f;

		private const float FadeOutDuration = 0.3f;

		private const float CompletionFlashDuration = 1.5f;

		private const float CompletionLingerDuration = 2f;

		private const float StepAdvanceDuration = 0.8f;

		private const float CompactTintRounding = 8f;

		private const float CompactPadTop = 10f;

		private const float CompactPadBottom = 6f;

		private const float CompactPadLeft = 8f;

		private const float CompactPadRight = 6f;

		private const int DrawFlagsRoundCornersAll = 240;

		private readonly GuideData _data;

		private readonly QuestStateTracker _state;

		private readonly NavigationController _nav;

		private readonly TrackerState _tracker;

		private readonly GuideWindow _guide;

		private readonly GuideConfig _config;

		private bool _visible = true;

		private readonly Dictionary<string, EntryAnimation> _animations = new Dictionary<string, EntryAnimation>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, float> _fadingOut = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, float> _completionTimers = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

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

		private readonly Dictionary<string, StepDistance> _distances = new Dictionary<string, StepDistance>(StringComparer.OrdinalIgnoreCase);

		private int _lastStateVersion = -1;

		private float _lastProximitySort;

		private TrackerSortMode _lastSortMode;

		private readonly Dictionary<string, int> _cachedStepIndex = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		private bool _compact = true;

		private Vector2 _contentMin;

		private Vector2 _contentMax;

		public bool Visible => _visible;

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

		public void Show()
		{
			_visible = true;
		}

		public void Hide()
		{
			_visible = false;
		}

		public TrackerWindow(GuideData data, QuestStateTracker state, NavigationController nav, TrackerState tracker, GuideWindow guide, GuideConfig config)
		{
			_data = data;
			_state = state;
			_nav = nav;
			_tracker = tracker;
			_guide = guide;
			_config = config;
			_tracker.Tracked += OnQuestTracked;
			_tracker.Untracked += OnQuestUntracked;
			_tracker.QuestCompleted += OnQuestCompleted;
			_tracker.StepAdvanced += OnQuestStepAdvanced;
		}

		public void Dispose()
		{
			_tracker.Tracked -= OnQuestTracked;
			_tracker.Untracked -= OnQuestUntracked;
			_tracker.QuestCompleted -= OnQuestCompleted;
			_tracker.StepAdvanced -= OnQuestStepAdvanced;
		}

		public void Update()
		{
			PruneAnimations();
		}

		private void OnQuestTracked(string dbName)
		{
			_animations[dbName] = new EntryAnimation
			{
				AddedAt = Time.realtimeSinceStartup
			};
			_fadingOut.Remove(dbName);
			_visible = true;
		}

		private void OnQuestUntracked(string dbName)
		{
			_fadingOut[dbName] = Time.realtimeSinceStartup;
			_completionTimers.Remove(dbName);
		}

		private void OnQuestCompleted(string questKey)
		{
			EntryAnimation orDefaultAnim = GetOrDefaultAnim(questKey);
			orDefaultAnim.CompletedAt = Time.realtimeSinceStartup;
			_animations[questKey] = orDefaultAnim;
			QuestFlags questFlags = _data.GetByRuntimeKey(questKey)?.Flags;
			if (questFlags != null && questFlags.Repeatable)
			{
				_completionTimers.Remove(questKey);
				_cachedStepIndex.Remove(questKey);
			}
			else
			{
				_completionTimers[questKey] = Time.realtimeSinceStartup;
			}
		}

		private void OnQuestStepAdvanced(string questKey)
		{
			EntryAnimation orDefaultAnim = GetOrDefaultAnim(questKey);
			orDefaultAnim.StepAdvancedAt = Time.realtimeSinceStartup;
			_animations[questKey] = orDefaultAnim;
		}

		public void Draw()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible || !_tracker.Enabled || (_contentMax.Y > _contentMin.Y && GameWindowOverlap.ShouldSuppressTracker(_contentMin.X, _contentMin.Y, _contentMax.X, _contentMax.Y)))
			{
				return;
			}
			DetectStepAdvances();
			RebuildSortedListIfNeeded();
			if (_sorted.Count == 0 && _fadingOut.Count == 0)
			{
				return;
			}
			ImGuiCond val = (ImGuiCond)(_config.LayoutResetRequested ? 1 : 4);
			float resolvedUiScale = _config.ResolvedUiScale;
			Vector2 vector = Theme.DisplaySize();
			ImGui.SetNextWindowSize(new Vector2(340f * resolvedUiScale, 260f * resolvedUiScale), val);
			ImGui.SetNextWindowPos(new Vector2(40f, vector.Y * 0.5f), val, new Vector2(0f, 0.5f));
			int num = 0;
			bool flag = false;
			using (Theme.WindowStyleScope())
			{
				try
				{
					if (_compact)
					{
						ImGui.PushStyleColor((ImGuiCol)2, 0u);
						ImGui.PushStyleColor((ImGuiCol)3, 0u);
						ImGui.PushStyleColor((ImGuiCol)5, 0u);
						ImGui.PushStyleColor((ImGuiCol)10, 0u);
						ImGui.PushStyleColor((ImGuiCol)11, 0u);
						ImGui.PushStyleColor((ImGuiCol)12, 0u);
						ImGui.PushStyleColor((ImGuiCol)21, 0u);
						ImGui.PushStyleColor((ImGuiCol)7, 0u);
						num = 8;
					}
					if (_compact && _contentMax.Y > _contentMin.Y)
					{
						uint col = Theme.Rgba(0f, 0f, 0f, _config.TrackerBackgroundOpacity.Value);
						IntPtr self = CimguiNative.igGetBackgroundDrawList_Nil();
						CimguiNative.ImDrawList_AddRectFilled(self, new CimguiNative.Vec2(_contentMin.X, _contentMin.Y), new CimguiNative.Vec2(_contentMax.X, _contentMax.Y), col, 8f, 240);
					}
					ImGuiWindowFlags val2 = (ImGuiWindowFlags)798752;
					if (_compact)
					{
						val2 = (ImGuiWindowFlags)(val2 | 0xA);
					}
					bool flag2 = ((!_compact) ? ImGui.Begin("Quest Tracker###Tracker", ref _visible, val2) : ImGui.Begin("###Tracker", val2));
					flag = true;
					if (flag2)
					{
						if (_compact)
						{
							ImGui.PushStyleVar((ImGuiStyleVar)0, 0f);
							try
							{
								DrawHeaderBar();
							}
							finally
							{
								ImGui.PopStyleVar();
							}
						}
						else
						{
							DrawHeaderBar();
						}
						DrawQuestList();
						bool flag3 = ImGui.IsWindowHovered((ImGuiHoveredFlags)3);
						bool flag4 = ImGui.IsWindowFocused((ImGuiFocusedFlags)3) && ImGui.IsMouseDown((ImGuiMouseButton)0);
						_compact = !flag3 && !flag4;
						if (_compact && ImGui.IsWindowFocused((ImGuiFocusedFlags)3))
						{
							ImGui.SetWindowFocus((string)null);
						}
					}
					Theme.ClampWindowPosition();
				}
				finally
				{
					if (flag)
					{
						ImGui.End();
					}
					if (num > 0)
					{
						ImGui.PopStyleColor(num);
					}
				}
			}
		}

		private void DrawHeaderBar()
		{
			DrawSortButton("Px", TrackerSortMode.Proximity, "Sort by proximity");
			ImGui.SameLine(0f, 2f);
			DrawSortButton("Lv", TrackerSortMode.Level, "Sort by level");
			ImGui.SameLine(0f, 2f);
			DrawSortButton("Az", TrackerSortMode.Alphabetical, "Sort alphabetically");
			ImGui.Separator();
		}

		private void DrawSortButton(string label, TrackerSortMode mode, string tooltip)
		{
			bool flag = _tracker.SortMode == mode;
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
			}
			if (ImGui.SmallButton(label + "##tsort"))