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

namespace Rs.MotionPlat.Flow
{
    public enum ETaskMode
    {
        Load,
        Unload,
        Change,
        TestLoad,
        TestUnload
    }

    public class LoadAndUnloadTask
    {
        private SchedulingMaterial m_schedulingMaterial;
        /// <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>();

        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(ETaskMode.Load) + GetTaskNum(ETaskMode.Unload) + GetTaskNum(ETaskMode.Change);
                int count2 = GetTaskNum(ETaskMode.TestLoad) + GetTaskNum(ETaskMode.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;
        }


        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);
        }

        /// <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());
            LogHelper.Debug("发送:" + content);
            return content;
        }
        public string GetTestLoadString()
        {
            TurnoverInfos infos = new TurnoverInfos();
            infos.Instruction = EInstruction.LoadAndUnloadResult;
            infos.GroupID = m_schedulingMaterial.GroupID;
            infos.TurnoverID = m_schedulingMaterial.TurnoverID;
            infos.Infos = testLoadTaskList;
            string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
            LogHelper.Debug("发送:" + content);
            return content;
        }
        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;
        }

        public List<TurnoverInfo> GetTestLoadTasks()
        {
            return testLoadTaskList;
        }

        public List<TurnoverInfo> GetTestUnLoadTasks()
        {
            return testUnloadTaskList;
        }

        /// <summary>
        /// 获取任务的个数
        /// </summary>
        /// <param name="taskMode"></param>
        /// <returns></returns>
        public int GetTaskNum(ETaskMode taskMode)
        {
            lock(this)
            {
                switch (taskMode)
                {
                    case ETaskMode.Load:
                        if (loadTaskList == null) return 0;
                        return loadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskMode.Unload:
                        if (unloadTaskList == null) return 0;
                        return unloadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskMode.Change:
                        if (changeTaskList == null) return 0;
                        return changeTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskMode.TestLoad:
                        if (testLoadTaskList == null) return 0;
                        return testLoadTaskList.Where(t => t.Dealed == false).Count();
                    case ETaskMode.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>
        /// 清除任务
        /// </summary>
        public void Clear()
        {
            lock(this)
            {
                if (turnoverResult != null)
                {
                    turnoverResult.Clear();
                    loadTaskList.Clear();
                    unloadTaskList.Clear();
                    changeTaskList.Clear();
                    testLoadTaskList.Clear();
                    testUnloadTaskList.Clear();
                }
            }
        }
        
        /// <summary>
        /// 向上下料任务中，添加任务
        /// </summary>
        /// <param name="sm"></param>
        /// <returns></returns>
        public bool Add(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)
            {
                foreach (ActionItem item in ais)
                {
                    loadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskMode.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)
            {
                foreach (ActionItem item in ais)
                {
                    unloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskMode.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)
            {
                foreach (ActionItem item in ais)
                {
                    changeTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskMode.Change));
                }
            }
        }

        /// <summary>
        /// 加载上料任务
        /// </summary>
        private void DealTestLoadTask(SchedulingMaterial sm)
        {
            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)
            {
                foreach (ActionItem item in ais)
                {
                    testLoadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskMode.TestLoad));
                }
            }
        }

        /// <summary>
        /// 加载上料任务
        /// </summary>
        private void DealTestUnLoadTask(SchedulingMaterial sm)
        {
            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)
            {
                foreach (ActionItem item in ais)
                {
                    testUnloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskMode.TestUnload));
                }
            }
        }

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

        public TurnoverInfo GetUnLoadTask()
        {
            if (unloadTaskList == null)
                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, ETaskMode 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;
        }
    }
}