using System;
using System.Collections.Generic;
using System.Linq;
using Dalamud.Game.ClientState.Objects.SubKinds;
using Dalamud.Plugin.Services;
using FFXIVClientStructs.FFXIV.Client.Game;
using Lumina.Excel;
using Lumina.Excel.Sheets;
using QuestionableCompanion.Data;

namespace QuestionableCompanion.Services;

public class MSQProgressionService
{
	private readonly IDataManager dataManager;

	private readonly IPluginLog log;

	private readonly QuestDetectionService questDetectionService;

	private readonly IClientState clientState;

	private readonly IFramework framework;

	private List<Quest>? mainScenarioQuests;

	private Dictionary<uint, string> questNameCache = new Dictionary<uint, string>();

	private Dictionary<string, List<Quest>> questsByExpansion = new Dictionary<string, List<Quest>>();

	private static readonly uint[] MSQ_JOURNAL_GENRE_IDS = new uint[14]
	{
		1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u,
		11u, 12u, 13u, 14u
	};

	private const uint LAST_ARR_QUEST_ID = 65964u;

	private static readonly Dictionary<uint, MSQExpansionData.Expansion> JournalGenreToExpansion = new Dictionary<uint, MSQExpansionData.Expansion>
	{
		{
			1u,
			MSQExpansionData.Expansion.ARealmReborn
		},
		{
			2u,
			MSQExpansionData.Expansion.ARealmReborn
		},
		{
			3u,
			MSQExpansionData.Expansion.Heavensward
		},
		{
			4u,
			MSQExpansionData.Expansion.Heavensward
		},
		{
			5u,
			MSQExpansionData.Expansion.Heavensward
		},
		{
			6u,
			MSQExpansionData.Expansion.Stormblood
		},
		{
			7u,
			MSQExpansionData.Expansion.Stormblood
		},
		{
			8u,
			MSQExpansionData.Expansion.Shadowbringers
		},
		{
			9u,
			MSQExpansionData.Expansion.Shadowbringers
		},
		{
			10u,
			MSQExpansionData.Expansion.Shadowbringers
		},
		{
			11u,
			MSQExpansionData.Expansion.Endwalker
		},
		{
			12u,
			MSQExpansionData.Expansion.Endwalker
		},
		{
			13u,
			MSQExpansionData.Expansion.Dawntrail
		},
		{
			14u,
			MSQExpansionData.Expansion.Dawntrail
		}
	};

	public MSQProgressionService(IDataManager dataManager, IPluginLog log, QuestDetectionService questDetectionService, IClientState clientState, IFramework framework)
	{
		this.dataManager = dataManager;
		this.log = log;
		this.questDetectionService = questDetectionService;
		this.clientState = clientState;
		this.framework = framework;
		InitializeMSQData();
		framework.RunOnTick(delegate
		{
			DebugCurrentCharacterQuest();
		}, default(TimeSpan), 60);
	}

	private void InitializeMSQData()
	{
		try
		{
			log.Information("[MSQProgression] === INITIALIZING MSQ DATA ===");
			ExcelSheet<Quest> questSheet = dataManager.GetExcelSheet<Quest>();
			if (questSheet == null)
			{
				log.Error("[MSQProgression] Failed to load Quest sheet from Lumina!");
				return;
			}
			int totalQuests = questSheet.Count();
			log.Information($"[MSQProgression] ✓ Lumina Quest Sheet loaded: {totalQuests} total quests");
			int manualCount = 0;
			foreach (Quest item in questSheet)
			{
				_ = item;
				manualCount++;
			}
			log.Information($"[MSQProgression] Manual iteration count: {manualCount} quests");
			List<Quest> highIdQuests = questSheet.Where((Quest q) => q.RowId > 66000).ToList();
			log.Information($"[MSQProgression] Quests with RowId > 66000: {highIdQuests.Count}");
			if (highIdQuests.Count > 0)
			{
				Quest firstHighId = highIdQuests.First();
				log.Information($"[MSQProgression] First High ID Quest: {firstHighId.RowId}");
				log.Information($"[MSQProgression]   - Name: {firstHighId.Name}");
				log.Information($"[MSQProgression]   - Expansion.RowId: {firstHighId.Expansion.RowId}");
				log.Information($"[MSQProgression]   - JournalGenre.RowId: {firstHighId.JournalGenre.RowId}");
			}
			log.Information("[MSQProgression] Analyzing JournalGenre distribution...");
			foreach (IGrouping<uint, Quest> group in (from q in questSheet
				where q.RowId != 0
				group q by q.JournalGenre.RowId into g
				orderby g.Key
				select g).Take(10))
			{
				log.Information($"[MSQProgression]   Genre {group.Key}: {group.Count()} quests");
			}
			log.Information("[MSQProgression] Filtering MSQ quests by JournalGenre categories (1-14)...");
			mainScenarioQuests = (from q in questSheet
				where ((ReadOnlySpan<uint>)MSQ_JOURNAL_GENRE_IDS).Contains(q.JournalGenre.RowId)
				orderby q.RowId
				select q).ToList();
			log.Information($"[MSQProgression] ✓ Found {mainScenarioQuests.Count} total MSQ quests across all expansions!");
			if (mainScenarioQuests.Count == 0)
			{
				log.Error("[MSQProgression] No MSQ quests found! JournalGenre filter may be incorrect.");
				return;
			}
			log.Information("[MSQProgression] === DETAILED MSQ QUEST ANALYSIS (First 20) ===");
			foreach (Quest quest in mainScenarioQuests.Take(20))
			{
				log.Information($"[MSQProgression] Quest {quest.RowId}:");
				log.Information($"[MSQProgression]   - Name: {quest.Name}");
				log.Information($"[MSQProgression]   - Expansion.RowId: {quest.Expansion.RowId}");
				try
				{
					string expansionName = quest.Expansion.Value.Name.ToString();
					log.Information("[MSQProgression]   - Expansion.Name: " + expansionName);
				}
				catch (Exception ex)
				{
					log.Information("[MSQProgression]   - Expansion.Name: ERROR - " + ex.Message);
				}
				log.Information($"[MSQProgression]   - JournalGenre.RowId: {quest.JournalGenre.RowId}");
			}
			log.Information("[MSQProgression] === MSQ QUESTS BY JOURNALGENRE (EXPANSION) ===");
			foreach (IGrouping<uint, Quest> group2 in from q in mainScenarioQuests
				group q by q.JournalGenre.RowId into g
				orderby g.Key
				select g)
			{
				uint genreId = group2.Key;
				MSQExpansionData.Expansion expansion = JournalGenreToExpansion.GetValueOrDefault(genreId, MSQExpansionData.Expansion.ARealmReborn);
				string genreName = group2.First().JournalGenre.Value.Name.ToString();
				string sampleQuests = string.Join(", ", from q in group2.Take(3)
					select q.RowId);
				log.Information($"[MSQProgression] JournalGenre {genreId} ({expansion}):");
				log.Information("[MSQProgression]   - Name: " + genreName);
				log.Information($"[MSQProgression]   - Count: {group2.Count()} quests");
				log.Information("[MSQProgression]   - Samples: " + sampleQuests + "...");
			}
			log.Information("[MSQProgression] === MSQ QUESTS BY EXPANSION (GROUPED) ===");
			foreach (IGrouping<MSQExpansionData.Expansion, Quest> group3 in from q in mainScenarioQuests
				group q by JournalGenreToExpansion.GetValueOrDefault(q.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn) into g
				orderby g.Key
				select g)
			{
				log.Information($"[MSQProgression] {group3.Key}: {group3.Count()} quests total");
			}
			MSQExpansionData.ClearQuests();
			log.Information("[MSQProgression] Building expansion quest mappings...");
			foreach (Quest quest2 in mainScenarioQuests)
			{
				string name = quest2.Name.ToString();
				if (!string.IsNullOrEmpty(name))
				{
					questNameCache[quest2.RowId] = name;
				}
				MSQExpansionData.Expansion expansion2 = JournalGenreToExpansion.GetValueOrDefault(quest2.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn);
				if (quest2.JournalGenre.RowId != 2 || quest2.RowId <= 65964)
				{
					MSQExpansionData.RegisterQuest(quest2.RowId, expansion2);
					string shortName = MSQExpansionData.GetExpansionShortName(expansion2);
					if (!questsByExpansion.ContainsKey(shortName))
					{
						questsByExpansion[shortName] = new List<Quest>();
					}
					questsByExpansion[shortName].Add(quest2);
				}
			}
			log.Information("[MSQProgression] === EXPANSION BREAKDOWN ===");
			foreach (MSQExpansionData.Expansion exp in MSQExpansionData.GetAllExpansions())
			{
				string shortName2 = MSQExpansionData.GetExpansionShortName(exp);
				List<Quest> quests = questsByExpansion.GetValueOrDefault(shortName2);
				int count = quests?.Count ?? 0;
				if (count > 0 && quests != null)
				{
					string sampleIds = string.Join(", ", from q in quests.Take(5)
						select q.RowId);
					log.Information($"[MSQProgression] ✓ {MSQExpansionData.GetExpansionName(exp)} ({shortName2}): {count} quests (IDs: {sampleIds}...)");
				}
				else
				{
					log.Warning($"[MSQProgression] ⚠ {MSQExpansionData.GetExpansionName(exp)} ({shortName2}): {count} quests (EMPTY!)");
				}
			}
			log.Information("[MSQProgression] === MSQ DATA INITIALIZATION COMPLETE ===");
		}
		catch (Exception ex2)
		{
			log.Error("[MSQProgression] EXCEPTION during MSQ data initialization: " + ex2.Message);
			log.Error("[MSQProgression] Stack trace: " + ex2.StackTrace);
		}
	}

	public (uint questId, string questName) GetLastCompletedMSQ(string characterName)
	{
		if (mainScenarioQuests == null || mainScenarioQuests.Count == 0)
		{
			return (questId: 0u, questName: "—");
		}
		try
		{
			List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
			Quest lastMSQ = (from q in mainScenarioQuests
				where completedQuests.Contains(q.RowId)
				orderby q.RowId descending
				select q).FirstOrDefault();
			if (lastMSQ.RowId != 0)
			{
				string questName = questNameCache.GetValueOrDefault(lastMSQ.RowId, "Unknown Quest");
				return (questId: lastMSQ.RowId, questName: questName);
			}
		}
		catch (Exception ex)
		{
			log.Error("[MSQProgression] Failed to get last completed MSQ: " + ex.Message);
		}
		return (questId: 0u, questName: "—");
	}

	public float GetMSQCompletionPercentage()
	{
		if (mainScenarioQuests == null || mainScenarioQuests.Count == 0)
		{
			return 0f;
		}
		try
		{
			List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
			return (float)mainScenarioQuests.Count((Quest q) => completedQuests.Contains(q.RowId)) / (float)mainScenarioQuests.Count * 100f;
		}
		catch (Exception ex)
		{
			log.Error("[MSQProgression] Failed to calculate MSQ completion: " + ex.Message);
			return 0f;
		}
	}

	public int GetTotalMSQCount()
	{
		return mainScenarioQuests?.Count ?? 0;
	}

	public int GetCompletedMSQCount()
	{
		if (mainScenarioQuests == null || mainScenarioQuests.Count == 0)
		{
			return 0;
		}
		try
		{
			List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
			return mainScenarioQuests.Count((Quest q) => completedQuests.Contains(q.RowId));
		}
		catch (Exception ex)
		{
			log.Error("[MSQProgression] Failed to get completed MSQ count: " + ex.Message);
			return 0;
		}
	}

	public string GetQuestName(uint questId)
	{
		return questNameCache.GetValueOrDefault(questId, "Unknown Quest");
	}

	public bool IsMSQ(uint questId)
	{
		return mainScenarioQuests?.Any((Quest q) => q.RowId == questId) ?? false;
	}

	public ExpansionInfo? GetExpansionForQuest(uint questId)
	{
		MSQExpansionData.Expansion expansion = MSQExpansionData.GetExpansionForQuest(questId);
		return new ExpansionInfo
		{
			Name = MSQExpansionData.GetExpansionName(expansion),
			ShortName = MSQExpansionData.GetExpansionShortName(expansion),
			MinQuestId = 0u,
			MaxQuestId = 0u,
			ExpectedQuestCount = MSQExpansionData.GetExpectedQuestCount(expansion)
		};
	}

	public List<ExpansionInfo> GetExpansions()
	{
		return (from exp in MSQExpansionData.GetAllExpansions()
			select new ExpansionInfo
			{
				Name = MSQExpansionData.GetExpansionName(exp),
				ShortName = MSQExpansionData.GetExpansionShortName(exp),
				MinQuestId = 0u,
				MaxQuestId = 0u,
				ExpectedQuestCount = MSQExpansionData.GetExpectedQuestCount(exp)
			}).ToList();
	}

	public (int completed, int total) GetExpansionProgress(string expansionShortName)
	{
		List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
		List<Quest>? obj = questsByExpansion.GetValueOrDefault(expansionShortName) ?? new List<Quest>();
		int completed = obj.Count((Quest q) => completedQuests.Contains(q.RowId));
		int total = obj.Count;
		return (completed: completed, total: total);
	}

	public ExpansionInfo? GetCurrentExpansion()
	{
		try
		{
			log.Information("[MSQProgression] ========================================");
			log.Information("[MSQProgression] === DETECTING CURRENT EXPANSION ===");
			log.Information("[MSQProgression] ========================================");
			List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
			log.Information($"[MSQProgression] Total completed quests: {completedQuests.Count}");
			log.Information("[MSQProgression] METHOD 1: Using AgentScenarioTree (Game Data)");
			log.Information("[MSQProgression] ------------------------------------------------");
			(MSQExpansionData.Expansion expansion, string debugInfo) currentExpansionFromGameWithDebug = MSQExpansionData.GetCurrentExpansionFromGameWithDebug();
			MSQExpansionData.Expansion gameExpansion = currentExpansionFromGameWithDebug.expansion;
			string[] array = currentExpansionFromGameWithDebug.debugInfo.Split('\n');
			foreach (string line in array)
			{
				if (!string.IsNullOrWhiteSpace(line))
				{
					log.Information("[MSQProgression] " + line);
				}
			}
			log.Information("[MSQProgression] Game Data Result: " + MSQExpansionData.GetExpansionName(gameExpansion));
			log.Information("[MSQProgression] METHOD 2: Using Completed Quests Analysis");
			log.Information("[MSQProgression] ------------------------------------------------");
			MSQExpansionData.Expansion analysisExpansion = MSQExpansionData.GetCurrentExpansion(completedQuests);
			log.Information("[MSQProgression] Analysis Result: " + MSQExpansionData.GetExpansionName(analysisExpansion));
			array = MSQExpansionData.GetExpansionDetectionDebugInfo(completedQuests).Split('\n');
			foreach (string line2 in array)
			{
				if (!string.IsNullOrWhiteSpace(line2))
				{
					log.Debug("[MSQProgression] " + line2);
				}
			}
			log.Information("[MSQProgression] COMPARISON:");
			log.Information("[MSQProgression]   Game Data:    " + MSQExpansionData.GetExpansionName(gameExpansion));
			log.Information("[MSQProgression]   Analysis:     " + MSQExpansionData.GetExpansionName(analysisExpansion));
			MSQExpansionData.Expansion finalExpansion = gameExpansion;
			if (gameExpansion == MSQExpansionData.Expansion.ARealmReborn && analysisExpansion != MSQExpansionData.Expansion.ARealmReborn)
			{
				log.Warning("[MSQProgression] Game data returned ARR but analysis found higher expansion!");
				log.Warning("[MSQProgression] Using analysis result: " + MSQExpansionData.GetExpansionName(analysisExpansion));
				finalExpansion = analysisExpansion;
			}
			log.Information("[MSQProgression] ========================================");
			log.Information("[MSQProgression] >>> FINAL EXPANSION: " + MSQExpansionData.GetExpansionName(finalExpansion) + " <<<");
			log.Information("[MSQProgression] ========================================");
			return new ExpansionInfo
			{
				Name = MSQExpansionData.GetExpansionName(finalExpansion),
				ShortName = MSQExpansionData.GetExpansionShortName(finalExpansion),
				MinQuestId = 0u,
				MaxQuestId = 0u,
				ExpectedQuestCount = MSQExpansionData.GetExpectedQuestCount(finalExpansion)
			};
		}
		catch (Exception ex)
		{
			log.Error("[MSQProgression] Error detecting expansion: " + ex.Message);
			log.Error("[MSQProgression] Stack: " + ex.StackTrace);
			return GetExpansions().FirstOrDefault();
		}
	}

	public Dictionary<string, (int completed, int total)> GetExpansionProgressForCharacter(List<uint> completedQuestIds)
	{
		Dictionary<string, (int, int)> result = new Dictionary<string, (int, int)>();
		foreach (ExpansionInfo exp in GetExpansions())
		{
			List<Quest> expansionQuests = questsByExpansion.GetValueOrDefault(exp.ShortName) ?? new List<Quest>();
			int completed = expansionQuests.Count((Quest q) => completedQuestIds.Contains(q.RowId));
			result[exp.ShortName] = (completed, expansionQuests.Count);
		}
		return result;
	}

	public List<Quest> GetAllMSQQuests()
	{
		return mainScenarioQuests ?? new List<Quest>();
	}

	public Dictionary<string, ExpansionProgressInfo> GetExpansionProgress()
	{
		Dictionary<string, ExpansionProgressInfo> result = new Dictionary<string, ExpansionProgressInfo>();
		List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
		foreach (MSQExpansionData.Expansion expansion in MSQExpansionData.GetAllExpansions())
		{
			ExpansionProgress progress = MSQExpansionData.GetExpansionProgress(completedQuests, expansion);
			result[progress.ExpansionName] = new ExpansionProgressInfo
			{
				ExpansionName = progress.ExpansionName,
				ShortName = progress.ExpansionShortName,
				TotalQuests = progress.ExpectedCount,
				CompletedQuests = progress.CompletedCount,
				Percentage = progress.Percentage
			};
		}
		return result;
	}

	public Dictionary<string, ExpansionProgressInfo> GetExpansionProgressForCharacter(List<string> completedQuestIds)
	{
		Dictionary<string, ExpansionProgressInfo> result = new Dictionary<string, ExpansionProgressInfo>();
		uint result2;
		List<uint> completedQuestIdsUint = (from id in completedQuestIds
			select uint.TryParse(id, out result2) ? result2 : 0u into id
			where id != 0
			select id).ToList();
		foreach (MSQExpansionData.Expansion expansion in MSQExpansionData.GetAllExpansions())
		{
			ExpansionProgress progress = MSQExpansionData.GetExpansionProgress(completedQuestIdsUint, expansion);
			result[progress.ExpansionName] = new ExpansionProgressInfo
			{
				ExpansionName = progress.ExpansionName,
				ShortName = progress.ExpansionShortName,
				TotalQuests = progress.ExpectedCount,
				CompletedQuests = progress.CompletedCount,
				Percentage = progress.Percentage
			};
		}
		return result;
	}

	public ExpansionInfo? GetCurrentExpansion(uint lastCompletedQuestId)
	{
		MSQExpansionData.Expansion expansion = MSQExpansionData.GetExpansionForQuest(lastCompletedQuestId);
		return new ExpansionInfo
		{
			Name = MSQExpansionData.GetExpansionName(expansion),
			ShortName = MSQExpansionData.GetExpansionShortName(expansion),
			MinQuestId = 0u,
			MaxQuestId = 0u,
			ExpectedQuestCount = MSQExpansionData.GetExpectedQuestCount(expansion)
		};
	}

	private MSQExpansionData.Expansion ConvertLuminaExpansionToOurs(uint luminaExpansionId)
	{
		return luminaExpansionId switch
		{
			0u => MSQExpansionData.Expansion.ARealmReborn, 
			1u => MSQExpansionData.Expansion.Heavensward, 
			2u => MSQExpansionData.Expansion.Stormblood, 
			3u => MSQExpansionData.Expansion.Shadowbringers, 
			4u => MSQExpansionData.Expansion.Endwalker, 
			5u => MSQExpansionData.Expansion.Dawntrail, 
			_ => MSQExpansionData.Expansion.ARealmReborn, 
		};
	}

	public void DebugCurrentCharacterQuest()
	{
		try
		{
			log.Information("[MSQProgression] === DEBUG CURRENT CHARACTER QUEST ===");
			IPlayerCharacter player = clientState.LocalPlayer;
			if (player == null)
			{
				log.Warning("[MSQProgression] LocalPlayer is null - not logged in yet?");
				framework.RunOnTick(delegate
				{
					DebugCurrentCharacterQuest();
				}, default(TimeSpan), 60);
				return;
			}
			string characterName = player.Name.TextValue;
			string worldName = player.HomeWorld.Value.Name.ToString();
			log.Information("[MSQProgression] Character: " + characterName + " @ " + worldName);
			ExcelSheet<Quest> questSheet = dataManager.GetExcelSheet<Quest>();
			if (questSheet == null)
			{
				log.Error("[MSQProgression] Failed to load Quest sheet!");
				return;
			}
			List<Quest> completedMSQQuests = new List<Quest>();
			log.Information("[MSQProgression] Checking MSQ quest completion...");
			foreach (Quest quest in questSheet)
			{
				if (((ReadOnlySpan<uint>)MSQ_JOURNAL_GENRE_IDS).Contains(quest.JournalGenre.RowId) && QuestManager.IsQuestComplete((ushort)quest.RowId))
				{
					completedMSQQuests.Add(quest);
				}
			}
			log.Information($"[MSQProgression] Character has {completedMSQQuests.Count} completed MSQ quests");
			if (completedMSQQuests.Count == 0)
			{
				log.Warning("[MSQProgression] No completed MSQ quests found!");
				return;
			}
			Quest latestMSQQuest = completedMSQQuests.OrderByDescending((Quest quest2) => quest2.RowId).First();
			log.Information($"[MSQProgression] Latest completed MSQ quest ID: {latestMSQQuest.RowId}");
			Quest questData = latestMSQQuest;
			log.Information("[MSQProgression] === LATEST MSQ QUEST DETAILS ===");
			log.Information($"[MSQProgression] Quest ID: {questData.RowId}");
			log.Information($"[MSQProgression] Quest Name: {questData.Name}");
			log.Information($"[MSQProgression] JournalGenre.RowId: {questData.JournalGenre.RowId}");
			try
			{
				string genreName = questData.JournalGenre.Value.Name.ToString();
				log.Information("[MSQProgression] JournalGenre.Name: " + genreName);
			}
			catch
			{
				log.Information("[MSQProgression] JournalGenre.Name: ERROR");
			}
			log.Information($"[MSQProgression] Expansion.RowId: {questData.Expansion.RowId}");
			try
			{
				string expansionName = questData.Expansion.Value.Name.ToString();
				log.Information("[MSQProgression] Expansion.Name: " + expansionName);
			}
			catch
			{
				log.Information("[MSQProgression] Expansion.Name: ERROR");
			}
			log.Information("[MSQProgression] === CHARACTER IS IN THIS EXPANSION ===");
			log.Information($"[MSQProgression] Character is at Quest {questData.RowId} which is in:");
			log.Information($"[MSQProgression]   - JournalGenre: {questData.JournalGenre.RowId}");
			log.Information($"[MSQProgression]   - Expansion: {questData.Expansion.RowId}");
			log.Information("[MSQProgression] === RECENT COMPLETED MSQ QUESTS (Last 10) ===");
			foreach (Quest q in completedMSQQuests.OrderByDescending((Quest quest2) => quest2.RowId).Take(10).ToList())
			{
				log.Information($"[MSQProgression] Quest {q.RowId}: {q.Name} (Genre: {q.JournalGenre.RowId}, Exp: {q.Expansion.RowId})");
			}
			log.Information("[MSQProgression] === COMPLETED MSQ QUESTS BY EXPANSION ===");
			foreach (IGrouping<MSQExpansionData.Expansion, Quest> group in from quest2 in completedMSQQuests
				group quest2 by JournalGenreToExpansion.GetValueOrDefault(quest2.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn) into g
				orderby g.Key
				select g)
			{
				log.Information($"[MSQProgression] {group.Key}: {group.Count()} quests completed");
			}
		}
		catch (Exception ex)
		{
			log.Error("[MSQProgression] ERROR in DebugCurrentCharacterQuest: " + ex.Message);
			log.Error("[MSQProgression] Stack trace: " + ex.StackTrace);
		}
	}
}