using Cal.DataTable;
using System;
using System.Collections.Generic;

namespace ET
{
    public class UpdateTaskStateEvent : AEvent<EventType.UpdateTaskState>
    {
        public override async ETTask Run(EventType.UpdateTaskState args)
        {
            try
            {

                Unit unit = args.unit;
                if (!unit)
                {
                    Log.Error($"unit is invalid where unitId = {unit.Id}");
                    return;
                }
                UnitTask unitTask = unit.GetComponent<UnitTask>();
                if (!unitTask)
                    return;
                TaskTargetType type = args.type;
                int value = args.value;
                switch (type)
                {
                    case TaskTargetType.KillSpecialTask:
                    case TaskTargetType.CollectionTask:
                    case TaskTargetType.SubmitTask:
                        //!value:怪物Id/ItemId
                        for (int ii = 0; ii < unitTask.RunningTaskList.Count; ii++)
                        {
                            try
                            {
                                Task task = unitTask.RunningTaskList[ii];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase ==null where id = {taskId}");
                                    for (int i = 0; i < taskbase.CountTargetArr.Length; i++)
                                    {
                                        TaskBase.CountTarget countTarget = taskbase.CountTargetArr[i];
                                        if (countTarget.CountTarget_Id == value)
                                        {
                                            task.UpdateAmount(i);
                                            break;
                                        }
                                    }
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Log.Error(e);
                            }
                        }
                        break;
                    case TaskTargetType.KillAnyTask:
                        //!value:怪物Id
                        int level = unit.GetComponent<NumericComponent>().GetAsInt(NumericType.Level);
                        MonsterBase monsterBase = DataTableHelper.Get<MonsterBase>(value);
                        if (monsterBase == null) return;
                        for (int i = 0; i < unitTask.RunningTaskList.Count; i++)
                        {
                            try
                            {
                                Task task = unitTask.RunningTaskList[i];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase==null where id = {taskId}");
                                    if (level- monsterBase.Level <= taskbase.AnyTargetLevel)
                                        task.UpdateAmount(0);
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }

                            }
                            catch (Exception e)
                            {
                                Log.Error(e.ToString());
                            }
                        }
                        break;
                    case TaskTargetType.DialogTask:
                        //!value:NPCId
                        for (int i = 0; i < unitTask.RunningTaskList.Count; i++)
                        {
                            try
                            {
                                Task task = unitTask.RunningTaskList[i];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase==null where id = {taskId}");
                                    if (value == taskbase.DialogTargetId)
                                        task.UpdateAmount(0);
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }

                            }
                            catch (Exception e)
                            {
                                Log.Error(e);
                            }
                        }
                        break;
                    case TaskTargetType.LevelTask:
                        //!value:Level
                        for (int i = 0; i < unitTask.RunningTaskList.Count; i++)
                        {
                            try
                            {

                                Task task = unitTask.RunningTaskList[i];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase==null where id = {taskId}");
                                    if (value >= taskbase.TargetLevel)
                                        task.UpdateAmount(0);
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Log.Error(e);
                            }
                        }
                        break;
                    case TaskTargetType.ChangeMapTask:
                        //!value:Sys_SceneId x 100 + Maplayer x 1
                        for (int i = 0; i < unitTask.RunningTaskList.Count; i++)
                        {
                            try
                            {

                                Task task = unitTask.RunningTaskList[i];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase==null where id = {taskId}");
                                    if (value / 100 == taskbase.TargetSceneId &&
                                        value % 100 == taskbase.TargetMaplayer)
                                        task.UpdateAmount(0);
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Log.Error(e);
                            }
                        }
                        break;
                    case TaskTargetType.NoneTask:
                        break;
                    case TaskTargetType.CompleteTask:
                        for (int i = 0; i < unitTask.RunningTaskList.Count; i++)
                        {
                            try
                            {

                                Task task = unitTask.RunningTaskList[i];
                                if (task.TaskTargetType == type)
                                {
                                    int taskId = (int)task.Id;
                                    TaskBase taskbase = DataTableHelper.Get<TaskBase>(taskId);
                                    if (taskbase == null) Log.Error($"taskBase==null where id = {taskId}");
                                    task.UpdateAmount(0);
                                    if (task.IsComplete)
                                    {
                                        unitTask.CompleteTask(taskbase);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Log.Error(e);
                            }
                        }
                        break;
                }
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
            await ETTask.CompletedTask;
        }
    }
}