using BrewMonster.Scripts.Task;
using PerfectWorld.Scripts.Task;

namespace BrewMonster.Scripts.Task
{
    public partial class ATaskTempl
    {
	    public uint GetID()
	    {
		    return m_FixedData.m_ID;
	    }
	    
	    // Process Part

		public uint CheckPrerequisite(
			TaskInterface pTask,
			ActiveTaskList pList,
			uint ulCurTime,
			bool bCheckPrevTask = true,
			bool bCheckTeam = true,
			bool bCheckBudge = true,
			bool bCheckLevel = true)
		{
			uint ulRet = 0u;

			// �����Ǹ��ڵ� // English: Not the root node
			if (m_pParent != null)
			{
				ulRet = (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_NOT_ROOT;
				goto ret_here;
			}

			if (bCheckBudge)
			{
				ulRet = CheckBudget(pList);
				if (ulRet != 0u) goto ret_here;
			}
			// else if (pList->GetEntry(m_ID)) // English: Already has the same task
			else if (pTask.HasTask(m_FixedData.m_ID))
			{
				ulRet = (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_SAME_TASK;
				goto ret_here;
			}

			// �Ƿ����� // English: Is task forbidden
			if (pTask.CheckTaskForbid(m_FixedData.m_ID))
			{
				ulRet = (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_TASK_FORBID;
				goto ret_here;
			}
			
			// ��ΪPQ�����ж������Ƿ��Ѿ���PQ���� // English: If current is PQ task, ensure no existing PQ task
			if (m_FixedData.m_bPQTask)
			{
				for (byte i = 0; i < pList.m_uTaskCount; i++)
				{
					var CurEntry = pList.m_TaskEntries[i];
					if (CurEntry == null) continue;
					ATaskTempl pTempl = CurEntry.GetTempl();

					if (pTempl != null && pTempl.m_FixedData.m_bPQTask)
					{
						ulRet = (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_ALREADY_HAS_PQ;
						goto ret_here;
					}
				}
			}

			ulRet = CheckGivenItems(pTask);
			if (ulRet != 0u) goto ret_here;

			// �Ƿ����㷢��ʱ�� // English: Check if within delivery timetable
			ulRet = CheckTimetable(ulCurTime);
			if (ulRet != 0u) goto ret_here;

			// ����ʱ���� // English: Check deliver time
			ulRet = CheckDeliverTime(pTask, ulCurTime);
			if (ulRet != 0u) goto ret_here;

			ulRet = CheckFnshLst(pTask, ulCurTime);
			if (ulRet != 0u) goto ret_here;

			// �Ƿ�ﵽ�˺�������ɴ��� // English: Check daily deliver count limit
			ulRet = CheckDeliverCount(pTask);
			if (ulRet != 0u) goto ret_here;
			
			// �Ƿ�ﵽ��ֵ��� // English: Check RMB/account balance
			ulRet = CheckAccountRMB(pTask);
			if (ulRet != 0u) goto ret_here;
			
			// �Ƿ������ɫ������¼ʱ������ // English: Check character time requirements
			ulRet = CheckCharTime(pTask);
			if (ulRet != 0u) goto ret_here;

			// Check Level // English: Level constraints
			if (bCheckLevel)
			{
				ulRet = CheckLevel(pTask);
				if (ulRet != 0u) goto ret_here;
			}

			// ת������ // English: Reincarnation constraints
			ulRet = CheckReincarnation(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����ȼ� // English: Realm level constraints
			ulRet = CheckRealmLevel(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���羭���Ƿ����� // English: Realm exp full check
			ulRet = CheckRealmExpFull(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���� // English: Reputation check
			ulRet = CheckRepu(pTask);
			if (ulRet != 0u) goto ret_here;

			// Ѻ�� // English: Deposit check
			ulRet = CheckDeposit(pTask);
			if (ulRet != 0u) goto ret_here;

			// ������Ʒ // English: Items check
			ulRet = CheckItems(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���� // English: Faction check
			ulRet = CheckFaction(pTask);
			if (ulRet != 0u) goto ret_here;

			// �Ա� // English: Gender check
			ulRet = CheckGender(pTask);
			if (ulRet != 0u) goto ret_here;

			// ְҵ // English: Occupation check
			ulRet = CheckOccupation(pTask);
			if (ulRet != 0u) goto ret_here;

			// �����ض�ʱ�� // English: Specific period check
			ulRet = CheckPeriod(pTask);
			if (ulRet != 0u) goto ret_here;

			// �Ƿ�GM // English: GM check
			ulRet = CheckGM(pTask);
			if (ulRet != 0u) goto ret_here;
			
			// �Ƿ���������û� // English: Shielded user check
			ulRet = CheckShieldUser(pTask);
			if (ulRet != 0u) goto ret_here;

			// �������� // English: Previous task check
			if (bCheckPrevTask)
			{
				ulRet = CheckPreTask(pTask);
				if (ulRet != 0u) goto ret_here;
			}

			// �������� // English: Mutex task check
			ulRet = CheckMutexTask(pTask, ulCurTime);
			if (ulRet != 0u) goto ret_here;

			// ���򴥷� // English: In-zone trigger check
			ulRet = CheckInZone(pTask);
			if (ulRet != 0u) goto ret_here;

			// ������� // English: Team task check
			if (bCheckTeam)
			{
				ulRet = CheckTeamTask(pTask);
				if (ulRet != 0u) goto ret_here;
			}

			// ���� // English: Spouse check
			ulRet = CheckSpouse(pTask);
			if (ulRet != 0u) goto ret_here;

			ulRet = CheckWeddingOwner(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���� // English: Marriage check
			ulRet = CheckMarriage(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����������� // English: Living skill check
			ulRet = CheckLivingSkill(pTask);
			if (ulRet != 0u) goto ret_here;

			// �������� // English: Special award activity check
			ulRet = CheckSpecialAward(pTask);
			if (ulRet != 0u) goto ret_here;

			// ȫ��key/value // English: Global key/value
			ulRet = CheckGlobalKeyValue(pTask, false);
			if (ulRet != 0u) goto ret_here;

			if (m_FixedData.m_bCompareItemAndInventory)
			{
				ulRet = CheckIvtrEmptySlot(pTask);
				if (ulRet != 0u) goto ret_here;
			}
			// ���ɹ��׶� // English: Faction contribution check
			ulRet = CheckFactionContrib(pTask);
			if (ulRet != 0u) goto ret_here;

			// ��¼��ɽ��������ɸ��� // English: Recorded tasks number check
			ulRet = CheckRecordTasksNum(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����״̬ // English: Transform mask check
			ulRet = CheckTransform(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���� // English: Force check
			ulRet = CheckForce(pTask);
			if (ulRet != 0u) goto ret_here;

			// �������� // English: Force reputation check
			ulRet = CheckForceReputation(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����ս�� // English: Force contribution check
			ulRet = CheckForceContribution(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����ֵ // English: EXP check
			ulRet = CheckExp(pTask);
			if (ulRet != 0u) goto ret_here;
			
			// Ԫ��ֵ // English: SP check
			ulRet = CheckSP(pTask);
			if (ulRet != 0u) goto ret_here;

			// ������Ծ�ȼ� // English: Force activity level check
			ulRet = CheckForceActivityLevel(pTask);
			if (ulRet != 0u) goto ret_here;

			// ���� // English: King check
			ulRet = CheckKing(pTask);
			if (ulRet != 0u) goto ret_here;

			// ������� // English: Not in team check
			ulRet = CheckNotInTeam(pTask);
			if (ulRet != 0u) goto ret_here;
			// �ƺ� // English: Title check
			ulRet = CheckTitle(pTask);
			if (ulRet != 0u) goto ret_here;

			// ��ʷ�ƽ��׶� // English: History stage check
			ulRet = CheckHistoryStage(pTask);
			if (ulRet != 0u) goto ret_here;

			// �ռ����� // English: Card collection count check
			ulRet = CheckCardCollection(pTask);
			if (ulRet != 0u) goto ret_here;

			// ����ijƷ��ӵ������ // English: Specific card rank count check
			ulRet = CheckCardRankCount(pTask);
			if (ulRet != 0u) goto ret_here;
			
			// �����󣬲��ܽ�ȡǿ���ƶ����� // English: No navigate when in transform shape
			ulRet = CheckInTransformShape(pTask);
			if (ulRet != 0u) goto ret_here;
			
		ret_here:
		
			// TODO: pTask.GetPlayerId() not available in managed interface; use 0
			string log = $"CheckPrerequisite: ret = {ulRet}";
			CECTaskInterface.WriteLog(0, (int)m_FixedData.m_ID, 1, log);

			return ulRet;
		}
	    
        #if _TASK_CLIENT
		// bool CanShowTask				(TaskInterface* pTask) const;
		// bool HasShowCond()				const;	
		public void GetGlobalTaskChar(TaskInterface pTask, Task_State_info.abase_vector_wchar_t_ptr TaskCharArr)
		{
			// Build display strings for global expressions
			// 生成用于显示的全局表达式字符串
			for (int i = 0; i < (int)m_FixedData.m_ulTaskCharCnt; i++)
			{
				// Read one UTF-16 row from m_pTaskChar and convert to C# string
				// 从 m_pTaskChar 读取一行 UTF-16 并转换为 C# 字符串
				int colCount = BrewMonster.Scripts.Task.TaskTemplConstants.TASK_AWARD_MAX_DISPLAY_CHAR_LEN;
				ushort[] row = new ushort[colCount];
				for (int j = 0; j < colCount; j++)
				{
					row[j] = m_FixedData.m_pTaskChar[i, j];
				}
				string src = ModelRenderer.Scripts.Common.ByteToStringUtils.UshortArrayToUnicodeString(row);
				if (string.IsNullOrEmpty(src))
				{
					continue;
				}

				// Parse '%' placeholders like %1, %2... and replace with computed values
				// 解析形如 %1, %2 的占位符并替换为计算结果
				var sb = new System.Text.StringBuilder();
				int idx = 0;
				char percent = '%'; // Percent sign
				// ����% (percent sign)
				while (idx < src.Length)
				{
					int pos = src.IndexOf(percent, idx);
					if (pos >= 0)
					{
						// Append text before '%'
						// 追加 '%' 之前的文本
						sb.Append(src, idx, pos - idx);
						int j = pos + 1;
						int startDigits = j;
						while (j < src.Length && char.IsDigit(src[j])) j++;
						string digits = (j > startDigits) ? src.Substring(startDigits, j - startDigits) : string.Empty;
						int nVal;
						// If there's a valid index after '%', compute the global expression value
						// ��ȡ���õ�ȫ�ֱ���ʽ�к� (get referenced global expression index)
						if (!string.IsNullOrEmpty(digits) && int.TryParse(digits, out nVal) && nVal != 0)
						{
							// Compute one global expression
							// ����ȫ�ֱ���ʽ
							int nRet = (int)CalcOneGlobalExp(pTask, nVal - 1);
							// Convert number to string and append
							// ת�����ַ��������ַ���
							sb.Append(nRet.ToString());
							// Skip all digits after '%<digits>'
							// 跳过 '%' 后面的所有数字
							idx = j;
							continue;
						}
						else
						{
							// No valid number found; keep the '%'
							// 未找到合法数字；保留 '%'
							sb.Append(percent);
							idx = pos + 1;
						}
					}
					else
					{
						// No more '%' found; append the rest
						// δ�ҵ�ȫ�ֱ�������ʽ����ֱ����ʾ��������
						sb.Append(src, idx, src.Length - idx);
						break;
					}
				}

				string result = sb.ToString();
				if (!string.IsNullOrEmpty(result))
				{
					// Original: TaskCharArr.push_back(pszNewchar);
					// 原逻辑：将结果指针压入向量（此处托管环境不直接推入原生向量）
					// NOTE: If needed, map 'result' into UI/managed list here.
				}
			}
		}
		private float CalcOneGlobalExp(TaskInterface pTask, int nIndex)
		{
			// Evaluate one global expression row
			// 计算一行全局表达式
			if (nIndex < 0 || nIndex >= (int)m_FixedData.m_ulExpCnt)
			{
				return 0f;
			}
			try
			{
				int colCount = BrewMonster.Scripts.Task.TaskTemplConstants.TASK_AWARD_MAX_DISPLAY_CHAR_LEN;
				float result = 0f;
				for (int i = 0; i < colCount; i++)
				{
					TASK_EXPRESSION expr = m_FixedData.m_pExpArr[nIndex, i];
					if (expr.type == -1) break; // Sentinel terminator // 结束标记
					// Fallback evaluation: accumulate values
					// 回退求值：累加表达式值
					result += expr.value;
				}
				return result;
			}
			catch (System.Exception ex)
			{
				CECTaskInterface.WriteLog(0, (int)m_FixedData.m_ID, 0, $"CalcOneGlobalExp, Expression run err: {ex.Message}");
				return 0f;
			}
		}
		// bool CanShowInExclusiveUI		(TaskInterface* pTask, unsigned long ulCurTime) const;
		#else
		// void NotifyClient				(TaskInterface* pTask, const ActiveTaskEntry* pEntry, unsigned char uReason, unsigned long ulCurTime, unsigned long ulParam = 0, int dps = 0, int dph = 0) const;
		// bool CheckGlobalRequired		(TaskInterface* pTask, unsigned long ulSubTaskId, const TaskPreservedData* pPreserve, const TaskGlobalData* pGlobal, unsigned short reason) const;
		// bool CheckKillMonster			(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, unsigned long ulTemplId, unsigned long ulLev, bool bTeam, float fRand, int dps, int dph) const;
		// bool CheckKillPlayer			(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, int iOccupation, int iLevel, bool bGender, int iForce, float fRand) const;
		// void CheckCollectItem			(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, bool bAtNPC, int nChoice) const;
		// void CheckMonsterKilled			(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, bool bAtNPC, int nChoice) const;
		// void CheckMining				(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry) const;
		// void CheckWaitTime				(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, unsigned long ulCurTime, bool bAtNPC, int nChoice) const;
		// void GiveUpOneTask				(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, bool bForce) const;
		// void OnSetFinished				(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, bool bNotifyMem = true) const;
		// bool DeliverAward				(TaskInterface* pTask, ActiveTaskList* pList, ActiveTaskEntry* pEntry, int nChoice, bool bNotifyTeamMem = true, TaskGlobalData* pGlobal = NULL) const;
		// void RemoveAcquiredItem			(TaskInterface* pTask, bool bClearTask, bool bSuccess) const;
		// void TakeAwayGivenItems			(TaskInterface* pTask) const;
		// bool OnDeliverTeamMemTask		(TaskInterface* pTask, TaskGlobalData* pGlobal) const;
		// unsigned long CheckDeliverTask	(TaskInterface* pTask, unsigned long ulSubTaskId, TaskGlobalData* pGlobal, bool bNotifyErr = true, bool bMemTask = false, unsigned long ulCapId = 0) const;
		// bool HasGlobalData() const;
		#endif
	    
#if _TASK_CLIENT
	    // void SyncTaskType(); // ʹ����������������游����
	    // bool GetShowGfxFlag() { return m_bShowGfxFinished;} 
	    // const wchar_t* GetDescription() const { assert(m_pwstrDescript); return (wchar_t*)m_pwstrDescript; }
	    // const wchar_t* GetOkText() const { assert(m_pwstrOkText); return (wchar_t*)m_pwstrOkText; }
	    // const wchar_t* GetNoText() const { assert(m_pwstrNoText); return (wchar_t*)m_pwstrNoText; }
	    // const wchar_t* GetTribute() const { assert(m_pwstrTribute); return (wchar_t*)m_pwstrTribute; }
	    //
	    // const talk_proc* GetDeliverTaskTalk() const { return &m_DelvTaskTalk; }
	    // const talk_proc* GetUnqualifiedTalk() const { return &m_UnqualifiedTalk; }
	    // const talk_proc* GetDeliverItemTalk() const { return &m_DelvItemTalk; }
	    // const talk_proc* GetUnfinishedTalk() const { return &m_ExeTalk; }
	    // const talk_proc* GetAwardTalk() const { return &m_AwardTalk; }
	    //
	    public uint GetDeliverNPC() { return m_FixedData.m_ulDelvNPC; }
	    public uint GetAwardNPC() { return m_FixedData.m_ulAwardNPC; }
	    //
	    // void SaveToTextFile(FILE* fp);
	    // bool SaveToTextFile(const char* szPath);
	    // void SaveToBinFile(FILE* fp) { SaveBinary(fp); }
	    // void SaveDescription(FILE* fp);
	    // void SaveDescriptionBin(FILE* fp);
	    // void SaveTribute(FILE* fp);
	    // void SaveTributeBin(FILE* fp);
	    // void SaveAllText(FILE* fp);
	    // int MarshalKillMonster(char* pData);
	    // int MarshalCollectItems(char* pData);
	    // int MarshalDynTask(char* pData);
	    // int MarshalSpecialAwardData(char* pData);
	    //
	    // ATaskTempl& operator= (const ATaskTempl& src);
	    // bool operator == (const ATaskTempl& src) const
	    // {
		   //  return *(ATaskTemplFixedData*)this == *(const ATaskTemplFixedData*)&src;
	    // }
#endif

	    
	    public bool _compare_key_value(TaskInterface pTask, COMPARE_KEY_VALUE CompKeyVal)
	    {
		    long lleftValue = CompKeyVal.lLeftNum;
		    if (CompKeyVal.nLeftType == 0)
		    {
			    lleftValue = pTask.GetGlobalValue(CompKeyVal.lLeftNum);
		    }

		    long lRightValue = CompKeyVal.lRightNum;
		    if (CompKeyVal.nRightType == 0)
		    {
			    lRightValue = pTask.GetGlobalValue(CompKeyVal.lRightNum);
		    }

		    switch(CompKeyVal.nCompOper)
		    {
			    case 0:
			    {
				    if (lleftValue > lRightValue)
					    return true;
			    }
				    break;
			    case 1:
			    {
				    if (lleftValue == lRightValue)
					    return true;
			    }
				    break;
			    case 2:
			    {
				    if (lleftValue < lRightValue)
					    return true;
			    }
				    break;
			    default:
				    break;
		    }

		    return false;
	    }
	    
		// Early out: skip if this phase does not require key-value comparison
		public uint CheckGlobalKeyValue(TaskInterface pTask, bool bFinCheck)
		{
			if ((bFinCheck && !m_FixedData.m_bFinNeedComp)
				|| (!bFinCheck && !m_FixedData.m_bPremNeedComp))
			{
				return 0;
			}

			// Initialize comparison flags
			bool bFlag1 = false;
			bool bFlag2 = false;

			if (bFinCheck)
			{
				// Finish-conditions branch: evaluate two key-value comparisons
				bFlag1 = _compare_key_value(pTask, m_FixedData.m_Fin1KeyValue);
				bFlag2 = _compare_key_value(pTask, m_FixedData.m_Fin2KeyValue);

				// Evaluate logical mode: 0 = OR, 1 = AND
				if ((m_FixedData.m_nFinExp1AndOrExp2 == 0 && (bFlag1 || bFlag2))
					|| (m_FixedData.m_nFinExp1AndOrExp2 == 1 && (bFlag1 && bFlag2)))
				{
					return 0;
				}
			}
			else
			{		
				// Premise-conditions branch: evaluate two key-value comparisons
				bFlag1 = _compare_key_value(pTask, m_FixedData.m_Prem1KeyValue);
				bFlag2 = _compare_key_value(pTask, m_FixedData.m_Prem2KeyValue);

				// Evaluate logical mode: 0 = OR, 1 = AND
				if ((m_FixedData.m_nPremExp1AndOrExp2 == 0 && (bFlag1 || bFlag2))
					|| (m_FixedData.m_nPremExp1AndOrExp2 == 1 && (bFlag1 && bFlag2)))
				{
					return 0;
				}
			}		

			// Failure: global key-value prerequisite not satisfied
			return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_GLOBAL_KEYVAL;
		}
		
		public bool CheckReachLevel(BrewMonster.Scripts.Task.TaskInterface pTask)
		{
			bool bLevel = true, bReincarnationCount = true, bRealmLevel = true;
			if (m_FixedData.m_ulReachLevel != 0) bLevel = pTask.GetPlayerLevel() >= m_FixedData.m_ulReachLevel;
			if (m_FixedData.m_ulReachReincarnationCount != 0) bReincarnationCount = GetReincarnationCount(pTask) >= m_FixedData.m_ulReachReincarnationCount;
			if (m_FixedData.m_ulReachRealmLevel != 0) bRealmLevel = GetRealmLevel(pTask) >= m_FixedData.m_ulReachRealmLevel;
			return bLevel && bReincarnationCount && bRealmLevel;
		}

		private static uint GetReincarnationCount(BrewMonster.Scripts.Task.TaskInterface pTask)
		{
			return 0u;
		}

		private static uint GetRealmLevel(BrewMonster.Scripts.Task.TaskInterface pTask)
		{
			var host = BrewMonster.Network.EC_Game.GetGameRun()?.GetHostPlayer();
			if (host != null)
			{
				var bp = host.GetBasicProps();
				return (uint)bp.iLevel2;
			}
			return 0u;
		}

		public bool IsKeyTask()
		{
			ATaskTempl m = GetTopTask();
			return m.m_FixedData.m_bKeyTask; 
			
		}
		
		// ===== Missing methods converted from C++ (TaskTempl.inl) =====
		// 保留原中文注释，并在旁加入英文翻译
		
		// inline unsigned long _get_item_count(TaskInterface* pTask, unsigned long ulItemId, bool bCommon)
		// 获取道具数量（通用/任务） // English: Get item count (common/task)
		// public static uint _get_item_count(TaskInterface pTask, uint ulItemId, bool bCommon)
		// {
		// 	return bCommon ? pTask.GetCommonItemCount(ulItemId) : pTask.GetTaskItemCount(ulItemId);
		// }
		
		// inline unsigned long ATaskTempl::CheckBudget(ActiveTaskList* pList) const
		// 检查任务栏容量与空间 // English: Check task list budget and space
		public uint CheckBudget(ActiveTaskList pList)
		{
			// TODO: Convert full logic with TASK_HIDDEN_COUNT/TASK_TITLE_TASK_COUNT/TASK_ACTIVE_LIST_MAX_LEN and list counters when constants and fields are available
			// 占位返回通过 // English: Placeholder pass
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckGivenItems(TaskInterface* pTask) const
		// 检查交付所需道具容量合法性 // English: Check deliverable item capacity
		public uint CheckGivenItems(TaskInterface pTask)
		{
			// TODO: Use m_FixedData.m_ulGivenItems, m_ulGivenCmnCount, m_ulGivenTskCount and pTask.CanDeliver* API when fields confirmed
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckTimetable(unsigned long ulCurTime) const
		// 检查任务可接时间表 // English: Check task timetable window
		public uint CheckTimetable(uint ulCurTime)
		{
			// TODO: Implement judge_time_date against m_FixedData.m_tmStart/m_tmEnd/m_tmType
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckDeliverTime(TaskInterface* pTask, unsigned long ulCurTime) const
		// 检查任务发放频率限制（日/周/月/年） // English: Check deliver frequency limits (day/week/month/year)
		public uint CheckDeliverTime(TaskInterface pTask, uint ulCurTime)
		{
			// TODO: Implement with FinishedTimeList/FinishedCntList and timezone bias when types are available
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckFnshLst(TaskInterface* pTask, unsigned long ulCurTime) const
		// 检查完成与失败记录是否允许重复领取 // English: Check finished/failed list for redo permissions
		public uint CheckFnshLst(TaskInterface pTask, uint ulCurTime)
		{
			// TODO: Implement using FinishedTaskList and m_FixedData.m_bCanRedo/m_bCanRedoAfterFailure
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckDeliverCount(TaskInterface* pTask) const
		// 检查周期内角色/账号次数限制 // English: Check period deliver counts for role/account
		public uint CheckDeliverCount(TaskInterface pTask)
		{
			// TODO: Implement with FinishedCountList/FinishedTaskList based on account/role limits
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckAccountRMB(TaskInterface* pTask) const
		// 检查账号现金（RMB）范围 // English: Check account total cash (RMB) range
		public uint CheckAccountRMB(TaskInterface pTask)
		{
			if (m_FixedData.m_ulPremRMBMin != 0u && m_FixedData.m_ulPremRMBMax != 0u)
			{
				uint total = pTask.GetAccountTotalCash();
				if (total < m_FixedData.m_ulPremRMBMin || total > m_FixedData.m_ulPremRMBMax)
				{
					return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_RMB_NOT_ENOUGH;
				}
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckCharTime(TaskInterface* pTask) const
		// 检查角色创建/登录时间窗口 // English: Check character time window
		public uint CheckCharTime(TaskInterface pTask)
		{
			// TODO: Implement using m_FixedData.m_bCharTime, m_iCharStartTime/m_iCharEndTime, m_tmCharEndTime and pTask time APIs
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckLevel(TaskInterface* pTask) const
		// 等级上下限 // English: Level min/max
		public uint CheckLevel(TaskInterface pTask)
		{
			uint level = m_FixedData.m_bPremCheckMaxHistoryLevel > 0 ? pTask.GetMaxHistoryLevel() : pTask.GetPlayerLevel();
			if (m_FixedData.m_ulPremise_Lev_Min != 0u && level < m_FixedData.m_ulPremise_Lev_Min)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_LEVEL;
			if (m_FixedData.m_ulPremise_Lev_Max != 0u && level > m_FixedData.m_ulPremise_Lev_Max)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_ABOVE_LEVEL;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckReincarnation(TaskInterface* pTask) const
		// 转生次数上下限 // English: Reincarnation count min/max
		public uint CheckReincarnation(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremCheckReincarnation)
			{
				uint count = pTask.GetReincarnationCount();
				if (count < m_FixedData.m_ulPremReincarnationMin) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_REINCARNATION;
				if (count > m_FixedData.m_ulPremReincarnationMax) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_ABOVE_REINCARNATION;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckRealmLevel(TaskInterface* pTask) const
		// 修真境界等级 // English: Realm level
		public uint CheckRealmLevel(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremCheckRealmLevel)
			{
				uint level = GetRealmLevel(pTask);
				if (level < m_FixedData.m_ulPremRealmLevelMin) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_REALMLEVEL;
				if (level > m_FixedData.m_ulPremRealmLevelMax) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_ABOVE_REALMLEVEL;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckRealmExpFull(TaskInterface* pTask) const
		// 修真经验是否已满 // English: Realm EXP full check
		public uint CheckRealmExpFull(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremCheckRealmExpFull)
			{
				if (!pTask.IsRealmExpFull()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_REALM_EXP_FULL;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckRepu(TaskInterface* pTask) const
		// 声望上下限 // English: Reputation min/max
		public uint CheckRepu(TaskInterface pTask)
		{
			if (m_FixedData.m_lPremise_Reputation != 0 && pTask.GetReputation() < (uint)m_FixedData.m_lPremise_Reputation)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_REPU;
			if (m_FixedData.m_lPremise_RepuMax != 0 && pTask.GetReputation() > (uint)m_FixedData.m_lPremise_RepuMax)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_REPU;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckDeposit(TaskInterface* pTask) const
		// 寄存金（金币） // English: Deposit (gold)
		public uint CheckDeposit(TaskInterface pTask)
		{
			if (m_FixedData.m_ulPremise_Deposit != 0u && pTask.GetGoldNum() < m_FixedData.m_ulPremise_Deposit)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_NO_DEPOSIT;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckItems(TaskInterface* pTask) const
		// 前置道具检查（任一/全部） // English: Prerequisite item check (any/ALL)
		public uint CheckItems(TaskInterface pTask)
		{
			// TODO: Implement using m_FixedData.m_ulPremItems, m_bPremItemsAnyOne, m_PremItems[]
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckFaction(TaskInterface* pTask) const
		// 家族/帮派及职位 // English: Faction/clan and role
		public uint CheckFaction(TaskInterface pTask)
		{
			int role = pTask.GetFactionRole();
			bool roleOk = role <= m_FixedData.m_iPremise_FactionRole;
			if (m_FixedData.m_ulPremise_Faction != 0u && !(pTask.IsInFaction(m_FixedData.m_ulPremise_Faction) && roleOk))
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CLAN;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckGender(TaskInterface* pTask) const
		// 性别 // English: Gender
		public uint CheckGender(TaskInterface pTask)
		{
			bool isMale = pTask.IsMale();
			if (m_FixedData.m_ulGender == TaskTemplConstants.TASK_GENDER_MALE && !isMale) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_GENDER;
			if (m_FixedData.m_ulGender == TaskTemplConstants.TASK_GENDER_FEMALE && isMale) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_GENDER;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckOccupation(TaskInterface* pTask) const
		// 职业 // English: Occupation
		public uint CheckOccupation(TaskInterface pTask)
		{
			if (m_FixedData.m_ulOccupations == 0u) return 0u;
			uint current = pTask.GetPlayerOccupation();
			for (uint i = 0; i < m_FixedData.m_ulOccupations; i++)
			{
				if (m_FixedData.m_Occupations[i] == current)
					return 0u;
			}
			return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_NOT_IN_OCCU;
		}
		
		// inline unsigned long ATaskTempl::CheckPeriod(TaskInterface* pTask) const
		// 历练阶段（区间） // English: Period check (interval)
		public uint CheckPeriod(TaskInterface pTask)
		{
			uint cur = pTask.GetCurPeriod();
			if (cur < m_FixedData.m_ulPremise_Period) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_PERIOD;
			if (m_FixedData.m_ulPremise_Period < 20u) return 0u;
			if (m_FixedData.m_ulPremise_Period < 30u) return cur < 30u ? 0u : (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_PERIOD;
			if (m_FixedData.m_ulPremise_Period < 40u) return cur < 40u ? 0u : (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_PERIOD;
			return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WRONG_PERIOD;
		}
		
		// inline unsigned long ATaskTempl::CheckGM(TaskInterface* pTask) const
		// GM 限制 // English: GM check
		public uint CheckGM(TaskInterface pTask)
		{
			return m_FixedData.m_bGM ? (pTask.IsGM() ? 0u : (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_GM) : 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckShieldUser(TaskInterface* pTask) const
		// 屏蔽用户 // English: Shielded user
		public uint CheckShieldUser(TaskInterface pTask)
		{
			return m_FixedData.m_bShieldUser ? (pTask.IsShieldUser() ? 0u : (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_SHIELD_USER) : 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckPreTask(TaskInterface* pTask) const
		// 前置任务 // English: Previous tasks
		public uint CheckPreTask(TaskInterface pTask)
		{
			// TODO: Implement using FinishedTaskList and m_FixedData.m_ulPremise_Tasks[*]
			return 0u;
		}
		
		// (No inline in provided snippet) 互斥任务 // English: Mutex task
		public uint CheckMutexTask(TaskInterface pTask, uint ulCurTime)
		{
			// TODO: Implement when mutex task data is available
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckInZone(TaskInterface* pTask) const
		// 区域检查 // English: In-zone check
		public uint CheckInZone(TaskInterface pTask)
		{
			// TODO: Implement worldId + region bounding box check using m_FixedData.m_ulDelvWorld and m_pDelvRegion
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckTeamTask(TaskInterface* pTask) const
		// 组队接任务要求 // English: Team-task requirements
		public uint CheckTeamTask(TaskInterface pTask)
		{
			// TODO: Implement full team captain and member checks per HasAllTeamMemsWanted
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckSpouse(TaskInterface* pTask) const
		// 配偶要求 // English: Spouse requirement
		public uint CheckSpouse(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremise_Spouse && !pTask.IsMarried())
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_INDETERMINATE;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckWeddingOwner(TaskInterface* pTask) const
		// 婚礼举办者检查 // English: Wedding owner check
		public uint CheckWeddingOwner(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremiseWeddingOwner)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_MARRIAGE;
				if (!pTask.IsWeddingOwner()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_WEDDING_OWNER;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckMarriage(TaskInterface* pTask) const
		// 结婚任务条件 // English: Marriage task requirements
		public uint CheckMarriage(TaskInterface pTask)
		{
			// TODO: Implement two-person team with opposite gender per original logic if APIs exist
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckLivingSkill(TaskInterface* pTask) const
		// 生活技能等级 // English: Living skill level
		public uint CheckLivingSkill(TaskInterface pTask)
		{
			// TODO: Loop m_FixedData.m_lSkillLev[MAX_LIVING_SKILLS] with skill ids and pTask.HasLivingSkill/GetLivingSkillLevel
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckIvtrEmptySlot(TaskInterface* pTask) const
		// 背包空位检查 // English: Inventory empty slot check
		public uint CheckIvtrEmptySlot(TaskInterface pTask)
		{
			if (!m_FixedData.m_bCompareItemAndInventory) return 0u;
			if (pTask.GetInvEmptySlot() < m_FixedData.m_ulInventorySlotNum)
			{
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_NOT_IVTRSLOTNUM;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckFactionContrib(TaskInterface* pTask) const
		// 家族贡献 // English: Faction contribution
		public uint CheckFactionContrib(TaskInterface pTask)
		{
			int contrib = pTask.GetFactionContrib();
			if (m_FixedData.m_iPremiseFactionContrib != 0 && contrib < m_FixedData.m_iPremiseFactionContrib)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_BELOW_FACTION_CONTRIB;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckRecordTasksNum(TaskInterface* pTask) const
		// 完成记录任务数量 // English: Finished-record tasks count
		public uint CheckRecordTasksNum(TaskInterface pTask)
		{
			// TODO: Implement using FinishedTaskList scanning for recorded tasks count
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckTransform(TaskInterface* pTask) const
		// 变身形态 // English: Transform mask
		public uint CheckTransform(TaskInterface pTask)
		{
			byte playerShapeType = pTask.GetShapeMask();
			// 0xFF 不限制 // English: 0xFF = no restriction
			if (m_FixedData.m_ucPremiseTransformedForm == 0xFF) return 0u;
			// 职业变身 // English: Occupation transform
			if (m_FixedData.m_ucPremiseTransformedForm == 0x80)
			{
				if ((playerShapeType >> 6) != 2) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_TRANSFORM_MASK;
				return 0u;
			}
			// 指定形态 // English: Specific form
			if (m_FixedData.m_ucPremiseTransformedForm != playerShapeType)
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_TRANSFORM_MASK;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckForce(TaskInterface* pTask) const
		// 势力检查 // English: Force check
		public uint CheckForce(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremCheckForce)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (m_FixedData.m_iPremForce == -1)
				{
					if (pTask.GetForce() == 0) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_FORCE;
				}
				else if (pTask.GetForce() != m_FixedData.m_iPremForce)
				{
					return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_FORCE;
				}
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckForceReputation(TaskInterface* pTask) const
		// 势力声望 // English: Force reputation
		public uint CheckForceReputation(TaskInterface pTask)
		{
			if (m_FixedData.m_iPremForceReputation != 0)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (pTask.GetForceReputation() < m_FixedData.m_iPremForceReputation)
					return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_FORCE_REPUTATION;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckForceContribution(TaskInterface* pTask) const
		// 势力贡献 // English: Force contribution
		public uint CheckForceContribution(TaskInterface pTask)
		{
			if (m_FixedData.m_iPremForceContribution != 0)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (pTask.GetForceContribution() < m_FixedData.m_iPremForceContribution)
					return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_FORCE_REPUTATION;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckExp(TaskInterface* pTask) const
		// 势力经验 // English: Force EXP
		public uint CheckExp(TaskInterface pTask)
		{
			if (m_FixedData.m_iPremForceExp != 0)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (pTask.GetExp() < m_FixedData.m_iPremForceExp) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_EXP;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckSP(TaskInterface* pTask) const
		// 势力SP // English: Force SP
		public uint CheckSP(TaskInterface pTask)
		{
			if (m_FixedData.m_iPremForceSP != 0)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (pTask.GetSP() < m_FixedData.m_iPremForceSP) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_SP;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckForceActivityLevel(TaskInterface* pTask) const
		// 势力活跃等级 // English: Force activity level
		public uint CheckForceActivityLevel(TaskInterface pTask)
		{
			if (m_FixedData.m_iPremForceActivityLevel != -1)
			{
				if (pTask.IsAtCrossServer()) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_CROSSSERVER_NO_FORCE;
				if (m_FixedData.m_iPremForceActivityLevel != pTask.GetForceActivityLevel())
					return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_FORCE_AL;
			}
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckKing(TaskInterface* pTask) const
		// 王检查 // English: King check
		public uint CheckKing(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremIsKing && !pTask.IsKing())
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_KING;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckNotInTeam(TaskInterface* pTask) const
		// 不在队伍 // English: Not in team
		public uint CheckNotInTeam(TaskInterface pTask)
		{
			if (m_FixedData.m_bPremNotInTeam && pTask.IsInTeam())
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_IN_TEAM;
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckTitle(TaskInterface* pTask) const
		// 称号检查 // English: Title check
		public uint CheckTitle(TaskInterface pTask)
		{
			// TODO: Implement using m_FixedData.m_iPremTitleNumTotal/m_iPremTitleNumRequired and award title arrays
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckHistoryStage(TaskInterface* pTask) const
		// 历史阶段 // English: History stage
		public uint CheckHistoryStage(TaskInterface pTask)
		{
			// TODO: Implement using pTask.GetCurHistoryStageIndex() and m_FixedData.m_iPremHistoryStageIndex[2]
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckCardCollection(TaskInterface* pTask) const
		// 将星卡收集数量 // English: General card collection count
		public uint CheckCardCollection(TaskInterface pTask)
		{
			// TODO: Implement using pTask.GetObtainedGeneralCardCount() and m_FixedData.m_ulPremGeneralCardCount
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckCardRankCount(TaskInterface* pTask) const
		// 指定品级将星卡数量 // English: Specific rank general card count
		public uint CheckCardRankCount(TaskInterface pTask)
		{
			// TODO: Implement using pTask.GetObtainedGeneralCardCountByRank(rank) and m_FixedData fields
			return 0u;
		}
		
		// inline unsigned long ATaskTempl::CheckInTransformShape(TaskInterface* pTask) const
		// 变身中禁止导航 // English: No navigate while in shaped
		public uint CheckInTransformShape(TaskInterface pTask)
		{
			if (m_FixedData.m_enumMethod == (uint)TaskCompletionMethod.enumTMSimpleClientTaskForceNavi && pTask.GetShapeMask() != 0)
			{
				return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_NO_NAVIGATE_INSHPAED;
			}
			return 0u;
		}
		
		// 特殊活动奖励检查 // English: Special award activity check
		public uint CheckSpecialAward(TaskInterface pTask)
		{
			// 非“特殊活动奖励”类型则直接通过 // English: Pass if not a special-award dynamic task
			if (m_FixedData.m_DynTaskType != (byte)DynTaskType.enumDTTSpecialAward) return 0u;
			// 未配置特殊奖励标识则失败 // English: Fail if special award id not configured
			if (m_FixedData.m_ulSpecialAward == 0u) return (uint)TaskInterfaceConstants.TASK_PREREQU_FAIL_SPECIAL_AWARD;
			
			// TODO: 获取玩家特殊奖励信息并校验 // English: Fetch player's special-award info and validate against required id
			// 受限于当前 TaskInterface 未暴露获取接口，暂时视为通过 // English: Interface lacks API; treat as pass for now
			return 0u;
		}
    }
}