using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;

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 delegate void RobotTaskChangedEventHandler(TaskEventArgs taskEventArgs);
        public static event RobotTaskChangedEventHandler RobotTaskChangedEvent;
        public static void OnRobotTaskChanged(int robotType)
        {
            RobotTaskChangedEventHandler eventHandler = Volatile.Read(ref RobotTaskChangedEvent);
            if (eventHandler != null)
                eventHandler?.Invoke(new TaskEventArgs() { RobotType = robotType, Tasks = GetTask(robotType).ToList() });
            else
                eventHandler?.Invoke(null);
        }

        static FinishedTrans finishedTrans
        {
            get { return (FinishedTrans)MushinyManager.GetCTUBean().businessRobot; }
        }
        /// <summary>
        /// 获取当前正在执行任务的占用点（需要是先分配车再执行）
        /// </summary>
        /// <returns></returns>
        public static List<PointCode> GetUsedPointsInTasks()
        {
            var usedPoints = new List<PointCode>();
            foreach (var item in robotTasks)
            {
                var srcPos = MushinyManager.GetCTUBean().GetPosInfoByName(item.SrcPoint);
                var dstPos = MushinyManager.GetCTUBean().GetPosInfoByName(item.DestPoint);
                if (item.TaskState == RobotTaskState.去取货路上 || item.TaskState == RobotTaskState.等待分配车)
                {
                    if (srcPos != null)
                    {
                        var find = usedPoints.Find(s => s.Id == srcPos.PointCode);
                        if (find == null)
                        {
                            var pp = MushinyManager.GetCTUBean().GetPointCode(srcPos.PointCode);
                            if (pp != null)
                            {
                                usedPoints.Add(pp);
                            }
                        }
                    }
                }
                if (item.TaskState == RobotTaskState.去放货路上 || item.TaskState == RobotTaskState.已取货)
                {
                    if (dstPos != null)
                    {
                        var find = usedPoints.Find(s => s.Id == dstPos.PointCode);
                        if (find == null)
                        {
                            var pp = MushinyManager.GetCTUBean().GetPointCode(dstPos.PointCode);
                            if (pp != null)
                            {
                                usedPoints.Add(pp);
                            }
                        }
                    }
                }

            }
            return usedPoints;
        }

        //if(pp.Above!=null)
        //{
        //    pp = MushinyManager.GetCTUBean().GetPointCode(pp.Above.Id);
        //    if(pp!=null)
        //    {
        //        usedPoints.Add(pp);
        //    }
        //}

        //if (pp.Right != null)
        //{
        //    pp = MushinyManager.GetCTUBean().GetPointCode(pp.Right.Id);
        //    if (pp != null)
        //    {
        //        usedPoints.Add(pp);
        //    }
        //}

        //if (pp.Below != null)
        //{
        //    pp = MushinyManager.GetCTUBean().GetPointCode(pp.Below.Id);
        //    if (pp != null)
        //    {
        //        usedPoints.Add(pp);
        //    }
        //}

        //if (pp.Left != null)
        //{
        //    pp = MushinyManager.GetCTUBean().GetPointCode(pp.Left.Id);
        //    if (pp != null)
        //    {
        //        usedPoints.Add(pp);
        //    }
        //}
        /// <summary>
        /// 加载任务缓存
        /// </summary>
        public static void LoadTasks()
        {
            if (!MushinyManager.UseBuff) return;
            try
            {
                string cache = ConfigAppSettings.GetValue("Buff_AllTasksCache", "");
                if (string.IsNullOrEmpty(cache))
                {
                    robotTasks = new List<RobotTask>();
                }
                else
                {
                    robotTasks = JsonHelper.DeserializeJsonToList<RobotTask>(cache);
                    if (robotTasks == null)
                    {
                        robotTasks = new List<RobotTask>();
                    }
                    LogUtil.error($"加载任务缓存完成【{cache}】");
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("加载任务缓存异常", ex);
            }

        }
        static void SaveTasks()
        {
            try
            {
                if (robotTasks == null) return;
                var tempTasks = robotTasks.ToList();

                var rtn = tempTasks.FindAll(s => s.TaskState >= RobotTaskState.已分配车);
                ConfigAppSettings.SaveValue("Buff_AllTasksCache", JsonHelper.SerializeObject(rtn));
            }
            catch (Exception ex)
            {
                LogUtil.error("保存任务缓存异常", ex);
            }
        }
        public static void AddTask(RobotTask robotTask)
        {
            robotTasks.Add(robotTask);
            SaveTasks();
        }
        public static void RemoveTask(RobotTask robotTask)
        {
            robotTasks.Remove(robotTask);
            SaveTasks();
        }
        public static RobotTask GetTaskByTaskId(string id)
        {
            return robotTasks.Find(s => s.TaskId.Equals(id));
        }
        public static List<RobotTask> GetTask(int robotType)
        {
            return robotTasks.FindAll(s => s.RobotType == robotType);
        }
        /// <summary>
        /// 获取入料机构的入库任务
        /// </summary>
        /// <param name="robotType"></param>
        /// <returns></returns>
        public static List<FinishedCtuTask> GetInEquipInTasks()
        {
            return finishedTrans.GetInletInStores();
        }

        /// <summary>
        /// 获取入料机构的出库任务
        /// </summary>
        /// <returns></returns>
        public static List<FinishedCtuTask> GetInEquipOutTasks()
        {
            return finishedTrans.GetInletOutStores();
        }
        public static List<FinishedCtuTask> GetOutEquipInTasks(string equipPrefix)
        {
            var allTasks = finishedTrans.GetOutletInStores();
            if (string.IsNullOrEmpty(equipPrefix))
            {
                return allTasks;
            }
            else
            {
                return allTasks?.FindAll(s => s.fromLoc.StartsWith(equipPrefix));
            }
        }
        public static List<FinishedCtuTask> GetManualInTasks()
        {
            return finishedTrans.GetManualInStores();
        }
        public static List<FinishedCtuTask> GetOutEquipOutTasks()
        {
            return finishedTrans.GetOutletOutStores();
        }
        public static List<FinishedCtuTask> GetManualOutTasks()
        {
            return finishedTrans.GetManualOutStores();
        }
        static int urgentTaskPriority { get { return ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "UrgentTaskPriority", 998); } }

        public static List<RobotTask> GetAllTasks()
        {
            return robotTasks;
        }
        /// <summary>
        /// 改变任务状态
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="taskState"></param>
        public static void ChangeTaskState(string taskId, RobotTaskState taskState)
        {
            if (string.IsNullOrEmpty(taskId))
            {
                return;
            }
            var find = robotTasks.Find(s => s.TaskId.Equals(taskId));
            if (find != null)
            {
                find.TaskState = taskState;
                LogUtil.info($"任务状态改变【{find.TaskId}】【{find.TaskState}】");
                OnRobotTaskChanged(find.RobotType);
            }
            else
            {
                LogUtil.error($"无法改变任务状态【{taskId}】【{taskState}】，因未找到任务编号");
            }
        }
        public static void ChangeTaskState(RobotTask robotTask, RobotTaskState taskState)
        {
            if (robotTask == null) return;
            robotTask.TaskState = taskState;
            LogUtil.info($"任务状态改变【{robotTask.TaskId}】【{robotTask.TaskState}】");
            OnRobotTaskChanged(robotTask.RobotType);

        }
    }

    /// <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 ContainerCode { 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 int A { get; set; }
        public int B { get; set; }
        public int C { 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(),
                ContainerCode,
                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; }
    }

}