using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Rs.DataAccess;
using Rs.Framework;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Entitys.Trays;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Rs.MotionPlat.Flow
{

    public enum ETaskDealStatus
    {
        /// <summary>
        /// 未处理过的任务
        /// </summary>
        Undeal,
        /// <summary>
        /// 已处理过的任务
        /// </summary>
        Dealed,
        /// <summary>
        /// 所有
        /// </summary>
        All
    }
    /// <summary>
    /// 中控发过来的任务的类型
    /// </summary>
    public enum ETaskType
    {
        /// <summary>
        /// 中转盘上料
        /// </summary>
        Load,
        /// <summary>
        /// 中转盘下料
        /// </summary>
        Unload,
        /// <summary>
        /// 中转盘换料
        /// </summary>
        Change,
        /// <summary>
        /// 测试工位上料
        /// </summary>
        TestLoad,
        /// <summary>
        /// 测试工位下料
        /// </summary>
        TestUnload
    }

    public class LoadAndUnloadTask
    {
        private SchedulingMaterial m_schedulingMaterial;

        #region 中控发过来的任务
        /// <summary>
        /// 中转盘上料任务
        /// </summary>
        List<TurnoverInfo> loadTaskList = new List<TurnoverInfo>();
        /// <summary>
        /// 中转盘下料任务
        /// </summary>
        List<TurnoverInfo> unloadTaskList = new List<TurnoverInfo>();
        /// <summary>
        /// 中转盘换料任务
        /// </summary>
        List<TurnoverInfo> changeTaskList = new List<TurnoverInfo>();
        /// <summary>
        /// 测试位上料任务
        /// </summary>
        List<TurnoverInfo> testLoadTaskList = new List<TurnoverInfo>();

        /// <summary>
        /// 测试位下料任务
        /// </summary>
        List<TurnoverInfo> testUnloadTaskList = new List<TurnoverInfo>();

        #endregion

        List<TurnoverInfo> turnoverResult = new List<TurnoverInfo>();

        SqliteHelper db = new SqliteHelper();

        private LoadAndUnloadTask()
        {
            Categories = new List<TurnoverType>();
            MoveDir = new List<string>();
        }

        public bool CanRunTask()
        {
            lock(this)
            {
                int count1 = GetTaskNum(ETaskType.Load) + GetTaskNum(ETaskType.Unload) + GetTaskNum(ETaskType.Change);
                int count2 = GetTaskNum(ETaskType.TestLoad) + GetTaskNum(ETaskType.TestUnload);
                if (count1 > 0 && count2 > 0)
                    return false;
                return true;
            }
        }
        private static LoadAndUnloadTask instance;
        public static LoadAndUnloadTask Instance
        {
            get
            {
                if(instance==null)
                {
                    instance = new LoadAndUnloadTask();
                }
                return instance;
            }
        }

        public List<TurnoverInfo> GetTask()
        {
            List<TurnoverInfo> tilist = new List<TurnoverInfo>();
            tilist.AddRange(loadTaskList);
            tilist.AddRange(unloadTaskList);
            tilist.AddRange(changeTaskList);
            return tilist;
        }

        /// <summary>
        /// 获取未执行的任务
        /// </summary>
        /// <returns></returns>
        public List<TurnoverInfo> GetUnDealedTask()
        {
            List<TurnoverInfo> tilist = new List<TurnoverInfo>();
            tilist.AddRange(loadTaskList.Where(tr=>tr.Dealed==false));
            tilist.AddRange(unloadTaskList.Where(tr => tr.Dealed == false));
            tilist.AddRange(changeTaskList.Where(tr => tr.Dealed == false));
            return tilist;
        }

        /// <summary>
        /// 获取还没有执行的放到周转盘的任务
        /// </summary>
        /// <returns></returns>
        public List<TurnoverInfo> GetUndealedLoadToTurnoverTask()
        {
            List<TurnoverInfo> tilist = new List<TurnoverInfo>();
            tilist.AddRange(loadTaskList.Where(tr => tr.Dealed == false));
            tilist.AddRange(changeTaskList.Where(tr => tr.Dealed == false));
            return tilist;
        }
        /// <summary>
        /// 清除未执行的任务
        /// </summary>
        public void ClearUndoTask()
        {
           List<TurnoverInfo> removeList = loadTaskList.Where(t => t.Dealed == false).ToList();
            foreach(var t in removeList)
            {
                loadTaskList.Remove(t);
            }
        }


        public void AddTurnoverResult(Nozzle nozzle)
        {
            TurnoverInfo turnoverInfo = new TurnoverInfo();
            turnoverInfo.FromType = nozzle.FromType;
            turnoverInfo.FromFloor = nozzle.FromFloor;
            turnoverInfo.FromIndex = nozzle.FromIndex;
            turnoverInfo.ToType = nozzle.ToType;
            turnoverInfo.ToFloor = nozzle.ToFloor;
            turnoverInfo.ToIndex = nozzle.ToIndex;
            turnoverInfo.SN = nozzle.SN;
            turnoverInfo.Dealed = true;
            turnoverInfo.SuckerNo = nozzle.NozzleIndex;
            turnoverResult.Add(turnoverInfo);
        }

        public void CopyBarcodeToTask(int slotIndex,string sn)
        {
            TurnoverInfo ti = turnoverResult.Where(r => r.ToIndex == slotIndex && r.ToType == TurnoverType.Turnover).First();
            if(ti!=null)
            {
                ti.SN = sn;
            }
        }

        /// <summary>
        /// 获取测试治具上料的任务信息
        /// </summary>
        /// <param name="turnoverInfoList"></param>
        /// <returns></returns>
        public string GetLoadString()
        {
            TurnoverInfos infos = new TurnoverInfos();
            infos.Instruction = EInstruction.LoadAndUnloadResult;
            infos.GroupID = m_schedulingMaterial.GroupID;
            infos.TurnoverID = m_schedulingMaterial.TurnoverID;
            infos.Infos = turnoverResult;
            string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
            return content;
        }
        public string GetTestLoadString()
        {
            List<TurnoverInfo> turnoverInfos= new List<TurnoverInfo>();
            //1、获取有产品的吸嘴
            List<TransitNozzle> transitNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
            foreach (TransitNozzle nozzle in transitNozzles)
            {
                TurnoverInfo ti = new TurnoverInfo();
                ti.GUID = GuidHelper.Create();
                ti.FromType = nozzle.FromType;
                ti.FromFloor = nozzle.FromFloor;
                ti.FromIndex = nozzle.FromIndex;
                ti.SN = nozzle.SN;
                ti.ToType = nozzle.ToType;
                ti.ToFloor =nozzle.ToFloor;
                ti.ToIndex = nozzle.ToIndex;
                ti.SuckerNo = nozzle.NozzleIndex;
                turnoverInfos.Add(ti);
            }
            //2、获取测试盘中有产品的穴位
            List<TestTraySlot> testSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
            foreach (TestTraySlot slot in testSlots)
            {
                TurnoverInfo ti = new TurnoverInfo();
                ti.GUID = GuidHelper.Create();
                ti.FromType = slot.FromType;
                ti.FromFloor = 0;
                ti.FromIndex = slot.FromIndex;
                ti.SN = slot.SN;
                ti.ToType = TurnoverType.Tester;
                ti.ToFloor = 0;
                ti.ToIndex = slot.Index-1;
                turnoverInfos.Add(ti);
            }
           
            TurnoverInfos infos = new TurnoverInfos();
            infos.Instruction = EInstruction.LoadAndUnloadResult;
            infos.GroupID = m_schedulingMaterial.GroupID;
            infos.TurnoverID = m_schedulingMaterial.TurnoverID;
            infos.Infos = turnoverInfos;
            string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
            return content;
        }

        /// <summary>
        /// 获取测试治具下料的任务信息
        /// </summary>
        /// <returns></returns>
        public string GetTestUnLoadString()
        {
            //TurnoverInfos infos = new TurnoverInfos();
            //infos.Instruction = EInstruction.LoadAndUnloadResult;
            //infos.GroupID = m_schedulingMaterial.GroupID;
            //infos.TurnoverID = m_schedulingMaterial.TurnoverID;
            //infos.Infos = testUnloadTaskList;
            //string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
            //LogHelper.Debug("发送:" + content);
            //return content;

            List<TurnoverInfo> turnoverInfos = new List<TurnoverInfo>();
            //1、获取有产品的吸嘴
            List<TurnoverTraySlot> transitNozzles = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.Tested, ETurnoverTraySlotStatus.Have);
            foreach (TurnoverTraySlot slot in transitNozzles)
            {
                TurnoverInfo ti = new TurnoverInfo();
                ti.GUID = GuidHelper.Create();
                ti.FromType = slot.FromType;
                ti.FromFloor = 1;
                ti.FromIndex = slot.FromIndex;
                ti.SN = slot.SN;
                ti.ToType = TurnoverType.Turnover;
                ti.ToFloor = 1;
                ti.ToIndex = slot.Index - 1;
                ti.SuckerNo = slot.SuckerNo;
                turnoverInfos.Add(ti);
            }
            
            TurnoverInfos infos = new TurnoverInfos();
            infos.Instruction = EInstruction.LoadAndUnloadResult;
            infos.GroupID = m_schedulingMaterial.GroupID;
            infos.TurnoverID = m_schedulingMaterial.TurnoverID;
            infos.Infos = turnoverInfos;
            string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
            return content;
        }
        /// <summary>
        /// 获取从中转盘到测试位的任务
        /// </summary>
        /// <param name="status"></param>
        /// <returns></returns>
        public List<TurnoverInfo> GetTurnoverToTestTasks(ETaskDealStatus status= ETaskDealStatus.All)
        {
            List<TurnoverInfo> reslut = new List<TurnoverInfo>();
            switch (status)
            {
                case ETaskDealStatus.Undeal:
                    reslut = testLoadTaskList?.Where(t => t.Dealed == false).ToList();
                    break;
                case ETaskDealStatus.Dealed:
                    reslut = testLoadTaskList?.Where(t => t.Dealed == true).ToList();
                    break;
                case ETaskDealStatus.All:
                    reslut = testLoadTaskList;
                    break;
                default:
                    break;
            }
            return reslut;
        }
        /// <summary>
        /// 获取从测试位到的中转盘任务
        /// </summary>
        /// <returns></returns>
        public List<TurnoverInfo> GetTestToTurnoverTasks(ETaskDealStatus status = ETaskDealStatus.All)
        {
            List<TurnoverInfo> reslut = new List<TurnoverInfo>();
            switch (status)
            {
                case ETaskDealStatus.Undeal:
                    reslut = testUnloadTaskList?.Where(t => t.Dealed == false).ToList();
                    break;
                case ETaskDealStatus.Dealed:
                    reslut = testUnloadTaskList?.Where(t => t.Dealed == true).ToList();
                    break;
                case ETaskDealStatus.All:
                    reslut = testUnloadTaskList;
                    break;
                default:
                    break;
            }
            return reslut;
        }

        /// <summary>
        /// 根据任务的fromIndex获取任务
        /// </summary>
        /// <param name="fromIndex"></param>
        /// <returns></returns>
        public TurnoverInfo GetTestUnloadTask(int fromIndex)
        {
            return testUnloadTaskList.Where(t => t.FromIndex == fromIndex-1).First();
        }

        /// <summary>
        /// 获取任务的个数
        /// </summary>
        /// <param name="taskMode"></param>
        /// <returns></returns>
        public int GetTaskNum(ETaskType taskMode)
        {
            lock(this)
            {
                switch (taskMode)
                {
                    case ETaskType.Load:
                        if (loadTaskList == null) return 0;
                        return loadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskType.Unload:
                        if (unloadTaskList == null) return 0;
                        return unloadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskType.Change:
                        if (changeTaskList == null) return 0;
                        return changeTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskType.TestLoad:
                        if (testLoadTaskList == null) return 0;
                        return testLoadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskType.TestUnload:
                        if (testUnloadTaskList == null) return 0;
                        return testUnloadTaskList.Where(t => t.Dealed == false).Count();
                }
                return 0;
            }
        }


        /// <summary>
        /// 任务数量
        /// </summary>
        public int Count 
        { 
            get 
            { 
                lock (this)
                {
                    return loadTaskList.Count + unloadTaskList.Count + changeTaskList.Count + testLoadTaskList.Count + testUnloadTaskList.Count;
                }
                
            } 
        }
        /// <summary>
        /// 任务种类
        /// </summary>
        public List<TurnoverType> Categories { get; set; }

        /// <summary>
        /// 周转时的运动方向
        /// </summary>
        public List<string> MoveDir { get; set; }

        /// <summary>
        /// 清除任务
        /// 任务类型，0=排料任务，1=测试任务
        /// </summary>
        public void Clear(int taskMode=0)
        {
            lock(this)
            {
                if (turnoverResult != null)
                {
                    if (taskMode == 0)
                    {
                        turnoverResult.Clear();
                        loadTaskList.Clear();
                        unloadTaskList.Clear();
                        changeTaskList.Clear();
                    }
                    else if(taskMode==1)
                    {
                        testLoadTaskList.Clear();
                        testUnloadTaskList.Clear();
                    }
                }
            }
        }

        public SchedulingMaterial GetCurTask()
        {
            return m_schedulingMaterial;
        }

        /// <summary>
        /// 向上下料任务中，添加任务
        /// </summary>
        /// <param name="sm"></param>
        /// <returns></returns>
        public bool AddTask(SchedulingMaterial sm)
        {
            lock (this)
            {
                m_schedulingMaterial = sm;



                //加载上料任务
                DealLoadTask(sm);
                DealUnloadTask(sm);
                DealChangeTask(sm);
                DealTestLoadTask(sm);
                DealTestUnLoadTask(sm);
            }
            
            //lock(this)
            //{
            //    if (Categories != null && Categories.Count > 0)
            //        Categories.Clear();
            //    if (MoveDir != null && MoveDir.Count > 0)
            //        MoveDir.Clear();
            //    List<ActionItem> turnOverTaskList = new List<ActionItem>();
            //    List<ActionItem> otherTaskList = new List<ActionItem>();
            //    bool bHaveTurnover = false;
            //    bool bHaveOther = false;
                
            //    if (turnoverInfoList != null && turnoverInfoList.Count > 0)
            //        return false;
            //    //这里开始任务的分配
            //    //如果有从周转载盘到其他盘，
            //    var types = sm.ActionItems.GroupBy(ai => ai.Load.Type);
            //    foreach (var type in types)
            //    {
            //        if (type.Key == TurnoverType.Turnover)
            //        {
            //            bHaveTurnover = true;
            //        }
            //        else
            //        {
            //            bHaveOther = true;
            //        }
            //        Categories.Add(type.Key);
            //    }
            //    if (bHaveTurnover)
            //    {
            //        //turnOverTaskList = sm.ActionItems.Where(ai => ai.Load.Type == TurnoverType.Turnover).OrderBy(t => t.To.Type).ToList();
            //        turnOverTaskList = sm.ActionItems.Where(ai => ai.Load.Type == TurnoverType.Turnover).OrderBy(t => t.Load.Index).ToList();
            //    }
            //    if (bHaveOther)
            //    {
            //        otherTaskList = sm.ActionItems.Where(ai => ai.Load.Type != TurnoverType.Turnover).ToList();
            //    }
            //    if (bHaveTurnover && bHaveOther)
            //    {

            //        // 1 2 3 4 5 6 7 
            //        // 1 2 3 4 5 6 7 8
            //        int maxNum = Math.Max(turnOverTaskList.Count, otherTaskList.Count);
            //        int nozzleNum = NozzleManager.GetNozzles().Count;
            //        for (int i = 0; i < maxNum; i += nozzleNum)
            //        {
            //            for(int nozzle=0;nozzle< nozzleNum; nozzle++)
            //            {
            //                if (turnOverTaskList.Count > i + nozzle)
            //                {
            //                    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + nozzle]);
            //                    turnoverInfoList.Add(ti);
            //                }
            //            }
            //            for (int nozzle = 0; nozzle < nozzleNum; nozzle++)
            //            {
            //                if (otherTaskList.Count > i + nozzle)
            //                {
            //                    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + nozzle]);
            //                    turnoverInfoList.Add(ti);
            //                }
            //            }

            //            //if (turnOverTaskList.Count >= i + 1)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 2)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 1]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 3)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 2]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 4)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 3]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 5)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 4]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 6)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 5]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 7)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 6]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (turnOverTaskList.Count >= i + 8)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 7]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 1)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 2)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 1]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 3)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 2]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 4)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 3]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 5)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 4]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 6)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 5]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 7)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 6]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //            //if (otherTaskList.Count >= i + 8)
            //            //{
            //            //    TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 7]);
            //            //    turnoverInfoList.Add(ti);
            //            //}
            //        }
            //    }
            //    else if (bHaveTurnover)
            //    {
            //        foreach (ActionItem ai in turnOverTaskList)
            //        {
            //            TurnoverInfo ti = ActionItem2TurnoverInfo(sm, ai);
            //            turnoverInfoList.Add(ti);
            //        }
            //    }
            //    else if (bHaveOther)
            //    {
            //        foreach (ActionItem ai in otherTaskList)
            //        {
            //            TurnoverInfo ti = ActionItem2TurnoverInfo(sm, ai);
            //            turnoverInfoList.Add(ti);
            //        }
            //    }
            //}
            //if(turnoverInfoList.Count>0)
            //{
            //    Insert2Db();
            //}
            return true;
        }
        /// <summary>
        /// 加载上料任务
        /// </summary>
        private void DealLoadTask(SchedulingMaterial sm)
        {
            if (sm == null)
                return;
            List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.ToBeTested).ToList();
            if (ais != null && ais.Count > 0)
            {
                TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
                foreach (ActionItem item in ais)
                {
                    loadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Load));
                }
            }
        }
        /// <summary>
        /// 加载下料任务
        /// </summary>
        private void DealUnloadTask(SchedulingMaterial sm)
        {
            if (sm == null)
                return;
            List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && (l.To.Type != TurnoverType.Turnover && l.To.Type != TurnoverType.Tester)).ToList();
            if (ais != null && ais.Count > 0)
            {
                TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
                foreach (ActionItem item in ais)
                {
                    unloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Unload));
                }
            }
        }
        /// <summary>
        /// 加载换料任务
        /// </summary>
        private void DealChangeTask(SchedulingMaterial sm)
        {
            if (sm == null)
                return;
            List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && l.To.Type == TurnoverType.Turnover).ToList();
            if(ais!=null&&ais.Count>0)
            {
                TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
                foreach (ActionItem item in ais)
                {
                    changeTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Change));
                }
            }
        }

        /// <summary>
        /// 加载上料任务
        /// </summary>
        private void DealTestLoadTask(SchedulingMaterial sm)
        {
            lock(obj)
            {
                if (sm == null)
                    return;
                List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && l.To.Type == TurnoverType.Tester).ToList();
                if (ais != null && ais.Count > 0)
                {
                    TestloadTaskArrived = true;
                    //如果上料任务列表里面有任务，说明是自己生成的任务，就不再向里面添加了
                    if (testLoadTaskList.Count > 0)
                        return;
                    foreach (ActionItem item in ais)
                    {
                        testLoadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.TestLoad));
                    }
                }
            }
            
        }
        /// <summary>
        /// 测试治具下料任务是否已经到达
        /// </summary>
        public bool TestUnloadTaskArrived = false;
        /// <summary>
        /// 测试治具上料任务是否已经到达
        /// </summary>
        public bool TestloadTaskArrived = false;
        /// <summary>
        /// 加载上料任务
        /// </summary>
        private void DealTestUnLoadTask(SchedulingMaterial sm)
        {
            lock(obj)
            {
                if (sm == null)
                    return;
                List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Tester && l.To.Type == TurnoverType.Turnover).ToList();
                if (ais != null && ais.Count > 0)
                {
                    TestUnloadTaskArrived = true;
                    //如果下料任务列表里面有任务，说明是自己生成的任务，就不再向里面添加了
                    if (testUnloadTaskList.Count > 0)
                        return;
                    foreach (ActionItem item in ais)
                    {
                        testUnloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.TestUnload));
                    }
                }
            }
        }

        public TurnoverInfo GetLoadTask()
        {
            if (loadTaskList == null)
                return null;
            else
            {
                return loadTaskList.Where(t=>t.Dealed==false).First();
            }
        }

        public TurnoverInfo GetUnLoadTask()
        {
            if (unloadTaskList == null || unloadTaskList.Where(t => t.Dealed == false).Count()==0)
                return null;
            else
            {
                return  unloadTaskList.Where(t => t.Dealed == false).First();
            }
        }

        public TurnoverInfo GetChangeTask()
        {
            if (changeTaskList == null)
                return null;
            else
            {
                return  changeTaskList.Where(t => t.Dealed == false).First();
            }
        }

        public TurnoverInfo GetTestLoadTask()
        {
            if (changeTaskList == null)
                return null;
            else
            {
                return testLoadTaskList.Where(t => t.Dealed == false).First();
            }
        }

        public TurnoverInfo GetTestUnLoadTask()
        {
            if (changeTaskList == null)
                return null;
            else
            {
                return testUnloadTaskList.Where(t => t.Dealed == false).First();
            }
        }


        private TurnoverInfo ActionItem2TurnoverInfo(SchedulingMaterial sm,ActionItem ai, ETaskType taskMode)
        {
            TurnoverInfo ti=new TurnoverInfo();
            ti.GUID = GuidHelper.Create();
            ti.FromType = ai.Load.Type;
            ti.FromFloor = ai.Load.Floor;
            ti.FromIndex = ai.Load.Index;
            ti.SN = ai.SN;
            ti.ToType = ai.To.Type;
            ti.ToFloor = ai.To.Floor;
            ti.ToIndex = ai.To.Index;
            ti.taskMode = taskMode;
            ti.Instruction = sm.Instruction;
            ti.GroupID = sm.GroupID;
            ti.TurnoverID = sm.TurnoverID;
            //MoveDir.Add(ti.FromType.ToString()+"_"+ti.ToType.ToString());
            return ti;
        }

        /// <summary>
        /// 创建测试治具上料任务
        /// </summary>
        public void CreateTestLoadTask()
        {
            lock(obj)
            {
                testLoadTaskList.Clear();
                //从周转盘生成测试治具的上料任务
                List<TurnoverTraySlot> slots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have);
                foreach (TurnoverTraySlot slot in slots)
                {
                    TurnoverInfo ti = new TurnoverInfo();
                    ti.GUID = GuidHelper.Create();
                    ti.FromType = TurnoverType.Turnover;
                    ti.FromFloor = 1;
                    ti.FromIndex = slot.Index - 1;
                    ti.SN = slot.SN;
                    ti.ToType = TurnoverType.Tester;
                    ti.ToFloor = 1;
                    ti.ToIndex = TestLoadSlotIndexChange(slot.Index) - 1;
                    ti.taskMode = ETaskType.TestLoad;
                    ti.Instruction = EInstruction.LoadAndUnload;
                    ti.GroupID = 0;
                    ti.TurnoverID = 0;
                    testLoadTaskList.Add(ti);
                }
            }
        }

        private static object obj = new object();

        /// <summary>
        /// 创建测试治具下料任务
        /// </summary>
        public void CreateTestUnLoadTask()
        {
            lock(obj)
            {
                testUnloadTaskList.Clear();
                //从周转盘生成测试治具的上料任务
                List<TestTraySlot> slots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
                foreach (TestTraySlot slot in slots)
                {
                    TurnoverInfo ti = new TurnoverInfo();
                    ti.GUID = GuidHelper.Create();
                    ti.FromType = TurnoverType.Tester;
                    ti.FromFloor = 1;
                    ti.FromIndex = slot.Index - 1;
                    ti.SN = slot.SN;
                    ti.ToType = TurnoverType.Turnover;
                    ti.ToFloor = 1;
                    ti.ToIndex = TestUnLoadSlotIndexChange(slot.Index) - 1;
                    ti.taskMode = ETaskType.TestLoad;
                    ti.Instruction = EInstruction.LoadAndUnload;
                    ti.GroupID = 0;
                    ti.TurnoverID = 0;
                    testUnloadTaskList.Add(ti);
                }
            }
        }

        /// <summary>
        /// 测试位上料索引转换
        /// </summary>
        /// <returns></returns>
        private int TestLoadSlotIndexChange(int slotIndex)
        {
            if (slotIndex <= 8) return slotIndex;
            else return slotIndex - 8;
        }
        /// <summary>
        /// 测试位下料到周转盘索引转换
        /// </summary>
        /// <param name="slotIndex"></param>
        /// <returns></returns>
        private int TestUnLoadSlotIndexChange(int slotIndex)
        {
            if (slotIndex <= 8) return slotIndex + 8;
            else return slotIndex + 16;
        }

        /// <summary>
        /// 创建从排料吸嘴到多功能料仓的下料任务
        /// </summary>
        public void CreateDischargeNozzleCleanOutTask()
        {
            lock(this)
            {
                
                List<Nozzle> unloadNozzles = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload);
                if (unloadNozzles != null && unloadNozzles.Count > 0)
                {
                    foreach (Nozzle nozzle in unloadNozzles)
                    {
                        TurnoverInfo ti = new TurnoverInfo();
                        ti.GUID = GuidHelper.Create();
                        ti.FromType = TurnoverType.Turnover;
                        ti.FromFloor = 1;
                        ti.FromIndex = nozzle.NozzleIndex-1;
                        ti.SN = "";
                        ti.ToType = TurnoverType.Multifunction;
                        ti.ToFloor = 1;
                        ti.ToIndex = 0;
                        ti.taskMode = ETaskType.Unload;
                        ti.Instruction = EInstruction.LoadAndUnload;
                        ti.GroupID = 0;
                        ti.TurnoverID = 0;
                        unloadTaskList.Add(ti);
                    }
                }
            }
        }

        /// <summary>
        /// 创建周转盘清料任务
        /// </summary>
        public void CreateTurnoverTrayCleanTask()
        {
            lock(this)
            {
                foreach(TurnoverTraySlot slot in  TurnoverTrayManager.Instance.Slots)
                {
                    if(slot.IsHasProduct)
                    {
                        TurnoverInfo ti = new TurnoverInfo();
                        ti.GUID = GuidHelper.Create();
                        ti.FromType = TurnoverType.Turnover;
                        ti.FromFloor = 1;
                        ti.FromIndex = slot.Index - 1;
                        ti.SN = "";
                        ti.ToType = TurnoverType.Multifunction;
                        ti.ToFloor = 1;
                        ti.ToIndex = 0;
                        ti.taskMode = ETaskType.Unload;
                        ti.Instruction = EInstruction.LoadAndUnload;
                        ti.GroupID = 0;
                        ti.TurnoverID = 0;
                        unloadTaskList.Add(ti);
                    }
                }
            }
        }

        /// <summary>
        /// 创建周转吸嘴
        /// </summary>
        public void CreateTurnoverNozzleTestTrayCleanTask()
        {
            lock(this)
            {
                List<TransitNozzle> hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
                if (hasProductNozzles != null && hasProductNozzles.Count > 0)
                {
                    foreach (TransitNozzle nozzle in hasProductNozzles)
                    {
                        TurnoverInfo ti = new TurnoverInfo();
                        ti.GUID = GuidHelper.Create();
                        ti.FromType = TurnoverType.Tester;
                        ti.FromFloor = 1;
                        ti.FromIndex = nozzle.NozzleIndex-1;
                        ti.SN = "";
                        ti.ToType = TurnoverType.Turnover;
                        ti.ToFloor = 1;
                        ti.ToIndex = TestUnLoadSlotIndexChange(nozzle.NozzleIndex) - 1;
                        ti.taskMode = ETaskType.TestLoad;
                        ti.Instruction = EInstruction.LoadAndUnload;
                        ti.GroupID = 0;
                        ti.TurnoverID = 0;
                        testUnloadTaskList.Add(ti);
                    }
                }

                List<TestTraySlot> hasProductSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
                if (hasProductSlots != null && hasProductSlots.Count > 0)
                {
                    foreach (TestTraySlot slot in hasProductSlots)
                    {
                        TurnoverInfo ti = new TurnoverInfo();
                        ti.GUID = GuidHelper.Create();
                        ti.FromType = TurnoverType.Tester;
                        ti.FromFloor = 1;
                        ti.FromIndex = slot.Index - 1;
                        ti.SN = "";
                        ti.ToType = TurnoverType.Turnover;
                        ti.ToFloor = 1;
                        ti.ToIndex = TestUnLoadSlotIndexChange(slot.Index) - 1;
                        ti.taskMode = ETaskType.TestLoad;
                        ti.Instruction = EInstruction.LoadAndUnload;
                        ti.GroupID = 0;
                        ti.TurnoverID = 0;
                        testUnloadTaskList.Add(ti);
                    }
                }
            }
           
        }
    }

    /// <summary>
    /// 排料任务管理
    /// </summary>
    public class DischargeTaskManager
    {
        private DischargeTaskManager() { }
        private static DischargeTaskManager instance;
        public  static DischargeTaskManager Instance
        {
            get
            {
                if(instance==null)
                    instance = new DischargeTaskManager();
                return instance;
            }
        }
        public ETaskStatus Status { get; set; } = ETaskStatus.Idle;
        private SchedulingMaterial m_schedulingMaterial;
        /// <summary>
        /// 上料任务
        /// </summary>
        List<TurnoverInfo> stockTray2TurnoverTrayList = new List<TurnoverInfo>();
        /// <summary>
        /// 下料任务
        /// </summary>
        List<TurnoverInfo> turnoverTray2StockTrayList = new List<TurnoverInfo>();
        /// <summary>
        /// 换料任务
        /// </summary>
        List<TurnoverInfo> turnoverTray2turnoverTrayList = new List<TurnoverInfo>();
    }

    /// <summary>
    /// 周转任务管理
    /// </summary>
    public class TransitTaskManager
    {
        public ETaskStatus Status { get; set; } = ETaskStatus.Idle;
        private SchedulingMaterial m_schedulingMaterial;
    }

    /// <summary>
    /// 任务状态
    /// </summary>
    public enum ETaskStatus
    {
        Idle,
        Running
    }
}