using DeviceLibrary.ESS;
using Mushiny;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Dispatcher;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace CtuDeviceLib
{
    /// <summary>
    /// 任务管理
    /// </summary>
    public class TaskManager
    {
        static List<RobotTask> robotTasks = new List<RobotTask>();


        public static bool Remove(string taskId, string taskSatus)
        {
            if (!string.IsNullOrEmpty(taskId))
            {
                var task = robotTasks.Find(s => taskId.Equals(s.TaskId));
                if (task != null)
                {
                    robotTasks.Remove(task);
                    LogUtil.info($"删除任务【{taskSatus}】:{JsonHelper.SerializeObject(task)}");
                    return true;
                }
                else
                {
                    LogUtil.error($"删除任务失败【{taskSatus}】,不存在的任务编号:{taskId}");

                }
            }
            return false;
        }
        public static EssModel ContainerArrived = null;


        public static void SetTaskState(RobotTask task, RobotTaskState state)
        {
            var find = robotTasks.Find(s => task.TaskId.Equals(s.TaskId));
            if (find != null)
            {
                find.TaskState = state;
            }
            task.TaskState = state;
            LogUtil.info($"设置任务状态【{task.BoxCode}】【{state}】【{JsonHelper.SerializeObject(task)}】");
        }
        /// <summary>
        /// 是否有入库未执行的入库任务
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static bool HasInstoreTask(out RobotTask task)
        {
            task = robotTasks.Find(s => s.TaskType == RobotTaskType.Insotre && s.TaskState < RobotTaskState.已分配车);
            return task != null;
        }
        /// <summary>
        /// 是否有入库任务且已就位
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static bool HasInstoreBoxReady(out RobotTask task)
        {
            task = robotTasks.Find(s => s.TaskType == RobotTaskType.Insotre && s.TaskState < RobotTaskState.已分配车 && ContainerArrived != null && ContainerArrived.containerCode.Equals(s.BoxCode));
            return task != null;
        }
        public static bool InstoreBoxReady(string boxCode)
        {
            return ContainerArrived != null && boxCode.Equals(ContainerArrived.containerCode);
        }
        public static void SetContainerArrived(EssModel containerArrived)
        {
            ContainerArrived = new EssModel()
            {
                containerCode = containerArrived.containerCode,
                containerAttribute = containerArrived.containerAttribute,
                slotCode = containerArrived.slotCode,
            };
        }
        public static void ClearContainerArrived()
        {
            LogUtil.info($"清理到达信息：【{JsonHelper.SerializeObject(ContainerArrived)}】");
            ContainerArrived = null;
        }
        public static List<RobotTask> GetAllTasks()
        {
            return robotTasks;
        }
        public static bool CreateInstoreTask(ESSTask eSSTask)
        {
            try
            {
                var find = robotTasks.Find(s => s.BoxCode.Equals(eSSTask.taskDescribe.containerCode));
                if (find != null)
                {
                    return false;
                }
                else
                {
                    robotTasks.Add(new RobotTask()
                    {
                        BoxCode = eSSTask.taskDescribe.containerCode,
                        CreateTime = DateTime.Now,
                        SrcPoint = ConfigAppSettings.GetValue("DischargeEquipName", "rawLine_out", "缓存线体出口"),
                        DestPoint = eSSTask.taskDescribe.toStationCode,
                        TaskId = eSSTask.taskCode,
                        TaskType = RobotTaskType.Insotre,
                        TaskState = RobotTaskState.已生成,
                    });
                    return true;
                }
            }
            catch (Exception e)
            {
                LogUtil.error($"创建入库任务异常：{JsonHelper.SerializeObject(eSSTask)}", e);
            }

            return false;
        }
        public static bool CreateOutstoreTask(ESSTask eSSTask)
        {
            try
            {
                var find = robotTasks.Find(s => s.BoxCode.Equals(eSSTask.taskDescribe.containerCode));
                if (find != null)
                {
                    return false;
                }
                else
                {
                    robotTasks.Add(new RobotTask()
                    {
                        BoxCode = eSSTask.taskDescribe.containerCode,
                        CreateTime = DateTime.Now,
                        DestPoint = ConfigAppSettings.GetValue("FeedEquipName", "rawLine_in", "缓存线体入口"),
                        SrcPoint = eSSTask.taskDescribe.toStationCode,
                        TaskId = eSSTask.taskCode,
                        TaskType = RobotTaskType.Outstore,
                        TaskState = RobotTaskState.已生成,
                    });
                    return true;
                }
            }
            catch (Exception e)
            {
                LogUtil.error($"创建出库任务异常：{JsonHelper.SerializeObject(eSSTask)}", e);
            }
            return false;
        }

        public static bool CancelTask(ESSTask eSSTask)
        {
            try
            {
                var find = robotTasks.Find(s => s.BoxCode.Equals(eSSTask.taskDescribe.containerCode));
                if (find != null)
                {
                    if (find.TaskState < RobotTaskState.已分配车)
                    {
                        robotTasks.Remove(find);
                        LogUtil.info($"取消任务：{find.BoxCode}");
                        return true;
                    }
                    else
                    {
                        LogUtil.error($"取消任务失败，已开始执行：{find.BoxCode}");
                    }
                }
                else
                {
                    return true;
                }
            }
            catch (Exception e)
            {
                LogUtil.error($"取消任务任务异常：{JsonHelper.SerializeObject(eSSTask)}", e);
            }
            return false;
        }
        public static RobotTask GenRobotTask(FinishedCtuTask finishedCtuTask)
        {
            if (finishedCtuTask == null) return null;
            RobotTask robotTask = new RobotTask()
            {
                SrcPoint = finishedCtuTask.fromLoc,
                DestPoint = finishedCtuTask.toLoc,
                BoxCode = finishedCtuTask.boxCode,
                CreateTime = finishedCtuTask.createDate,
                TaskId = finishedCtuTask.id
            };
            if (finishedCtuTask.taskType == SmfTaskType.Instore)
            {
                robotTask.TaskType = RobotTaskType.Insotre;
            }
            else if (finishedCtuTask.taskType == SmfTaskType.OutStore)
            {
                robotTask.TaskType = RobotTaskType.Outstore;
            }
            robotTasks.Add(robotTask);
            return robotTask;
        }
        public static RobotTask GenRobotTask(Basket basket)
        {
            if (basket == null) return null;
            RobotTask robotTask = new RobotTask()
            {
                DestPoint = basket.DstName,
                BoxCode = basket.BoxCode,
                CreateTime = DateTime.Now,
                TaskId = $"{basket.Row}"
            };
            return robotTask;
        }
        public static RobotTask GenRobotTask(string boxCode, string dstName = "")
        {
            if (string.IsNullOrEmpty(boxCode)) return null;
            RobotTask robotTask = new RobotTask()
            {
                DestPoint = dstName,
                BoxCode = boxCode,
            };
            return robotTask;
        }
        public static void ClearRobotTask(string boxCode)
        {
            if (string.IsNullOrEmpty(boxCode)) return;
            if (robotTasks != null && robotTasks.Count > 0)
            {
                var find = robotTasks?.Find(s => boxCode.Equals(s.BoxCode));
                if (find != null)
                {
                    robotTasks.Remove(find);
                }
            }

        }
    }

    /// <summary>
    /// 机器人任务
    /// </summary>
    public class RobotTask
    {
        /// <summary>
        /// 优先级
        /// 值越大，优先级越高
        /// </summary>

        public int Priority { get; set; } = 0;
        /// <summary>
        /// 任务标志
        /// 避免重复相同任务生成
        /// </summary>
        public string TaskFlag { get; set; }
        public string TaskId { get; set; }
        public string TaskName { get; set; } = "";
        public DateTime CreateTime { get; set; }
        public string SrcPoint { get; set; }
        public string DestPoint { get; set; }
        /// <summary>
        /// 机器人类型
        /// </summary>
        public int RobotType { get; set; }
        /// <summary>
        /// 料箱码
        /// </summary>
        public string BoxCode { get; set; }
        public RobotTaskType TaskType { get; set; }
        public RobotTaskState TaskState { get; set; }
        /// <summary>
        /// 任务组
        /// </summary>
        public RobotTaskGroup TaskGroup { get; set; } = RobotTaskGroup.Common;
        /// <summary>
        /// Ctu名称
        /// </summary>
        public string CtuName { get; set; }
        /// <summary>
        /// 需要重新分配目的地
        /// </summary>
        public bool NeedReAssignTarget { get; set; }
        /// <summary>
        /// 备注
        /// </summary>
        public string Remark { get; set; }
        public string[] ToDatagridData()
        {
            List<string> strings = new List<string>()
            {
                TaskId,
                Priority.ToString(),
                CtuName,
                TaskState.ToString(),
                SrcPoint,
                DestPoint,
                CreateTime.ToString("MM-dd HH:mm:ss:fff")
            };
            return strings.ToArray();
        }
        public string[] ToDatagridData2()
        {
            List<string> strings = new List<string>()
            {
                TaskId,
                Priority.ToString(),
                BoxCode,
                SrcPoint,
                DestPoint,
                Remark,
            };
            return strings.ToArray();
        }
        public static string GenTaskId(string custStr, string prefix = "")
        {
            if (string.IsNullOrEmpty(prefix))
                return $"{custStr}";
            else
            {
                return $"{prefix}-{custStr}";

            }
        }
    }

    public enum RobotTaskType
    {
        None,
        Insotre,
        Outstore,
        Charge,
        Standby,
        Switch,
    }
    /// <summary>
    /// 任务组
    /// </summary>
    public enum RobotTaskGroup
    {
        /// <summary>
        /// 常用逻辑
        /// </summary>
        Common,
        /// <summary>
        /// 原材料-入料机构
        /// </summary>
        Finished_InEquip,
        /// <summary>
        /// 原材料-出料机构
        /// </summary>
        Finished_OutEquip,
        /// <summary>
        /// 原材料-手动线
        /// </summary>
        Finished_ManualLine,

    }

    /// <summary>
    /// 任务状态
    /// </summary>
    public enum RobotTaskState
    {
        已生成,
        已创建,
        等待分配车,
        已分配车,
        执行中,
        去取货路上,
        到达取货点,
        取货中,
        已取货,
        等待放货点需要料箱,
        去放货前点,
        到达放货前点,
        去放货路上,
        到达放货点,
        准备放货,
        准备放货完成,
        放货中,
        已放货,
        去充电预备点,
        到达充电预备点,
        去充电路上,
        到达充电点,
        充电中,
        充电完成,
        准备离开充电区域,
        离开充电区域成功,
        去待机点,
        到达待机点,
        完成,
        手动完成,
        手动取消,
        取消中,
        取消,
        暂停,
        异常
    }
    /// <summary>
    /// 任务事件参数
    /// </summary>
    public class TaskEventArgs : EventArgs
    {
        public int RobotType { get; set; }
        public List<RobotTask> Tasks { get; set; }
    }

}