using Asa;
using CodeLibrary;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Configuration;
using System.Web.Routing;
using System.Windows.Forms;

namespace OnlineStore.DeviceLibrary
{
    partial class InputEquip
    {
        #region 出库
        private DateTime startOutTime = DateTime.Now;
        bool outstoreNG = false;
        int maxCnt = ConfigAppSettings.GetIntValue(Setting_Init.MaxCntInBox, 15);
        public override bool StartOutstore(InOutParam param)
        {
            if (!NoAlarm())
            {
                SetWarnMsg("报警中，无法开始出库：" + param.PosInfo.ToStr());
                return false;
            }
            if (!IsInSafePos())
            {
                SetWarnMsg("机器人不在安全位置。出库失败：" + param.PosInfo.ToStr());
                return false;
            }

            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                outstoreNG = false;
                //获取料仓两个出料口信息
                List<BoxTaskInfo> boxInfos = SServerManager.GetOutStateInfo();
                if (boxInfos == null)
                {
                    SetWarnMsg("无法获取出料口信息，无法开始出库：" + param.PosInfo.ToStr());
                    return false;
                }
                BoxA.UpdateBoxInfo(boxInfos);
                BoxB.UpdateBoxInfo(boxInfos);
                bool canOutstore = false;
                if (BufferDataManager.LabelInfo != null)
                {
                    outstoreNG = BufferDataManager.LabelInfo.outstoreNG;
                    if (!outstoreNG)//有贴标信息
                    {
                        if (PrintLabel.LabelInfo != null)
                        {
                            param.Label_LZ = PrintLabel?.LabelInfo.ToCopy();
                        }
                        else
                        {
                            param.Label_LZ = SServerManager.GetFeederInfo(BufferDataManager.LabelInfo.barcode);
                        }

                        if (param.Label_LZ != null)
                        {
                            if (boxInfos.Count == 0)//无料箱绑定，读取到哪个箱子就放哪个箱子
                            {
                                if(ReadBoxAId())
                                {
                                    if (param.Label_LZ.side.Equals("T"))
                                    {
                                        param.ShelfType = 1;
                                        canOutstore = true;
                                    }
                                    else if (param.Label_LZ.side.Equals("B"))
                                    {
                                        param.ShelfType = 2;
                                        canOutstore = true;
                                    }

                                    LogUtil.info($"两出料口无料箱绑定，使用A周转箱：{(param.Label_LZ.hSerial ?? "")}");
                                }
                                else if(ReadBoxBId())
                                {
                                    if (param.Label_LZ.side.Equals("T"))
                                    {
                                        param.ShelfType = 3;
                                        canOutstore = true;
                                    }
                                    else if (param.Label_LZ.side.Equals("B"))
                                    {
                                        param.ShelfType = 4;
                                        canOutstore = true;
                                    }
                                    LogUtil.info($"两出料口无料箱绑定，使用B周转箱：{(param.Label_LZ.hSerial ?? "")}");
                                }
                                else
                                {
                                    SetWarnMsg("两出料口均未读到RFID，无法工单出库");
                                }
                            }
                            else
                            {
                                var box = boxInfos.Find(s => param.Label_LZ.hSerial.Equals(s.hSerial) && (s.boxBCount < maxCnt && s.boxTCount < maxCnt));
                                StringBuilder sb = new StringBuilder();
                                if (box != null)//相同工单且有空位
                                {
                                    TurnoverBox turnoverBox = turnoverBoxes.Find(s => s.outLet.Equals(box.outlet));
                                    if (turnoverBox.ReadBoxId())
                                    {
                                        if (turnoverBox.BoxId.Equals(box.rfid))
                                        {
                                            if (turnoverBox.outLet.Equals("A"))
                                            {
                                                if (param.Label_LZ.side.Equals("T"))
                                                {
                                                    param.ShelfType = 1;
                                                    canOutstore = true;
                                                }
                                                else if (param.Label_LZ.side.Equals("B"))
                                                {
                                                    param.ShelfType = 2;
                                                    canOutstore = true;
                                                }
                                            }
                                            else
                                            {
                                                if (param.Label_LZ.side.Equals("T"))
                                                {
                                                    param.ShelfType = 3;
                                                    canOutstore = true;
                                                }
                                                else if (param.Label_LZ.side.Equals("B"))
                                                {
                                                    param.ShelfType = 4;
                                                    canOutstore = true;
                                                }
                                            }
                                            LogUtil.info($"相同工单且有空位，使用{turnoverBox.Name}：{(param.Label_LZ.hSerial ?? "")}");
                                        }
                                        else
                                        {
                                            SetWarnMsg($"工单{box.hSerial}已有料在{turnoverBox.Name}放入{box.rfid}中,无法放入其他料箱{turnoverBox.BoxId}");
                                        }
                                    }
                                    else
                                    {
                                        SetWarnMsg($"未读到RFID，工单{box.hSerial}已有料在{turnoverBox.Name}放入{box.rfid}中");
                                        return false;
                                    }
                                }
                                else //工单不同或者格口已满
                                {
                                    if (BoxA.ReadBoxId())
                                    {
                                        var boxTmp = boxInfos.Find(s => BoxA.outLet.Equals(s.outlet));
                                        if (boxTmp != null)//有A周转信息
                                        {
                                            if (!BoxA.BoxId.Equals(boxTmp.rfid))
                                            {
                                                if (param.Label_LZ.side.Equals("T"))
                                                {
                                                    param.ShelfType = 1;
                                                    canOutstore = true;
                                                }
                                                else if (param.Label_LZ.side.Equals("B"))
                                                {
                                                    param.ShelfType = 2;
                                                    canOutstore = true;
                                                }
                                                LogUtil.info($"工单不同或者上一料箱格口已满,当前料箱{BoxA.BoxId}与上一料箱{boxTmp.rfid}不同，工单{param.Label_LZ.hSerial}使用料箱{BoxA.BoxId}");
                                            }
                                            else
                                            {
                                                sb.Append($"{BoxA.Name}内工单{boxTmp.hSerial}与待出库工单{param.Label_LZ.hSerial}不符,无法出库");
                                            }
                                        }
                                        else//无A周转信息
                                        {
                                            if (param.Label_LZ.side.Equals("T"))
                                            {
                                                param.ShelfType = 1;
                                                canOutstore = true;
                                            }
                                            else if (param.Label_LZ.side.Equals("B"))
                                            {
                                                param.ShelfType = 2;
                                                canOutstore = true;
                                            }
                                            LogUtil.info($"工单不同或者上一料箱格口已满,出料口无信息，工单{param.Label_LZ.hSerial}使用料箱{BoxA.BoxId}");
                                        }
                                    }
                                    if (!canOutstore)
                                    {
                                        if (BoxB.ReadBoxId())
                                        {
                                            var boxTmp1 = boxInfos.Find(s => BoxB.outLet.Equals(s.outlet));
                                            if (boxTmp1 != null)
                                            {
                                                if (!BoxB.BoxId.Equals(boxTmp1.rfid))
                                                {
                                                    if (param.Label_LZ.side.Equals("T"))
                                                    {
                                                        param.ShelfType = 3;
                                                        canOutstore = true;
                                                    }
                                                    else if (param.Label_LZ.side.Equals("B"))
                                                    {
                                                        param.ShelfType = 4;
                                                        canOutstore = true;
                                                    }
                                                    LogUtil.info($"工单不同或者上一料箱格口已满,当前料箱{BoxB.BoxId}与上一料箱{boxTmp1.rfid}不同，工单{param.Label_LZ.hSerial}使用料箱{BoxB.BoxId}");
                                                }
                                                else
                                                {
                                                    sb.Append($"{BoxB.Name}内工单{boxTmp1.hSerial}与待出库工单{param.Label_LZ.hSerial}不符,无法出库");
                                                }
                                            }
                                            else//无B周转信息
                                            {
                                                if (param.Label_LZ.side.Equals("T"))
                                                {
                                                    param.ShelfType = 3;
                                                    canOutstore = true;
                                                }
                                                else if (param.Label_LZ.side.Equals("B"))
                                                {
                                                    param.ShelfType = 4;
                                                    canOutstore = true;
                                                }
                                                LogUtil.info($"工单不同或者上一料箱格口已满,出料口无信息，工单{param.Label_LZ.hSerial}使用料箱{BoxB.BoxId}");
                                            }
                                        }
                                        else
                                        {
                                            SetWarnMsg("周转箱线体上无可用料箱");
                                        }
                                    }
                                }

                                if (!string.IsNullOrEmpty(sb.ToString()))
                                {
                                    SetWarnMsg(sb.ToString());
                                }
                            }

                        }
                        else
                            outstoreNG = true;
                    }
                }
                else if (PrintLabel.LabelInfo == null)
                {
                    outstoreNG = true;
                }

                if (!outstoreNG)//正常出库
                {
                    if (!canOutstore) return false;
                }
                else
                {
                    StartNGReelOut(param);
                    return true;
                }
                runStatus = RunStatus.Busy;
                MoveInfo.NewMove(MoveType.OutStore, param);
                startOutTime = DateTime.Now;
                MoveInfo.NextMoveStep(StepEnum.IO01_ReelCheck);
                LogUtil.info($"工单出库：barcode【{param?.PosInfo?.barcode ?? ""}】hSerial【{param?.Label_LZ?.hSerial ?? ""}】box【{getSideName(param.ShelfType)}】【{BoxA.BoxId}】【{BoxB.BoxId}】");
                return true;
            }
            return false;
        }

        private void TrayHasLeave()
        {

        }

        private void TrayStartLeave()
        {
            // int shelf = MoveInfo.MoveParam.ShelfType;
            // if (shelf.Equals(1))
            //{
            //    BatchMove.GetTrayStartLeave();
            //}
        }
        string getSideName(int shelf)
        {
            if (shelf == 1)
            {
                return "A周转箱内侧【T面】";
            }
            else if (shelf == 2)
            {
                return "A周转箱外侧【B面】";
            }
            else if (shelf == 3)
            {
                return "B周转箱内侧【T面】";
            }
            else if (shelf == 4)
            {
                return "B周转箱外侧【B面】";
            }
            return "周转箱";
        }
        /// <summary>
        /// 出库NG料盘去NG区域
        /// </summary>
        void StartNGReelOut(InOutParam param)
        {
            runStatus = RunStatus.Busy;
            MoveInfo.NewMove(MoveType.OutStore, param);
            startOutTime = DateTime.Now;
            //获取位置是左侧还是右侧。
            int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
            if (startp.Equals(1))
            {
                MoveInfo.NextMoveStep(StepEnum.IO10_ToLowerA);
                ToA下皮带末端();
                MoveLog($"出库A->NG箱:机器人去A下");
            }
            else
            {
                MoveInfo.NextMoveStep(StepEnum.IO16_ToLowerB);
                ToB下皮带末端();
                MoveLog($"出库B->NG箱:机器人去B下");
            }
        }
        protected override void OutstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            int shelf = MoveInfo.MoveParam.ShelfType;

            #region 打印标签
            if (MoveInfo.IsStep(StepEnum.IO01_ReelCheck))
            {
                MoveInfo.NextMoveStep(StepEnum.IO07_ToPrintPos);
                To打印机();
                MoveLog($"出库->{getSideName(shelf)}:去打印机取标签处");
                //MoveInfo.NextMoveStep(StepEnum.IO03_PrintLabel);
                //MoveLog($"出库->{getSideName(shelf)}:开始打印标签:{labelInfo.ToStr()}");
                //Printer.Print(new Label_LZ(labelInfo?.pn, labelInfo?.side, labelInfo?.station, labelInfo?.line), out string msg);
                //Printer.Connect();
                //MoveLog($"出库->周转箱:获取贴标信息");
                //new Label_LZ("123456789", "1", "ABCD-10_1  1A");
            }
            //else if (MoveInfo.IsStep(StepEnum.IO02_GetReelLabelInfo))
            //{
            //    MoveInfo.NextMoveStep(StepEnum.IO03_PrintLabel);
            //    Label_CylinderBack(MoveInfo);
            //    MoveLog($"出库->{shelf}周转箱:标签气缸后退");
            //}
            //else if (MoveInfo.IsStep(StepEnum.IO03_PrintLabel))
            //{
            //    MoveInfo.NextMoveStep(StepEnum.IO04_CheckPrinterState);
            //    MoveLog($"出库->{getSideName(shelf)}:检查打印机口是否有标签");
            //}
            //else if (MoveInfo.IsStep(StepEnum.IO04_CheckPrinterState))
            //{
            //    //if (Printer.IsLabelOnPeeler())
            //    //{
            //    //    SetWarnMsg("打印机口有标签，无法打印，需要处理");
            //    //}
            //    //else
            //    {
            //        IO05_WaitPrintLabelOK(shelf);
            //    }

            //}
            //else if (MoveInfo.IsStep(StepEnum.IO05_WaitPrintLabelOK))
            //{
            //    MoveInfo.NextMoveStep(StepEnum.IO06_PrinteLabelFwd);
            //    Label_CylinderFwd(MoveInfo);
            //    MoveLog($"出库->{getSideName(shelf)}:标签气缸前进");
            //}
            //else if (MoveInfo.IsStep(StepEnum.IO06_PrinteLabelFwd))
            //{
            //    MoveInfo.NextMoveStep(StepEnum.IO07_ToPrintPos);
            //    To打印机();
            //    MoveLog($"出库->{getSideName(shelf)}:去打印机取标签处");
            //}
            else if (MoveInfo.IsStep(StepEnum.IO07_ToPrintPos))
            {
                MoveInfo.NextMoveStep(StepEnum.IO08_ClamWork);
                ClampWork(null, true, MoveInfo.MoveParam.PosInfo.barcode);
                MoveLog($"出库->{getSideName(shelf)}:吸取标签");
            }
            else if (MoveInfo.IsStep(StepEnum.IO08_ClamWork))
            {
                MoveInfo.NextMoveStep(StepEnum.IO09_BackToP1);
                From打印机回原();
                MoveLog($"出库->{getSideName(shelf)}:从打印机回原点");
            }
            else if (MoveInfo.IsStep(StepEnum.IO09_BackToP1))
            {
                //料盘放贴标平台,机器人取好标签
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.GET_LABEL);
                //获取位置是左侧还是右侧。
                int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
                int round = BufferDataManager.LabelInfo.relativeAngle;
                if (startp.Equals(1))
                {
                    // if (scanCode == null || (scanCode.IsCompleted))
                    //{
                    //round = LabelManager.CalcLabelAngle(MoveInfo?.MoveParam?.PosInfo?.LabelParam);
                    MoveInfo.NextMoveStep(StepEnum.IO10_ToLowerA);
                    ToA下皮带末端(round);
                    MoveLog($"出库A->{getSideName(shelf)}:机器人去A下,并旋转 {round}°");
                    BufferDataManager.LabelInfo = null;
                    //}
                }
                else
                {
                    //if (scanCode == null || (scanCode.IsCompleted))
                    //{
                    //round = LabelManager.CalcLabelAngle(MoveInfo?.MoveParam?.PosInfo?.LabelParam);
                    MoveInfo.NextMoveStep(StepEnum.IO16_ToLowerB);
                    ToB下皮带末端(round);
                    MoveLog($"出库B->{getSideName(shelf)}:机器人去B下,并旋转 {round}°");
                    BufferDataManager.LabelInfo = null;
                    //}
                }

                //Label_CylinderBack();
            }
            #endregion
            #region 出库A侧取料
            else if (MoveInfo.IsStep(StepEnum.IO10_ToLowerA))
            {
                MoveInfo.NextMoveStep(StepEnum.IO11_ClamRelax);
                //ClampRelax(null, MoveInfo.MoveParam.PosInfo.barcode);
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                MoveLog($"出库A->{getSideName(shelf)}:将标签贴到料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO11_ClamRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.IO12_ReClamWork);
                //贴标完成,等待放入周转箱
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.LABELED);
                ClampWork(null, true, MoveInfo.MoveParam.PosInfo.barcode);
                MoveLog($"出库A->{getSideName(shelf)}:吸取料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO12_ReClamWork))
            {
                MoveInfo.NextMoveStep(StepEnum.IO13_BackToP1);
                FromA下皮带末端回原();
                MoveLog($"出库A->{getSideName(shelf)}:从出料暂存区回原点");
            }
            else if (MoveInfo.IsStep(StepEnum.IO13_BackToP1))
            {
                //
                //if (!HasBoxInPos())
                //{
                //    {
                //        MoveInfo.NextMoveStep(StepEnum.IO21_WaitBoxReady);
                //        MoveLog($"出库A->{shelf}周转箱: 等待周转箱到位");
                //    }
                //}
                //else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO14_WaitReelCheckLow);
                    MoveLog($"出库A->{getSideName(shelf)}: 料盘已拿走，等待料盘检测信号=0");
                    MoveInfo.TimeOutSeconds = 10;
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.LineA_ReelInPlaceCheck, IO_VALUE.LOW));
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO14_WaitReelCheckLow))
            {
                MoveInfo.NextMoveStep(StepEnum.IO21_WaitBoxReady);
                BufferDataManager.AOutStoreInfo = null;
                //料盘在机器人上,准备放入周转箱
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.TO_BOX);
                MoveLog($"出库A->{getSideName(shelf)}: 等待周转箱到达");
            }
            #endregion

            #region 出库B侧取料
            else if (MoveInfo.IsStep(StepEnum.IO16_ToLowerB))
            {
                MoveInfo.NextMoveStep(StepEnum.IO17_ClamRelax);
                //ClampRelax(null, MoveInfo.MoveParam.PosInfo.barcode);
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                MoveLog($"出库B->{getSideName(shelf)}:将标签贴到料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO17_ClamRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.IO18_ReClamWork);
                //贴标完成,等待放入周转箱
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.LABELED);
                ClampWork(null, true, MoveInfo.MoveParam.PosInfo.barcode);
                MoveLog($"出库B->{getSideName(shelf)}:吸取料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO18_ReClamWork))
            {
                MoveInfo.NextMoveStep(StepEnum.IO19_BackToP1);
                FromB下皮带末端回原();
                MoveLog($"出库B->{getSideName(shelf)}:从出料暂存区回原点");
            }
            else if (MoveInfo.IsStep(StepEnum.IO19_BackToP1))
            {
                //判断料盘信号是否消失 
                //if (!HasBoxInPos())
                //{
                //    // if (!HasBoxInPos())
                //    {
                //        MoveInfo.NextMoveStep(StepEnum.IO21_WaitBoxReady);
                //        MoveLog($"出库B->{shelf}周转箱: 等待周转箱到达");
                //    }
                //}
                //else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO20_WaitReelCheckLow);
                    MoveLog($"出库B->{getSideName(shelf)}: 料盘已拿走，等待料盘检测信号=0");
                    MoveInfo.TimeOutSeconds = 10;
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.LineB_ReelInPlaceCheck, IO_VALUE.LOW));
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO20_WaitReelCheckLow))
            {
                MoveInfo.NextMoveStep(StepEnum.IO21_WaitBoxReady);
                //料盘在机器人上,准备放入周转箱
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.TO_BOX);
                BufferDataManager.BOutStoreInfo = null;
                if (outstoreNG)
                {
                    MoveLog($"出库B->NG箱子");
                }
                else
                    MoveLog($"出库B->{getSideName(shelf)}: 等待周转箱到位");
            }
            #endregion
            #region 出库放料到周转箱
            else if (MoveInfo.IsStep(StepEnum.IO21_WaitBoxReady))
            {
                if (outstoreNG)
                {
                    IO40_ToUrgentBoxPos();
                }
                else
                {
                    if (HasBoxInPos())
                    {
                        IO23_ToBoxPos(shelf);
                        ClearSpecifiedAlarm($"等待{getSideName(shelf)}到位");
                    }
                    else if (MoveInfo.IsTimeOut(15))
                    {
                        SetWarnMsg($"等待{getSideName(shelf)}到位");
                    }
                }

            }
            else if (MoveInfo.IsStep(StepEnum.IO23_ToBoxPos))
            {
                MoveInfo.NextMoveStep(StepEnum.IO24_ClamRelax);
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
                MoveLog($"出库->{getSideName(shelf)}:放下料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO24_ClamRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.IO25_UpdateLocInfo);
                UploadLocInfo(shelf);
            }
            else if (MoveInfo.IsStep(StepEnum.IO25_UpdateLocInfo))
            {
                MoveInfo.NextMoveStep(StepEnum.IO26_BackToP1);
                IO26_BackToP1(shelf);
            }
            else if (MoveInfo.IsStep(StepEnum.IO26_BackToP1))
            {
                PutReelInBox(shelf);
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                TimeSpan span = DateTime.Now - startOutTime;
                MoveLog($"出库->{getSideName(shelf)}: 放料完成，耗时【{FormUtil.GetSpanStr(span)}】");
            }
            #endregion

            #region 出库到紧急料区域
            else if (MoveInfo.IsStep(StepEnum.IO40_ToUrgentBoxPos))
            {
                MoveInfo.NextMoveStep(StepEnum.IO41_ClamRelax);
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
                MoveLog($"出库->紧急料箱子:放下料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IO41_ClamRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.IO42_UploadReelInfo);
            }
            else if (MoveInfo.IsStep(StepEnum.IO42_UploadReelInfo))
            {
                MoveInfo.NextMoveStep(StepEnum.IO43_BackToP1);
                // NGBox.PutIn(MoveInfo.MoveParam);
                SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.FINISHED);
                IO43_BackToP1(shelf);
            }
            else if (MoveInfo.IsStep(StepEnum.IO43_BackToP1))
            {
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                TimeSpan span = DateTime.Now - startOutTime;
                MoveLog($"出库->紧急料箱子: 放料完成，耗时【{FormUtil.GetSpanStr(span)}】");
            }
            #endregion
        }
        void UploadLocInfo(int shelf)
        {
            string boxSide = "B";
            if (shelf == 1 || shelf == 3)
            {
                boxSide = "T";
            }
            if (shelf.Equals(1) || shelf.Equals(2))
            {
                //料盘在机器人上,准备放入周转箱
                BoxA.BoxTaskInfo = SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.FINISHED, BoxAId, MoveInfo.MoveParam?.Label_LZ?.hSerial ?? "", BoxA.outLet, boxSide);
                SServerManager.ShelfFinish(BoxAId, MoveInfo.MoveParam.PosInfo.barcode, MoveInfo.MoveParam.Label_LZ, BoxA.outLet, boxSide, BoxA?.BoxTaskInfo?.remainTaskCount ?? -1);
            }
            else if (shelf.Equals(3) || shelf.Equals(4))
            {
                //料盘在机器人上,准备放入周转箱
                BoxB.BoxTaskInfo = SServerManager.UploadLocInfo(MoveInfo.MoveParam.PosInfo.barcode, LocStatus.FINISHED, BoxBId, MoveInfo.MoveParam?.Label_LZ?.hSerial ?? "", BoxB.outLet, boxSide);
                SServerManager.ShelfFinish(BoxBId, MoveInfo.MoveParam.PosInfo.barcode, MoveInfo.MoveParam?.Label_LZ, BoxB.outLet, boxSide, BoxB?.BoxTaskInfo?.remainTaskCount ?? -1);
            }

        }
        void IO05_WaitPrintLabelOK(int shelf)
        {
            ClearSpecifiedAlarm("打印机口有标签，无法打印，需要处理");
            MoveInfo.NextMoveStep(StepEnum.IO05_WaitPrintLabelOK);
            MoveInfo.TimeOutSeconds = 30;
            // Printer.Print(new Label_LZ(labelInfo?.pn, labelInfo?.side, labelInfo?.station), out string msg);
            //Task.Factory.StartNew(delegate
            //{
            //    int cnt = 1;
            //    while (cnt > 0)
            //    {
            //        // if (!Printer.IsLabelOnPeeler())
            //        Printer.Print(new Label_LZ(labelInfo?.pn, labelInfo?.side, labelInfo?.station), out string msg);
            //        //Thread.Sleep(2000);
            //        if (Printer.IsLabelOnPeeler())
            //            break;
            //        cnt--;
            //    }

            //});
            MoveInfo.OneWaitCanEndStep = true;
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitPrintOK());
            MoveLog($"出库->{getSideName(shelf)}:等待标签打印完成");//结果：{msg}
        }
        void PutReelInBox(int shelf)
        {
            if (shelf.Equals(1) || shelf.Equals(2))
            {
                //ReadBoxAId();
                BoxA.PutReelIn(shelf);
            }
            if (shelf.Equals(3) || shelf.Equals(4))
            {
                //ReadBoxBId();
                BoxB.PutReelIn(shelf);
            }
        }
        void IO26_BackToP1(int shelf)
        {
            /// 0=未知，1=A侧周转箱内侧，2=A侧周转箱外
            /// 3=B侧周转箱内侧，4=B侧周转箱外
            if (shelf.Equals(1))
            {
                FromA周转1_内侧回原();
                MoveLog($"出库->{getSideName(shelf)}:机器人从A周转箱内侧回原");
            }
            else if (shelf.Equals(2))
            {
                FromA周转2_外侧回原();
                MoveLog($"出库->{getSideName(shelf)}:机器人从A周转箱外侧回原");
            }
            else if (shelf.Equals(3))
            {
                FromB周转1_内侧回原();
                MoveLog($"出库->{getSideName(shelf)}:机器人从B周转箱内侧回原");
            }
            else if (shelf.Equals(4))
            {
                FromB周转2_外侧回原();
                MoveLog($"出库->{getSideName(shelf)}:机器人从B周转箱外侧回原");
            }
        }
        void IO43_BackToP1(int shelf)
        {
            From紧急料回原();
            MoveLog($"出库->紧急料箱子:从紧急料区域回原");
        }
        void IO23_ToBoxPos(int shelf)
        {
            MoveInfo.NextMoveStep(StepEnum.IO23_ToBoxPos);
            //清空暂存区
            int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
            //if (startp.Equals(1))
            //{
            //    BufferDataManager.AOutStoreInfo = null;
            //}
            //else
            //{
            //    BufferDataManager.BOutStoreInfo = null;
            //}
            /// 0=未知，1=A侧周转箱内侧，2=A侧周转箱外
            /// 3=B侧周转箱内侧，4=B侧周转箱外
            string pos = "";
            if (startp.Equals(1))//从A下
            {
                pos = getSideName(shelf);
                if (shelf.Equals(1))
                {
                    A下ToA周转1_内侧();
                }
                else if (shelf.Equals(2))
                {
                    A下ToA周转2_外侧();
                }
                else if (shelf.Equals(3))
                {
                    A下ToB周转1_内侧();
                }
                else if (shelf.Equals(4))
                {
                    A下ToB周转2_外侧();
                }
            }
            else//从B下
            {
                if (shelf.Equals(1))
                {
                    B下ToA周转1_内侧();
                }
                else if (shelf.Equals(2))
                {
                    B下ToA周转2_外侧();
                }
                else if (shelf.Equals(3))
                {
                    B下ToB周转1_内侧();
                }
                else if (shelf.Equals(4))
                {
                    B下ToB周转2_外侧();
                }
            }
            MoveLog($"出库->{getSideName(shelf)}:机器人去{getSideName(shelf)}");
        }

        void IO40_ToUrgentBoxPos()
        {
            //if (NGBox.CanPutIn(out string msg))
            {
                MoveInfo.NextMoveStep(StepEnum.IO40_ToUrgentBoxPos);
                ClearSpecifiedAlarm("无法放料");
                BufferDataManager.LabelInfo = null;
                //清空暂存区
                int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
                //if (startp.Equals(1))
                //{
                //    BufferDataManager.AOutStoreInfo = null;
                //}
                //else
                //{
                //    BufferDataManager.BOutStoreInfo = null;
                //}
                /// 0=未知，1=A侧周转箱内侧，2=A侧周转箱外
                /// 3=B侧周转箱内侧，4=B侧周转箱外
                if (startp.Equals(1))//从A下
                {
                    //ToNG箱();
                    To紧急料();
                }
                else//从B下
                {
                    //B下ToNG箱();
                    B下To紧急料();
                }
                MoveLog($"出库->紧急料箱子:机器人去紧急料箱子");
            }
            //else
            //{
            //    SetWarnMsg(msg);
            //}
        }
        /// <summary>
        /// 是否有周转箱
        /// </summary>
        /// <returns></returns>
        private bool HasBoxInPos()
        {
            bool isTest = MoveInfo.MoveParam.PosInfo.barcode.EndsWith("TEST");
            int shelf = MoveInfo.MoveParam.ShelfType;
            bool shelfOk = false;
            if (shelf.Equals(1) || shelf.Equals(2))
            {
                shelfOk = IOValue(IO_Type.TurnoverBoxA_InPlaceCheck).Equals(IO_VALUE.HIGH) && ReadBoxAId();
            }
            else if (shelf.Equals(3) || shelf.Equals(4))
            {
                shelfOk = IOValue(IO_Type.TurnoverBoxB_InPlaceCheck).Equals(IO_VALUE.HIGH) && ReadBoxBId();
            }
            //shelfOk = TurnoverBox.HasBoxInPos(shelf);
            if (isTest || shelfOk)
            {
                ClearSpecifiedAlarm($"等待{getSideName(shelf)}到位");
                //MoveInfo.NextMoveStep(StepEnum.IO23_ToBoxPos);
                return true;
            }
            return false;

        }

        private void ShelfBatchAxisDown()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            //判断料串是否完成
            if (shelf.Equals(1))
            {
                BatchMove.NewReelOut(MoveInfo.MoveParam.PosInfo);
            }
            else
            {
                LogUtil.error($"{Name}{MoveInfo.SLog}出库错误：未找到准备好的料串    ");
            }
        }

        #endregion
    }
}