using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using BPASmartClient.Device;
using BPASmartClient.Helper;
using BPA.Message.Enum;
using BPASmartClient.Model;
using BPASmartClient.EventBus;
using static BPASmartClient.EventBus.EventBus;
using BPASmartClient.MorkM.Model;
using System.Collections.ObjectModel;
using BPASmartClient.Model.PLC;
using BPASmartClient.MorkM.ViewModel;

namespace BPASmartClient.MorkM
{
    public class Control_MORKM : BaseDevice
    {
        public override DeviceClientType DeviceType => DeviceClientType.MORKM;
        GVL_MORKM mORKS = new GVL_MORKM();
        Alarm alarm = new Alarm();
        HardwareStatus hardwareStatus = new HardwareStatus();



        public void SimOrder<T>(T simOrder)
        {

            if (simOrder != null)
            {

                if (simOrder is List<ushort> locs)
                {
                    OrderInformation newOrder = new OrderInformation();//新加
                    List<OrderLocInfo> orders = new List<OrderLocInfo>();
                    string subId = Guid.NewGuid().ToString();
                    foreach (var item in locs)
                    {
                        if (item >= 1 && item <= 5)
                        {
                            orders.Add(new OrderLocInfo() { Loc = item, SuborderId = subId, MakeType = false });
                            //mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo() { Loc = item, SuborderId = subId });
                            //DeviceProcessLogShow($"添加订单：面条位置【{item}】");
                        }
                        if (item >= 10 && item <= 11)
                        {
                            mORKS.TakeBowlTask.Enqueue(new OrderLocInfo() { Loc = item, SuborderId = subId, MakeType = false });
                            DeviceProcessLogShow($"添加订单：碗位置【{item}】");
                        }
                    }
                    mORKS.DishNumber = orders.Count;//订单中配菜的数量
                    while (orders.Count > 0)
                    {
                        for (int i = 0; i < orders.Count; i++)
                        {
                            var res = orders.FirstOrDefault(p => p.Loc % 2 != 0);
                            if (res != null)
                            {
                                //if (mORKS.RBTakeNoodleTask.FirstOrDefault(p => p.SuborderId == res.SuborderId) == null)
                                mORKS.RBTakeNoodleTask.Enqueue(res);

                                orders.Remove(res);

                            }
                            else
                            {
                                //if (mORKS.RBTakeNoodleTask.FirstOrDefault(p => p.SuborderId == orders[i].SuborderId) == null)
                                mORKS.RBTakeNoodleTask.Enqueue(orders[i]);
                                mORKS.VegtabNum++;
                                orders.RemoveAt(i);

                            }
                        }
                    }
                    Dictionary<string, OrderInformation> dic = new Dictionary<string, OrderInformation>();
                    newOrder.DishNum = mORKS.DishNumber;
                    newOrder.VegatableNumber = mORKS.VegtabNum;
                    dic.Add(subId, newOrder);
                    mORKS.Conqueue.Enqueue(dic);
                    mORKS.VegtabNum = 0;
                    mORKS.DishNumber = 0;
                }
            }
        }

        ///// <summary>
        ///// IOT 广播消息命令
        ///// </summary>
        //public void IotBroadcast<T>(T broadcast)
        //{
        //    if (broadcast != null && broadcast is IOTCommandModel iOTCommand)
        //    {
        //        DeviceProcessLogShow($"IOT 广播消息命令 {iOTCommand.deviceName} 设备命令 {iOTCommand.CommandName} 控制变量{iOTCommand.CommandValue.Keys.First()}{iOTCommand.CommandValue[iOTCommand.CommandValue.Keys.First()]}");
        //        switch (iOTCommand.CommandName)
        //        {
        //            case 0://控制类
        //                if (iOTCommand.CommandValue != null)
        //                {
        //                    if (iOTCommand.CommandValue.ContainsKey("order"))
        //                    {
        //                        List<ushort> vs = new List<ushort>();
        //                        vs.Add((ushort)(new Random().Next(1, 5)));
        //                        vs.Add(ushort.Parse(iOTCommand.CommandValue["order"]));
        //                        SimOrder(vs);
        //                    }
        //                    else if (iOTCommand.CommandValue.ContainsKey("init"))
        //                    {
        //                        DeviceInit();
        //                    }
        //                    else if (iOTCommand.CommandValue.ContainsKey("stop"))
        //                    {
        //                    }
        //                    else if (iOTCommand.CommandValue.ContainsKey("start"))
        //                    {
        //                    }
        //                }
        //                break;
        //            case 1://设置属性

        //                break;
        //            case 2://通知消息

        //                break;
        //            default:
        //                break;
        //        }
        //    }
        //}

        int OrderCount = 0;
        ///// <summary>
        ///// 数据解析
        ///// </summary>
        public void DataParse()
        {
            EventBus.EventBus.GetInstance().Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {
                if (@event == null) return;
                if (@event is DoOrderEvent order)
                {
                    mORKS.doOrderEvents.Add(order);
                    if (order.MorkOrder.GoodBatchings == null) return;
                    OrderCount++;
                    OrderChange(order.MorkOrder.SuborderId, ORDER_STATUS.WAIT);
                    DeviceProcessLogShow($"接收到{OrderCount}次订单");
                    //if (order is MorkOrderPush morkOrderPush)
                    //{
                    OrderInformation newOrder = new OrderInformation();//2022.4.30 修改
                    List<OrderLocInfo> locs = new List<OrderLocInfo>();
                    foreach (var item in order.MorkOrder.GoodBatchings)
                    {
                        var res = Json<BatchingInfoPar>.Data.orderMaterialDelivery?.BatchingInfo?.FirstOrDefault(p => p.BatchingId == item.BatchingId);
                        if (res != null)
                        {
                            if (ushort.TryParse(res.BatchingLoc, out ushort loc))
                            {
                                if (loc >= 1 && loc <= 5)
                                {
                                    locs.Add(new OrderLocInfo() { Loc = ushort.Parse(res.BatchingLoc), SuborderId = order.MorkOrder.SuborderId, BatchingId = res.BatchingId, MakeType = order.MorkOrder.MakeID == "2" }); //新增冒菜干拌or加汤
                                }
                                else if (loc >= 10 && loc <= 11)
                                {
                                    int index = 0;
                                    if (Json<BatchingInfoPar>.Data.recipeBoms != null)
                                    {
                                        index = Array.FindIndex(Json<BatchingInfoPar>.Data.recipeBoms?.RecipeIds.ToArray(), p => p.RecipeId == order.MorkOrder.RecipeId);
                                        index++;
                                    }
                                    if (mORKS.TakeBowlTask.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                        mORKS.TakeBowlTask.Enqueue(new OrderLocInfo()
                                        {
                                            Loc = 11,
                                            SuborderId = order.MorkOrder.SuborderId,
                                            RecipeNumber = (index >= 1 && index <= 10) ? (ushort)index : (ushort)0
                                        });
                                }
                            }
                        }
                    }
                    //手动供碗 调试用
                    mORKS.TakeBowlTask.Enqueue(new OrderLocInfo()
                    {
                        Loc = 11,
                        SuborderId = order.MorkOrder.SuborderId,
                        MakeType = order.MorkOrder.MakeID == "2"
                    });
                    mORKS.DishNumber = locs.Count;//订单中配菜的数量  2022.4.30 修改
                    while (locs.Count > 0)
                    {
                        for (int i = 0; i < locs.Count; i++)
                        {
                            var res = locs.FirstOrDefault(p => p.Loc % 2 != 0);
                            if (res != null)
                            {
                                //if (mORKS.RBTakeNoodleTask.FirstOrDefault(p => p.SuborderId == res.SuborderId) == null)
                                mORKS.RBTakeNoodleTask.Enqueue(res);
                                locs.Remove(res);

                            }
                            else
                            {
                                //if (mORKS.RBTakeNoodleTask.FirstOrDefault(p => p.SuborderId == locs[i].SuborderId) == null)
                                mORKS.RBTakeNoodleTask.Enqueue(locs[i]);
                                mORKS.VegtabNum++;
                                locs.RemoveAt(i);

                            }
                        }
                    }

                    Dictionary<string, OrderInformation> dic = new Dictionary<string, OrderInformation>();
                    newOrder.DishNum = mORKS.DishNumber;
                    newOrder.VegatableNumber = mORKS.VegtabNum;
                    //newOrder.MakeType = morkOrderPush.MakeType;
                    dic.Add(order.MorkOrder.SuborderId, newOrder);
                    mORKS.Conqueue.Enqueue(dic);
                    mORKS.VegtabNum = 0;
                    mORKS.DishNumber = 0;
                    //}
                }
            });
        }

        public override void MainTask()
        {
            mORKS.AllowRun = mORKS.InitComplete;
            if (Json<KeepDataBase>.Data.IsVerify)
                IsHealth = mORKS.Error && mORKS.InitComplete;
            else
                IsHealth = true;

            //if (mORKS.AllowRun)
            //{
            TakeBowlTask();

            TakeNoodleTask();

            OutNoodleTask();

            SingleDetect();

            TurntableControl();
        }

        /// <summary>
        /// 取碗控制
        /// </summary>
        private void TakeBowlTask()
        {
            if (mORKS.AllowRun && mORKS.TakeBowlTask.Count > 0 && !mORKS.TakeBowlIdle && !mORKS.TakeBowlInterlock)
            {
                if (mORKS.TakeBowlTask.TryDequeue(out OrderLocInfo orderLocInfo))
                {
                    mORKS.TakeBowlId = orderLocInfo.SuborderId;
                    mORKS.OutMealType = orderLocInfo.MakeType;//新增冒菜干拌or加汤
                    TakeBowlControl(orderLocInfo.Loc);
                    SetRecipeNumber(orderLocInfo.RecipeNumber);
                    OrderChange(mORKS.TakeBowlId, ORDER_STATUS.COOKING);
                    DeviceProcessLogShow($"订单【{ mORKS.TakeBowlId}】执行取碗控制,位置:[{orderLocInfo.Loc}]");
                }
                mORKS.TakeBowlInterlock = true;
            }
        }

        /// <summary>
        /// 转台控制
        /// </summary>
        private void TurntableControl()
        {
            if (GeneralConfig.EnableLocalSimOrder)
            {
                //不做轮询，直接取面，模拟订单使用
                if (mORKS.TurntableMoveInPlace && !mORKS.Feeding && mORKS.InitComplete && !mORKS.AllowTakeNoodle && mORKS.RBTakeNoodleTask.Count > 0)
                {
                    if (mORKS.TurntableLowerLimit)
                    {
                        TurntableStart(mORKS.RBTakeNoodleTask.ElementAt(0).Loc);
                        if (mORKS.RBTakeNoodleTask.ElementAt(0).Loc == mORKS.TurntableFeedbackloc)
                        {
                            mORKS.TurntableLocLists.Clear();
                            mORKS.AllowTakeNoodle = true;
                            DeviceProcessLogShow($"控制机器人去转台【{mORKS.RBTakeNoodleTask.ElementAt(0).Loc}】号位置取面");
                        }
                    }
                }
            }
            else
            {
                //正常轮询
                if (mORKS.TurntableMoveInPlace && !mORKS.Feeding && mORKS.InitComplete && !mORKS.AllowTakeNoodle && mORKS.RBTakeNoodleTask.Count > 0)
                {
                    var result = Json<BatchingInfoPar>.Data.orderMaterialDelivery.BatchingInfo.Where(p => p.BatchingId == mORKS.RBTakeNoodleTask.ElementAt(0).BatchingId).ToList();
                    if (result != null)
                    {
                        var res = result.FirstOrDefault(P => P.BatchingLoc == mORKS.TurntableFeedbackloc.ToString());
                        if (mORKS.TurntableLowerLimit && res != null)
                        {
                            TurntableStart(mORKS.TurntableFeedbackloc);
                            mORKS.TurntableLocLists.Clear();
                            mORKS.AllowTakeNoodle = true;
                            DeviceProcessLogShow($"控制机器人去转台【{mORKS.TurntableFeedbackloc}】号位置取面");
                        }
                        else
                        {
                            if (!mORKS.TurntableInterlock)
                            {
                                foreach (var item in result)
                                {
                                    if (ushort.TryParse(item.BatchingLoc, out ushort loc))
                                    {
                                        if (mORKS.TurntableFeedbackloc != loc && !mORKS.TurntableLocLists.Contains(loc))
                                        {
                                            TurntableStart(loc);
                                            DeviceProcessLogShow($"没有物料检测的启动转台控制,转台位置：[{loc}]");
                                            break;
                                        }
                                        else if (mORKS.TurntableFeedbackloc == loc && !mORKS.TurntableLocLists.Contains(loc)) mORKS.TurntableLocLists.Add(loc);
                                    }
                                }
                            }
                        }
                    }
                    else DeviceProcessLogShow("未找到可用的物料信息");
                }
            }

            //转台到位检测
            if (RTrig.GetInstance("TurntableInPlace").Start(mORKS.TurntableMoveInPlace && mORKS.CurrentLoc == mORKS.TurntableFeedbackloc))
            {
                mORKS.CurrentLoc = 0;
                mORKS.TurntableInterlock = false;
                DeviceProcessLogShow("转台到位检测");
            }

            //补料完成检测
            if (RTrig.GetInstance("FeedComplete").Start(mORKS.FeedComplete))
            {
                if (!mORKS.AllowTakeNoodle && mORKS.TurntableLocLists.Count > 0)
                {
                    mORKS.TurntableLocLists.Clear();
                    mORKS.TurntableInterlock = false;
                    DeviceProcessLogShow("补料完成检测");
                }
            }
        }
        /// <summary>
        /// 取面任务
        /// </summary>
        private void TakeNoodleTask()
        {
            //取面控制
            if (mORKS.AllowRun && mORKS.RobotIdle && !mORKS.Feeding && (!mORKS.RobotTaskInterlock || !mORKS.VegNoodlesLock && mORKS.relock) && mORKS.AllowTakeNoodle && mORKS.TurntableMoveInPlace && !mORKS.TakeNoodleInterlock && !mORKS.OutNoodleing && mORKS.RBTakeNoodleTask.Count > 0)
            {

                int loc = Array.FindIndex(mORKS.NoodleCookerStatus, p => p == false);//查找煮面炉空闲位置
                if (loc >= 0 && loc <= 5)
                {

                    if (mORKS.RBTakeNoodleTask.TryDequeue(out OrderLocInfo orderLocInfo))
                    {

                        //  mORKS.CookNodelId[loc] = orderLocInfo.SuborderId;
                        mORKS.orderLocInfos[loc] = orderLocInfo;
                        SetFallNoodleLoc((ushort)(loc + 1));
                        //机器人开始取面
                        RobotTakeNoodle();
                        // SimpleFactory.GetInstance.OrderChanged(orderLocInfo.SuborderId, ORDER_STATUS.COOKING);
                        DeviceProcessLogShow($"订单【{orderLocInfo.SuborderId}】,机器人倒面至【{loc + 1}】号煮面栏");

                        //写入煮菜时间
                        List<ushort> values = new List<ushort>();
                        if (mORKS.orderLocInfos[loc].Loc % 2 == 0)//素菜
                        {
                            values.Add(2);//分
                            values.Add(0);//秒
                            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address =$"VW{ 116 + (loc * 6) }" , Value = values.ToArray() });
                        }
                        else //荤菜
                        {
                            values.Add(4);//分
                            values.Add(0);//秒
                            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = $"VW{ 116 + (loc * 6) }", Value = values.ToArray() });
                        }


                        mORKS.TakeNoodleInterlock = true;
                    }
                }

            }
        }

        /// <summary>
        /// 出餐控制
        /// </summary>
        private void OutNoodleTask()
        {
            if (mORKS.AllowFallNoodle && mORKS.RobotTaskInterlock && !mORKS.TakeNoodleInterlock && mORKS.RobotIdle && !mORKS.TakeMealDetect)
            {
                //  var  list= mORKS.CookNoodlesComplete.Where(p => p == true).ToList();
                mORKS.HasVeg = false;
                for (int i = 0; i < mORKS.CookNoodlesComplete.Length; i++)
                {
                    if (mORKS.CookNoodlesComplete[i] && mORKS.orderLocInfos[i] != null && mORKS.orderLocInfos[i].SuborderId == mORKS.IngredientsCompleteId)
                    {
                        if (!mORKS.relock)
                        {
                            if (mORKS.Conqueue.TryDequeue(out Dictionary<string, OrderInformation> dic))
                            {
                                mORKS.Vnum = dic[mORKS.orderLocInfos[i].SuborderId].VegatableNumber;
                                mORKS.TotalNum = dic[mORKS.orderLocInfos[i].SuborderId].DishNum;
                                mORKS.relock = true;
                            }
                        }
                        if (mORKS.orderLocInfos[i].Loc % 2 == 0)
                        {
                            mORKS.HasVeg = true;
                            mORKS.ListOrder.Add(i, mORKS.orderLocInfos[i]);//找出当前订单煮熟的素菜
                        }
                        else if (!mORKS.HasVeg)
                        {
                            mORKS.ListOrderMeat.Add(i, mORKS.orderLocInfos[i]);//找出当前订单煮熟的荤菜
                        }
                    }
                }
                if (mORKS.ListOrder.Count > 0)
                {
                    foreach (KeyValuePair<int, OrderLocInfo> item in mORKS.ListOrder)
                    {
                        while (!mORKS.RobotIdle)
                        {

                        }
                        int location = item.Key; //煮面炉位置
                        ushort number = item.Value.Loc;//荤素编号
                        SetTakeNoodleLoc((ushort)(location + 1));
                        RobotOutMeal();
                        CookNoodleStatusReset((ushort)(location + 1));
                        // ResetAllowFallNoodle();
                        mORKS.OutMealId = mORKS.IngredientsCompleteId;
                        //  mORKS.CookNodelId[loc] = string.Empty;
                        mORKS.orderLocInfos[location] = null;

                        DeviceProcessLogShow($"{location + 1}号位置出餐控制");
                        mORKS.OutNoodleing = true;
                        mORKS.Count++;
                        CheckLastDish();
                    }

                }
                if (mORKS.ListOrderMeat.Count > 0 && mORKS.Count == mORKS.Vnum && mORKS.ListOrder.Count == 0)
                {
                    foreach (KeyValuePair<int, OrderLocInfo> item in mORKS.ListOrderMeat)
                    {
                        while (!mORKS.RobotIdle)
                        {

                        }
                        int location = item.Key; //煮面炉位置
                        ushort number = item.Value.Loc;//荤素编号
                        SetTakeNoodleLoc((ushort)(location + 1));
                        RobotOutMeal();
                        CookNoodleStatusReset((ushort)(location + 1));
                        // ResetAllowFallNoodle();
                        mORKS.OutMealId = mORKS.IngredientsCompleteId;
                        //  mORKS.CookNodelId[loc] = string.Empty;
                        mORKS.orderLocInfos[location] = null;
                        // mORKS.Count++;
                        DeviceProcessLogShow($"{location + 1}号位置出餐控制");
                        mORKS.OutNoodleing = true;
                        mORKS.CountMeat++;
                        CheckLastDish();
                    }

                }
                mORKS.ListOrder.Clear();
                mORKS.ListOrderMeat.Clear();
            }
        }

        /// <summary>
        /// 检查是否是当前订单最后一个配菜
        /// </summary>
        public void CheckLastDish()
        {
            mORKS.Num = 0;
            foreach (var item1 in mORKS.orderLocInfos)
            {
                if (item1 != null)
                {
                    if (item1.SuborderId == mORKS.OutMealId)
                    {
                        mORKS.Num++;
                        //mORKS.Count++;
                        //mORKS.CountMeat++;
                    }
                }

            }
            if (mORKS.Num == 0 && mORKS.Count + mORKS.CountMeat == mORKS.TotalNum)
            {
                if (mORKS.OutMealType)
                {
                    AddSoup();//加汤
                    DeviceProcessLogShow("正在加汤");
                }
                else
                {
                    //不加汤
                }
                CookComplete(); //告诉机器人冒菜已经煮完
                ResetAllowFallNoodle();
                //mORKS.VegNoodlesLock = false;
                mORKS.VegN = 0;
                mORKS.relock = false;
                mORKS.Count = 0;
                mORKS.CountMeat = 0;
                mORKS.IngredientsCompleteId = string.Empty;
                mORKS.TakeBowlId = string.Empty;
                mORKS.TakeBowlInterlock = false;

            }
            else
            {

                while (mORKS.RobotIdle)
                {

                }
                // Thread.Sleep(3000);
            }

        }
        /// <summary>
        /// 信号检测
        /// </summary>
        private void SingleDetect()
        {

            //允许倒面信号检测
            if (RTrig.GetInstance("AllowFallNoodle").Start(mORKS.AllowFallNoodle))
            {

                mORKS.IngredientsCompleteId = mORKS.TakeBowlId;
                // mORKS.TakeBowlId = string.Empty;
                // DeviceProcessLogShow("碗到位，允许到面");
                DeviceProcessLogShow($"碗到位，允许到面,{mORKS.IngredientsCompleteId}");
                // mORKS.TakeBowlInterlock = false;
            }

            //出餐完成信号检测
            if (RTrig.GetInstance("CompleteChange").Start(mORKS.RbOutMealComplete))
            {

                OrderChange(mORKS.OutMealId, ORDER_STATUS.COMPLETED_COOK);
                DeviceProcessLogShow($"订单【{mORKS.OutMealId}】制作完成");
                mORKS.OutNoodleing = false;
            }

            //取餐完成逻辑处理
            if (DelayRTrig.GetInstance("CompleteChange1").Start(mORKS.RbOutMealComplete && !mORKS.TakeMealDetect, 2))
            {
                OrderChange(mORKS.OutMealId, ORDER_STATUS.COMPLETED_TAKE);
                DeviceProcessLogShow($"订单【{mORKS.OutMealId}】取餐完成");
                ResetCookComplete();
                mORKS.OutMealId = string.Empty;
            }

            //机器人取面完成信号检测
            if (RTrig.GetInstance("TakeNoodleComplete").Start(mORKS.RbTakeNoodleComplete))
            {
                mORKS.TakeNoodleInterlock = false;
                mORKS.AllowTakeNoodle = false;
                mORKS.TurntableInterlock = false;
                DeviceProcessLogShow("机器人取面完成信号检测");
                TakeNoodleCompleteReset();
            }

            //转台到位检测
            //if (RTrig.GetInstance("TurntableInPlace").Start(mORKS.TurntableMoveInPlace))
            //{
            //    mORKS.TurntableInterlock = false;
            //}

            mORKS.VegNoodlesLock = false;

            for (int i = 0; i < mORKS.CookNoodlesComplete.Length; i++)
            {
                if (mORKS.CookNoodlesComplete[i] && mORKS.orderLocInfos[i] != null && mORKS.orderLocInfos[i].SuborderId == mORKS.IngredientsCompleteId)
                {
                    if ((mORKS.orderLocInfos[i].Loc % 2 == 0 || mORKS.Vnum == 0) && mORKS.relock)
                    {
                        mORKS.VegNoodlesLock = true;
                        mORKS.VegN++;
                        break;
                    }


                }
            }
            if (mORKS.VegN == mORKS.Vnum && mORKS.VegN < mORKS.TotalNum && mORKS.relock)
            {
                mORKS.VegNoodlesLock = true;
            }
            int OutMealRequstCount = mORKS.CookNoodlesComplete.Where(p => p == true).ToList().Count;
            int mlCount = mORKS.NoodleCookerStatus.Where(p => p == true).ToList().Count;
            mORKS.RobotTaskInterlock = OutMealRequstCount > 0 && mORKS.AllowFallNoodle && (mlCount >= 1 || mORKS.RBTakeNoodleTask.Count == 0);
            if (mORKS.RobotIdle && mORKS.RobotTaskInterlock == false)
            {
                mORKS.OutNoodleing = false;
            }
        }


        #region PLC 控制函数

        /// <summary>
        /// 写入配方数据到 PLC
        /// </summary>
        private void WriteRecipeBoms()
        {
            List<ushort> recipeBoms = new List<ushort>();
            if (this.recipeBoms == null) return;
            foreach (var item in this.recipeBoms.RecipeIds)
            {
                foreach (var rec in item.Recipes)
                {
                    recipeBoms.Add((ushort)rec);
                }
            }
            if (recipeBoms.Count > 0)
            {
                //配方数据地址范围：VW2000 - VW2278
                WriteData("VW2000", recipeBoms.ToArray());
                DeviceProcessLogShow("写配方成功");
            }
            else { DeviceProcessLogShow("配方数据为空"); }
        }

        /// <summary>
        /// 取面完成复位
        /// </summary>
        private void TakeNoodleCompleteReset()
        {
            WriteData("M100.4", false);
        }

        /// <summary>
        /// 指定煮面口状态复位
        /// </summary>
        /// <param name="num"></param>
        private void CookNoodleStatusReset(int num)
        {
            if (num >= 1 && num <= 6)
            {
                WriteData($"102.{num - 1}", false);
                DeviceProcessLogShow($"{num}号煮面口占用复位");
            }

        }

        /// <summary>
        /// 写配方编号
        /// </summary>
        /// <param name="num"></param>
        private void SetRecipeNumber(ushort num)
        {
            WriteData("VW0", num);
        }

        /// <summary>
        /// 启动转台
        /// </summary>
        /// <param name="loc"></param>
        private void TurntableStart(ushort loc)
        {
            mORKS.CurrentLoc = loc;
            mORKS.TurntableInterlock = true;
            mORKS.TurntableLocLists.Add(loc);
            WriteData("VW2", loc);
            WriteData("M0.5", true);
        }

        /// <summary>
        /// 设置倒面位置
        /// </summary>
        /// <param name="loc"></param>
        private void SetFallNoodleLoc(ushort loc)
        {
            WriteData("VW4", loc);
        }

        /// <summary>
        /// 设置取面位置
        /// </summary>
        /// <param name="loc"></param>
        private void SetTakeNoodleLoc(ushort loc)
        {
            WriteData("VW6", loc);
        }

        /// <summary>
        /// 取碗控制
        /// </summary>
        /// <param name="loc"></param>
        private void TakeBowlControl(ushort loc)
        {
            if (loc == 10)//小碗
            {
                WriteData("M0.1", true);
            }
            else if (loc == 11)//大碗
            {
                WriteData("M0.2", true);
            }
        }

        /// <summary>
        /// 机器人取面
        /// </summary>
        private void RobotTakeNoodle()
        {
            WriteData("M0.3", true);
        }

        /// <summary>
        /// 机器人取餐
        /// </summary>
        private void RobotOutMeal()
        {
            WriteData("M0.4", true);
        }

        /// <summary>
        /// 制作完成信号复位
        /// </summary>
        private void ResetCookComplete()
        {
            WriteData("M100.6", false);
        }

        /// <summary>
        /// 复位允许取面信号
        /// </summary>
        private void ResetAllowFallNoodle()
        {
            WriteData("M100.3", false);
        }

        /// <summary>
        /// 设备初始化
        /// </summary>
        public async void DeviceInit()
        {
            WriteData("M0.0", true);
            await Task.Delay(1000);
            WriteData("M0.0", false);

        }

        /// <summary>
        /// 制作完成，允许机器人往外推碗
        /// </summary>
        public void CookComplete()
        {
            ////ModbusTcpHelper.GetInstance.Write((ushort)ModbusTcpHelper.GetInstance.GetBoolAddress("M0.6"), WriteType.Coils, true);
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = "M0.6", Value = true });
        }

        /// <summary>
        /// 是否加汤
        /// </summary>
        public void AddSoup()
        {
            ////ModbusTcpHelper.GetInstance.Write((ushort)ModbusTcpHelper.GetInstance.GetBoolAddress("M0.7"), WriteType.Coils, true);
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = "M0.7", Value = true });
        }

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

            //配方数据信息
            EventBus.EventBus.GetInstance().Subscribe<RecipeBomEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (@event == null) return;
                if (@event is RecipeBomEvent recipe)
                {
                    recipeBoms = recipe.recipeBoms;
                    WriteRecipeBoms();
                }
            });
        }

        public override void DoMain()
        {
            MonitorViewModel.DeviceId = DeviceId;
            ServerInit();
            DataParse();

            Json<MorksPar>.Read();
            if (Json<MorksPar>.Data.parSets == null) Json<MorksPar>.Data.parSets = new ObservableCollection<ParSet>();
            if (Json<MorksPar>.Data.parSets.Count < 6)
            {
                Json<MorksPar>.Data.parSets.Clear();
                for (int i = 0; i < 6; i++)
                {
                    Json<MorksPar>.Data.parSets.Add(new ParSet()
                    {
                        CheckBoxContext = $"煮面口{i + 1}屏蔽",
                        Minute = 1,
                        Second = 0,
                        IsShield = false,
                        TextBlockContext = $"煮面口{i + 1}时间设定"
                    });
                }
            }

            ActionManage.GetInstance.Register(new Action<object>((o) =>
            {
                if (o != null && o is WritePar writePar) WriteData(writePar.Address, writePar.Value);
            }), "WriteVW");
            ActionManage.GetInstance.Register(new Action<object>((o) =>
            {
                if (o != null && o is WritePar writePar) WriteData(writePar.Address, writePar.Value);
            }), "WriteBools");
            ActionManage.GetInstance.Register(new Action(() => { DeviceInit(); }), "InitDevice");//设备初始化注册
            ActionManage.GetInstance.Register(new Action<object>((o) => {SimOrder(o); }), "SimOrder");//模拟订单委托注册
           
        }
        private void WriteData(string address, object value)
        {
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });
        }
        public override void ResetProgram()
        {
            mORKS = null;
            mORKS = new GVL_MORKM();
        }

        private void GetStatus(string key, Action<object> action)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    action?.Invoke(peripheralStatus[key]);
                }
            }
        }

        private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)
        {
            var res = mORKS.doOrderEvents.FirstOrDefault(p => p.MorkOrder.SuborderId == subid);
            string goodName = string.Empty;
            string SortNum = string.Empty;
            if (res != null)
            {
                goodName = res.MorkOrder.GoodsName;
                SortNum = res.MorkOrder.SortNum.ToString();
            }
            EventBus.EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { SortNum = SortNum, GoodName = goodName, Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });
        }


        public override void Stop()
        {
            
        }

        public override void ReadData()
        {
            GetStatus("M230.0", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 24)
                {
                    alarm.MachineLeftLowTemperature = bools[0];
                    alarm.MachineRightLowTemperature = bools[1];
                    alarm.Supply1_LossBowl = bools[2];
                    alarm.Supply2_LossBowl = bools[3];
                    alarm.Supply1_ErrorOutBowl = bools[4];
                    alarm.Supply2_ErrorOutBowl = bools[5];
                    alarm.PushBowlCylinderError = bools[6];
                    alarm.NoodleMacCommunicateError = bools[7];
                    alarm.DosingMacCommunicateError = bools[8];
                    alarm.RobotMacCommunicateError = bools[9];
                    alarm.DeviceEstop = bools[10];
                    alarm.RobotInitError = bools[11];
                    alarm.RobotUrgentStop = bools[12];
                    alarm.RobotNotInRemoteMode = bools[13];
                    alarm.RobotNotInReady = bools[14];
                    alarm.RobotSelfInException = bools[15];
                    alarm.LeftLackWater = bools[16];
                    alarm.RightLackWater = bools[17];
                    alarm.SvrewInitFail = bools[18];
                    alarm.TurntableInitFail = bools[19];
                    alarm.RobotInitFail = bools[20];
                    alarm.NoodleCookerInitFail = bools[21];
                    alarm.PushBowlInitFail1 = bools[22];
                    alarm.PushBowlInitFail2 = bools[23];
                }
            }));

            GetStatus("M0.3", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 3)
                {
                    mORKS.RobotTakeNoodle = bools[0];
                    mORKS.RobotOutMeal = bools[1];
                    mORKS.MoveTurntable = bools[2];
                }
            }));

            GetStatus("M100.0", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 16)
                {
                    mORKS.InitComplete = bools[0];
                    mORKS.TakeBowlIdle = bools[1];
                    mORKS.TemperatureReached = bools[2];
                    mORKS.AllowFallNoodle = bools[3];
                    mORKS.RbTakeNoodleComplete = bools[4];
                    mORKS.RbFallNoodleComplete = bools[5];
                    mORKS.RbOutMealComplete = bools[6];
                    mORKS.RobotIdle = bools[7];
                    mORKS.TakeMealDetect = bools[8];
                    mORKS.MissingBowl = bools[9];
                    Initing = bools[10];
                    mORKS.TurntableLowerLimit = bools[11];
                    mORKS.MissingBowlSignal2 = bools[12];
                    mORKS.TurntableUpLimit = bools[13];
                    mORKS.FeedComplete = bools[14];
                    mORKS.TurntableMoveInPlace = bools[15];
                }

            }));

            GetStatus("M235.0", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)
                {
                    mORKS.Error = bools[0];
                }
            }));


            GetStatus("M102.0", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 7)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        mORKS.NoodleCookerStatus[i] = bools[i];
                    }
                    mORKS.Feeding = bools[6];
                }
            }));

            GetStatus("M103.0", new Action<object>((obj) =>
            {
                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 6)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        mORKS.CookNoodlesComplete[i] = bools[i];
                    }
                }

            }));

            GetStatus("VW372", new Action<object>((obj) =>
            {
                if (obj is ushort[] UshortValue && UshortValue.Length > 0 && UshortValue.Length <= 1)
                    mORKS.TurntableFeedbackloc = UshortValue[0];
            }));
        }

       

        #endregion



    }

}


