using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using Dalamud.Plugin;
using Dalamud.Plugin.Ipc;
using Dalamud.Plugin.Services;
using FFXIVClientStructs.FFXIV.Client.Game;
using Microsoft.Extensions.DependencyInjection;
using Questionable.Controller;
using Questionable.Controller.Conditions;
using Questionable.Controller.Steps;
using Questionable.Data;
using Questionable.Functions;
using Questionable.Model;
using Questionable.Model.Questing;
using Questionable.Windows.JournalComponents;
using Questionable.Windows.QuestComponents;

namespace Questionable.External;

internal sealed class QuestionableIpc : IDisposable
{
	public sealed class StepData
	{
		public required string QuestId { get; init; }

		public required byte Sequence { get; init; }

		public required int Step { get; init; }

		public required string InteractionType { get; init; }

		public required Vector3? Position { get; init; }

		public required ushort TerritoryId { get; init; }
	}

	public sealed class TaskData
	{
		public required string TaskName { get; init; }

		public required int RemainingTaskCount { get; init; }
	}

	public sealed class StopConditionData
	{
		public required bool Enabled { get; init; }

		public required int TargetValue { get; init; }
	}

	public sealed class MsqLevelLockData
	{
		public required bool IsLevelLocked { get; init; }

		public required int LevelsNeeded { get; init; }

		public required int RequiredLevel { get; init; }

		public required string? QuestName { get; init; }
	}

	private const string IpcGetAlliedSocietyRemainingAllowances = "Questionable.AlliedSociety.GetRemainingAllowances";

	private const string IpcGetAlliedSocietyTimeUntilReset = "Questionable.AlliedSociety.GetTimeUntilReset";

	private const string IpcGetAlliedSocietyAvailableQuestIds = "Questionable.AlliedSociety.GetAvailableQuestIds";

	private const string IpcGetAlliedSocietyAllAvailableQuestCounts = "Questionable.AlliedSociety.GetAllAvailableQuestCounts";

	private const string IpcGetAlliedSocietyIsMaxRank = "Questionable.AlliedSociety.IsMaxRank";

	private const string IpcGetAlliedSocietyCurrentRank = "Questionable.AlliedSociety.GetCurrentRank";

	private const string IpcGetAlliedSocietiesWithAvailableQuests = "Questionable.AlliedSociety.GetSocietiesWithAvailableQuests";

	private const string IpcAddAlliedSocietyOptimalQuests = "Questionable.AlliedSociety.AddOptimalQuests";

	private const string IpcGetAlliedSocietyOptimalQuests = "Questionable.AlliedSociety.GetOptimalQuests";

	private const string IpcGetBlacklistedQuests = "Questionable.GetBlacklistedQuests";

	private const string IpcAddBlacklistedQuest = "Questionable.AddBlacklistedQuest";

	private const string IpcRemoveBlacklistedQuest = "Questionable.RemoveBlacklistedQuest";

	private const string IpcClearBlacklistedQuests = "Questionable.ClearBlacklistedQuests";

	private const string IpcIsQuestBlacklisted = "Questionable.IsQuestBlacklisted";

	private readonly QuestController _questController;

	private readonly EventInfoComponent _eventInfoComponent;

	private readonly QuestRegistry _questRegistry;

	private readonly QuestFunctions _questFunctions;

	private readonly QuestData _questData;

	private readonly ManualPriorityComponent _manualPriorityComponent;

	private readonly Configuration _configuration;

	private readonly IDalamudPluginInterface _pluginInterface;

	private readonly IServiceProvider _serviceProvider;

	private readonly AutoDutyIpc _autoDutyIpc;

	private readonly IObjectTable _objectTable;

	private readonly List<Action> _unregisterActions = new List<Action>();

	private const string IpcGetDefaultDutyMode = "Questionable.GetDefaultDutyMode";

	private const string IpcSetDefaultDutyMode = "Questionable.SetDefaultDutyMode";

	private const string IpcGetDutyModeOverride = "Questionable.GetDutyModeOverride";

	private const string IpcSetDutyModeOverride = "Questionable.SetDutyModeOverride";

	private const string IpcClearDutyModeOverride = "Questionable.ClearDutyModeOverride";

	private const string IpcClearAllDutyModeOverrides = "Questionable.ClearAllDutyModeOverrides";

	private const string IpcIsLevelingModeEnabled = "Questionable.IsLevelingModeEnabled";

	private const string IpcSetLevelingModeEnabled = "Questionable.SetLevelingModeEnabled";

	private const string IpcGetMsqLevelLockInfo = "Questionable.GetMsqLevelLockInfo";

	private const string IpcStartLevelingMode = "Questionable.StartLevelingMode";

	private const string IpcStopLevelingMode = "Questionable.StopLevelingMode";

	private static readonly (int Major, int Minor) ApiVersion = (Major: 1, Minor: 0);

	private const string IpcApiVersion = "Questionable.ApiVersion";

	private const string IpcGetMsqPriorityMode = "Questionable.GetMsqPriorityMode";

	private const string IpcSetMsqPriorityMode = "Questionable.SetMsqPriorityMode";

	private const string IpcImportQuestPriority = "Questionable.ImportQuestPriority";

	private const string IpcClearQuestPriority = "Questionable.ClearQuestPriority";

	private const string IpcAddQuestPriority = "Questionable.AddQuestPriority";

	private const string IpcInsertQuestPriority = "Questionable.InsertQuestPriority";

	private const string IpcExportQuestPriority = "Questionable.ExportQuestPriority";

	private const string IpcGetPriorityQuests = "Questionable.GetPriorityQuests";

	private const string IpcRemovePriorityQuest = "Questionable.RemovePriorityQuest";

	private const string IpcReorderPriorityQuest = "Questionable.ReorderPriorityQuest";

	private const string IpcGetAvailablePresets = "Questionable.GetAvailablePresets";

	private const string IpcGetPresetQuests = "Questionable.GetPresetQuests";

	private const string IpcAddPresetToPriority = "Questionable.AddPresetToPriority";

	private const string IpcIsPresetAvailable = "Questionable.IsPresetAvailable";

	private const string IpcIsQuestInPriority = "Questionable.IsQuestInPriority";

	private const string IpcGetQuestPriorityIndex = "Questionable.GetQuestPriorityIndex";

	private const string IpcHasAvailablePriorityQuests = "Questionable.HasAvailablePriorityQuests";

	private const string IpcIsRunning = "Questionable.IsRunning";

	private const string IpcGetCurrentQuestId = "Questionable.GetCurrentQuestId";

	private const string IpcGetCurrentStepData = "Questionable.GetCurrentStepData";

	private const string IpcGetCurrentTask = "Questionable.GetCurrentTask";

	private const string IpcGetCurrentlyActiveEventQuests = "Questionable.GetCurrentlyActiveEventQuests";

	private const string IpcStartQuest = "Questionable.StartQuest";

	private const string IpcStartSingleQuest = "Questionable.StartSingleQuest";

	private const string IpcIsQuestLocked = "Questionable.IsQuestLocked";

	private const string IpcIsQuestComplete = "Questionable.IsQuestComplete";

	private const string IpcIsReadyToAcceptQuest = "Questionable.IsReadyToAcceptQuest";

	private const string IpcIsQuestAccepted = "Questionable.IsQuestAccepted";

	private const string IpcIsQuestUnobtainable = "Questionable.IsQuestUnobtainable";

	private const string IpcGetStopConditionsEnabled = "Questionable.GetStopConditionsEnabled";

	private const string IpcSetStopConditionsEnabled = "Questionable.SetStopConditionsEnabled";

	private const string IpcGetStopQuestList = "Questionable.GetStopQuestList";

	private const string IpcAddStopQuest = "Questionable.AddStopQuest";

	private const string IpcRemoveStopQuest = "Questionable.RemoveStopQuest";

	private const string IpcClearStopQuests = "Questionable.ClearStopQuests";

	private const string IpcGetLevelStopCondition = "Questionable.GetLevelStopCondition";

	private const string IpcSetLevelStopCondition = "Questionable.SetLevelStopCondition";

	private const string IpcGetSequenceStopCondition = "Questionable.GetSequenceStopCondition";

	private const string IpcSetSequenceStopCondition = "Questionable.SetSequenceStopCondition";

	private const string IpcGetQuestSequenceStopCondition = "Questionable.GetQuestSequenceStopCondition";

	private const string IpcSetQuestSequenceStopCondition = "Questionable.SetQuestSequenceStopCondition";

	private const string IpcRemoveQuestSequenceStopCondition = "Questionable.RemoveQuestSequenceStopCondition";

	private const string IpcGetAllQuestSequenceStopConditions = "Questionable.GetAllQuestSequenceStopConditions";

	private const string IpcGetLevelStopMode = "Questionable.GetLevelStopMode";

	private const string IpcSetLevelStopMode = "Questionable.SetLevelStopMode";

	private const string IpcGetSequenceStopMode = "Questionable.GetSequenceStopMode";

	private const string IpcSetSequenceStopMode = "Questionable.SetSequenceStopMode";

	private const string IpcGetQuestStopMode = "Questionable.GetQuestStopMode";

	private const string IpcSetQuestStopMode = "Questionable.SetQuestStopMode";

	private void RegisterAlliedSocietyIpc()
	{
		Register("Questionable.AlliedSociety.GetRemainingAllowances", GetAlliedSocietyRemainingAllowances);
		Register("Questionable.AlliedSociety.GetTimeUntilReset", GetAlliedSocietyTimeUntilReset);
		Register<byte, List<string>>("Questionable.AlliedSociety.GetAvailableQuestIds", GetAlliedSocietyAvailableQuestIds);
		Register("Questionable.AlliedSociety.GetAllAvailableQuestCounts", GetAlliedSocietyAllAvailableQuestCounts);
		Register<byte, bool>("Questionable.AlliedSociety.IsMaxRank", GetAlliedSocietyIsMaxRank);
		Register<byte, int>("Questionable.AlliedSociety.GetCurrentRank", GetAlliedSocietyCurrentRank);
		Register("Questionable.AlliedSociety.GetSocietiesWithAvailableQuests", GetAlliedSocietiesWithAvailableQuests);
		Register<byte, int>("Questionable.AlliedSociety.AddOptimalQuests", AddAlliedSocietyOptimalQuests);
		Register<byte, List<string>>("Questionable.AlliedSociety.GetOptimalQuests", GetAlliedSocietyOptimalQuests);
	}

	private unsafe int GetAlliedSocietyRemainingAllowances()
	{
		QuestManager* ptr = QuestManager.Instance();
		if (ptr == null)
		{
			return 12;
		}
		return (int)ptr->GetBeastTribeAllowance();
	}

	private long GetAlliedSocietyTimeUntilReset()
	{
		TimeSpan item = AlliedSocietyJournalComponent.CalculateTimeUntilReset().TimeUntilReset;
		return item.Ticks;
	}

	private List<string> GetAlliedSocietyAvailableQuestIds(byte alliedSocietyId)
	{
		if (alliedSocietyId == 0 || !Enum.IsDefined(typeof(EAlliedSociety), alliedSocietyId))
		{
			return new List<string>();
		}
		EAlliedSociety alliedSociety = (EAlliedSociety)alliedSocietyId;
		return (from q in _serviceProvider.GetRequiredService<AlliedSocietyQuestFunctions>().GetAvailableAlliedSocietyQuests(alliedSociety)
			select q.ToString()).ToList();
	}

	private Dictionary<byte, int> GetAlliedSocietyAllAvailableQuestCounts()
	{
		Dictionary<byte, int> dictionary = new Dictionary<byte, int>();
		AlliedSocietyQuestFunctions requiredService = _serviceProvider.GetRequiredService<AlliedSocietyQuestFunctions>();
		EAlliedSociety[] values = Enum.GetValues<EAlliedSociety>();
		foreach (EAlliedSociety eAlliedSociety in values)
		{
			if (eAlliedSociety != EAlliedSociety.None)
			{
				int count = requiredService.GetAvailableAlliedSocietyQuests(eAlliedSociety).Count;
				if (count > 0)
				{
					dictionary[(byte)eAlliedSociety] = count;
				}
			}
		}
		return dictionary;
	}

	private unsafe bool GetAlliedSocietyIsMaxRank(byte alliedSocietyId)
	{
		if (!Enum.IsDefined(typeof(EAlliedSociety), alliedSocietyId) || alliedSocietyId == 0)
		{
			return false;
		}
		QuestManager* ptr = QuestManager.Instance();
		if (ptr == null)
		{
			return false;
		}
		byte b = (byte)(ptr->BeastReputation[alliedSocietyId - 1].Rank & 0x7F);
		return b >= (EAlliedSociety)alliedSocietyId switch
		{
			EAlliedSociety.Amaljaa => 3, 
			EAlliedSociety.Sylphs => 3, 
			EAlliedSociety.Kobolds => 3, 
			EAlliedSociety.Sahagin => 3, 
			EAlliedSociety.Ixal => 7, 
			_ => 8, 
		};
	}

	private unsafe int GetAlliedSocietyCurrentRank(byte alliedSocietyId)
	{
		if (!Enum.IsDefined(typeof(EAlliedSociety), alliedSocietyId) || alliedSocietyId == 0)
		{
			return -1;
		}
		QuestManager* ptr = QuestManager.Instance();
		if (ptr == null)
		{
			return -1;
		}
		return (byte)(ptr->BeastReputation[alliedSocietyId - 1].Rank & 0x7F);
	}

	private List<byte> GetAlliedSocietiesWithAvailableQuests()
	{
		List<byte> list = new List<byte>();
		AlliedSocietyQuestFunctions requiredService = _serviceProvider.GetRequiredService<AlliedSocietyQuestFunctions>();
		EAlliedSociety[] values = Enum.GetValues<EAlliedSociety>();
		foreach (EAlliedSociety eAlliedSociety in values)
		{
			if (eAlliedSociety != EAlliedSociety.None && requiredService.GetAvailableAlliedSocietyQuests(eAlliedSociety).Count > 0)
			{
				list.Add((byte)eAlliedSociety);
			}
		}
		return list;
	}

	private int AddAlliedSocietyOptimalQuests(byte alliedSocietyId)
	{
		if (!Enum.IsDefined(typeof(EAlliedSociety), alliedSocietyId) || alliedSocietyId == 0)
		{
			return 0;
		}
		EAlliedSociety eAlliedSociety = (EAlliedSociety)alliedSocietyId;
		List<QuestId> availableAlliedSocietyQuests = _serviceProvider.GetRequiredService<AlliedSocietyQuestFunctions>().GetAvailableAlliedSocietyQuests(eAlliedSociety);
		if (availableAlliedSocietyQuests.Count == 0)
		{
			return 0;
		}
		IQuestInfo questInfo;
		Quest quest;
		List<QuestInfo> list = (from questInfo in availableAlliedSocietyQuests.Select((QuestId questId) => (!_questData.TryGetQuestInfo(questId, out questInfo)) ? null : questInfo).OfType<QuestInfo>()
			where _questRegistry.TryGetQuest(questInfo.QuestId, out quest) && !quest.Root.Disabled
			where !_questController.ManualPriorityQuests.Any((Quest pq) => pq.Id.Equals(questInfo.QuestId))
			orderby questInfo.AlliedSocietyRank descending
			select questInfo).ToList();
		if (list.Count == 0)
		{
			return 0;
		}
		int val = (((int)eAlliedSociety <= 5) ? 12 : 3);
		int alliedSocietyRemainingAllowances = GetAlliedSocietyRemainingAllowances();
		int count = Math.Min(Math.Min(val, alliedSocietyRemainingAllowances), list.Count);
		int num = 0;
		foreach (QuestInfo item in list.Take(count))
		{
			if (_questController.AddQuestPriority(item.QuestId))
			{
				num++;
			}
		}
		return num;
	}

	private List<string> GetAlliedSocietyOptimalQuests(byte alliedSocietyId)
	{
		if (!Enum.IsDefined(typeof(EAlliedSociety), alliedSocietyId) || alliedSocietyId == 0)
		{
			return new List<string>();
		}
		EAlliedSociety eAlliedSociety = (EAlliedSociety)alliedSocietyId;
		List<QuestId> availableAlliedSocietyQuests = _serviceProvider.GetRequiredService<AlliedSocietyQuestFunctions>().GetAvailableAlliedSocietyQuests(eAlliedSociety);
		if (availableAlliedSocietyQuests.Count == 0)
		{
			return new List<string>();
		}
		IQuestInfo questInfo;
		Quest quest;
		List<QuestInfo> list = (from questInfo in availableAlliedSocietyQuests.Select((QuestId questId) => (!_questData.TryGetQuestInfo(questId, out questInfo)) ? null : questInfo).OfType<QuestInfo>()
			where _questRegistry.TryGetQuest(questInfo.QuestId, out quest) && !quest.Root.Disabled
			where !_questController.ManualPriorityQuests.Any((Quest pq) => pq.Id.Equals(questInfo.QuestId))
			orderby questInfo.AlliedSocietyRank descending
			select questInfo).ToList();
		if (list.Count == 0)
		{
			return new List<string>();
		}
		int val = (((int)eAlliedSociety <= 5) ? 12 : 3);
		int alliedSocietyRemainingAllowances = GetAlliedSocietyRemainingAllowances();
		int count = Math.Min(Math.Min(val, alliedSocietyRemainingAllowances), list.Count);
		return (from q in list.Take(count)
			select q.QuestId.ToString()).ToList();
	}

	private void RegisterBlacklistIpc()
	{
		Register("Questionable.GetBlacklistedQuests", GetBlacklistedQuests);
		Register<string, bool>("Questionable.AddBlacklistedQuest", AddBlacklistedQuest);
		Register<string, bool>("Questionable.RemoveBlacklistedQuest", RemoveBlacklistedQuest);
		Register("Questionable.ClearBlacklistedQuests", ClearBlacklistedQuests);
		Register<string, bool>("Questionable.IsQuestBlacklisted", IsQuestBlacklistedIpc);
	}

	private List<string> GetBlacklistedQuests()
	{
		return _configuration.General.BlacklistedQuests.Select((ElementId q) => q.ToString()).ToList();
	}

	private bool AddBlacklistedQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _configuration.General.BlacklistedQuests.Add(elementId))
		{
			_pluginInterface.SavePluginConfig(_configuration);
			return true;
		}
		return false;
	}

	private bool RemoveBlacklistedQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			bool num = _configuration.General.BlacklistedQuests.Remove(elementId);
			if (num)
			{
				_pluginInterface.SavePluginConfig(_configuration);
			}
			return num;
		}
		return false;
	}

	private bool ClearBlacklistedQuests()
	{
		_configuration.General.BlacklistedQuests.Clear();
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private bool IsQuestBlacklistedIpc(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questFunctions.IsQuestBlacklisted(elementId);
		}
		return false;
	}

	public QuestionableIpc(QuestController questController, EventInfoComponent eventInfoComponent, QuestRegistry questRegistry, QuestFunctions questFunctions, QuestData questData, ManualPriorityComponent manualPriorityComponent, Configuration configuration, IDalamudPluginInterface pluginInterface, IServiceProvider serviceProvider, AutoDutyIpc autoDutyIpc, IObjectTable objectTable)
	{
		_questController = questController;
		_eventInfoComponent = eventInfoComponent;
		_questRegistry = questRegistry;
		_questFunctions = questFunctions;
		_questData = questData;
		_manualPriorityComponent = manualPriorityComponent;
		_configuration = configuration;
		_pluginInterface = pluginInterface;
		_serviceProvider = serviceProvider;
		_autoDutyIpc = autoDutyIpc;
		_objectTable = objectTable;
		RegisterMetaIpc();
		RegisterQuestStateIpc();
		RegisterDutyModeIpc();
		RegisterPriorityQuestIpc();
		RegisterStopConditionIpc();
		RegisterAlliedSocietyIpc();
		RegisterLevelingModeIpc();
		RegisterBlacklistIpc();
		RegisterMsqPriorityIpc();
	}

	private void Register<TRet>(string name, Func<TRet> handler)
	{
		ICallGateProvider<TRet> ipcProvider = _pluginInterface.GetIpcProvider<TRet>(name);
		ipcProvider.RegisterFunc(handler);
		_unregisterActions.Add(ipcProvider.UnregisterFunc);
	}

	private void Register<T1, TRet>(string name, Func<T1, TRet> handler)
	{
		ICallGateProvider<T1, TRet> ipcProvider = _pluginInterface.GetIpcProvider<T1, TRet>(name);
		ipcProvider.RegisterFunc(handler);
		_unregisterActions.Add(ipcProvider.UnregisterFunc);
	}

	private void Register<T1, T2, TRet>(string name, Func<T1, T2, TRet> handler)
	{
		ICallGateProvider<T1, T2, TRet> ipcProvider = _pluginInterface.GetIpcProvider<T1, T2, TRet>(name);
		ipcProvider.RegisterFunc(handler);
		_unregisterActions.Add(ipcProvider.UnregisterFunc);
	}

	public void Dispose()
	{
		foreach (Action unregisterAction in _unregisterActions)
		{
			unregisterAction();
		}
		_unregisterActions.Clear();
	}

	private void RegisterDutyModeIpc()
	{
		Register("Questionable.GetDefaultDutyMode", GetDefaultDutyMode);
		Register<int, bool>("Questionable.SetDefaultDutyMode", SetDefaultDutyMode);
		Register<uint, int>("Questionable.GetDutyModeOverride", GetDutyModeOverride);
		Register<uint, int, bool>("Questionable.SetDutyModeOverride", SetDutyModeOverride);
		Register<uint, bool>("Questionable.ClearDutyModeOverride", ClearDutyModeOverride);
		Register("Questionable.ClearAllDutyModeOverrides", ClearAllDutyModeOverrides);
	}

	private int GetDefaultDutyMode()
	{
		return (int)_configuration.Duties.DefaultDutyMode;
	}

	private bool SetDefaultDutyMode(int dutyMode)
	{
		if (!Enum.IsDefined(typeof(EDutyMode), dutyMode))
		{
			return false;
		}
		_configuration.Duties.DefaultDutyMode = (EDutyMode)dutyMode;
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private int GetDutyModeOverride(uint contentFinderConditionId)
	{
		if (_configuration.Duties.DutyModeOverrides.TryGetValue(contentFinderConditionId, out var value))
		{
			return (int)value;
		}
		return -1;
	}

	private bool SetDutyModeOverride(uint contentFinderConditionId, int dutyMode)
	{
		if (!Enum.IsDefined(typeof(EDutyMode), dutyMode))
		{
			return false;
		}
		_configuration.Duties.DutyModeOverrides[contentFinderConditionId] = (EDutyMode)dutyMode;
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private bool ClearDutyModeOverride(uint contentFinderConditionId)
	{
		bool num = _configuration.Duties.DutyModeOverrides.Remove(contentFinderConditionId);
		if (num)
		{
			_pluginInterface.SavePluginConfig(_configuration);
		}
		return num;
	}

	private bool ClearAllDutyModeOverrides()
	{
		_configuration.Duties.DutyModeOverrides.Clear();
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private void RegisterLevelingModeIpc()
	{
		Register("Questionable.IsLevelingModeEnabled", IsLevelingModeEnabled);
		Register<bool, bool>("Questionable.SetLevelingModeEnabled", SetLevelingModeEnabled);
		Register("Questionable.GetMsqLevelLockInfo", GetMsqLevelLockInfo);
		Register("Questionable.StartLevelingMode", StartLevelingMode);
		Register("Questionable.StopLevelingMode", StopLevelingMode);
	}

	private bool IsLevelingModeEnabled()
	{
		return _configuration.Duties.RunLevelingModeWhenUnderleveled;
	}

	private bool SetLevelingModeEnabled(bool enabled)
	{
		_configuration.Duties.RunLevelingModeWhenUnderleveled = enabled;
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private MsqLevelLockData? GetMsqLevelLockInfo()
	{
		var (flag, levelsNeeded, requiredLevel, questName) = _questFunctions.GetMsqLevelLockInfo();
		if (!flag)
		{
			return null;
		}
		return new MsqLevelLockData
		{
			IsLevelLocked = flag,
			LevelsNeeded = levelsNeeded,
			RequiredLevel = requiredLevel,
			QuestName = questName
		};
	}

	private bool StartLevelingMode()
	{
		if (!_autoDutyIpc.IsConfiguredToRunLevelingMode(_objectTable.LocalPlayer?.Level ?? 0))
		{
			return false;
		}
		return _autoDutyIpc.StartLevelingMode();
	}

	private bool StopLevelingMode()
	{
		return _autoDutyIpc.Stop();
	}

	private void RegisterMetaIpc()
	{
		Register("Questionable.ApiVersion", () => ((int, int))ApiVersion);
	}

	private void RegisterMsqPriorityIpc()
	{
		Register("Questionable.GetMsqPriorityMode", GetMsqPriorityMode);
		Register<int, bool>("Questionable.SetMsqPriorityMode", SetMsqPriorityMode);
	}

	private int GetMsqPriorityMode()
	{
		return (int)_configuration.General.MsqPriority;
	}

	private bool SetMsqPriorityMode(int mode)
	{
		if (!Enum.IsDefined(typeof(Configuration.EMsqPriorityMode), mode))
		{
			return false;
		}
		_configuration.General.MsqPriority = (Configuration.EMsqPriorityMode)mode;
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private void RegisterPriorityQuestIpc()
	{
		Register<string, bool>("Questionable.ImportQuestPriority", ImportQuestPriority);
		Register<string, bool>("Questionable.AddQuestPriority", AddQuestPriority);
		Register("Questionable.ClearQuestPriority", ClearQuestPriority);
		Register<int, string, bool>("Questionable.InsertQuestPriority", InsertQuestPriority);
		Register("Questionable.ExportQuestPriority", _manualPriorityComponent.EncodeQuestPriority);
		Register("Questionable.GetPriorityQuests", GetPriorityQuests);
		Register<string, bool>("Questionable.RemovePriorityQuest", RemovePriorityQuest);
		Register<string, int, bool>("Questionable.ReorderPriorityQuest", ReorderPriorityQuest);
		Register("Questionable.GetAvailablePresets", GetAvailablePresets);
		Register<string, List<string>>("Questionable.GetPresetQuests", GetPresetQuests);
		Register<string, int>("Questionable.AddPresetToPriority", AddPresetToPriority);
		Register<string, bool>("Questionable.IsPresetAvailable", IsPresetAvailable);
		Register<string, bool>("Questionable.IsQuestInPriority", IsQuestInPriority);
		Register<string, int>("Questionable.GetQuestPriorityIndex", GetQuestPriorityIndex);
		Register("Questionable.HasAvailablePriorityQuests", HasAvailablePriorityQuests);
	}

	private bool ImportQuestPriority(string encodedQuestPriority)
	{
		List<ElementId> list = ManualPriorityComponent.DecodeQuestPriority(encodedQuestPriority);
		if (list.Count > 0)
		{
			return _questController.ImportQuestPriority(list);
		}
		return false;
	}

	private bool ClearQuestPriority()
	{
		_questController.ClearQuestPriority();
		return true;
	}

	private bool AddQuestPriority(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.IsKnownQuest(elementId))
		{
			return _questController.AddQuestPriority(elementId);
		}
		return false;
	}

	private bool InsertQuestPriority(int index, string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.IsKnownQuest(elementId))
		{
			return _questController.InsertQuestPriority(index, elementId);
		}
		return false;
	}

	private List<string> GetPriorityQuests()
	{
		return _questController.ManualPriorityQuests.Select((Quest q) => q.Id.ToString()).ToList();
	}

	private bool RemovePriorityQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			Quest quest = _questController.ManualPriorityQuests.FirstOrDefault((Quest q) => q.Id.Equals(elementId));
			if (quest != null)
			{
				_questController.ManualPriorityQuests.Remove(quest);
				_questController.SavePriorityQuests();
				return true;
			}
		}
		return false;
	}

	private bool ReorderPriorityQuest(string questId, int newIndex)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			Quest quest = _questController.ManualPriorityQuests.FirstOrDefault((Quest q) => q.Id.Equals(elementId));
			if (quest != null && newIndex >= 0 && newIndex < _questController.ManualPriorityQuests.Count)
			{
				_questController.ManualPriorityQuests.Remove(quest);
				_questController.ManualPriorityQuests.Insert(newIndex, quest);
				_questController.SavePriorityQuests();
				return true;
			}
		}
		return false;
	}

	private List<string> GetAvailablePresets()
	{
		return new List<string> { "crystal_tower", "hard_primals" };
	}

	private List<string> GetPresetQuests(string presetName)
	{
		List<ElementId> source = ((presetName == "crystal_tower") ? QuestData.CrystalTowerQuests.Cast<ElementId>().ToList() : ((!(presetName == "hard_primals")) ? new List<ElementId>() : QuestData.HardModePrimals.Cast<ElementId>().ToList()));
		return source.Select((ElementId q) => q.ToString()).ToList();
	}

	private int AddPresetToPriority(string presetName)
	{
		List<string> presetQuests = GetPresetQuests(presetName);
		int num = 0;
		foreach (string item in presetQuests)
		{
			if (ElementId.TryFromString(item, out ElementId elementId) && elementId != null && (_questFunctions.IsReadyToAcceptQuest(elementId) || _questFunctions.IsQuestAccepted(elementId)) && !_questController.ManualPriorityQuests.Any((Quest q) => q.Id.Equals(elementId)) && _questRegistry.IsKnownQuest(elementId) && _questController.AddQuestPriority(elementId))
			{
				num++;
			}
		}
		return num;
	}

	private bool IsPresetAvailable(string presetName)
	{
		return GetAvailablePresets().Contains(presetName);
	}

	private bool IsQuestInPriority(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questController.ManualPriorityQuests.Any((Quest q) => q.Id.Equals(elementId));
		}
		return false;
	}

	private int GetQuestPriorityIndex(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			Quest quest = _questController.ManualPriorityQuests.FirstOrDefault((Quest q) => q.Id.Equals(elementId));
			if (quest != null)
			{
				return _questController.ManualPriorityQuests.IndexOf(quest);
			}
		}
		return -1;
	}

	private bool HasAvailablePriorityQuests()
	{
		return _questFunctions.GetNextPriorityQuestsThatCanBeAccepted().Any((PriorityQuestInfo x) => x.IsAvailable);
	}

	private void RegisterQuestStateIpc()
	{
		Register("Questionable.IsRunning", () => _questController.AutomationType != QuestController.EAutomationType.Manual || _questController.IsRunning);
		Register("Questionable.GetCurrentQuestId", () => _questController.CurrentQuest?.Quest.Id.ToString());
		Register("Questionable.GetCurrentStepData", GetStepData);
		Register("Questionable.GetCurrentTask", GetCurrentTask);
		Register("Questionable.GetCurrentlyActiveEventQuests", () => (from q in _eventInfoComponent.GetCurrentlyActiveEventQuests()
			select q.ToString()).ToList());
		Register("Questionable.StartQuest", (string questId) => StartQuest(questId, single: false));
		Register("Questionable.StartSingleQuest", (string questId) => StartQuest(questId, single: true));
		Register<string, bool>("Questionable.IsQuestLocked", IsQuestLocked);
		Register<string, bool>("Questionable.IsQuestComplete", IsQuestComplete);
		Register<string, bool>("Questionable.IsReadyToAcceptQuest", IsReadyToAcceptQuest);
		Register<string, bool>("Questionable.IsQuestAccepted", IsQuestAccepted);
		Register<string, bool>("Questionable.IsQuestUnobtainable", IsQuestUnobtainable);
	}

	private bool StartQuest(string questId, bool single)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.TryGetQuest(elementId, out Quest quest))
		{
			_questController.SetNextQuest(quest);
			if (single)
			{
				_questController.StartSingleQuest("IPCQuestSelection");
			}
			else
			{
				_questController.Start("IPCQuestSelection");
			}
			return true;
		}
		return false;
	}

	private StepData? GetStepData()
	{
		QuestController.QuestProgress currentQuest = _questController.CurrentQuest;
		if (currentQuest == null)
		{
			return null;
		}
		string text = currentQuest.Quest.Id.ToString();
		if (string.IsNullOrEmpty(text))
		{
			return null;
		}
		QuestStep questStep = currentQuest.Quest.FindSequence(currentQuest.Sequence)?.FindStep(currentQuest.Step);
		if (questStep == null)
		{
			return null;
		}
		return new StepData
		{
			QuestId = text,
			Sequence = currentQuest.Sequence,
			Step = currentQuest.Step,
			InteractionType = questStep.InteractionType.ToString(),
			Position = questStep.Position,
			TerritoryId = questStep.TerritoryId
		};
	}

	private TaskData? GetCurrentTask()
	{
		ITask task = _questController.TaskQueue.CurrentTaskExecutor?.CurrentTask;
		if (task == null)
		{
			return null;
		}
		int remainingTaskCount = _questController.TaskQueue.RemainingTasks.Count();
		string taskName = task.ToString() ?? "Unknown";
		return new TaskData
		{
			TaskName = taskName,
			RemainingTaskCount = remainingTaskCount
		};
	}

	private bool IsQuestLocked(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.TryGetQuest(elementId, out Quest _))
		{
			return _questFunctions.IsQuestLocked(elementId);
		}
		return true;
	}

	private bool IsQuestComplete(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questFunctions.IsQuestComplete(elementId);
		}
		return false;
	}

	private bool IsReadyToAcceptQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questFunctions.IsReadyToAcceptQuest(elementId);
		}
		return false;
	}

	private bool IsQuestAccepted(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questFunctions.IsQuestAccepted(elementId);
		}
		return false;
	}

	private bool IsQuestUnobtainable(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			return _questFunctions.IsQuestUnobtainable(elementId);
		}
		return false;
	}

	private void RegisterStopConditionIpc()
	{
		Register("Questionable.GetStopConditionsEnabled", GetStopConditionsEnabled);
		Register<bool, bool>("Questionable.SetStopConditionsEnabled", SetStopConditionsEnabled);
		Register("Questionable.GetStopQuestList", GetStopQuestList);
		Register<string, bool>("Questionable.AddStopQuest", AddStopQuest);
		Register<string, bool>("Questionable.RemoveStopQuest", RemoveStopQuest);
		Register("Questionable.ClearStopQuests", ClearStopQuests);
		Register("Questionable.GetLevelStopCondition", GetLevelStopCondition);
		Register<bool, int, bool>("Questionable.SetLevelStopCondition", SetLevelStopCondition);
		Register("Questionable.GetSequenceStopCondition", GetSequenceStopCondition);
		Register<bool, int, bool>("Questionable.SetSequenceStopCondition", SetSequenceStopCondition);
		Register<string, int>("Questionable.GetQuestSequenceStopCondition", GetQuestSequenceStopCondition);
		Register<string, int, bool>("Questionable.SetQuestSequenceStopCondition", SetQuestSequenceStopCondition);
		Register<string, bool>("Questionable.RemoveQuestSequenceStopCondition", RemoveQuestSequenceStopCondition);
		Register("Questionable.GetAllQuestSequenceStopConditions", GetAllQuestSequenceStopConditions);
		Register("Questionable.GetLevelStopMode", GetLevelStopMode);
		Register<int, bool>("Questionable.SetLevelStopMode", SetLevelStopMode);
		Register("Questionable.GetSequenceStopMode", GetSequenceStopMode);
		Register<int, bool>("Questionable.SetSequenceStopMode", SetSequenceStopMode);
		Register<string, int>("Questionable.GetQuestStopMode", GetQuestStopMode);
		Register<string, int, bool>("Questionable.SetQuestStopMode", SetQuestStopMode);
	}

	private bool GetStopConditionsEnabled()
	{
		return _configuration.Stop.Enabled;
	}

	private bool SetStopConditionsEnabled(bool enabled)
	{
		_configuration.Stop.Enabled = enabled;
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private List<string> GetStopQuestList()
	{
		return (from c in _configuration.Stop.Conditions.OfType<QuestCompleteCondition>()
			select c.QuestId.ToString()).ToList();
	}

	private bool AddStopQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.IsKnownQuest(elementId) && !_configuration.Stop.Conditions.OfType<QuestCompleteCondition>().Any((QuestCompleteCondition c) => c.QuestId.Equals(elementId)))
		{
			_configuration.Stop.Conditions.Add(new QuestCompleteCondition
			{
				QuestId = elementId,
				Mode = EStopConditionMode.Stop
			});
			_pluginInterface.SavePluginConfig(_configuration);
			return true;
		}
		return false;
	}

	private bool RemoveStopQuest(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId));
			if (questCompleteCondition != null)
			{
				_configuration.Stop.Conditions.Remove(questCompleteCondition);
				_pluginInterface.SavePluginConfig(_configuration);
				return true;
			}
		}
		return false;
	}

	private bool ClearStopQuests()
	{
		_configuration.Stop.Conditions.RemoveAll((StopCondition c) => c is QuestCompleteCondition);
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private StopConditionData GetLevelStopCondition()
	{
		LevelCondition levelCondition = _configuration.Stop.Conditions.OfType<LevelCondition>().FirstOrDefault();
		return new StopConditionData
		{
			Enabled = (levelCondition != null),
			TargetValue = (levelCondition?.TargetLevel ?? 50)
		};
	}

	private bool SetLevelStopCondition(bool enabled, int targetLevel)
	{
		if (targetLevel < 1 || targetLevel > 100)
		{
			return false;
		}
		LevelCondition levelCondition = _configuration.Stop.Conditions.OfType<LevelCondition>().FirstOrDefault();
		if (!enabled)
		{
			if (levelCondition != null)
			{
				_configuration.Stop.Conditions.Remove(levelCondition);
			}
		}
		else if (levelCondition != null)
		{
			levelCondition.TargetLevel = targetLevel;
			levelCondition.Mode = EStopConditionMode.Stop;
		}
		else
		{
			_configuration.Stop.Conditions.Add(new LevelCondition
			{
				TargetLevel = targetLevel,
				Mode = EStopConditionMode.Stop
			});
		}
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private StopConditionData GetSequenceStopCondition()
	{
		GlobalSequenceCondition globalSequenceCondition = _configuration.Stop.Conditions.OfType<GlobalSequenceCondition>().FirstOrDefault();
		return new StopConditionData
		{
			Enabled = (globalSequenceCondition != null),
			TargetValue = (globalSequenceCondition?.TargetSequence ?? 1)
		};
	}

	private bool SetSequenceStopCondition(bool enabled, int targetSequence)
	{
		if (targetSequence < 0 || targetSequence > 255)
		{
			return false;
		}
		GlobalSequenceCondition globalSequenceCondition = _configuration.Stop.Conditions.OfType<GlobalSequenceCondition>().FirstOrDefault();
		if (!enabled)
		{
			if (globalSequenceCondition != null)
			{
				_configuration.Stop.Conditions.Remove(globalSequenceCondition);
			}
		}
		else if (globalSequenceCondition != null)
		{
			globalSequenceCondition.TargetSequence = targetSequence;
			globalSequenceCondition.Mode = EStopConditionMode.Stop;
		}
		else
		{
			_configuration.Stop.Conditions.Add(new GlobalSequenceCondition
			{
				TargetSequence = targetSequence,
				Mode = EStopConditionMode.Stop
			});
		}
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private int GetQuestSequenceStopCondition(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId));
			if (questCompleteCondition != null)
			{
				return questCompleteCondition.Sequence ?? (-1);
			}
		}
		return -1;
	}

	private bool SetQuestSequenceStopCondition(string questId, int targetSequence)
	{
		if (targetSequence < 0 || targetSequence > 255)
		{
			return false;
		}
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.IsKnownQuest(elementId))
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId));
			if (questCompleteCondition != null)
			{
				questCompleteCondition.Sequence = targetSequence;
			}
			else
			{
				_configuration.Stop.Conditions.Add(new QuestCompleteCondition
				{
					QuestId = elementId,
					Sequence = targetSequence,
					Mode = EStopConditionMode.Stop
				});
			}
			_pluginInterface.SavePluginConfig(_configuration);
			return true;
		}
		return false;
	}

	private bool RemoveQuestSequenceStopCondition(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId) && c.Sequence.HasValue);
			if (questCompleteCondition != null)
			{
				_configuration.Stop.Conditions.Remove(questCompleteCondition);
				_pluginInterface.SavePluginConfig(_configuration);
				return true;
			}
		}
		return false;
	}

	private Dictionary<string, int> GetAllQuestSequenceStopConditions()
	{
		return (from c in _configuration.Stop.Conditions.OfType<QuestCompleteCondition>()
			where c.Sequence.HasValue
			select c).ToDictionary((QuestCompleteCondition c) => c.QuestId.ToString(), (QuestCompleteCondition c) => c.Sequence.Value);
	}

	private int GetLevelStopMode()
	{
		return (int)(_configuration.Stop.Conditions.OfType<LevelCondition>().FirstOrDefault()?.Mode ?? EStopConditionMode.Off);
	}

	private bool SetLevelStopMode(int mode)
	{
		if (!Enum.IsDefined(typeof(EStopConditionMode), mode))
		{
			return false;
		}
		LevelCondition levelCondition = _configuration.Stop.Conditions.OfType<LevelCondition>().FirstOrDefault();
		if (mode == 0)
		{
			if (levelCondition != null)
			{
				_configuration.Stop.Conditions.Remove(levelCondition);
			}
		}
		else if (levelCondition != null)
		{
			levelCondition.Mode = (EStopConditionMode)mode;
		}
		else
		{
			_configuration.Stop.Conditions.Add(new LevelCondition
			{
				TargetLevel = 50,
				Mode = (EStopConditionMode)mode
			});
		}
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private int GetSequenceStopMode()
	{
		return (int)(_configuration.Stop.Conditions.OfType<GlobalSequenceCondition>().FirstOrDefault()?.Mode ?? EStopConditionMode.Off);
	}

	private bool SetSequenceStopMode(int mode)
	{
		if (!Enum.IsDefined(typeof(EStopConditionMode), mode))
		{
			return false;
		}
		GlobalSequenceCondition globalSequenceCondition = _configuration.Stop.Conditions.OfType<GlobalSequenceCondition>().FirstOrDefault();
		if (mode == 0)
		{
			if (globalSequenceCondition != null)
			{
				_configuration.Stop.Conditions.Remove(globalSequenceCondition);
			}
		}
		else if (globalSequenceCondition != null)
		{
			globalSequenceCondition.Mode = (EStopConditionMode)mode;
		}
		else
		{
			_configuration.Stop.Conditions.Add(new GlobalSequenceCondition
			{
				TargetSequence = 1,
				Mode = (EStopConditionMode)mode
			});
		}
		_pluginInterface.SavePluginConfig(_configuration);
		return true;
	}

	private int GetQuestStopMode(string questId)
	{
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null)
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId));
			if (questCompleteCondition != null)
			{
				return (int)questCompleteCondition.Mode;
			}
		}
		return -1;
	}

	private bool SetQuestStopMode(string questId, int mode)
	{
		if (!Enum.IsDefined(typeof(EStopConditionMode), mode))
		{
			return false;
		}
		if (ElementId.TryFromString(questId, out ElementId elementId) && elementId != null && _questRegistry.IsKnownQuest(elementId))
		{
			QuestCompleteCondition questCompleteCondition = _configuration.Stop.Conditions.OfType<QuestCompleteCondition>().FirstOrDefault((QuestCompleteCondition c) => c.QuestId.Equals(elementId));
			if (mode == 0)
			{
				if (questCompleteCondition != null)
				{
					_configuration.Stop.Conditions.Remove(questCompleteCondition);
				}
			}
			else if (questCompleteCondition != null)
			{
				questCompleteCondition.Mode = (EStopConditionMode)mode;
			}
			else
			{
				_configuration.Stop.Conditions.Add(new QuestCompleteCondition
				{
					QuestId = elementId,
					Mode = (EStopConditionMode)mode
				});
			}
			_pluginInterface.SavePluginConfig(_configuration);
			return true;
		}
		return false;
	}
}