using System;
using System.Collections.Generic;
using System.Text;
using KKSG;
using UnityEngine;
using XMainClient.UI;
using XMainClient.UI.UICommon;
using XUtliPoolLib;

namespace XMainClient
{
	internal class XTaskDocument : XDocComponent
	{
		public override uint ID
		{
			get
			{
				return XTaskDocument.uuID;
			}
		}

		public XTaskRecord TaskRecord
		{
			get
			{
				return this.m_TaskRecord;
			}
		}

		public uint CurrentSelect { get; set; }

		public Dictionary<uint, uint> TaskMonstersKilled
		{
			get
			{
				return this.m_TaskMonstersKilled;
			}
		}

		public int NaviTarget
		{
			get
			{
				return this.m_NaviTarget;
			}
		}

		public uint NaviScene
		{
			get
			{
				return this.m_NaviScene;
			}
		}

		public uint NaviTask
		{
			get
			{
				return this.m_NaviTask;
			}
		}

		public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("TaskDocument");

		private string FX_TASK_BEGIN = "Effects/FX_Particle/Scene/Lzg_scene/rwts_01";

		private string FX_TASK_INPROCESS = "Effects/FX_Particle/Scene/Lzg_scene/rwts_02";

		private string FX_TASK_END = "Effects/FX_Particle/Scene/Lzg_scene/rwts_03";

		private List<XFx> m_Fxes = new List<XFx>();

		public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();

		private static TaskTableNew _TaskTable = new TaskTableNew();

		private Dictionary<uint, List<uint>> m_AppearNpcs = new Dictionary<uint, List<uint>>();

		private Dictionary<uint, List<uint>> m_DisappearNpcs = new Dictionary<uint, List<uint>>();

		private XTaskRecord m_TaskRecord = new XTaskRecord();

		private static uint[] TypeSortValue = new uint[20];

		private string m_TempTarget;

		private uint[] m_TempNpcData;

		private Dictionary<uint, XTaskInfo> m_TempNpcTopTask = new Dictionary<uint, XTaskInfo>();

		private List<uint> m_TempTasks = new List<uint>();

		private Dictionary<uint, uint> m_TaskMonstersKilled = new Dictionary<uint, uint>();

		private int m_NaviTarget;

		private uint m_NaviScene;

		private uint m_NaviTask;

		private static uint _HighestPriorityTask = 0u;

		public static void Execute(OnLoadedCallback callback = null)
		{
			XTaskDocument.AsyncLoader.AddTask("Table/TaskListNew", XTaskDocument._TaskTable, false);
			XTaskDocument.AsyncLoader.Execute(callback);
		}

		public override void OnAttachToHost(XObject host)
		{
			base.OnAttachToHost(host);
			string[] andSeparateValue = XSingleton<XGlobalConfig>.singleton.GetAndSeparateValue("TaskTypeSort", XGlobalConfig.ListSeparator);
			uint num = 0u;
			while ((ulong)num < (ulong)((long)andSeparateValue.Length))
			{
				XTaskDocument.TypeSortValue[(int)uint.Parse(andSeparateValue[(int)num])] = num;
				num += 1u;
			}
			this.m_AppearNpcs.Clear();
			this.m_DisappearNpcs.Clear();
			XNpcInfo npcInfo = XSingleton<XEntityMgr>.singleton.NpcInfo;
			for (int i = 0; i < npcInfo.Table.Length; i++)
			{
				XNpcInfo.RowData rowData = npcInfo.Table[i];
				bool flag = rowData.RequiredTaskID > 0u;
				if (flag)
				{
					List<uint> list;
					bool flag2 = !this.m_AppearNpcs.TryGetValue(rowData.RequiredTaskID, out list);
					if (flag2)
					{
						list = new List<uint>();
						this.m_AppearNpcs.Add(rowData.RequiredTaskID, list);
					}
					list.Add(rowData.ID);
				}
				bool flag3 = rowData.DisappearTask > 0u;
				if (flag3)
				{
					List<uint> list2;
					bool flag4 = !this.m_DisappearNpcs.TryGetValue(rowData.DisappearTask, out list2);
					if (flag4)
					{
						list2 = new List<uint>();
						this.m_DisappearNpcs.Add(rowData.DisappearTask, list2);
					}
					list2.Add(rowData.ID);
				}
			}
		}

		protected override void EventSubscribe()
		{
			base.EventSubscribe();
			base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this._OnEntityDie));
			base.RegisterEvent(XEventDefine.XEvent_TaskStateChange, new XComponent.XEventHandler(this._OnTaskStateChanged));
			base.RegisterEvent(XEventDefine.XEvent_NpcFavorFxChange, new XComponent.XEventHandler(this._NotifyXTaskDocFx));
		}

		public static TaskTableNew.RowData GetTaskData(uint taskID)
		{
			return XTaskDocument._TaskTable.GetByTaskID(taskID);
		}

		public void ResetNavi()
		{
			this.m_NaviScene = 0u;
			this.m_NaviTarget = 0;
		}

		public XTaskInfo GetTaskInfo(uint taskID)
		{
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				bool flag = this.TaskRecord.Tasks[i].ID == taskID;
				if (flag)
				{
					return this.TaskRecord.Tasks[i];
				}
			}
			return null;
		}

		public TaskStatus GetTaskStatue()
		{
			TaskStatus taskStatus = TaskStatus.TaskStatus_Over;
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				TaskTableNew.RowData taskData = XTaskDocument.GetTaskData(this.TaskRecord.Tasks[i].ID);
				bool flag = taskData == null || (ulong)this.TaskRecord.Tasks[i].TableData.TaskType != (ulong)((long)XFastEnumIntEqualityComparer<XTaskType>.ToInt(XTaskType.TT_GuildDailyTask));
				if (!flag)
				{
					taskStatus = this.TaskRecord.Tasks[i].Status;
					bool flag2 = taskStatus == TaskStatus.TaskStatus_Taked || taskStatus == TaskStatus.TaskStatus_Finish;
					if (flag2)
					{
						break;
					}
				}
			}
			return taskStatus;
		}

		private bool _GetNpcData(TaskTableNew.RowData data, XTaskInfo info)
		{
			bool flag = data == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = info == null;
				if (flag2)
				{
					this.m_TempNpcData = data.BeginTaskNPCID;
				}
				else
				{
					TaskStatus status = info.Status;
					if (status - TaskStatus.TaskStatus_Taked > 1)
					{
						this.m_TempNpcData = data.BeginTaskNPCID;
					}
					else
					{
						this.m_TempNpcData = data.EndTaskNPCID;
					}
				}
				result = true;
			}
			return result;
		}

		private bool _GetTempData(TaskTableNew.RowData data, XTaskInfo info)
		{
			bool flag = data == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = info == null;
				if (flag2)
				{
					this.m_TempNpcData = data.BeginTaskNPCID;
					this.m_TempTarget = data.BeginDesc;
				}
				else
				{
					TaskStatus status = info.Status;
					if (status != TaskStatus.TaskStatus_Taked)
					{
						if (status != TaskStatus.TaskStatus_Finish)
						{
							this.m_TempNpcData = data.BeginTaskNPCID;
							this.m_TempTarget = data.BeginDesc;
						}
						else
						{
							this.m_TempTarget = data.EndDesc;
							this.m_TempNpcData = data.EndTaskNPCID;
						}
					}
					else
					{
						this.m_TempTarget = data.InprocessDesc;
						this.m_TempNpcData = null;
					}
				}
				result = true;
			}
			return result;
		}

		public string ParseTaskDesc(TaskTableNew.RowData data, XTaskInfo info, bool bCRLF)
		{
			bool flag = !this._GetTempData(data, info);
			string result;
			if (flag)
			{
				result = string.Empty;
			}
			else
			{
				StringBuilder stringBuilder = new StringBuilder(this.m_TempTarget);
				if (bCRLF)
				{
					stringBuilder.Replace("{n}", "\n");
				}
				else
				{
					stringBuilder.Replace("{n}", "  ");
				}
				uint key = XSingleton<UiUtility>.singleton.ChooseProfData<uint>(this.m_TempNpcData, 0u);
				XNpcInfo.RowData byNPCID = XSingleton<XEntityMgr>.singleton.NpcInfo.GetByNPCID(key);
				bool flag2 = byNPCID != null;
				if (flag2)
				{
					stringBuilder = stringBuilder.Replace("{npc}", byNPCID.Name);
				}
				bool flag3 = info == null;
				if (flag3)
				{
					uint num = XSingleton<UiUtility>.singleton.ChooseProfData<uint>(ref data.PassScene, 0u, 0);
					SceneTable.RowData rowData = null;
					bool flag4 = num > 0u;
					if (flag4)
					{
						rowData = XSingleton<XSceneMgr>.singleton.GetSceneData(num);
					}
					bool flag5 = rowData != null;
					if (flag5)
					{
						stringBuilder.Replace("{scene}", rowData.Comment);
					}
				}
				else
				{
					for (int i = 0; i < info.Conds.Count; i++)
					{
						TaskConditionInfo taskConditionInfo = info.Conds[i];
						switch (taskConditionInfo.type)
						{
						case TaskConnType.TaskConn_ItemID:
						{
							ItemList.RowData itemConf = XBagDocument.GetItemConf((int)taskConditionInfo.id);
							bool flag6 = itemConf != null;
							if (flag6)
							{
								stringBuilder.Replace("{item}", XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemName, 0u));
							}
							break;
						}
						case TaskConnType.TaskConn_StageID:
						{
							SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(taskConditionInfo.id);
							bool flag7 = sceneData != null;
							if (flag7)
							{
								stringBuilder.Replace("{scene}", sceneData.Comment);
							}
							break;
						}
						case TaskConnType.TaskConn_MonsterID:
						{
							XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(taskConditionInfo.id);
							bool flag8 = byID != null;
							if (flag8)
							{
								stringBuilder.Replace("{monster}", byID.Name);
							}
							break;
						}
						}
						this._FormatCount(stringBuilder, taskConditionInfo);
					}
				}
				result = stringBuilder.ToString();
			}
			return result;
		}

		private void _FormatCount(StringBuilder sb, TaskConditionInfo cond)
		{
			bool flag = cond != null;
			if (flag)
			{
				string newValue = XSingleton<XCommon>.singleton.StringCombine(cond.step.ToString(), "/", cond.max_step.ToString());
				switch (cond.type)
				{
				case TaskConnType.TaskConn_ItemID:
					sb.Replace("{itemcount}", newValue);
					break;
				case TaskConnType.TaskConn_StageID:
					sb.Replace("{scenecount}", newValue);
					break;
				case TaskConnType.TaskConn_MonsterID:
					sb.Replace("{monstercount}", newValue);
					break;
				}
			}
		}

		public void OnTaskStatusUpdate(TaskInfo info)
		{
			bool flag = false;
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				bool flag2 = this.TaskRecord.Tasks[i].ID == info.id;
				if (flag2)
				{
					flag = true;
					this.TaskRecord.Tasks[i].Init(info);
					bool flag3 = info.status == TaskStatus.TaskStatus_Over;
					if (flag3)
					{
						this.TaskRecord.Tasks.RemoveAt(i);
						this.TaskRecord.FinishTask(info.id);
						bool flag4 = info.id == XTaskDocument._HighestPriorityTask;
						if (flag4)
						{
							this._ResetHighestPriorityTask(false);
						}
					}
					break;
				}
			}
			bool flag5 = !flag;
			if (flag5)
			{
				bool flag6 = info.status == TaskStatus.TaskStatus_Over;
				if (flag6)
				{
					this.TaskRecord.FinishTask(info.id);
				}
				else
				{
					this.TaskRecord.AddTask(info);
				}
			}
			this._RefreshUI();
			this.SetupNpcHeadFx();
			XTaskStatusChangeArgs @event = XEventPool<XTaskStatusChangeArgs>.GetEvent();
			@event.id = info.id;
			@event.status = info.status;
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			XSingleton<XEventMgr>.singleton.FireEvent(@event);
		}

		private void _RefreshUI()
		{
			bool flag = DlgBase<XTaskView, XTaskBehaviour>.singleton.IsVisible();
			if (flag)
			{
				DlgBase<XTaskView, XTaskBehaviour>.singleton.RefreshPage();
			}
			bool flag2 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();
			if (flag2)
			{
				bool flag3 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.TaskHandler.IsVisible();
				if (flag3)
				{
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.TaskHandler.RefreshData();
				}
			}
		}

		public void SetHighestPriorityTask(uint taskID)
		{
			XTaskDocument._HighestPriorityTask = taskID;
			this._OnHighestPriorityTaskChanged(true);
		}

		private void _ResetHighestPriorityTask(bool bUpdateUI)
		{
			bool flag = XTaskDocument._HighestPriorityTask > 0u;
			if (flag)
			{
				XTaskDocument._HighestPriorityTask = 0u;
				this._OnHighestPriorityTaskChanged(bUpdateUI);
			}
		}

		private void _OnHighestPriorityTaskChanged(bool bUpdateUI)
		{
			this.TaskRecord.Tasks.Sort(new Comparison<XTaskInfo>(XTaskDocument.SortInTaskList));
			if (bUpdateUI)
			{
				this._RefreshUI();
				this.SetupNpcHeadFx();
			}
		}

		public void DoTask(uint id)
		{
			XTaskInfo taskInfo = this.GetTaskInfo(id);
			bool flag = taskInfo == null;
			if (!flag)
			{
				TaskTableNew.RowData tableData = taskInfo.TableData;
				bool flag2 = !this._GetTempData(tableData, taskInfo);
				if (!flag2)
				{
					uint num = XSingleton<UiUtility>.singleton.ChooseProfData<uint>(this.m_TempNpcData, 0u);
					uint sceneID = XTaskDocument.GetSceneID(ref tableData.TaskScene);
					bool flag3 = sceneID != 0u && taskInfo.Status == TaskStatus.TaskStatus_Taked;
					if (flag3)
					{
						XExpeditionDocument specificDocument = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
						int expIDBySceneID = specificDocument.GetExpIDBySceneID(sceneID);
						bool flag4 = expIDBySceneID != 0;
						if (flag4)
						{
							XTeamDocument specificDocument2 = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
							specificDocument2.SetAndMatch(expIDBySceneID);
						}
						else
						{
							PtcC2G_EnterSceneReq ptcC2G_EnterSceneReq = new PtcC2G_EnterSceneReq();
							ptcC2G_EnterSceneReq.Data.sceneID = sceneID;
							XSingleton<XClientNetwork>.singleton.Send(ptcC2G_EnterSceneReq);
						}
					}
					else
					{
						bool flag5 = num == 0u && tableData.TaskType == 4u;
						if (flag5)
						{
							DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.SetVisibleWithAnimation(true, null);
						}
						else
						{
							bool flag6 = num == 0u && tableData.TaskType == 7u;
							if (flag6)
							{
								DlgBase<XGuildWeeklyBountyView, XGuildWeeklyBountyBehavior>.singleton.SetVisibleWithAnimation(true, null);
							}
							else
							{
								bool flag7 = num == 0u && tableData.TaskID == XCampDuelDocument.Doc.TaskID;
								if (flag7)
								{
									DlgBase<XOperatingActivityView, XOperatingActivityBehaviour>.singleton.Show(XSysDefine.XSys_CampDuel, false);
								}
								else
								{
									uint sceneID2 = XTaskDocument.GetSceneID(ref tableData.PassScene);
									this.NaviToNpc(num, sceneID2);
									this.m_NaviTask = id;
								}
							}
						}
					}
				}
			}
		}

		public void NaviToNpc(uint npcid, uint sceneid)
		{
			bool flag = npcid == 0u;
			if (flag)
			{
				DlgBase<DungeonSelect, DungeonSelectBehaviour>.singleton.IsTaskMode = true;
				this._NavigateToBattle();
				this.m_NaviTarget = 1;
				this.m_NaviScene = sceneid;
			}
			else
			{
				XSingleton<XInput>.singleton.LastNpc = XSingleton<XEntityMgr>.singleton.GetNpc(npcid);
			}
		}

		private void _NavigateToBattle()
		{
			bool flag = XSingleton<XEntityMgr>.singleton.Player == null || XSingleton<XEntityMgr>.singleton.Player.Deprecated;
			if (!flag)
			{
				XSingleton<XInput>.singleton.LastNpc = null;
				Vector3 normalized = (XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position - XSingleton<XScene>.singleton.BattleTargetPoint).normalized;
				Vector3 dest = XSingleton<XScene>.singleton.BattleTargetPoint + normalized * 5.8f;
				XNavigationEventArgs @event = XEventPool<XNavigationEventArgs>.GetEvent();
				@event.Firer = XSingleton<XEntityMgr>.singleton.Player;
				@event.Dest = dest;
				XSingleton<XEventMgr>.singleton.FireEvent(@event);
			}
		}

		public List<uint> GetSceneTaskState(uint sceneid)
		{
			this.m_TempTasks.Clear();
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i];
				bool flag = xtaskInfo == null || xtaskInfo.TableData == null;
				if (!flag)
				{
					bool flag2 = sceneid == XTaskDocument.GetSceneID(ref xtaskInfo.TableData.PassScene);
					if (flag2)
					{
						this.m_TempTasks.Add(xtaskInfo.ID);
					}
					else
					{
						bool flag3 = sceneid == XTaskDocument.GetSceneID(ref xtaskInfo.TableData.TaskScene);
						if (flag3)
						{
							this.m_TempTasks.Add(xtaskInfo.ID);
						}
					}
				}
			}
			return this.m_TempTasks;
		}

		public NpcTaskState GetNpcTaskState(uint npcid, ref XTaskInfo task)
		{
			task = null;
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i];
				TaskTableNew.RowData tableData = xtaskInfo.TableData;
				bool flag = !this._GetNpcData(tableData, xtaskInfo);
				if (!flag)
				{
					bool flag2 = tableData != null && XSingleton<UiUtility>.singleton.ChooseProfData<uint>(this.m_TempNpcData, 0u) == npcid;
					if (flag2)
					{
						bool flag3 = xtaskInfo.ID == this.m_NaviTask;
						if (flag3)
						{
							task = xtaskInfo;
							return xtaskInfo.NpcState;
						}
						bool flag4 = XTaskDocument.SortInDialog(xtaskInfo, task) < 0;
						if (flag4)
						{
							task = xtaskInfo;
						}
					}
				}
			}
			bool flag5 = task != null;
			if (flag5)
			{
				return task.NpcState;
			}
			return NpcTaskState.Normal;
		}

		private XTaskInfo FindTaskInfo(uint npcId)
		{
			XTaskInfo xtaskInfo = null;
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				XTaskInfo xtaskInfo2 = this.TaskRecord.Tasks[i];
				bool flag = !this._GetNpcData(xtaskInfo2.TableData, xtaskInfo2);
				if (!flag)
				{
					uint num = XSingleton<UiUtility>.singleton.ChooseProfData<uint>(this.m_TempNpcData, 0u);
					bool flag2 = npcId != num;
					if (!flag2)
					{
						bool flag3 = xtaskInfo == null;
						if (flag3)
						{
							xtaskInfo = xtaskInfo2;
						}
						else
						{
							bool flag4 = XTaskDocument.SortInDialog(xtaskInfo2, xtaskInfo) < 0;
							if (flag4)
							{
								xtaskInfo = xtaskInfo2;
							}
						}
					}
				}
			}
			return xtaskInfo;
		}

		private bool _NotifyXTaskDocFx(XEventArgs e)
		{
			this.SetupNpcHeadFx();
			return true;
		}

		protected void SetupNpcHeadFx()
		{
			List<uint> npcs = XSingleton<XEntityMgr>.singleton.GetNpcs(XSingleton<XScene>.singleton.SceneID);
			this.m_TempNpcTopTask.Clear();
			this.ClearFx();
			bool flag = npcs == null;
			if (!flag)
			{
				for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
				{
					XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i];
					bool flag2 = !this._GetNpcData(xtaskInfo.TableData, xtaskInfo);
					if (!flag2)
					{
						uint key = XSingleton<UiUtility>.singleton.ChooseProfData<uint>(this.m_TempNpcData, 0u);
						XTaskInfo task;
						bool flag3 = this.m_TempNpcTopTask.TryGetValue(key, out task);
						if (flag3)
						{
							bool flag4 = XTaskDocument.SortInDialog(xtaskInfo, task) < 0;
							if (flag4)
							{
								this.m_TempNpcTopTask[key] = xtaskInfo;
							}
						}
						else
						{
							this.m_TempNpcTopTask[key] = xtaskInfo;
						}
					}
				}
				for (int j = 0; j < npcs.Count; j++)
				{
					XTaskInfo xtaskInfo2;
					bool flag5 = !this.m_TempNpcTopTask.TryGetValue(npcs[j], out xtaskInfo2);
					if (!flag5)
					{
						XNpc npc = XSingleton<XEntityMgr>.singleton.GetNpc(npcs[j]);
						bool flag6 = npc == null;
						if (!flag6)
						{
							NpcTaskState npcState = xtaskInfo2.NpcState;
							XFx xfx = null;
							bool flag7 = npcState == NpcTaskState.TaskBegin;
							if (flag7)
							{
								xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_BEGIN, null, true);
							}
							else
							{
								bool flag8 = npcState == NpcTaskState.TaskInprocess;
								if (flag8)
								{
									bool flag9 = false;
									bool flag10 = XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_NPCFavor);
									if (flag10)
									{
										XNPCFavorDocument specificDocument = XDocuments.GetSpecificDocument<XNPCFavorDocument>(XNPCFavorDocument.uuID);
										flag9 = specificDocument.IsShowFavorFx(npcs[j]);
									}
									bool flag11 = !flag9;
									if (flag11)
									{
										xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_INPROCESS, null, true);
									}
								}
								else
								{
									bool flag12 = npcState == NpcTaskState.TaskEnd;
									if (flag12)
									{
										xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_END, null, true);
									}
								}
							}
							bool flag13 = xfx != null;
							if (flag13)
							{
								this.m_Fxes.Add(xfx);
								xfx.Play(npc.EngineObject, new Vector3(-0.05f, npc.Height + 0.7f, 0f), Vector3.one, 1f, true, false, "", 0f);
							}
						}
					}
				}
				this.m_TempNpcTopTask.Clear();
			}
		}

		public void CreateFx(XNpc npc, uint npcId)
		{
			XTaskInfo xtaskInfo = this.FindTaskInfo(npcId);
			bool flag = xtaskInfo != null;
			if (flag)
			{
				NpcTaskState npcState = xtaskInfo.NpcState;
				XFx xfx = null;
				bool flag2 = npcState == NpcTaskState.TaskBegin;
				if (flag2)
				{
					xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_BEGIN, null, true);
				}
				else
				{
					bool flag3 = npcState == NpcTaskState.TaskInprocess;
					if (flag3)
					{
						xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_INPROCESS, null, true);
					}
					else
					{
						bool flag4 = npcState == NpcTaskState.TaskEnd;
						if (flag4)
						{
							xfx = XSingleton<XFxMgr>.singleton.CreateFx(this.FX_TASK_END, null, true);
						}
					}
				}
				bool flag5 = xfx != null;
				if (flag5)
				{
					this.m_Fxes.Add(xfx);
					xfx.Play(npc.EngineObject, new Vector3(-0.05f, npc.Height + 0.7f, 0f), Vector3.one, 1f, true, false, "", 0f);
				}
			}
		}

		protected void ClearFx()
		{
			for (int i = 0; i < this.m_Fxes.Count; i++)
			{
				XSingleton<XFxMgr>.singleton.DestroyFx(this.m_Fxes[i], true);
			}
			this.m_Fxes.Clear();
		}

		private void _ResetTaskMonsters()
		{
			this.m_TaskMonstersKilled.Clear();
		}

		private void _InitTaskMonsters()
		{
			for (int i = 0; i < this.TaskRecord.Tasks.Count; i++)
			{
				XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i];
				for (int j = 0; j < xtaskInfo.Conds.Count; j++)
				{
					TaskConditionInfo taskConditionInfo = xtaskInfo.Conds[j];
					bool flag = taskConditionInfo.type == TaskConnType.TaskConn_MonsterID && !this.m_TaskMonstersKilled.ContainsKey(taskConditionInfo.id);
					if (flag)
					{
						this.m_TaskMonstersKilled.Add(taskConditionInfo.id, 0u);
					}
				}
			}
		}

		private bool _OnEntityDie(XEventArgs arg)
		{
			bool syncMode = XSingleton<XGame>.singleton.SyncMode;
			bool result;
			if (syncMode)
			{
				result = true;
			}
			else
			{
				XRealDeadEventArgs xrealDeadEventArgs = arg as XRealDeadEventArgs;
				bool flag = xrealDeadEventArgs.TheDead.IsEnemy && this.m_TaskMonstersKilled.ContainsKey(xrealDeadEventArgs.TheDead.TypeID);
				if (flag)
				{
					Dictionary<uint, uint> taskMonstersKilled = this.m_TaskMonstersKilled;
					uint typeID = xrealDeadEventArgs.TheDead.TypeID;
					uint value = taskMonstersKilled[typeID] + 1u;
					taskMonstersKilled[typeID] = value;
				}
				result = true;
			}
			return result;
		}

		private bool _OnTaskStateChanged(XEventArgs arg)
		{
			XTaskStatusChangeArgs xtaskStatusChangeArgs = arg as XTaskStatusChangeArgs;
			bool flag = xtaskStatusChangeArgs.status == TaskStatus.TaskStatus_Over;
			if (flag)
			{
				List<uint> list;
				bool flag2 = this.m_AppearNpcs.TryGetValue(xtaskStatusChangeArgs.id, out list);
				if (flag2)
				{
					for (int i = 0; i < list.Count; i++)
					{
						XSingleton<XEntityMgr>.singleton.CreateNpc(list[i], true);
					}
				}
				bool flag3 = this.m_DisappearNpcs.TryGetValue(xtaskStatusChangeArgs.id, out list);
				if (flag3)
				{
					for (int j = 0; j < list.Count; j++)
					{
						XSingleton<XEntityMgr>.singleton.DestroyNpc(list[j]);
					}
				}
			}
			return true;
		}

		public static NpcTaskState TaskStatus2TaskState(TaskStatus status)
		{
			NpcTaskState result;
			switch (status)
			{
			case TaskStatus.TaskStatus_CanTake:
				result = NpcTaskState.TaskBegin;
				break;
			case TaskStatus.TaskStatus_Taked:
				result = NpcTaskState.TaskInprocess;
				break;
			case TaskStatus.TaskStatus_Finish:
				result = NpcTaskState.TaskEnd;
				break;
			case TaskStatus.TaskStatus_Over:
				result = NpcTaskState.Normal;
				break;
			default:
				result = NpcTaskState.Invalid;
				break;
			}
			return result;
		}

		public static uint GetSceneID(ref SeqListRef<uint> sceneData)
		{
			return XSingleton<UiUtility>.singleton.ChooseProfData<uint>(ref sceneData, 0u, 0);
		}

		public static int SortByType(int type0, int type1)
		{
			return XTaskDocument.TypeSortValue[type0].CompareTo(XTaskDocument.TypeSortValue[type1]);
		}

		public static int SortByNpcState(NpcTaskState state0, NpcTaskState state1)
		{
			return state0.CompareTo(state1);
		}

		public static int SortInTaskList(XTaskInfo task0, XTaskInfo task1)
		{
			bool flag = task0 == null;
			int result;
			if (flag)
			{
				result = 1;
			}
			else
			{
				bool flag2 = task1 == null;
				if (flag2)
				{
					result = -1;
				}
				else
				{
					bool flag3 = XTaskDocument._HighestPriorityTask > 0u;
					if (flag3)
					{
						bool flag4 = task0.ID == task1.ID;
						if (flag4)
						{
							return 0;
						}
						bool flag5 = task0.ID == XTaskDocument._HighestPriorityTask;
						if (flag5)
						{
							return -1;
						}
						bool flag6 = task1.ID == XTaskDocument._HighestPriorityTask;
						if (flag6)
						{
							return 1;
						}
					}
					int num = XTaskDocument.SortByType((int)task0.TableData.TaskType, (int)task1.TableData.TaskType);
					bool flag7 = num == 0;
					if (flag7)
					{
						num = XTaskDocument.SortByNpcState(task0.NpcState, task1.NpcState);
					}
					bool flag8 = num == 0;
					if (flag8)
					{
						num = task0.ID.CompareTo(task1.ID);
					}
					result = num;
				}
			}
			return result;
		}

		public static int SortInDialog(XTaskInfo task0, XTaskInfo task1)
		{
			bool flag = task0 == null;
			int result;
			if (flag)
			{
				result = 1;
			}
			else
			{
				bool flag2 = task1 == null;
				if (flag2)
				{
					result = -1;
				}
				else
				{
					bool flag3 = XTaskDocument._HighestPriorityTask > 0u;
					if (flag3)
					{
						bool flag4 = task0.ID == task1.ID;
						if (flag4)
						{
							return 0;
						}
						bool flag5 = task0.ID == XTaskDocument._HighestPriorityTask;
						if (flag5)
						{
							return -1;
						}
						bool flag6 = task0.ID == XTaskDocument._HighestPriorityTask;
						if (flag6)
						{
							return 1;
						}
					}
					int num = XTaskDocument.SortByNpcState(task0.NpcState, task1.NpcState);
					bool flag7 = num == 0;
					if (flag7)
					{
						num = XTaskDocument.SortByType((int)task0.TableData.TaskType, (int)task1.TableData.TaskType);
					}
					bool flag8 = num == 0;
					if (flag8)
					{
						num = task0.ID.CompareTo(task1.ID);
					}
					result = num;
				}
			}
			return result;
		}

		protected override void OnReconnected(XReconnectedEventArgs arg)
		{
			this.TaskRecord.InitFromServerData(arg.PlayerInfo.task_record);
			this._RefreshUI();
			this.SetupNpcHeadFx();
		}

		public override void OnEnterScene()
		{
			base.OnEnterScene();
			this.SetupNpcHeadFx();
			bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
			if (flag)
			{
				this._ResetTaskMonsters();
			}
			else
			{
				bool flag2 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.World;
				if (flag2)
				{
					this._InitTaskMonsters();
				}
			}
		}

		public override void OnLeaveScene()
		{
			this.ClearFx();
			this._ResetHighestPriorityTask(false);
			base.OnLeaveScene();
		}

		public bool ShouldNpcExist(uint npcID)
		{
			XNpcInfo.RowData byNPCID = XSingleton<XEntityMgr>.singleton.NpcInfo.GetByNPCID(npcID);
			bool flag = byNPCID == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = byNPCID.DisappearTask != 0u && this.TaskRecord.IsTaskFinished(byNPCID.DisappearTask);
				if (flag2)
				{
					result = false;
				}
				else
				{
					bool flag3 = byNPCID.RequiredTaskID == 0u || this.TaskRecord.IsTaskFinished(byNPCID.RequiredTaskID);
					result = flag3;
				}
			}
			return result;
		}
	}
}