using System;
using System.Collections.Generic;
using System.Diagnostics;
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 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: 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+bfa55558cb8c2118ef5fe2ac2ac03fdad8bac222")]
[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]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
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 AdventureGuide
{
	[BepInPlugin("wow-much.adventure-guide", "Adventure Guide", "2026.327.2")]
	public sealed class Plugin : BaseUnityPlugin
	{
		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 ImGuiRenderer? _imgui;

		private GuideWindow? _window;

		private TrackerState? _trackerState;

		private TrackerWindow? _tracker;

		private bool _wasTextInputActive;

		private bool _gameUIVisible = true;

		private bool _inGameplay;

		private bool _discoveryDone;

		private bool _wasEditUIMode;

		internal static ManualLogSource Log { get; private set; }

		static Plugin()
		{
			Log = null;
			AppDomain.CurrentDomain.AssemblyResolve += delegate(object _, ResolveEventArgs args)
			{
				if (new AssemblyName(args.Name).Name == "System.Numerics.Vectors")
				{
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly in assemblies)
					{
						if (assembly.GetName().Name == "System.Numerics")
						{
							return assembly;
						}
					}
				}
				return null;
			};
		}

		private void Awake()
		{
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Expected O, but got Unknown
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			_config = new GuideConfig(((BaseUnityPlugin)this).Config);
			_data = GuideData.Load(Log);
			_state = new QuestStateTracker(_data);
			_trackerState = new TrackerState();
			_trackerState.LoadFromConfig(_config);
			float num = ((_config.UiScale.Value >= 0f) ? _config.UiScale.Value : 1f);
			_config.ResolvedUiScale = num;
			string iniPath = Path.Combine(Paths.ConfigPath, "wow-much.adventure-guide.imgui.ini");
			_imgui = new ImGuiRenderer(Log)
			{
				UiScale = num,
				IniPath = iniPath
			};
			if (!_imgui.Init())
			{
				Log.LogError((object)"ImGui.NET init failed — mod cannot render UI");
				return;
			}
			_config.UiScale.SettingChanged += OnUiScaleChanged;
			_config.ResetWindowLayout.SettingChanged += OnResetWindowLayout;
			_entities = new EntityRegistry();
			_timers = new SpawnTimerTracker();
			_miningTracker = new MiningNodeTracker();
			SpawnPointBridge bridge = new SpawnPointBridge();
			_lootScanner = new LootScanner();
			_nav = new NavigationController(_data, _entities, _state, _timers, _miningTracker, _lootScanner);
			_arrow = new ArrowRenderer(_nav);
			_arrow.Enabled = _config.ShowArrow.Value;
			_config.ShowArrow.SettingChanged += OnShowArrowChanged;
			_groundPath = new GroundPathRenderer(_nav);
			_groundPath.Enabled = _config.ShowGroundPath.Value;
			_config.ShowGroundPath.SettingChanged += OnShowGroundPathChanged;
			_markers = new WorldMarkerSystem(_data, _state, bridge, _lootScanner, _config);
			_markers.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;
			DeathPatch.Registry = _entities;
			DeathPatch.Timers = _timers;
			DeathPatch.Markers = _markers;
			DeathPatch.Loot = _lootScanner;
			QuestMarkerPatch.SuppressGameMarkers = _config.ShowWorldMarkers.Value;
			PointerOverUIPatch.Renderer = _imgui;
			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();
			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++;
				}
			}
			Log.LogInfo((object)("Adventure Guide v2026.327.2\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\n" + "  Config: BepInEx/config/wow-much.adventure-guide.cfg\n  Tip: Install BepInEx ConfigurationManager for in-game settings (F1)"));
		}

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

		private void Update()
		{
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			bool isVisible = GameUIVisibility.IsVisible;
			if (isVisible != _gameUIVisible)
			{
				_gameUIVisible = isVisible;
				SyncVisibility();
				if (!isVisible)
				{
					_imgui?.ClearCaptureState();
					if (_wasTextInputActive)
					{
						GameData.PlayerTyping = false;
						_wasTextInputActive = false;
					}
				}
			}
			bool editUIMode = GameData.EditUIMode;
			if (_wasEditUIMode && !editUIMode)
			{
				GameWindowOverlap.InvalidateRects();
			}
			_wasEditUIMode = editUIMode;
			if (_gameUIVisible)
			{
				bool flag = _imgui?.WantTextInput ?? false;
				if (flag && !_wasTextInputActive)
				{
					GameData.PlayerTyping = true;
				}
				else if (!flag && _wasTextInputActive)
				{
					GameData.PlayerTyping = false;
				}
				_wasTextInputActive = flag;
			}
			if (!_discoveryDone)
			{
				TryMergeUnknownQuests();
			}
			string currentScene = _state?.CurrentZone ?? "";
			_lootScanner?.Update(_data, _state);
			_nav?.Update(currentScene);
			_groundPath?.Update(currentScene);
			_markers?.Update(currentScene);
			if (_config != null && _window != null && _inGameplay && !GameData.PlayerTyping)
			{
				if (Input.GetKeyDown(_config.ToggleKey.Value))
				{
					_window.Toggle();
				}
				if (_config.ReplaceQuestLog.Value && Input.GetKeyDown(InputManager.Journal))
				{
					_window.Toggle();
				}
				if (_config.TrackerEnabled.Value && Input.GetKeyDown(_config.TrackerToggleKey.Value))
				{
					_tracker?.Toggle();
				}
				if (Input.GetKeyDown(_config.GroundPathToggleKey.Value))
				{
					_config.ShowGroundPath.Value = !_config.ShowGroundPath.Value;
				}
			}
		}

		private void OnGUI()
		{
			if (_gameUIVisible)
			{
				_imgui?.OnGUI();
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (_config.UiScale.Value < 0f && ((Scene)(ref scene)).name != "Menu" && ((Scene)(ref scene)).name != "LoadScene")
			{
				float value = DetectUiScale();
				_config.UiScale.Value = value;
			}
			CameraCache.Invalidate();
			GameWindowOverlap.Reset();
			_inGameplay = ((Scene)(ref scene)).name != "Menu" && ((Scene)(ref scene)).name != "LoadScene";
			if (!_inGameplay)
			{
				_window?.Hide();
				_tracker?.Hide();
				_nav?.Clear();
			}
			_markers?.OnSceneLoaded();
			_entities?.Clear();
			_timers?.Clear();
			_miningTracker?.Rescan();
			_lootScanner?.OnSceneLoaded();
			_state?.OnSceneChanged(((Scene)(ref scene)).name);
			_trackerState?.OnCharacterLoaded();
			_trackerState?.PruneCompleted(_state);
			_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)
			{
				_imgui?.ClearWindowState();
				_config.LayoutResetRequested = true;
				_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 SyncVisibility()
		{
			bool gameUIVisible = _gameUIVisible;
			_arrow.Enabled = gameUIVisible && _config.ShowArrow.Value;
			_groundPath.Enabled = gameUIVisible && _config.ShowGroundPath.Value;
			_markers.Enabled = gameUIVisible && _config.ShowWorldMarkers.Value;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			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;
				QuestMarkerPatch.SuppressGameMarkers = false;
			}
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_tracker?.Dispose();
			_trackerState?.SaveToConfig();
			_nav?.SavePerCharacter();
			_imgui?.Dispose();
			_arrow?.Dispose();
			_groundPath?.Destroy();
			_markers?.Destroy();
			_timers?.Clear();
			_entities?.Clear();
			_miningTracker?.Clear();
			MarkerFonts.Destroy();
			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.327.2";
	}
}
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++;
					GuideConfig? config = _config;
					if (config != null)
					{
						((ConfigEntryBase)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++;
					GuideConfig? config = _config;
					if (config != null)
					{
						((ConfigEntryBase)config.ZoneFilter).SetSerializedValue(value ?? "");
					}
				}
			}
		}

		public QuestSortMode SortMode
		{
			get
			{
				return _sortMode;
			}
			set
			{
				if (_sortMode != value)
				{
					_sortMode = value;
					Version++;
					GuideConfig? config = _config;
					if (config != null)
					{
						((ConfigEntryBase)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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (_visible)
			{
				ImGuiCond val = (ImGuiCond)(_config.LayoutResetRequested ? 1 : 4);
				float resolvedUiScale = _config.ResolvedUiScale;
				ImGuiIOPtr iO = ImGui.GetIO();
				Vector2 displaySize = ((ImGuiIOPtr)(ref iO)).DisplaySize;
				ImGui.SetNextWindowSize(new Vector2(780f * resolvedUiScale, 530f * resolvedUiScale), val);
				ImGui.SetNextWindowPos(new Vector2(displaySize.X * 0.5f, displaySize.Y * 0.5f), val, new Vector2(0.5f, 0.5f));
				Theme.PushWindowStyle();
				if (ImGui.Begin("Adventure Guide", ref _visible, (ImGuiWindowFlags)32))
				{
					DrawTabBar();
				}
				Theme.ClampWindowPosition();
				ImGui.End();
				Theme.PopWindowStyle();
			}
		}

		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.SelectedQuestDBName = pageRef.Value.Key;
				}
			}
			if (ImGui.TabItemButton(">"))
			{
				NavigationHistory.PageRef? pageRef2 = _history.Forward();
				if (pageRef2.HasValue && pageRef2.Value.Type == NavigationHistory.PageType.Quest)
				{
					_state.SelectedQuestDBName = 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.SelectedQuestDBName == null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.TextWrapped("Select a quest from the list.");
				ImGui.PopStyleColor();
				return;
			}
			QuestEntry byDBName = _data.GetByDBName(_state.SelectedQuestDBName);
			if (byDBName == null)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.TextWrapped("Quest not found in guide data.");
				ImGui.PopStyleColor();
			}
			else
			{
				DrawHeader(byDBName);
				DrawObjectives(byDBName);
				DrawRewards(byDBName);
				DrawPrerequisites(byDBName);
			}
		}

		private void DrawHeader(QuestEntry quest)
		{
			if (_tracker.Enabled && !_state.IsCompleted(quest.DBName))
			{
				bool flag = _tracker.IsTracked(quest.DBName);
				if (flag)
				{
					ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
				}
				if (ImGui.SmallButton(flag ? "[Untrack]" : "[Track]"))
				{
					if (flag)
					{
						_tracker.Untrack(quest.DBName);
					}
					else
					{
						_tracker.Track(quest.DBName);
					}
				}
				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 flag2 = item2.ZoneName != null;
					bool flag3 = flag2;
					if (flag3)
					{
						text = item2.Method;
						bool flag4 = ((text == "item_turnin" || text == "dialog") ? true : false);
						flag3 = flag4;
					}
					if (flag3)
					{
						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();
			}
			else 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.DBName);
			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}";
			if (step.Action == "collect" && 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.DBName))
				{
					num2 = Theme.QuestCompleted;
				}
			}
			int? num4 = step.LevelEstimate?.Recommended;
			string action;
			if (num4.HasValue)
			{
				int valueOrDefault = num4.GetValueOrDefault();
				if (true)
				{
					action = step.Action;
					if (!(action == "collect") && !(action == "read"))
					{
						List<LevelFactor> factors = step.LevelEstimate.Factors;
						if (factors != null && factors.Count > 0)
						{
							text = text + "  ·  " + step.LevelEstimate.Factors[0].Name;
						}
					}
					text += $"  ·  Lv {valueOrDefault}";
					goto IL_026d;
				}
			}
			action = step.Action;
			if (!(action == "collect") && !(action == "read"))
			{
				List<LevelFactor> factors = step.LevelEstimate?.Factors;
				if (factors != null && factors.Count > 0)
				{
					text = text + "  ·  " + step.LevelEstimate.Factors[0].Name;
				}
			}
			goto IL_026d;
			IL_026d:
			DrawNavButton(step, quest);
			ImGui.PushStyleColor((ImGuiCol)0, num2);
			ImGui.Text(text);
			ImGui.PopStyleColor();
			DrawStepSources(step, quest, visited);
			DrawSubQuestSteps(step, visited);
			if (_nav.IsNavigating(quest.DBName, 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))).GetValueOrDefault();
			}
			bool flag2 = _nav.IsNavigating(quest.DBName, 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)
		{
			string action = step.Action;
			if ((!(action == "collect") && !(action == "read")) || step.TargetName == null)
			{
				DrawTips(step);
				return;
			}
			RequiredItemInfo requiredItemInfo = FindRequiredItem(quest, step);
			if (requiredItemInfo?.Sources == null || requiredItemInfo.Sources.Count == 0)
			{
				DrawTips(step);
				return;
			}
			ImGui.Indent(16f);
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			int num = Math.Min(requiredItemInfo.Sources.Count, 4);
			for (int i = 0; i < num; i++)
			{
				DrawSource(requiredItemInfo.Sources[i], quest, step, visited);
			}
			if (requiredItemInfo.Sources.Count > 4)
			{
				int num2 = requiredItemInfo.Sources.Count - 4;
				int valueOrDefault = requiredItemInfo.Sources[4].Level.GetValueOrDefault();
				List<ItemSource>? sources = requiredItemInfo.Sources;
				int valueOrDefault2 = sources[sources.Count - 1].Level.GetValueOrDefault(valueOrDefault);
				string arg = ((valueOrDefault == valueOrDefault2) ? $"Lv {valueOrDefault}" : $"Lv {valueOrDefault}-{valueOrDefault2}");
				if (ImGui.TreeNode($"{num2} more sources ({arg})##{step.Order}"))
				{
					for (int j = 4; j < requiredItemInfo.Sources.Count; j++)
					{
						DrawSource(requiredItemInfo.Sources[j], quest, step, visited);
					}
					ImGui.TreePop();
				}
			}
			ImGui.PopStyleColor();
			ImGui.Unindent(16f);
			DrawTips(step);
		}

		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.IsCompleted(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.DBName);
								}
								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)
		{
			string type = src.Type;
			if (1 == 0)
			{
			}
			string text;
			int? nodeCount;
			switch (type)
			{
			case "drop":
				text = "Drops from: " + src.Name;
				break;
			case "vendor":
				text = "Sold by: " + 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.DBName);
						}
						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.DBName);
				}
				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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _state.IsCompleted(subQuest.DBName);
			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.DBName);
				}
				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.DBName);
					}
				}
				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.DBName);
		}

		private static RequiredItemInfo? FindRequiredItem(QuestEntry quest, QuestStep step)
		{
			QuestStep step2 = step;
			return quest.RequiredItems?.Find((RequiredItemInfo ri) => string.Equals(ri.ItemName, step2.TargetName, StringComparison.OrdinalIgnoreCase));
		}

		private bool HasNavigableSource(ItemSource s)
		{
			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 int _filterIndex;

		private const string CurrentZoneSentinel = "\u001current";

		private readonly string[] _zoneNames;

		private int _zoneIndex;

		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)
		{
			QuestFilterMode filterMode = _filter.FilterMode;
			if (1 == 0)
			{
			}
			bool flag = filterMode switch
			{
				QuestFilterMode.Active => _state.IsActive(quest.DBName), 
				QuestFilterMode.Available => !_state.IsActive(quest.DBName) && !_state.IsCompleted(quest.DBName), 
				QuestFilterMode.Completed => _state.IsCompleted(quest.DBName), 
				QuestFilterMode.All => true, 
				_ => true, 
			};
			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 = quest.DBName == _state.SelectedQuestDBName;
			uint questColor = GetQuestColor(quest);
			if (flag)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.Accent);
			}
			string text = ((_tracker.Enabled && _tracker.IsTracked(quest.DBName)) ? "·" : " ");
			QuestFlags flags = quest.Flags;
			string text2 = ((flags != null && flags.Repeatable) ? " [R]" : "");
			int? num = quest.LevelEstimate?.Recommended;
			string text3;
			if (num.HasValue)
			{
				int valueOrDefault = num.GetValueOrDefault();
				text3 = $"{text}{valueOrDefault,2}  {quest.DisplayName}{text2}";
			}
			else
			{
				text3 = text + "    " + quest.DisplayName + text2;
			}
			string text4 = text3;
			ImGui.PushStyleColor((ImGuiCol)0, questColor);
			if (ImGui.Selectable(text4 + "##" + quest.DBName, flag))
			{
				_state.SelectQuest(quest.DBName);
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				if (quest.ZoneContext != null)
				{
					ImGui.Text(quest.ZoneContext);
				}
				string text5 = (_state.IsCompleted(quest.DBName) ? "Completed" : (_state.IsImplicitlyActive(quest.DBName) ? "Completable here" : (_state.IsActive(quest.DBName) ? "Active" : "Available")));
				ImGui.Text(text5);
				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.DBName);
		}
	}
	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
	{
		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;

		public static void PushWindowStyle()
		{
			ImGui.PushStyleColor((ImGuiCol)2, Background);
			ImGui.PushStyleColor((ImGuiCol)3, Surface);
		}

		public static void PopWindowStyle()
		{
			ImGui.PopStyleColor(2);
		}

		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 void ClampWindowPosition()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Vector2 windowPos = ImGui.GetWindowPos();
			Vector2 windowSize = ImGui.GetWindowSize();
			ImGuiIOPtr iO = ImGui.GetIO();
			Vector2 displaySize = ((ImGuiIOPtr)(ref iO)).DisplaySize;
			float num = windowPos.X;
			float num2 = windowPos.Y;
			if (num + windowSize.X < 40f)
			{
				num = 40f - windowSize.X;
			}
			if (num > displaySize.X - 40f)
			{
				num = displaySize.X - 40f;
			}
			if (num2 > displaySize.Y - 40f)
			{
				num2 = displaySize.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, string dbName)
		{
			if (state.IsImplicitlyActive(dbName))
			{
				return QuestImplicit;
			}
			if (state.IsActive(dbName))
			{
				return QuestActive;
			}
			if (state.IsCompleted(dbName))
			{
				return QuestCompleted;
			}
			return QuestAvailable;
		}
	}
	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, NavigationController nav, Vector3 playerPos, Dictionary<string, StepDistance> output)
		{
			//IL_0145: 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 byDBName = data.GetByDBName(text);
				if (byDBName == null)
				{
					output[text] = new StepDistance(inCurrentZone: false, float.MaxValue);
				}
				else if (nav.Target != null && string.Equals(nav.Target.QuestDBName, text, StringComparison.OrdinalIgnoreCase))
				{
					bool flag = !nav.Target.IsCrossZone(currentZone);
					if (flag && nav.Target.TargetKind == NavigationTarget.Kind.Zone)
					{
						string label = ((nav.Target.SourceId != null && nav.Target.SourceId.StartsWith("fishing:", StringComparison.Ordinal)) ? "Fishing" : null);
						output[text] = new StepDistance(inCurrentZone: true, float.MaxValue, label);
					}
					else
					{
						float meters = (flag ? nav.Distance : float.MaxValue);
						output[text] = new StepDistance(flag, meters);
					}
				}
				else if (!IsCurrentStepInZone(byDBName, state, data, currentZone))
				{
					output[text] = new StepDistance(inCurrentZone: false, float.MaxValue);
				}
				else
				{
					SourceDistance sourceDistance = ComputeStepDistance(byDBName, 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)
		{
			IReadOnlyDictionary<string, StepDistance> distances2 = distances;
			GuideData data2 = data;
			quests.Sort(delegate(string a, string b)
			{
				StepDistance value;
				StepDistance stepDistance = (distances2.TryGetValue(a, out value) ? value : new StepDistance(inCurrentZone: false, float.MaxValue));
				StepDistance value2;
				StepDistance stepDistance2 = (distances2.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 byDBName = data2.GetByDBName(a);
				QuestEntry byDBName2 = data2.GetByDBName(b);
				return string.Compare(byDBName?.DisplayName, byDBName2?.DisplayName, StringComparison.OrdinalIgnoreCase);
			});
		}

		private static void SortByLevel(List<string> quests, GuideData data)
		{
			GuideData data2 = data;
			quests.Sort(delegate(string a, string b)
			{
				QuestEntry byDBName = data2.GetByDBName(a);
				QuestEntry byDBName2 = data2.GetByDBName(b);
				int valueOrDefault = (byDBName?.LevelEstimate?.Recommended).GetValueOrDefault(int.MaxValue);
				int valueOrDefault2 = (byDBName2?.LevelEstimate?.Recommended).GetValueOrDefault(int.MaxValue);
				int num = valueOrDefault.CompareTo(valueOrDefault2);
				return (num != 0) ? num : string.Compare(byDBName?.DisplayName, byDBName2?.DisplayName, StringComparison.OrdinalIgnoreCase);
			});
		}

		private static void SortAlphabetical(List<string> quests, GuideData data)
		{
			GuideData data2 = data;
			quests.Sort(delegate(string a, string b)
			{
				QuestEntry byDBName = data2.GetByDBName(a);
				QuestEntry byDBName2 = data2.GetByDBName(b);
				return string.Compare(byDBName?.DisplayName ?? a, byDBName2?.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);
			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);
		}

		private static SourceDistance ComputeStepDistance(QuestEntry quest, QuestStateTracker state, GuideData data, string currentScene, Vector3 playerPos)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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;
			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, currentScene, playerPos);
				}
			}
			return SourceDistance.None;
		}

		private static SourceDistance NearestSourceDistance(List<ItemSource> sources, GuideData data, string currentScene, Vector3 playerPos)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			SourceDistance sourceDistance = SourceDistance.None;
			foreach (ItemSource source in sources)
			{
				if (source.Type == "quest_reward")
				{
					List<ItemSource> children = source.Children;
					if (children != null && children.Count > 0)
					{
						sourceDistance = SourceDistance.Best(sourceDistance, NearestSourceDistance(source.Children, data, 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, 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 < 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;
		}

		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 dbName)
		{
			EntryAnimation orDefaultAnim = GetOrDefaultAnim(dbName);
			orDefaultAnim.CompletedAt = Time.realtimeSinceStartup;
			_animations[dbName] = orDefaultAnim;
			_completionTimers[dbName] = Time.realtimeSinceStartup;
		}

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

		public void Draw()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: 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)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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;
			}
			PruneAnimations();
			DetectStepAdvances();
			RebuildSortedListIfNeeded();
			if (_sorted.Count == 0 && _fadingOut.Count == 0)
			{
				return;
			}
			ImGuiCond val = (ImGuiCond)(_config.LayoutResetRequested ? 1 : 4);
			float resolvedUiScale = _config.ResolvedUiScale;
			ImGuiIOPtr iO = ImGui.GetIO();
			Vector2 displaySize = ((ImGuiIOPtr)(ref iO)).DisplaySize;
			ImGui.SetNextWindowSize(new Vector2(340f * resolvedUiScale, 260f * resolvedUiScale), val);
			ImGui.SetNextWindowPos(new Vector2(40f, displaySize.Y * 0.5f), val, new Vector2(0f, 0.5f));
			int num = 0;
			int num2 = 0;
			Theme.PushWindowStyle();
			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);
			}
			if ((!_compact) ? ImGui.Begin("Quest Tracker###Tracker", ref _visible, val2) : ImGui.Begin("###Tracker", val2))
			{
				if (_compact)
				{
					ImGui.PushStyleVar((ImGuiStyleVar)0, 0f);
				}
				DrawHeaderBar();
				if (_compact)
				{
					ImGui.PopStyleVar();
				}
				DrawQuestList();
				bool flag = ImGui.IsWindowHovered((ImGuiHoveredFlags)3);
				bool flag2 = ImGui.IsWindowFocused((ImGuiFocusedFlags)3) && ImGui.IsMouseDown((ImGuiMouseButton)0);
				_compact = !flag && !flag2;
				if (_compact && ImGui.IsWindowFocused((ImGuiFocusedFlags)3))
				{
					ImGui.SetWindowFocus((string)null);
				}
			}
			Theme.ClampWindowPosition();
			ImGui.End();
			if (num > 0)
			{
				ImGui.PopStyleColor(num);
			}
			if (num2 > 0)
			{
				ImGui.PopStyleVar(num2);
			}
			Theme.PopWindowStyle();
		}

		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"))
			{
				_tracker.SortMode = mode;
				_lastSortMode = mode;
				RebuildSortedList();
			}
			if (flag)
			{
				ImGui.PopStyleColor();
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				ImGui.TextUnformatted(tooltip);
				ImGui.EndTooltip();
			}
		}

		private void DrawQuestList()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			ImGui.BeginChild("##TrackerScroll", Vector2.Zero, false);
			Vector2 cursorScreenPos = ImGui.GetCursorScreenPos();
			for (int i = 0; i < _sorted.Count; i++)
			{
				string dbName = _sorted[i];
				QuestEntry byDBName = _data.GetByDBName(dbName);
				if (byDBName != null)
				{
					DrawQuestEntry(byDBName, dbName, i);
				}
			}
			Vector2 cursorScreenPos2 = ImGui.GetCursorScreenPos();
			Vector2 windowPos = ImGui.GetWindowPos();
			float windowWidth = ImGui.GetWindowWidth();
			float windowHeight = ImGui.GetWindowHeight();
			ImGuiStylePtr style = ImGui.GetStyle();
			float y = ((ImGuiStylePtr)(ref style)).ItemSpacing.Y;
			float num = windowPos.Y + windowHeight;
			float y2 = ((cursorScreenPos2.Y <= num) ? (cursorScreenPos2.Y - y + 6f) : (num + 6f));
			_contentMin = new Vector2(windowPos.X - 8f, windowPos.Y - 10f);
			_contentMax = new Vector2(windowPos.X + windowWidth + 6f, y2);
			ImGui.EndChild();
		}

		private void DrawQuestEntry(QuestEntry quest, string dbName, int index)
		{
			EntryAnimation orDefaultAnim = GetOrDefaultAnim(dbName);
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float value;
			bool flag = _fadingOut.TryGetValue(dbName, out value);
			if (!flag && !_tracker.IsTracked(dbName))
			{
				return;
			}
			float num = 1f;
			if (flag)
			{
				float num2 = realtimeSinceStartup - value;
				num = Mathf.Clamp01(1f - num2 / 0.3f);
				if (num <= 0f)
				{
					return;
				}
			}
			else if (orDefaultAnim.AddedAt > 0f)
			{
				float num3 = realtimeSinceStartup - orDefaultAnim.AddedAt;
				if (num3 < 0.3f)
				{
					num = num3 / 0.3f;
				}
			}
			ImGui.PushID(index);
			if (num < 1f)
			{
				ImGui.PushStyleVar((ImGuiStyleVar)0, num);
			}
			bool flag2 = false;
			if (orDefaultAnim.CompletedAt > 0f && realtimeSinceStartup - orDefaultAnim.CompletedAt < 1.5f)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.Success);
				flag2 = true;
			}
			else if (orDefaultAnim.StepAdvancedAt > 0f && realtimeSinceStartup - orDefaultAnim.StepAdvancedAt < 0.8f)
			{
				ImGui.PushStyleColor((ImGuiCol)0, Theme.QuestActive);
				flag2 = true;
			}
			if (_config.ShowArrow.Value || _config.ShowGroundPath.Value)
			{
				DrawNavButton(quest);
				ImGui.SameLine();
			}
			DrawQuestNameAndLevel(quest);
			DrawCurrentStep(quest);
			if (ImGui.BeginPopupContextItem("##ctx" + quest.DBName))
			{
				if (ImGui.Selectable("Untrack"))
				{
					_tracker.Untrack(quest.DBName);
				}
				if (ImGui.Selectable("Open in Guide"))
				{
					_state.SelectQuest(quest.DBName);
					_guide.Show();
				}
				ImGui.EndPopup();
			}
			DrawPrerequisites(quest);
			ImGui.Spacing();
			if (flag2)
			{
				ImGui.PopStyleColor();
			}
			if (num < 1f)
			{
				ImGui.PopStyleVar();
			}
			ImGui.PopID();
		}

		private void DrawNavButton(QuestEntry quest)
		{
			(QuestStep? rawStep, QuestStep? displayStep, QuestEntry displayQuest) currentStep = GetCurrentStep(quest);
			QuestStep item = currentStep.rawStep;
			QuestStep item2 = currentStep.displayStep;
			QuestEntry item3 = currentStep.displayQuest;
			bool flag = item2?.TargetKey != null;
			bool flag2 = item != null && _nav.IsNavigating(quest.DBName, item.Order);
			if (!flag)
			{
				ImGui.PushStyleVar((ImGuiStyleVar)0, 0.3f);
				ImGui.SmallButton("[NAV]");
				ImGui.PopStyleVar();
				if (ImGui.IsItemHovered((ImGuiHoveredFlags)512))
				{
					ImGui.BeginTooltip();
					ImGui.TextUnformatted("No navigable target");
					ImGui.EndTooltip();
				}
				return;
			}
			if (flag2)
			{
				ImGui.PushStyleColor((ImGuiCol)21, Theme.QuestActive);
			}
			if (ImGui.SmallButton("[NAV]"))
			{
				if (flag2)
				{
					_nav.Clear();
				}
				else
				{
					_nav.NavigateTo(item, quest, _state.CurrentZone);
				}
			}
			if (flag2)
			{
				ImGui.PopStyleColor();
			}
			if (ImGui.IsItemHovered())
			{
				ImGui.BeginTooltip();
				ImGui.TextUnformatted(flag2 ? "Stop navigating" : "Navigate to current step");
				ImGui.EndTooltip();
			}
		}

		private void DrawQuestNameAndLevel(QuestEntry quest)
		{
			int? num = quest.LevelEstimate?.Recommended;
			string text;
			if (num.HasValue)
			{
				int valueOrDefault = num.GetValueOrDefault();
				text = $"{valueOrDefault,2}  {quest.DisplayName}";
			}
			else
			{
				text = "    " + quest.DisplayName;
			}
			string text2 = text;
			if (_distances.TryGetValue(quest.DBName, out var value))
			{
				if (value.HasDistance)
				{
					text2 += $" ({value.Meters:0}m)";
				}
				else if (value.HasLabel)
				{
					text2 = text2 + " (" + value.Label + ")";
				}
			}
			ImGui.PushStyleColor((ImGuiCol)0, Theme.GetQuestColor(_state, quest.DBName));
			if (ImGui.Selectable(text2 + "##name" + quest.DBName))
			{
				_state.SelectQuest(quest.DBName);
				_guide.Show();
			}
			ImGui.PopStyleColor();
		}

		private void DrawCurrentStep(QuestEntry quest)
		{
			(QuestStep? rawStep, QuestStep? displayStep, QuestEntry displayQuest) currentStep = GetCurrentStep(quest);
			QuestStep item = currentStep.displayStep;
			QuestEntry item2 = currentStep.displayQuest;
			ImGui.Indent(16f);
			ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
			if (item == null)
			{
				ImGui.TextWrapped(quest.HasSteps ? "Completed" : "No guide data available.");
				ImGui.PopStyleColor();
				ImGui.Unindent(16f);
				return;
			}
			string text = FormatStepText(item2, item);
			if (_distances.TryGetValue(quest.DBName, out var value) && !value.InCurrentZone && item.Action != "travel")
			{
				string stepZoneName = TrackerSorter.GetStepZoneName(quest, _state, _data);
				if (stepZoneName != null)
				{
					text = "Travel to " + stepZoneName + ".";
				}
			}
			ImGui.TextWrapped(text);
			ImGui.PopStyleColor();
			ImGui.Unindent(16f);
		}

		private string FormatStepText(QuestEntry quest, QuestStep step)
		{
			if (step.Quantity.HasValue && step.TargetKey != null)
			{
				int num = _state.CountItem(step.TargetKey);
				int value = step.Quantity.Value;
				return $"{step.Description} ({num}/{value})";
			}
			return step.Description;
		}

		private void DrawPrerequisites(QuestEntry quest)
		{
			if (quest.Prerequisites == null || quest.Prerequisites.Count == 0)
			{
				return;
			}
			foreach (Prerequisite prerequisite in quest.Prerequisites)
			{
				if (prerequisite.Item != null || _state.IsCompleted(prerequisite.QuestKey))
				{
					continue;
				}
				ImGui.Indent(16f);
				ImGui.PushStyleColor((ImGuiCol)0, Theme.TextSecondary);
				ImGui.PushStyleVar((ImGuiStyleVar)0, 0.6f);
				if (ImGui.Selectable("Requires: " + prerequisite.QuestName + "##prereq" + prerequisite.QuestKey))
				{
					_state.SelectQuest(prerequisite.QuestKey);
					_guide.Show();
				}
				ImGui.PopStyleVar();
				ImGui.PopStyleColor();
				ImGui.Unindent(16f);
				break;
			}
		}

		private void PruneAnimations()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			List<string> list = new List<string>();
			string key;
			float value;
			foreach (KeyValuePair<string, float> completionTimer in _completionTimers)
			{
				completionTimer.Deconstruct(out key, out value);
				string item = key;
				float num = value;
				if (realtimeSinceStartup - num > 2f)
				{
					list.Add(item);
				}
			}
			foreach (string item3 in list)
			{
				_completionTimers.Remove(item3);
				_tracker.Untrack(item3);
			}
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, float> item4 in _fadingOut)
			{
				item4.Deconstruct(out key, out value);
				string item2 = key;
				float num2 = value;
				if (realtimeSinceStartup - num2 > 0.3f)
				{
					list2.Add(item2);
				}
			}
			foreach (string item5 in list2)
			{
				_fadingOut.Remove(item5);
				_animations.Remove(item5);
				_cachedStepIndex.Remove(item5);
			}
		}

		private void RebuildSortedListIfNeeded()
		{
			bool isDirty = _tracker.IsDirty;
			bool flag = _state.Version != _lastStateVersion;
			bool flag2 = _tracker.SortMode != _lastSortMode;
			bool flag3 = Time.realtimeSinceStartup - _lastProximitySort > 2f;
			if (isDirty || flag || flag2 || flag3)
			{
				if (flag)
				{
					_lastStateVersion = _state.Version;
				}
				RebuildSortedList();
			}
		}

		private void RebuildSortedList()
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			_sorted.Clear();
			_sorted.AddRange(_tracker.TrackedQuests);
			foreach (string key in _fadingOut.Keys)
			{
				if (!_sorted.Contains(key))
				{
					_sorted.Add(key);
				}
			}
			_lastSortMode = _tracker.SortMode;
			_lastProximitySort = Time.realtimeSinceStartup;
			if ((Object)(object)GameData.PlayerControl != (Object)null)
			{
				Vector3 position = ((Component)GameData.PlayerControl).transform.position;
				TrackerSorter.ComputeDistances(_sorted, _data, _state, _nav, position, _distances);
			}
			else
			{
				_distances.Clear();
			}
			TrackerSorter.Sort(_sorted, _tracker.SortMode, _data, (_distances.Count > 0) ? _distances : null);
		}

		private void DetectStepAdvances()
		{
			foreach (string trackedQuest in _tracker.TrackedQuests)
			{
				QuestEntry byDBName = _data.GetByDBName(trackedQuest);
				if (byDBName?.Steps != null)
				{
					int currentStepIndex = StepProgress.GetCurrentStepIndex(byDBName, _state, _data);
					if (_cachedStepIndex.TryGetValue(trackedQuest, out var value) && currentStepIndex > value)
					{
						_tracker.OnStepAdvanced(trackedQuest);
					}
					_cachedStepIndex[trackedQuest] = currentStepIndex;
				}
			}
		}

		private (QuestStep? rawStep, QuestStep? displayStep, QuestEntry displayQuest) GetCurrentStep(QuestEntry quest)
		{
			if (quest.Steps == null || quest.Steps.Count == 0)
			{
				return (null, null, quest);
			}
			int currentStepIndex = StepProgress.GetCurrentStepIndex(quest, _state, _data);
			QuestStep questStep = ((currentStepIndex < quest.Steps.Count) ? quest.Steps[currentStepIndex] : null);
			if (questStep == null)
			{
				return (null, null, quest);
			}
			var (item, questEntry) = StepProgress.ResolveActiveStep(questStep, quest, _state, _data);
			return (questStep, item, questEntry ?? quest);
		}

		private EntryAnimation GetOrDefaultAnim(string dbName)
		{
			EntryAnimation value;
			return _animations.TryGetValue(dbName, out value) ? value : default(EntryAnimation);
		}
	}
}
namespace AdventureGuide.State
{
	internal static class GameUIVisibility
	{
		private static Canvas? _hudCanvas;

		private static bool _searched;

		public static bool IsVisible
		{
			get
			{
				if ((Object)(object)_hudCanvas == (Object)null)
				{
					if (_searched)
					{
						return true;
					}
					_searched = true;
					TypeText val = Object.FindObjectOfType<TypeText>();
					if ((Object)(object)val != (Object)null)
					{
						_hudCanvas = ((Component)val).GetComponent<Canvas>();
					}
				}
				return (Object)(object)_hudCanvas == (Object)null || ((Behaviour)_hudCanvas).enabled;
			}
		}
	}
	internal static class GameWindowOverlap
	{
		private struct WindowRect
		{
			public float Left;

			public float Top;

			public float Right;

			public float Bottom;

			public bool Overlaps(float otherLeft, float otherTop, float otherRight, float otherBottom)
			{
				return Left < otherRight && Right > otherLeft && Top < otherBottom && Bottom > otherTop;
			}
		}

		private static List<GameObject>? _uiWindows;

		private static bool _searched;

		private static WindowRect[]? _rects;

		private static bool[]? _wasActive;

		private static readonly HashSet<int> _suppressors = new HashSet<int>();

		public static bool ShouldSuppressTracker(float trackerLeft, float trackerTop, float trackerRight, float trackerBottom)
		{
			List<GameObject> uIWindows = GetUIWindows();
			if (uIWindows == null || uIWindows.Count == 0)
			{
				return false;
			}
			EnsureCaches(uIWindows.Count);
			for (int i = 0; i < uIWindows.Count; i++)
			{
				GameObject val = uIWindows[i];
				bool flag = (Object)(object)val != (Object)null && val.activeSelf;
				if (flag && !_wasActive[i])
				{
					EnsureRect(i, val);
					if (_rects[i].Overlaps(trackerLeft, trackerTop, trackerRight, trackerBottom))
					{
						_suppressors.Add(i);
					}
				}
				else if (!flag && _wasActive[i])
				{
					_suppressors.Remove(i);
				}
				_wasActive[i] = flag;
			}
			return _suppressors.Count > 0;
		}

		public static void InvalidateRects()
		{
			_rects = null;
		}

		public static void Reset()
		{
			_uiWindows = null;
			_searched = false;
			_rects = null;
			_wasActive = null;
			_suppressors.Clear();
		}

		private static List<GameObject>? GetUIWindows()
		{
			if (_uiWindows != null)
			{
				return _uiWindows;
			}
			if (_searched)
			{
				return null;
			}
			_searched = true;
			CameraController val = Object.FindObjectOfType<CameraController>();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			HashSet<GameObject> hashSet = new HashSet<GameObject>();
			List<GameObject> list = new List<GameObject>();
			foreach (GameObject uIWindow in val.UIWindows)
			{
				if ((Object)(object)uIWindow != (Object)null && hashSet.Add(uIWindow))
				{
					list.Add(uIWindow);
				}
			}
			if ((Object)(object)GameData.Misc != (Object)null)
			{
				foreach (GameObject uIWindow2 in GameData.Misc.UIWindows)
				{
					if ((Object)(object)uIWindow2 != (Object)null && hashSet.Add(uIWindow2))
					{
						list.Add(uIWindow2);
					}
				}
			}
			_uiWindows = list;
			return _uiWindows;
		}

		private static void EnsureCaches(int count)
		{
			if (_wasActive == null || _wasActive.Length != count)
			{
				_wasActive = new bool[count];
				for (int i = 0; i < count; i++)
				{
					GameObject val = _uiWindows[i];
					_wasActive[i] = (Object)(object)val != (Object)null && val.activeSelf;
				}
				_suppressors.Clear();
			}
			if (_rects == null || _rects.Length != count)
			{
				_rects = new WindowRect[count];
			}
		}

		private static void EnsureRect(int i, GameObject go)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (_rects[i].Right > 0f)
			{
				return;
			}
			RectTransform component = go.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				_rects[i] = default(WindowRect);
				return;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			component.GetWorldCorners(array);
			floa