using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Threading;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading.Tasks;
using BPASmartClient.Device;
using BPA.Message.Enum;
using BPA.Message;
using BPASmartClient.Helper;
using BPASmartClient.Model.咖啡机.Enum;
using BPASmartClient.Model;
using BPASmartClient.EventBus;
using static BPASmartClient.EventBus.EventBus;
using BPASmartClient.Message;
using BPASmartClient.Model.乐白机器人;
using BPASmartClient.Model.单片机;
using BPASmartClient.Model.PLC;

namespace BPASmartClient.MorkT_Container
{
    /*
     * 冰淇淋咖啡机组合套装
     * 物料位置：
     * 1：冰淇料
     * 2：冰淇淋杯
     * 5：咖啡
     * 6：咖啡杯
     * 9: 茶
     * 10: 茶杯
     */
    public class Control_MorkT_Container : BaseDevice
    {
        private Dictionary<string, PolymerBatching> batchings = new Dictionary<string, PolymerBatching>();
        //容器位置
        private string holderLoc;
        //主料位置
        private string mainMaterialLoc;
        public override global::BPA.Message.Enum.DeviceClientType DeviceType { get { return BPA.Message.Enum.DeviceClientType.MORKT; } }

        GVL_MorkT morkTLebaiJC =new GVL_MorkT();
        /// <summary>
        /// 果汁机做法，true:热饮，false:冷饮
        /// </summary>
        private bool GuMake = false;
        /// <summary>
        /// 订单是否加冰
        /// </summary>
        private bool IsAddIce = false;
        public override void DoMain()
        {
            if (Json<KeepDataBase>.Data.IsVerify)
            {
                IsHealth = true;
            }
            IsHealth = true;
            serverInit();
            DataParse();
            ActionManage.GetInstance.Register(new Action<object>((o) => { SimOrder(o); }), "SimOrder");//模拟订单委托注册
            
        }

        private void serverInit()
        {
            EventBus.EventBus.GetInstance().Subscribe<MaterialDeliveryEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (@event == null) return;
                if (@event is MaterialDeliveryEvent material)
                {
                    orderMaterialDelivery = material.orderMaterialDelivery;
                }
            });
        }
        private void DataParse()
        {
           
            EventBus.EventBus.GetInstance().Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {
                if (@event == null) return;
                if (@event is DoOrderEvent order)
                {
                    if (order.MorkOrder.GoodBatchings == null) return;
                    OrderCount++;
                    DeviceProcessLogShow($"接收到{OrderCount}次订单");
                    batchings = PolymerBatching.BuildAll();
                    //商品类型
                    GOODS_TYPE currentGoodsType = GOODS_TYPE.NEITHER;
                    foreach (var item in order.MorkOrder.GoodBatchings)
                    {
                        var res = orderMaterialDelivery?.BatchingInfo?.FirstOrDefault(p => p.BatchingId == item.BatchingId);
                        if (res != null)
                        {
                            //验证商品是做的某种饮料
                            if (ValidateGoodsByBatching(res.BatchingLoc) != GOODS_TYPE.NEITHER)
                            {
                                //获取当前物料所属商品类型
                                currentGoodsType = ValidateGoodsByBatching(res.BatchingLoc);
                            }
                            switch (batchings[res.BatchingLoc].BatchingClass)
                            {
                                case BATCHING_CLASS.HOLDER:
                                    holderLoc = res.BatchingLoc;
                                    break;
                                case BATCHING_CLASS.MAIN_MATERIAL:
                                    mainMaterialLoc = res.BatchingLoc;
                                    break;
                            }
                            //根据商品类型执行具体制作流程
                            switch (currentGoodsType)
                            {
                                case GOODS_TYPE.COFFEE:
                                    
                                    if (morkTLebaiJC.morkOrderPushesCoffee.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                    {
                                        morkTLebaiJC.morkOrderPushesCoffee.Enqueue(new OrderLocInfo()
                                        {
                                            SuborderId = order.MorkOrder.SuborderId,
                                            BatchingId = res.BatchingId,
                                            Loc = ushort.Parse( mainMaterialLoc),
                                            GoodName = order.MorkOrder.GoodsName,
                                        });
                                    }
                                    break;
                                case GOODS_TYPE.JUICE:
                                   
                                    if (morkTLebaiJC.morkOrderPushesJuicer.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                    {
                                        morkTLebaiJC.morkOrderPushesJuicer.Enqueue(new OrderLocInfo()
                                        {
                                            SuborderId = order.MorkOrder.SuborderId,
                                            BatchingId = res.BatchingId,
                                            Loc = ushort.Parse(mainMaterialLoc),
                                            GoodName = order.MorkOrder.GoodsName,
                                        });
                                    }
                                    break;
                                case GOODS_TYPE.TEA:
                                    if (morkTLebaiJC.morkOrderPushesTea.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                    {
                                        morkTLebaiJC.morkOrderPushesTea.Enqueue(new OrderLocInfo()
                                        {
                                            SuborderId = order.MorkOrder.SuborderId,
                                            BatchingId = res.BatchingId,
                                            Loc = ushort.Parse(mainMaterialLoc),
                                            GoodName = order.MorkOrder.GoodsName,
                                        });
                                    }
                                    break;
                                case GOODS_TYPE.WATER:
                                    if (morkTLebaiJC.morkOrderPushesWater.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                    {
                                        morkTLebaiJC.morkOrderPushesWater.Enqueue(new OrderLocInfo()
                                        {
                                            SuborderId = order.MorkOrder.SuborderId,
                                            BatchingId = res.BatchingId,
                                            Loc = ushort.Parse(mainMaterialLoc),
                                            GoodName = order.MorkOrder.GoodsName,
                                        });
                                    }
                                    break;
                                case GOODS_TYPE.NEITHER:
                                    DeviceProcessLogShow("未知的商品类型");
                                    break;
                            }
                        }
                    }
                }
            });
        }
        /// <summary>
        /// 将空杯放好到接饮料的地方的标志位
        /// </summary>
        private bool bFirstTrig_TeaWater = false;
        private bool bFirstTrig_Coffee   = false;
        private bool bFirstTrig_Juice    = false;
        /// <summary>
        /// 延迟的超时时间
        /// </summary>
        DateTime delayTimeOut_Water;
        DateTime delayTimeOut_Coffee;
        DateTime delayTimeOut_Juice;
        public override void MainTask()
        {
            EventBus.EventBus.GetInstance().Subscribe<DRCoffee_CoffeEndCookEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (morkTLebaiJC.IsHaveCoffeeCup && morkTLebaiJC.MakeCoffeeEnd != true)
                    morkTLebaiJC.MakeCoffeeEnd = true;
            });
            if (morkTLebaiJC.IsHaveCoffeeCup && morkTLebaiJC.MakeCoffeeEnd != true)
            {
                if (!bFirstTrig_Coffee)
                {
                    bFirstTrig_Coffee = true;
                    delayTimeOut_Coffee = DateTime.Now;
                }
                else if (DateTime.Now.Subtract(delayTimeOut_Coffee).TotalSeconds > 18 && bFirstTrig_Coffee == true) 
                {
                    bFirstTrig_Coffee = false;
                    if (morkTLebaiJC.IsHaveCoffeeCup)
                        morkTLebaiJC.MakeCoffeeEnd = true;
                }
            }

            if (morkTLebaiJC.IsHaveJuiceCup && morkTLebaiJC.MakeJuiceEnd != true)
            {
                var Juicestate = GetStatus<int[]>("GetDeviceStatus");
                if (Juicestate != null)
                {
                    if (Juicestate.Length > 0)
                    {
                        var Juicestate1 = Convert.ToString(Juicestate[0], 2);
                        var Juicestate2 = Juicestate[1];
                        if (Juicestate1.IndexOf("0") == 1 && Juicestate2 == 0)
                        {
                            morkTLebaiJC.MakeJuiceEnd = true;
                            bFirstTrig_Juice = false;
                        }
                    }
                }
                if (!morkTLebaiJC.MakeJuiceEnd)
                {
                    //若无状态返回 则加延迟
                    if (!bFirstTrig_Juice)
                    {
                        bFirstTrig_Juice = true;
                        delayTimeOut_Juice = DateTime.Now;
                    }
                    else if (DateTime.Now.Subtract(delayTimeOut_Juice).TotalSeconds > 3 && bFirstTrig_Juice == true)
                    {
                        bFirstTrig_Juice = false;
                        morkTLebaiJC.MakeJuiceEnd = true;
                    }
                }
            }
            if (morkTLebaiJC.IsHaveTeaWaterCup && morkTLebaiJC.MakeTeaEnd != true)
            {
                if (!bFirstTrig_TeaWater)
                {
                    bFirstTrig_TeaWater = true;
                    delayTimeOut_Water = DateTime.Now;//开启接水信号后，记录当前时间
                }
                else if (DateTime.Now.Subtract(delayTimeOut_Water).TotalSeconds >= 5 && bFirstTrig_TeaWater == true)//接水超过50s后，启动接水完成标志，开启接水程序
                {
                    bFirstTrig_TeaWater = false;
                    morkTLebaiJC.MakeTeaEnd = true;
                }
            }
            DoCoffee();
            DoJuice();
            DoBoiledTea();
            DoBoiledWater();
        }

        /// <summary>
        /// 订单状态改变
        /// </summary>
        /// <param name="subid"></param>
        /// <param name="oRDER_STATUS"></param>
        private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)
        {
            EventBus.EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });
        }
        /// <summary>
        /// 验证商品是做的某种饮料
        /// </summary>
        /// <param name="batchingLoc">物料位置</param>
        private GOODS_TYPE ValidateGoodsByBatching(string batchingLoc)
        {
            if (batchings.ContainsKey(batchingLoc))
                return batchings[batchingLoc].GoodsType;
            return GOODS_TYPE.NEITHER;
        }
        /// <summary>
        /// 乐白的场景结束等待
        /// </summary>
        /// <param name="value"></param>
        private void Wait(int value = 101)
        {
            while (!((bool)peripheralStatus["RobotOK"] && (int)peripheralStatus["RobotValue"] == value))
            {
                Thread.Sleep(5);
            }
            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
        }
        /// <summary>
        /// 乐白的场景
        /// </summary>
        /// <param name="sen"></param>
        private void Sence(int sen)
        {
            new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = sen }.Publish();
        }
        /// <summary>
        /// 乐白的数字量输出
        /// </summary>
        /// <param name="value"></param>
        /// <param name="pin"></param>
        private void Output(bool value,int pin)
        {
            new LebaiRobot_SetOutPutEvent { DeviceId = DeviceId, Pin = pin,Value=value }.Publish();
        }

        private T GetStatus<T>(string key)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    return (T)(peripheralStatus[key]);
                }
            }
            return default;
        }
        int[] devStatusBy = new int[2] { 0, 0 };
        bool outCupCheck = false;//放纸杯位置有无判断
        /// <summary>
        /// 传感器的输入信号 0:无意义 1：有信号 2：无信号 3：信号不正确
        /// </summary>
        int bSensorInput;
        
        /// <summary>
        /// 判断是否有咖啡订单
        /// </summary>
        /// <returns></returns>
        private bool IsMakeCoffee() 
        {
            bool bMake = (IsHealth && morkTLebaiJC.morkOrderPushesCoffee.Count > 0 && !morkTLebaiJC.IsHaveCoffeeCup) ? true : false;
            return bMake;
        }
        /// <summary>
        /// 判断是否有果汁订单
        /// </summary>
        /// <returns></returns>
        private bool IsMakeJuice()
        {
            bool bMake = (IsHealth && morkTLebaiJC.morkOrderPushesJuicer.Count > 0  && !morkTLebaiJC.IsHaveJuiceCup) ? true : false;
            return bMake;
        }
        /// <summary>
        /// 判断是否有茶订单
        /// </summary>
        /// <returns></returns>
        private bool IsMakeTeaWater()
        {
            bool bMake = (IsHealth && morkTLebaiJC.morkOrderPushesTea.Count > 0  && !morkTLebaiJC.IsHaveTeaWaterCup) ? true : false;
            return bMake;
        }
        /// <summary>
        /// 判断是否有开水订单
        /// </summary>
        /// <returns></returns>
        private bool IsMakeWater()
        {
            bool bMake = (IsHealth && morkTLebaiJC.morkOrderPushesWater.Count > 0  && !morkTLebaiJC.IsHaveTeaWaterCup) ? true : false;
            return bMake;
        }
        /// <summary>
        /// 做咖啡流程
        /// </summary>
        private void DoCoffee() 
        {
            if (IsMakeCoffee())
            {
                PickUpCoffee();//接咖啡
                morkTLebaiJC.IsHaveCoffeeCup = true;
            }
            else if(morkTLebaiJC.MakeCoffeeEnd)
            {
                try
                {
                    PutCoffeeCup();
                    morkTLebaiJC.MakeCoffeeEnd = false;
                    morkTLebaiJC.IsHaveCoffeeCup = false;
                    morkTLebaiJC.morkOrderPushesCoffee.TryDequeue(out OrderLocInfo orderLoc);
                }
                catch (Exception ex)
                {
                    MessageLog.GetInstance.ShowEx(ex.ToString());
                }
            }
        }
        private void DoJuice()
        {
            if (IsMakeJuice())
            {
                switch (morkTLebaiJC.morkOrderPushesJuicer.ElementAt(0).Loc) 
                {
                    case 1:
                        GuMake = true;
                        IsAddIce = false;
                        break;
                    case 2:
                        GuMake = false;
                        IsAddIce = false;
                        break;
                    case 3:
                        GuMake = false;
                        IsAddIce = true;
                        break;
                    default:
                        break;
                }
                PickUpJuicer();
                morkTLebaiJC.IsHaveJuiceCup = true;
            }
            else if (morkTLebaiJC.MakeJuiceEnd) 
            {
                try
                {
                    Thread.Sleep(5000);//延迟五秒，防止饮料口滴饮料
                    putJuice();
                    morkTLebaiJC.IsHaveJuiceCup = false;
                    morkTLebaiJC.MakeJuiceEnd = false;
                    morkTLebaiJC.morkOrderPushesJuicer.TryDequeue(out OrderLocInfo orderLoc);
                }
                catch (Exception ex) 
                {
                    MessageLog.GetInstance.ShowEx(ex.ToString());
                }
            }
        }
        public bool DoTeaOrWater;
        private void DoBoiledTea() 
        {
            if (IsMakeTeaWater())
            {
                PickUpTea();
                morkTLebaiJC.IsHaveTeaWaterCup = true;
                DoTeaOrWater = true;
            }
            else if (morkTLebaiJC.MakeTeaEnd && morkTLebaiJC.morkOrderPushesTea.Count > 0 && DoTeaOrWater)
            {
                try
                {
                    PutWaterCup();
                    DeviceProcessLogShow("-------------茶 制作完成------------");
                    OrderChange(morkTLebaiJC.morkOrderPushesTea.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                    morkTLebaiJC.IsHaveTeaWaterCup = false;
                    morkTLebaiJC.MakeTeaEnd = false;
                    morkTLebaiJC.morkOrderPushesTea.TryDequeue(out OrderLocInfo orderLoc);
                }
                catch (Exception ex)
                {
                    MessageLog.GetInstance.ShowEx(ex.ToString());
                }
            }
        }
        private void DoBoiledWater() 
        {
            if (IsMakeWater())
            {
                PickUpWater();
                morkTLebaiJC.IsHaveTeaWaterCup = true;
                DoTeaOrWater = false;
            }
            else if (morkTLebaiJC.MakeTeaEnd && morkTLebaiJC.morkOrderPushesWater.Count > 0 && DoTeaOrWater == false)
            {
                try
                {
                    PutWaterCup();
                    DeviceProcessLogShow("-------------开水 制作完成------------");
                    OrderChange(morkTLebaiJC.morkOrderPushesWater.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                    morkTLebaiJC.IsHaveTeaWaterCup = false;
                    morkTLebaiJC.MakeTeaEnd = false;
                    morkTLebaiJC.morkOrderPushesWater.TryDequeue(out OrderLocInfo orderLoc);
                }
                catch (Exception ex)
                {
                    MessageLog.GetInstance.ShowEx(ex.ToString());
                }
            }
        }


        #region 做咖啡流程
        /// <summary>
        /// 接咖啡
        /// </summary>
        private void PickUpCoffee()
        {
            if (!morkTLebaiJC.IsHaveCoffeeCup)
            {
                outCupCheck = false;
                OrderChange(morkTLebaiJC.morkOrderPushesCoffee.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
                int resultTakeCup = takeCup();
                if (resultTakeCup == 1)
                {
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.机器人安全位);
                    //Wait();

                    WritePLCData("",2);//将轴移动到接咖啡的位置
                    DeviceProcessLogShow("伺服电机移动到接咖啡的位置");

                    DeviceProcessLogShow("咖啡杯取杯完成");
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.接咖啡);
                    //Wait();
                    new DRCoffee_MakeCoffeeEvent() { DrinkCode = (DrCoffeeDrinksCode)int.Parse(mainMaterialLoc) }.Publish();  //接咖啡控制 //DrCoffeeDrinksCode.热水
                }
                else
                {
                    /*DeviceProcessLogShow("取杯失败 回到初始位，请及时处理！！");
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.机器人初始位);
                    //Wait();*/
                }
            }
        }
        /// <summary>
        /// 咖啡杯接好，放咖啡杯
        /// </summary>
        private void PutCoffeeCup()
        {
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    DeviceProcessLogShow("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
            Sence(GVL_MorkT.机器人安全位);
            //Wait();

            WritePLCData("", 2);//将轴移动到接咖啡的位置
            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
            Sence(GVL_MorkT.放咖啡杯);
            //Wait();
            OrderChange(morkTLebaiJC.morkOrderPushesCoffee.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
            DeviceProcessLogShow($"-------------{morkTLebaiJC.morkOrderPushesCoffee.ElementAt(0).GoodName}果汁 制作完成------------");
        }
        #endregion
        #region 做开水流程
        /// <summary>
        /// 接开水
        /// </summary>
        private void PickUpWater()
        {
            #region 接水流程
            if (!morkTLebaiJC.IsHaveTeaWaterCup)
            {
                OrderChange(morkTLebaiJC.morkOrderPushesWater.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
                int resultTakeCup = takeCup();
                if (resultTakeCup == 1)
                {
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.接开水);
                    //Wait();
                    Output(false, 1);
                    Output(false, 0);
                    Thread.Sleep(100);
                    Output(true, 0);
                    Thread.Sleep(3000);
                    Output(false, 0);
                    Thread.Sleep(100);

                    Output(false, 1);
                    Thread.Sleep(100);
                    Output(true, 1);
                    Thread.Sleep(500);
                    Output(false, 1);
                }
                else
                {
                    return;
                }
            }
            #endregion
        }
        #endregion
        #region 做茶流程
        /// <summary>
        /// 做茶
        /// </summary>
        private void PickUpTea()
        {
            #region 接茶流程
            if (!morkTLebaiJC.IsHaveTeaWaterCup)
            {
                OrderChange(morkTLebaiJC.morkOrderPushesTea.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
                int resultTakeCup = takeCup();
                if (resultTakeCup == 1)
                {
                    DeviceProcessLogShow("取茶杯完成");
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.接茶叶);
                    //Wait();

                    new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();
                    Thread.Sleep(1000);
                    new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 150 }.Publish();
                    Thread.Sleep(1000);
                    new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();

                    Thread.Sleep(3000);
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.接茶水);
                    //Wait();
                    Output(false, 1);
                    Output(false, 0);
                    Thread.Sleep(100);
                    Output(true, 0);
                    Thread.Sleep(3000);
                    Output(false, 0);
                    Thread.Sleep(100);

                    Output(false, 1);
                    Thread.Sleep(100);
                    Output(true, 1);
                    Thread.Sleep(500);
                    Output(false, 1);
                    morkTLebaiJC.IsHaveTeaWaterCup = true;
                }
                else
                {
                    return;
                }
            }
            #endregion
        }
        /// <summary>
        /// 放水杯流程
        /// </summary>
        private void PutWaterCup()
        {
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    DeviceProcessLogShow("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
            Sence(GVL_MorkT.放水杯);
        }

        #endregion
        #region 做果汁流程
        /// <summary>
        /// 果汁机控制信号
        /// </summary>
        private byte JuicerNum;

        private void getIce() 
        {
            IsAddIceNow = IsAddIce;
            if (IsAddIce)
            {
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.取杯位_机器人安全位);
                //Wait();

                WritePLCData("",3);//将模组移动到接冰的位置

                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.接冰块);
                //Wait();
                new StartMakeIce() { }.Publish();

                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.接冰_机器人安全位);
                //Wait();
            }
        }
        /// <summary>
        /// 当前订单是否加冰
        /// </summary>
        private bool IsAddIceNow = false;
        private int JuiceCH;
        /// <summary>
        /// 接果汁
        /// </summary>
        private void PickUpJuicer()
        {
            #region 接果汁流程
            if (!morkTLebaiJC.IsHaveJuiceCup)
            {
                OrderChange(morkTLebaiJC.morkOrderPushesJuicer.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
                int resultTakeCup = takeCup();  
                JuiceCH = int.Parse(mainMaterialLoc);
                if (resultTakeCup == 1)
                {
                    getIce();
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.机器人安全位);
                    //Wait();
                    WritePLCData("", 3);//将模组移动到接冰的位置
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.接果汁过渡位);
                    //Wait();
                    switch (JuiceCH)
                    {
                        case 52:
                            if (GuMake)
                                JuicerNum = 0x00;
                            else
                                JuicerNum = 0x01;
                            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                            Sence(GVL_MorkT.接果汁1);
                            //Wait();
                            break;
                        case 53:
                            if (GuMake)
                                JuicerNum = 0x02;
                            else
                                JuicerNum = 0x03;
                            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                            Sence(GVL_MorkT.接果汁2);
                            //Wait();
                            break;
                        case 54:
                            if (GuMake)
                                JuicerNum = 0x04;
                            else
                                JuicerNum = 0x05;
                            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                            Sence(GVL_MorkT.接果汁3);
                            //Wait();
                            break;
                        case 55:
                            if (GuMake)
                                JuicerNum = 0x06;
                            else
                                JuicerNum = 0x07;
                            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                            Sence(GVL_MorkT.接果汁4);
                            //Wait();
                            break;
                        default:
                            JuicerNum = 0x00;
                            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                            Sence(GVL_MorkT.接果汁1);
                            //Wait();
                            break;
                    }
                    new WriteJuicer() { Value = JuicerNum }.Publish();
                    morkTLebaiJC.IsHaveJuiceCup = true;
                }
                else
                {
                    return;
                }
            }
            #endregion
        }
        /// <summary>
        /// 取接好果汁杯
        /// </summary>
        private void putJuice()
        {
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    DeviceProcessLogShow("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            switch (JuiceCH)
            {
                case 52:
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.放果汁杯1);
                    //Wait();
                    break;
                case 53:
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.放果汁杯2);
                    //Wait();
                    break;
                case 54:
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.放果汁杯3);
                    //Wait();
                    break;
                case 55:
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.放果汁杯4);
                    //Wait();
                    break;
                default:
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(GVL_MorkT.放果汁杯1);
                    //Wait();
                    break;
            }
            OrderChange(morkTLebaiJC.morkOrderPushesJuicer.ElementAt(0).SuborderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
            DeviceProcessLogShow($"-------------{morkTLebaiJC.morkOrderPushesJuicer.ElementAt(0).GoodName}果汁 制作完成------------");
        }
        #endregion

        /// <summary>
        /// 取杯的次数
        /// </summary>
        private int nCnt;
        /// <summary>
        /// 取杯流程
        /// </summary>
        /// <returns>0:无意义，1：取杯成功 2：取杯失败</returns>
        private int takeCup()
        {
            try
            {
                nCnt = 0;
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.机器人初始位);
                //Wait();

                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.机器人安全位);
                //Wait();

                WritePLCData("", 1);

                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.取纸杯);
                //Wait();

                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.取纸杯检测);
                //Wait();
                nCnt++;
                Thread.Sleep(2000);
                while (!GetStatus<bool>("GetInput")) //读取传感器的值
                {
                    if (nCnt > 3)
                    {
                        nCnt = 0;
                        DeviceProcessLogShow("三次取杯失败，回原点");
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(GVL_MorkT.机器人安全位);
                        //Wait();
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(GVL_MorkT.机器人初始位);
                        //Wait();
                        return 2;
                    }
                    else
                    {
                        nCnt++;
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(GVL_MorkT.二次取杯);
                        //Wait();
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(GVL_MorkT.取纸杯检测);
                        //Wait();
                        
                    }
                    Thread.Sleep(1000);
                }
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(GVL_MorkT.取杯位_机器人安全位);
                //Wait();
                return 1;
            }
            catch (Exception ex)
            {
                DeviceProcessLogShow(ex.ToString());
            }
            return 2;
        }
        /// <summary>
        /// 放杯
        /// </summary>
        /// <returns>0:无意义 1：放杯成功 2：执行失败(传感器还有信号) 3：放杯异常</returns>
        private int putCup()
        {
            try
            {
                if (GetStatus<bool>("GetInput2")) return 2;
                Sence(GVL_MorkT.JUICE_放杯);
                //Wait();
                new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();
                Sence(GVL_MorkT.JUICE_放杯检测);
                //Wait();
                new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();
                if (GetStatus<bool>("GetInput2"))
                {
                    return 1;
                }
                else
                {
                    return 3;
                }
            }
            catch (Exception ex)
            {
                DeviceProcessLogShow(ex.ToString());
                return 0;
            }
        }
        public void SimOrder<T>(T simOrder)
        {
             
        }
        #region PLC 控制函数

        private void WritePLCData(string address, object value)
        {
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });
        }
        private void GetStatus(string key, Action<object> action)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    action?.Invoke(peripheralStatus[key]);
                }
            }
        }

        public override void ReadData()
        {
            GetStatus("", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 24)
                {
                    
                }
            }));
        }
        #endregion
        public override void Stop()
        {

        }

        public override void ResetProgram()
        {

        }

        public override void SimOrder()
        {

        }
    }
}
