using HalconDotNet;
using Rs.Camera;
using Rs.Controls;
using Rs.Framework;
using Rs.Motion;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Flow.Space;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Rs.MotionPlat.Flow
{
    public enum EWorkFlowStep
    {
        等待任务,
        到取料位上方,
        等待到取料位上方,
        到取料位下方,
        等待到取料位下方,
        开真空,
        取料真空检测,
        取料完成抬起,
        等待取料完成抬起,
        到下相机拍照起始位,
        等待到下相机拍照起始位,
        到下相机拍照结束位,
        等待到下相机拍照结束位,
        等待相机拍照完成,
        等待视觉处理结果,
        到放料位上方,
        等待到放料位上方,
        到放料位下方,
        等待到放料位下方,
        到放料破真空位,
        等待到放料破真空位,
        周转盘放料位真空检测,
        放料完成抬起,
        等待放料完成抬起,
        放料真空检测,
        放料任务完成,
        任务结束到安全位,
        等待任务结束到安全位,
        测试工位上料,
        等待测试工位上料完成,
        测试工位下料,
        等待测试工位下料完成,
        等待Input料盘搬运完成,
        等待Input料仓上料完成,
        IDLE
    }

    public class WorkFlow : BaseFlow
    {
        private bool grabOK = false;
        private static WorkFlow instance;

        public event Action<List<MatchResult>> OnMatchResult;
        public static WorkFlow Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new WorkFlow();
                }
                return instance;
            }
        }

        enum ELoadUnloadAction
        {
            /// <summary>
            /// 上料
            /// </summary>
            LOAD,
            /// <summary>
            /// 下料
            /// </summary>
            UNLOAD
        }
        private WorkFlow()
        {
            //HikCamera.Instance.GrabOkEvent += (camIndex,img) => {
            //    grabOK = true;
            //};
        }
        EWorkFlowStep flowStep = EWorkFlowStep.等待任务;
        EWorkFlowStep restoreFlowStep = EWorkFlowStep.IDLE;
        HObject[] imgs = new HObject[2];
        List<MatchResult> mrs = new List<MatchResult>();
        int FetchNum = 0;//取料次数
        bool bFetchBack = false;
        double targetX = 0.0;
        double targetY = 0.0;
        TraySlot tray = new TraySlot();
       // List<TurnoverInfo> totalTask = new List<TurnoverInfo>();
        List<TurnoverInfo> dealTask = new List<TurnoverInfo>();
        //TurnoverInfo curTurnoverTask = new TurnoverInfo();
        TurnoverInfo curTask = new TurnoverInfo();
        List<Nozzle> idleNozzle = new List<Nozzle>();
        Nozzle curNozzle = new Nozzle();
        SlotPoint curSlotPoint = new SlotPoint();
        SlotPoint nozzleDist = new SlotPoint();
        //List<Nozzle> unloadNozzles = new List<Nozzle>();
        TraySlot downSlot = new TraySlot();
        OffsetPoint turnoverOffsetPoint = new OffsetPoint();
        int needGrabNum = 0;//需要拍照的吸嘴数量
        ErrorCode errCode = ErrorCode.Ok;
        public override void Run()
        {
            switch (flowStep)
            {
                case EWorkFlowStep.等待任务:
                    if (LoadAndUnloadTask.Instance.Count > 0)
                    {
                        if(LoadAndUnloadTask.Instance.CanRunTask())
                        {
                            if(LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestLoad)>0)
                            {
                                flowStep = EWorkFlowStep.测试工位上料;
                            }
                            else if(LoadAndUnloadTask.Instance.GetTaskNum( ETaskMode.TestUnload)>0)
                            {
                                flowStep = EWorkFlowStep.测试工位下料;
                            }
                            else
                            {
                                flowStep = EWorkFlowStep.到取料位上方;
                            }
                        }
                    }
                    break;
                case EWorkFlowStep.到取料位上方:
                    //先取下料任务,再取上料任务，最后取换料任务
                    if(LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Unload)>0)
                    {
                        curTask = LoadAndUnloadTask.Instance.GetUnLoadTask();
                    }
                    else if(LoadAndUnloadTask.Instance.GetTaskNum( ETaskMode.Load)>0)
                    {
                        curTask = LoadAndUnloadTask.Instance.GetLoadTask();
                    }
                    else if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Change) > 0)
                    {
                        curTask = LoadAndUnloadTask.Instance.GetChangeTask();
                    }
                    curNozzle = NozzleManager.GetIdelNozzle();
                    if (curTask!=null && curNozzle != null)
                    {
                        if (XYCanMove())
                        {
                            curSlotPoint = null;
                            if (curTask.FromType == TurnoverType.Turnover)
                            {
                                curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "Turnover", curTask.FromIndex + 1, EPointType.RUN);
                                MessageQueue.Instance.Insert($"吸嘴{curTask.FromIndex + 1} 去周转盘 {curTask.FromIndex + 1} 号穴位取料");
                            }
                            else if (curTask.FromType == TurnoverType.ToBeTested)
                            {
                                TraySlot slot = GlobalTray.InputTray.GetSlot(ESlotStatus.Have);
                                if (slot != null)
                                {
                                    curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "Input", slot.Index, EPointType.BASE);
                                    MessageQueue.Instance.Insert($"吸嘴{curNozzle.NozzleIndex} 去Input盘 {slot.Index} 号穴位取料");
                                }
                                else
                                {
                                    Msg.ShowInfo("tray has take over,please change tray");
                                    GlobalTray.InputTray.ResetTray();
                                    GlobalTray.InputTray.Fill();
                                    //TakeTrayFlow.Instance.Take(EStockType.Input, EStockType.Empty1, ELoadUnloadType.Unload);
                                    //restoreFlowStep = EWorkFlowStep.到取料位上方;
                                    //flowStep = EWorkFlowStep.等待Input料盘搬运完成;
                                }
                            }
                            if (curSlotPoint != null)
                            {
                                nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
                                targetX = curSlotPoint.X + nozzleDist.X;
                                targetY = curSlotPoint.Y + nozzleDist.Y;
                                errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
                                if (errCode == ErrorCode.Ok)
                                {
                                    //if(Ops.IsHomedAndNearStartPos($"NozzleR{NozzleIndex}"))
                                    {
                                        errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<Double>($"NozzleR{curNozzle.NozzleIndex}StartPos"), (int)(GlobalVar.WholeSpeed));
                                        errCode = AxisControl.LoadY.MovePos(targetY, (int)(GlobalVar.WholeSpeed));
                                        if (errCode == ErrorCode.Ok)
                                        {
                                            flowStep = EWorkFlowStep.等待到取料位上方;
                                        }
                                    }
                                    //else
                                    // {
                                    //     Msg.ShowError($"吸头 NozzleR{NozzleIndex} 不在起始位，请手动手动回原后运动到起始位");
                                    // }
                                }
                            }
                        }
                        else
                        {
                            Msg.ShowError("x y move isn't safe");
                        }
                    }
                    
                    break;
                case EWorkFlowStep.等待到取料位上方:
                    if (Ops.IsStop("LoadX","LoadY", $"NozzleR{curNozzle.NozzleIndex}"))
                    {
                        Thread.Sleep(100);
                        flowStep = EWorkFlowStep.到取料位下方;
                        MessageQueue.Instance.Insert("已运动到取料位上方");

                    }
                    break;
                case EWorkFlowStep.到取料位下方:
                    if(AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").HomeStatus== EHomeStatus.Finished)
                    {
                        MessageQueue.Instance.Insert("准备运动到取料位下方");
                        if (curTask.FromType == TurnoverType.Turnover)
                        {
                            errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(GetVacOffsetHeight(FetchNum) + SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight"), GlobalVar.WholeSpeed);
                        }
                        else if (curTask.FromType == TurnoverType.ToBeTested)
                        {
                            errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(GetVacOffsetHeight(FetchNum) + SysConfigParam.GetValue<double>($"TrayNozzle{curNozzle.NozzleIndex}TakeHeight"), GlobalVar.WholeSpeed);
                        }
                        if (errCode == ErrorCode.Ok)
                        {
                            flowStep = EWorkFlowStep.等待到取料位下方;
                        }
                    }
                    else
                    {
                        Msg.ShowError($"NozzleZ{curNozzle.NozzleIndex} 不在原点，请手动回原后点击确定");
                    }
                    break;
                case EWorkFlowStep.等待到取料位下方:
                    if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}"))
                    {
                        Thread.Sleep(GlobalVar.AxisArrivedWaittime);
                        MessageQueue.Instance.Insert("已运动到取料位下方");
                        flowStep = EWorkFlowStep.开真空;
                    }
                    break;
                case EWorkFlowStep.开真空:
                    Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
                    MessageQueue.Instance.Insert($"打开{curNozzle.NozzleIndex}号吸嘴真空吸");
                    Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime);
                    if (curTask.FromType == TurnoverType.Turnover)
                    {
                        Ops.Off($"周转盘{curTask.FromIndex+1}号穴位真空吸");
                        Thread.Sleep(GlobalVar.TurnoverTrayCloseVacSuctionDelaytime);
                        Ops.On($"周转盘{curTask.FromIndex + 1}号穴位真空破");
                        Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime);
                        Ops.Off($"周转盘{curTask.FromIndex + 1}号穴位真空破");
                        Thread.Sleep(GlobalVar.TurnoverTrayCloseVacBreakDelaytime);
                    }
                    flowStep = EWorkFlowStep.取料完成抬起;
                    break;

                case EWorkFlowStep.取料完成抬起:
                    errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
                    if (errCode == ErrorCode.Ok)
                    {
                        flowStep = EWorkFlowStep.等待取料完成抬起;
                    }
                    break;
                case EWorkFlowStep.等待取料完成抬起:
                    if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}"))
                    {
                        flowStep = EWorkFlowStep.取料真空检测;
                    }
                    break;
                case EWorkFlowStep.取料真空检测:
                    if (Ops.IsOn($"{curNozzle.NozzleIndex}号吸嘴真空吸检测") || GlobalVar.RunSpace)
                    {
                        curNozzle.Status = ENozzleStatus.ToUnload;
                        curNozzle.FromType = curTask.FromType;
                        curNozzle.FromFloor = curTask.FromFloor;

                        curNozzle.ToType = curTask.ToType;
                        curNozzle.ToIndex = curTask.ToIndex;
                        curTask.SuckerNo = curNozzle.NozzleIndex ;
                        curNozzle.TurnoverGUID = curTask.GUID;
                       
                        FetchNum = 0;
                        if (curTask.FromType == TurnoverType.Turnover)
                        {
                            curNozzle.SN = curTask.SN;
                            curNozzle.FromIndex = curTask.FromIndex;
                            GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex+1, ESlotStatus.NotHave);
                        }
                        else if (curTask.FromType == TurnoverType.ToBeTested)
                        {
                            curNozzle.FromIndex = GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index;
                            GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
                        }
                        curNozzle.Update();
                        curTask.Dealed = true;
                        if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode)>0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
                        {
                            flowStep = EWorkFlowStep.到取料位上方;
                        }
                        else
                        {
                            flowStep = EWorkFlowStep.到下相机拍照起始位;
                        }
                    }
                    else
                    {
                        FetchNum++;
                        if (FetchNum == 6)
                        {
                            DialogResult dr = Msg.ShowError($"吸嘴{curNozzle.NozzleIndex}取料{FetchNum}次失败报警,请处理后点击确定", MessageBoxButtons.RetryCancel);
                            if(dr==  DialogResult.Retry)
                            {
                                FetchNum = 0;
                                flowStep = EWorkFlowStep.到取料位下方;
                            }
                            else
                            {
                                FetchNum = 0;
                                curNozzle.Status = ENozzleStatus.ToUnload;
                                curNozzle.FromType = curTask.FromType;
                                curNozzle.FromFloor = curTask.FromFloor;

                                curNozzle.ToType = curTask.ToType;
                                curNozzle.ToIndex = curTask.ToIndex;
                                curTask.SuckerNo = curNozzle.NozzleIndex;
                                curNozzle.TurnoverGUID = curTask.GUID;

                                FetchNum = 0;
                                if (curTask.FromType == TurnoverType.Turnover)
                                {
                                    curNozzle.SN = curTask.SN;
                                    curNozzle.FromIndex = curTask.FromIndex;
                                    GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex + 1, ESlotStatus.NotHave);
                                }
                                else if (curTask.FromType == TurnoverType.ToBeTested)
                                {
                                    curNozzle.FromIndex = GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index;
                                    GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
                                }
                                curNozzle.Update();
                                curTask.Dealed = true;
                                if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode) > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
                                {
                                    flowStep = EWorkFlowStep.到取料位上方;
                                }
                                else
                                {
                                    flowStep = EWorkFlowStep.到下相机拍照起始位;
                                }
                            }
                        }
                        flowStep = EWorkFlowStep.到取料位上方;
                    }
                    break;
                case EWorkFlowStep.到下相机拍照起始位:
                    if (XYCanMove())
                    {
                        ImageProcess.ClearAutoTrigger();
                        HikCamera.Instance.SetExposure("locationCamera", GlobalVar.FlyGrabExposureTime);
                        HikCamera.Instance.SetGain("locationCamera", GlobalVar.FlyGrabGain);
                        if(NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType== TurnoverType.Turnover)
                        {
                            needGrabNum = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count();
                            AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>($"Nozzle{needGrabNum}CenterX") - 30, GlobalVar.WholeSpeed);
                            AxisControl.LoadY.MovePos(SysConfigParam.GetValue<double>($"Nozzle8CenterY"), GlobalVar.WholeSpeed);
                        }
                        else
                        {
                            AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("Nozzle1CenterX") + 30, GlobalVar.WholeSpeed);
                            AxisControl.LoadY.MovePos(SysConfigParam.GetValue<double>("Nozzle1CenterY"), GlobalVar.WholeSpeed);
                        }
                        flowStep = EWorkFlowStep.等待到下相机拍照起始位;
                    }

                    break;
                case EWorkFlowStep.等待到下相机拍照起始位:
                    if (Ops.IsStop("LoadX", "LoadY"))
                    {
                        Thread.Sleep(100);
                        HikCamera.Instance.SetTrigger("locationCamera", ETriggerMode.Auto);
                        List<double> grabPoints = new List<double>();
                        //获取有几个吸嘴需要拍照
                        needGrabNum = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count();
                        if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover)
                        {
                            for (int i = needGrabNum; i >= 1; i--)
                            {
                                grabPoints.Add(SysConfigParam.GetValue<double>($"Nozzle{i}CenterX"));
                            }
                        }
                        else
                        {
                            for (int i = 1; i < needGrabNum + 1; i++)
                            {
                                grabPoints.Add(SysConfigParam.GetValue<double>($"Nozzle{i}CenterX"));
                            }
                        }
                            
                        errCode = AxisControl.LoadX.SetPosCompare(1, grabPoints.ToArray());
                        if(errCode== ErrorCode.Ok)
                        {
                            flowStep = EWorkFlowStep.到下相机拍照结束位;
                        }
                    }
                    break;

                case EWorkFlowStep.到下相机拍照结束位:
                    if (XYCanMove())
                    {
                        IoManager.Instance.WriteOut("下左相机光源触发", 1);
                        Thread.Sleep(50);
                        if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover)
                        {
                            AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>($"Nozzle1CenterX") + 10, GlobalVar.FlyCameraSpeed);
                        }
                        else
                        {
                            AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>($"Nozzle{needGrabNum}CenterX") - 10, GlobalVar.FlyCameraSpeed);
                        }
                            
                        flowStep = EWorkFlowStep.等待到下相机拍照结束位;
                    }

                    break;
                case EWorkFlowStep.等待到下相机拍照结束位:
                    Stopwatch stopwatch = new Stopwatch();

                    if (Ops.IsStop("LoadX"))
                    {
                        AxisControl.LoadX.ClearCompare(1);
                        IoManager.Instance.WriteOut("下左相机光源触发", 0);
                        flowStep = EWorkFlowStep.等待相机拍照完成;
                        stopwatch.Start();
                    }
                    break;
                case EWorkFlowStep.等待相机拍照完成:
                    imgs = ImageProcess.GetAutoImage();
                    if (imgs != null && imgs.Length == needGrabNum)
                    {
                        if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover)
                        {
                            imgs = imgs.Reverse().ToArray();
                        }
                        if (GlobalVar.RunSpace)
                        {
                            foreach(Nozzle nl in NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload))
                            {
                                nl.SN = nl.FromIndex.ToString().PadLeft(18, '0');
                                //nl.SN = GuidHelper.Create();
                            }
                            flowStep = EWorkFlowStep.到放料位上方;
                            mrs = new List<MatchResult>();
                            for(int i=0;i<needGrabNum;i++)
                            {
                                mrs.Add(new MatchResult());
                            }
                        }
                        else
                        {
                            //拍照完成
                            flowStep = EWorkFlowStep.等待视觉处理结果;
                        }

                    }
                    break;
                case EWorkFlowStep.等待视觉处理结果:
                    mrs = VisionProcess.Instance.MatchDownCam(imgs);
                    if (mrs != null && mrs.Count == imgs.Length && mrs.Where(m=>m.IsOK==true).Count()==imgs.Length)
                    {
                        //foreach (Nozzle nozzle in NozzleManager.GetNozzles())
                        //{
                        //    nozzle.SN = Guid.NewGuid().ToString();
                        //}
                        int ni = 1;
                        foreach (MatchResult item in mrs)
                        {
                            NozzleManager.GetNozzle(ni).SN = item.SN;
                            //File.AppendAllText("D://OFFSET.TXT",$"SN:{item.SN},X:{item.OffsetRow},Y:{item.OffsetCol},R:{AngleTool.Rad2Deg(item.Angle)}\r\n");
                            ni++;
                        }
                        //CameraOkEvent?.Invoke(imgs, mrs);
                        OnMatchResult?.Invoke(mrs);
                        flowStep = EWorkFlowStep.到放料位上方;
                        //Thread.Sleep(2000);
                    }
                    else
                    {
                        int ni = 1;
                        List<int> errCodeList = new List<int>();
                        foreach (MatchResult item in mrs)
                        {
                            if(item.IsOK)
                            {
                                NozzleManager.GetNozzle(ni).SN = item.SN;
                            }
                            else
                            {
                                errCodeList.Add(ni);
                                NozzleManager.GetNozzle(ni).SN = null;
                            }
                            ni++;
                        }
                        OnMatchResult?.Invoke(mrs);
                        DialogResult dr =  Msg.ShowQuestion($"吸嘴{string.Join(",",errCodeList)}扫描失败,点击取消则不再扫码", System.Windows.Forms.MessageBoxButtons.RetryCancel);
                        if(dr== DialogResult.Cancel)
                        {
                            flowStep = EWorkFlowStep.到放料位上方;
                        }
                        else if(dr== DialogResult.Retry)
                        {
                            flowStep = EWorkFlowStep.到下相机拍照起始位;
                        }
                    }
                    break;
                case EWorkFlowStep.到放料位上方:
                    if (XYCanMove())
                    {
                        turnoverOffsetPoint.Reset();
                        tray = null;
                        targetX = 0.0;
                        targetY = 0.0;
                        ///获取需要放料的吸嘴
                        curSlotPoint = null;
                        curNozzle = NozzleManager.GetToUnloadNozzle();
                        if (curNozzle != null)
                        {
                            if (curNozzle.ToType == TurnoverType.Turnover)
                            {
                                curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "Turnover", curNozzle.ToIndex + 1, EPointType.RUN);
                                turnoverOffsetPoint = TurnoverSlotOffset.GetOffsetPoint(curNozzle.ToIndex + 1);
                            }
                            else if (curNozzle.ToType == TurnoverType.Passed)
                            {
                                downSlot = GlobalTray.OkTary.GetSlot(ESlotStatus.NotHave);
                                if (downSlot != null)
                                {
                                    curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "OK", downSlot.Index, EPointType.RUN);
                                }
                                else
                                {
                                    Msg.ShowInfo("tray has take over,please change tray");
                                    GlobalTray.OkTary.ResetTray();
                                    GlobalTray.OkTary.Clear();
                                    //Msg.ShowError("last slot");
                                }
                            }
                            else if (curNozzle.ToType == TurnoverType.Failed)
                            {
                                downSlot = GlobalTray.NgTray.GetSlot(ESlotStatus.NotHave);
                                if (downSlot != null)
                                {
                                    curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "NG", downSlot.Index, EPointType.RUN);
                                }
                                else
                                {
                                    GlobalTray.NgTray.ResetTray();
                                    GlobalTray.NgTray.Clear();
                                }
                            }
                            else if (curNozzle.ToType == TurnoverType.Multifunction)
                            {
                                downSlot = GlobalTray.MultiTray.GetSlot(ESlotStatus.NotHave);
                                if (downSlot != null)
                                {
                                    curSlotPoint = TrayPointManager.GetSlotPoint(GlobalVar.CurRecipe, "Multi", downSlot.Index, EPointType.RUN);
                                }
                                else
                                {
                                    GlobalTray.MultiTray.ResetTray();
                                    GlobalTray.MultiTray.Clear();
                                }
                            }
                        }
                        
                        if (curSlotPoint!=null)
                        {
                            nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
                            if(mrs[curNozzle.NozzleIndex - 1].OffsetRow <5 && mrs[curNozzle.NozzleIndex - 1].OffsetCol<5)
                            {
                                targetX = mrs[curNozzle.NozzleIndex -1].OffsetCol +  curSlotPoint.X + nozzleDist.X+ turnoverOffsetPoint.X;
                                targetY = mrs[curNozzle.NozzleIndex- 1].OffsetRow +curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y;
                            }
                            else
                            {
                                targetX = curSlotPoint.X + nozzleDist.X + turnoverOffsetPoint.X;
                                targetY = curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y;
                            }
                            errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
                            if (errCode == ErrorCode.Ok)
                            {
                                errCode = AxisControl.LoadY.MovePos(targetY, GlobalVar.WholeSpeed);
                                if (errCode == ErrorCode.Ok)
                                {
                                    errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MoveOffset((mrs[curNozzle.NozzleIndex - 1].OffsetA)+ turnoverOffsetPoint.A, GlobalVar.WholeSpeed);
                                    if (errCode == ErrorCode.Ok)
                                    {
                                        flowStep = EWorkFlowStep.等待到放料位上方;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        Msg.ShowError("x y move isn't safe");
                    }
                    break;
                case EWorkFlowStep.等待到放料位上方:
                    if (Ops.IsStop("LoadX", "LoadY",$"NozzleR{curNozzle.NozzleIndex}"))
                    {
                        Thread.Sleep(100);
                        flowStep = EWorkFlowStep.到放料位下方;

                    }
                    break;
                case EWorkFlowStep.到放料位下方:

                    if (curNozzle.ToType == TurnoverType.Turnover)
                    {
                        errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight"), GlobalVar.WholeSpeed);
                    }
                    else
                    {
                        errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight") +3, GlobalVar.WholeSpeed);
                    }

                    if (errCode== ErrorCode.Ok)
                    {
                        flowStep = EWorkFlowStep.等待到放料位下方;
                    }
                    break;
                case EWorkFlowStep.等待到放料位下方:
                    if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}"))
                    {
                        if (curNozzle.ToType== TurnoverType.Turnover)
                        {
                            Ops.On($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸");
                            Thread.Sleep(GlobalVar.TurnoverTrayOpenVacSuctionDelaytime);
                            Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");//关闭真空
                            Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
                            Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
                            Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
                            Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
                            Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
                            flowStep = EWorkFlowStep.放料完成抬起;
                        }
                        else
                        {
                            Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
                            Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
                            Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
                            Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
                            Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
                            Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
                            flowStep = EWorkFlowStep.放料完成抬起;
                        }
                        
                    }
                    break;
                //case EWorkFlowStep.到放料破真空位:
                //    errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight")+1, GlobalVar.WholeSpeed);
                //    if (errCode == ErrorCode.Ok)
                //    {
                //        flowStep = EWorkFlowStep.等待到放料破真空位;
                //    }
                //    break;
                //case EWorkFlowStep.等待到放料破真空位:
                //    if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}"))
                //    {
                //        flowStep = EWorkFlowStep.周转盘放料位真空检测;
                //    }
                        
                //    break;
                //case EWorkFlowStep.周转盘放料位真空检测:
                //    if (curNozzle.ToType == TurnoverType.Turnover)
                //    {
                //        Thread.Sleep(100);
                //        if(Ops.IsOn($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸检测") || GlobalVar.RunSpace)
                //        {
                //            flowStep = EWorkFlowStep.放料完成抬起;
                //        }
                //        else
                //        {
                //            DialogResult dr = Msg.ShowError($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸异常,点击确定后跳过");
                //            if (dr == DialogResult.OK)
                //            {
                //                flowStep = EWorkFlowStep.放料完成抬起;
                //            }
                //        }
                //    }
                //    break;
                case EWorkFlowStep.放料完成抬起:
                    errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
                    if (errCode == ErrorCode.Ok)
                    {
                        flowStep = EWorkFlowStep.等待放料完成抬起;
                    }
                    break;
                case EWorkFlowStep.等待放料完成抬起:
                    if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}"))
                    {
                        flowStep = EWorkFlowStep.放料真空检测;
                    }
                    break;
                case EWorkFlowStep.放料真空检测:
                    if (curNozzle.ToType == TurnoverType.Turnover)
                    { 
                        if (Ops.IsOn($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸检测") || GlobalVar.RunSpace)
                        {
                            flowStep = EWorkFlowStep.放料任务完成;
                        }
                        else
                        {
                            DialogResult dr = Msg.ShowError($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸异常,点击确定后跳过");
                            if (dr == DialogResult.OK)
                            {
                                flowStep = EWorkFlowStep.放料任务完成;
                            }
                        }
                    }
                    else
                    {
                        flowStep = EWorkFlowStep.放料任务完成;
                    }
                    break;
                case EWorkFlowStep.放料任务完成:
                    AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").Home();
                    //Ops.HomeAndGoStartPos($"NozzleR{NozzleIndex}");
                    if (curNozzle.ToType == TurnoverType.Turnover)
                    {
                        GlobalTray.TurnoverTray.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
                    }
                    else if (curNozzle.ToType == TurnoverType.Passed)
                    {
                        GlobalTray.OkTary.ChangeStatus(downSlot.Index, ESlotStatus.Have);
                    }
                    else if (curNozzle.ToType == TurnoverType.Failed)
                    {
                        GlobalTray.NgTray.ChangeStatus(downSlot.Index, ESlotStatus.Have);
                    }
                    else if (curNozzle.ToType == TurnoverType.Multifunction)
                    {
                        GlobalTray.MultiTray.ChangeStatus(downSlot.Index, ESlotStatus.Have);
                    }
                    curNozzle.Reset();
                    Thread.Sleep(100);
                    LoadAndUnloadTask.Instance.AddTurnoverResult(curNozzle);
                    if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
                    {
                        flowStep = EWorkFlowStep.到放料位上方;
                    }
                    else
                    {
                        if (LoadAndUnloadTask.Instance.GetUnDealedTask().Count > 0)
                        {
                            flowStep = EWorkFlowStep.到取料位上方;
                        }
                        else
                        {
                            flowStep = EWorkFlowStep.任务结束到安全位;
                        }
                    }
                    break;

                case EWorkFlowStep.任务结束到安全位:
                    errCode = AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("LoadXStartPos"), GlobalVar.WholeSpeed);
                    if(errCode== ErrorCode.Ok)
                    {
                        errCode = AxisControl.LoadY.MovePos(SysConfigParam.GetValue<double>("LoadYStartPos"), GlobalVar.WholeSpeed);
                        if(errCode== ErrorCode.Ok)
                        {
                            flowStep = EWorkFlowStep.等待任务结束到安全位;
                        }
                    }
                    break;
                case EWorkFlowStep.等待任务结束到安全位:
                    if(Ops.IsStop("LoadX","LoadY"))
                    {
                        if (TestCenter.Instance.LoadResult())
                        {
                            LoadAndUnloadTask.Instance.Clear();
                        }
                        MachineManage.Instance.RunState = ERunState.Waiting;
                        flowStep = EWorkFlowStep.等待任务;
                    }
                    break;
                case EWorkFlowStep.测试工位上料:
                    TurnoverFlow.Instance.PressLoad(LoadAndUnloadTask.Instance.GetTestLoadTasks());
                    flowStep = EWorkFlowStep.等待测试工位上料完成;
                    break;
                case EWorkFlowStep.等待测试工位上料完成:
                    if (TurnoverFlow.Instance.LoadFinished())
                    {
                        TestCenter.Instance.LoadTestLoadResult();
                        LoadAndUnloadTask.Instance.Clear();
                        MachineManage.Instance.RunState = ERunState.Waiting;
                        //切换穴位状态
                        for (int i = 1; i < 9; i++)
                        {
                            GlobalTray.TurnoverTray.ChangeStatus(i, ESlotStatus.NotHave);
                        }
                        for (int i = 17; i < 25; i++)
                        {
                            GlobalTray.TurnoverTray.ChangeStatus(i, ESlotStatus.NotHave);
                        }
                        flowStep = EWorkFlowStep.等待任务;
                    }
                    break;
                case EWorkFlowStep.测试工位下料:
                    TurnoverFlow.Instance.PressUnload(LoadAndUnloadTask.Instance.GetTestUnLoadTasks());
                    flowStep = EWorkFlowStep.等待测试工位下料完成;
                    break;
                case EWorkFlowStep.等待测试工位下料完成:
                    if (TurnoverFlow.Instance.UnloadFinished())
                    {
                        TestCenter.Instance.LoadTestUnLoadResult();
                        LoadAndUnloadTask.Instance.Clear();
                        //切换穴位状态
                        for (int i = 9; i < 17; i++)
                        {
                            GlobalTray.TurnoverTray.ChangeStatus(i, ESlotStatus.Have);
                        }
                        for (int i = 25; i < 33; i++)
                        {
                            GlobalTray.TurnoverTray.ChangeStatus(i, ESlotStatus.Have);
                        }
                        MachineManage.Instance.RunState = ERunState.Waiting;
                        flowStep = EWorkFlowStep.等待任务;
                    }
                    break;
                case EWorkFlowStep.等待Input料盘搬运完成:
                    if(TakeTrayFlow.Instance.TakeStatus== ETakeStatus.TakeOK)
                    {
                        StockManager.Instance.UnLoad(EStockType.Empty1);
                        StockManager.Instance.Load(EStockType.Input);
                        flowStep = EWorkFlowStep.等待Input料仓上料完成;
                    }
                    break;
                case EWorkFlowStep.等待Input料仓上料完成:
                    if(StockManager.Instance.GetStockStatus(EStockType.Input)== AutoDischarge.V3.Flow.ETrayStatus.Loaded)
                    {
                        flowStep = restoreFlowStep;
                        restoreFlowStep = EWorkFlowStep.IDLE;
                    }
                    break;
                default:
                    break;
            }
        }

        private double GetVacOffsetHeight(int fetchNum)
        {
            switch (fetchNum)
            {
                case 0:
                    return 0;
                case 1:
                    return -0.1;
                case 2:
                    return -0.2;
                case 3:
                    return -0.3;
                case 4:
                    return 0.1;
                case 5:
                    return 0.2;
                case 6:
                    return 0.3;
                default:
                    return 0;
            }
        }
        /// <summary>
        /// 检测排料Y轴是否可以到周转盘
        /// </summary>
        /// <returns></returns>
        private bool CanGoTurnoverTray()
        {
            //获取周转Y轴的位置，当排料Y轴去周转盘的时候，检测是否安全
            double turnoverYPos = Ops.GetCurPosition("TurnoverY");
            if (turnoverYPos - SysConfigParam.GetValue<double>("PressY") < -1)
                return false;
            return true;
        }
        private bool XYCanMove()
        {
            if (!CanGoTurnoverTray())
                return false;
            //AxisControl.VacZ1.GetOrgStatus(out bool bOrgZ1);
            //AxisControl.VacZ2.GetOrgStatus(out bool bOrgZ2);
            //if (AxisControl.LoadX.HomeStatus == EHomeStatus.Finished
            //    && AxisControl.LoadY.HomeStatus == EHomeStatus.Finished
            //    && bOrgZ1 && bOrgZ2)
            //{
            //    return true;
            //}
            return true;
        }
    }
}