using AGVLib;
using CtuDeviceLib.manager;
using Mushiny;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;

namespace CtuDeviceLib
{
    /// <summary>
    /// 业务机器人
    /// </summary>
    public class IBusinessRobot
    {
        public string Name { get; set; }
        /// <summary>
        /// 业务编号
        /// </summary>
        public int Id { get; set; }
        public List<RobotStatus> RobotStatus { get; set; }
        public bool Enabled { get; set; }
        public List<RobotTask> robotTasks
        {
            get { return TaskManager.GetTask(Id); }
        }
        public List<ClientNode> clientNodes
        {
            get
            {
                return GetClientNodes();
            }
        }
        /// <summary>
        /// SMF服务器基地址
        /// </summary>
        public string ServerBase
        {
            get
            {
                return MushinyManager.ServerBase;
            }
        }
        public string RealtimeMsg { get; set; }
        /// <summary>
        /// 实时消息
        /// </summary>
        protected StringBuilder sbRealtimeMsg = new StringBuilder();
        /// <summary>
        /// 警告消息概括
        /// </summary>
        protected StringBuilder sbWarnMsgSumary = new StringBuilder();
        /// <summary>
        /// 警告详细信息
        /// </summary>
        protected StringBuilder sbWarnMsgDetails = new StringBuilder();
        protected System.Timers.Timer runProcessTimer = null;
        private System.Timers.Timer uploadProcessTimer = null;
        string url = ConfigAppSettings.GetValue("AGVLibService_BaseAddr", "http://127.0.0.1:9901");
        public List<ClientNode> GetClientNodes()
        {
            List<ClientNode> rtn = null;
            try
            {
                var str = HttpHelper.Get(url + $"/agv/getNodesByExecAgv?exec_agv={Id}");
                rtn = JsonHelper.DeserializeJsonToList<ClientNode>(str);
            }
            catch (Exception e)
            {
                LogUtil.error($"【{Name}】获取节点状态失败", e);
            }
            return rtn;
        }
        protected CTUBean ctuBean { get { return MushinyManager.GetCTUBean(); } }
        public IBusinessRobot()
        {
            runProcessTimer = new System.Timers.Timer();
            runProcessTimer.Interval = 500;
            runProcessTimer.AutoReset = true;
            runProcessTimer.Elapsed += RunProcessTimer_Elapsed; ;
            runProcessTimer.Enabled = true;

            uploadProcessTimer = new System.Timers.Timer();
            uploadProcessTimer.Interval = 1000;
            uploadProcessTimer.AutoReset = true;
            uploadProcessTimer.Elapsed += UploadProcessTimer_Elapsed;
            uploadProcessTimer.Enabled = true;
        }
        static object uploadLock = new object();
        public void OnRobotTaskChanged(int robotType)
        {
            TaskManager.OnRobotTaskChanged(robotType);
        }
        public void AddTask(RobotTask task)
        {
            if (task.TaskType == RobotTaskType.Charge || task.TaskType == RobotTaskType.Standby)
            {
                TaskManager.AddTask(task);
                OnRobotTaskChanged(task.RobotType);
            }
            else
            {
                TaskManager.AddTask(task);
                OnRobotTaskChanged(task.RobotType);
            }

        }

        Dictionary<string, DateTime> CtuStartFaultTime = new Dictionary<string, DateTime>();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ctu"></param>
        protected void handleEmptyCtuWithTask(CTU ctu)
        {
            if (MushinyManager.EnableCheckEnabledCtuIsOk) return;
            if (ctu == null) return;

            if (ctu.RunState == RunState.Executing)
            {
                if (CtuStartFaultTime.ContainsKey(ctu.IP))
                {
                    CtuStartFaultTime.Remove(ctu.IP);
                    LogUtil.info($"[{ctu.Name}] 故障结束【{ctu?.CurLandMark}】");
                }
                return;
            }
            else
            {
                if (!CtuStartFaultTime.ContainsKey(ctu.IP))
                {
                    CtuStartFaultTime.Add(ctu.IP, DateTime.Now);
                    LogUtil.info($"[{ctu.Name}] 故障开始 【{ctu?.CurLandMark}】【{ctu?.FaultInfo?.ToUploadStr()}】");
                }
            }
            bool needClear = false;
            if (!CtuStartFaultTime.ContainsKey(ctu.IP)) return;
            double minute = (DateTime.Now - CtuStartFaultTime[ctu.IP]).TotalMinutes;
            if (CtuStartFaultTime.ContainsKey(ctu.IP))
            {
                if (minute > MushinyManager.TaskTransWaitMinute)
                {
                    needClear = true;
                }
            }
            if (!needClear) return;
            bool enable = ConfigAppSettings.GetValue("Enable_AutoTransWaitGetTask", false);
            if (!enable) return;
            foreach (var item in ctu.Baskets)
            {
                try
                {
                    if (string.IsNullOrEmpty(item.TaskId)) continue;
                    var curTask = TaskManager.GetTaskByTaskId(item.TaskId);
                    if (curTask != null)
                    {
                        if (curTask.TaskState < RobotTaskState.到达取货点)
                        {
                            ctuBean.RemoveCTUTask(item.TaskId);
                            curTask.CtuName = "";
                            TaskManager.ChangeTaskState(curTask, RobotTaskState.等待分配车);
                            LogUtil.info($"[{ctu.Name}]故障时长[{minute}min]，清除当前任务[{item.TaskId}],改为等待分配车,由其他车接该任务");
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error($"[{ctu.Name}] 有故障，清除当前任务[{item.TaskId}] 异常", ex);
                }
            }
        }
        public bool UpdateLocInfo(RobotTask task, string status)
        {
            bool canRemove;
            string msg = "";
            bool rtn = false;
            if (MushinyManager.FinishedCTUName.Equals(ctuBean.Name))
            {
                rtn = SMFManager.updateFinishedTaskStatus(ctuBean.Name, ServerBase, task.ContainerCode, status, out canRemove, out msg);
            }
            else if (MushinyManager.SemiFinishedCTUName.Equals(ctuBean.Name))
            {
                rtn = SMFManager.updateSemiFinishedTaskStatus(ctuBean.Name, ServerBase, task.ContainerCode, status, out canRemove, out msg);
            }
            if (rtn)
            {
                LogUtil.info($"更新状态完成【{task.TaskId}】【{status}】【{msg}】");
            }
            else
            {
                sbWarnMsgSumary.AppendLine($"【{task.TaskId}】【{task.ContainerCode}】上报状态【{status}】失败,请手动处理");
                LogUtil.error($"更新状态失败【{task.TaskId}】【{status}】【{msg}】");
            }
            return rtn;
        }

        /// <summary>
        /// 转库状态更新
        /// </summary>
        /// <param name="task"></param>
        /// <param name="status"></param>
        /// <returns></returns>
        public bool UpdateSwitchLocInfo(RobotTask task, string status)
        {
            bool canRemove;
            string msg = "";
            bool rtn = false;
            if (MushinyManager.FinishedCTUName.Equals(ctuBean.Name))
            {
                rtn = SMFManager.updateFinishedTaskStatus(ctuBean.Name, ServerBase, task.ContainerCode, status, out canRemove, out msg);
            }
            else if (MushinyManager.SemiFinishedCTUName.Equals(ctuBean.Name))
            {
                rtn = SMFManager.updateSemiFinishedSwitchTaskStatus(ctuBean.Name, ServerBase, task.ContainerCode, status, out canRemove, out msg);
            }
            if (rtn)
            {
                LogUtil.info($"更新状态完成【{task.TaskId}】【{status}】【{msg}】");
            }
            else
            {
                sbWarnMsgSumary.AppendLine($"【{task.TaskId}】【{task.ContainerCode}】上报状态【{status}】失败,请手动处理");
                LogUtil.error($"更新状态失败【{task.TaskId}】【{status}】【{msg}】");
            }
            return rtn;
        }
        public virtual void RemoveTask(RobotTask task, bool force = false)
        {
            TaskManager.RemoveTask(task);
            OnRobotTaskChanged(task.RobotType);
        }
        private void UploadProcessTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (Monitor.TryEnter(uploadLock, 200))
            {
                try
                {
                    UploadAGVState();
                }
                finally
                { Monitor.Exit(uploadLock); }
            }

        }

        private void RunProcessTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (Monitor.TryEnter(runProcessTimer, 100))
            {
                //if (!Enabled) return;
                try
                {
                    sbRealtimeMsg.Clear();
                    sbWarnMsgDetails.Clear();
                    sbWarnMsgSumary.Clear();
                    CheckTask();
                    Execute();
                    if (ctuBean != null)
                    {
                        try
                        {
                            var ctus = ctuBean.GetCTUs();
                            foreach (var item in ctus)
                            {
                                if (item.Enabled)
                                {

                                    if (item.RunState == RunState.Executing)
                                    {
                                        if (item.SOC < CTUBean.executeMinPow)
                                            sbWarnMsgSumary.AppendLine($"【{item.Name}】电量小于【{CTUBean.executeMinPow}】，不接任务。请充电");
                                        showCtuError(item);
                                    }
                                    if (item.RunState == RunState.Offline)
                                    {
                                        sbWarnMsgSumary.AppendLine($"【{item.Name}】状态为离线状态，请处理");
                                    }

                                    var realtimeInfo = MushinyManager.GetRealTimeInfo(item);
                                    if (realtimeInfo != null)
                                    {
                                        if (realtimeInfo.MoveState != CtuMoveState.空闲)
                                            sbWarnMsgSumary.AppendLine($"【{item.Name}】优先级【{realtimeInfo.Priority}】目的地【{realtimeInfo?.DstPosInfo?.Name}】【{realtimeInfo?.DstPosInfo?.PointCode}】移动状态【{realtimeInfo.MoveState}】路线上的CTU【{string.Join(",", realtimeInfo.CtusInPath)}】");
                                    }
                                }
                                sbWarnMsgDetails.AppendLine($"【{item.Name}】【{(item.Enabled ? "启用" : "关闭")}】占用的地标：{string.Join(",", item.UsedPoint)}");
                            }

                        }
                        catch
                        {

                        }

                    }
                    RealtimeMsg = sbRealtimeMsg.ToString();
                    MushinyManager.WarnMsgDetails = sbWarnMsgDetails.ToString();
                    MushinyManager.WarnMsgSummary = sbWarnMsgSumary.ToString();
                }
                finally { Monitor.Exit(runProcessTimer); }
            }

        }
        void showCtuError(CTU ctu)
        {
            if (ctu.FaultInfo?.HasFault ?? false)
            {
                if (Mushiny.Common.GetFaultId(ctu?.FaultInfo?.FaultID, out FaultId faultId))
                {
                    if (canShow(faultId))
                        sbWarnMsgSumary.AppendLine($"【{ctu.Name}】有异常【{ctu.FaultInfo?.ToShowStr()}】");
                }
            }
        }
        bool canShow(FaultId faultId)
        {
            if (FaultId.待机状态下丢码.Equals(faultId) || FaultId.直行中丢码.Equals(faultId)
                || FaultId.直行中错码.Equals(faultId) || FaultId.直行过程因错码停下_要求路径重算.Equals(faultId)
                || FaultId.直行末尾点丢码.Equals(faultId) || FaultId.转弯中丢码.Equals(faultId)
                || FaultId.转弯中错码_要求路径重算.Equals(faultId) || FaultId.校正过程中丢码.Equals(faultId)
                || FaultId.位姿融合失败.Equals(faultId)
                || FaultId.直行过程中发生角度切换.Equals(faultId) || FaultId.充电对接过程中左右偏差过大.Equals(faultId)
                || FaultId.动作码参数异常.Equals(faultId) || FaultId.命令码参数异常.Equals(faultId)
                || FaultId.液晶屏失联.Equals(faultId) || FaultId.顶端灯带失联.Equals(faultId)
                || FaultId.语音播报模块失联.Equals(faultId))
            {
                return false;
            }
            return true;
        }
        protected virtual void CheckTask() { }
        public virtual void UploadAGVState()
        {
            try
            {
                if (RobotStatus == null || RobotStatus.Count == 0) return;
                List<AgvStatus> statuses = new List<AgvStatus>();
                foreach (var item in RobotStatus)
                {
                    var status = new AgvStatus()
                    {
                        elec = item.Power.ToString(),
                        name = item.Name,
                        type = Id,
                        loc = item.Loc,
                        message = item.ErrMsg
                    };
                    statuses.Add(status);
                    HttpManager.UploadAgvState(item);
                }
                SMFManager.UpdateAgvStatus(ServerBase, statuses);
            }
            catch (Exception ex)
            {
                LogUtil.error("IRobot.UploadAGVState error:", ex);
            }

        }
        protected virtual void Execute() { }

        /// <summary>
        /// 检查待机点，无任务去待机点
        /// </summary>
        protected void checkStandby()
        {
            var stands = MushinyManager.GetStands();
            stands?.ForEach(s =>
             {
                 var ff = ctuBean.GetCTUs()?.Find(kk => kk.IP.Equals(s.OccupiedCtu));
                 if (ff != null)
                 {
                     sbRealtimeMsg.AppendLine($"名称【{s.Name}】组别【{s.StandbyGroup}】路标【{s.PointCode}】占用CTU【{ff.Name}】");
                 }
                 //   else
                 //sbRealtimeMsg.AppendLine($"待机点:名称【{s.Name}】组别【{s.StandbyGroup}】路标【{s.PointCode}】占用CTU【{s.OccupiedCtu}】");
             }
             );

            var ctuScopes = MushinyManager.GetCtuScopes();
            ctuScopes?.ForEach(s =>
            {
                var ff = ctuBean.GetCTUs()?.Find(kk => kk.Name.Equals(s.CtuName));
                if (ff != null)
                {
                    sbRealtimeMsg.AppendLine($"区域名【{s.ScopeName}】CTU【{ff.Name}】巷道【{string.Join(",", s.LaneCodes)}】");
                }
                //   else
                //sbRealtimeMsg.AppendLine($"待机点:名称【{s.Name}】组别【{s.StandbyGroup}】路标【{s.PointCode}】占用CTU【{s.OccupiedCtu}】");
            }
 );
            //任务要去的路线和执行任务ctu占用的路线
            var usedPathways = new List<PathWay>();
            //ctu要去的任务点
            var usedPointInrunningTasks = TaskManager.GetUsedPointsInTasks();

            if (usedPointInrunningTasks == null || usedPointInrunningTasks.Count == 0)
            {
                //return;
            }
            else
            {
                usedPointInrunningTasks.ForEach(s =>
                {
                    var path = ctuBean.GetPathWay(s.Id);
                    if (path != null)
                    {
                        usedPathways.Add(path);
                    }
                });
            }


            var busyCtus = ctuBean.GetBusyCtus();
            if (busyCtus != null)
            {
                busyCtus.ForEach(s =>
                {
                    var path = ctuBean.GetPathWay(s.CurLandMark);
                    if (path != null)
                    {
                        usedPathways.Add(path);
                    }
                });
            }
            //if (usedPathways.Count == 0) return;
            //启用且无任务的ctu
            var idles = ctuBean.GetNoTaskCtus();
            foreach (var idle in idles)
            {
                if (idle.CurLandMark == 0) continue;
                if (idle.RunState != RunState.Executing) continue;
                var inletStands = MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet);
                //检查占用的路线上是否有空闲ctu
                var occupied = usedPathways.Find(s => s.Paths.Contains(idle.CurLandMark));
                if (occupied != null)//空闲车有占用
                {
                    //如果当前ctu为入料机构的待机，不清除
                    if (MushinyManager.CtuIsInInletStandby(idle))
                    {
                        if (MushinyManager.CtuIsInStandby(idle))//在待机点的入料机构ctu不动
                        {
                            continue;
                        }
                        else //入料机构ctu在占用巷道，回待机点
                        {
                            if (inletStands != null && inletStands.Count() > 0)
                            {
                                var inletstand = inletStands.Find(s => idle.IP.Equals(s.OccupiedCtu));
                                if (inletstand != null)
                                {
                                    string flag = $"{idle.Name}";
                                    var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                                    if (task == null)
                                    {
                                        task = new RobotTask()
                                        {
                                            TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                                            CreateTime = DateTime.Now,
                                            RobotType = Id,
                                            TaskFlag = flag,
                                            TaskState = RobotTaskState.已分配车,
                                            DestPoint = inletstand.DstPoint,
                                            TaskType = RobotTaskType.Standby,
                                            TaskName = $"待机任务",
                                            Priority = 999
                                        };
                                        ctuBean.AddOrUpdateCtuStandTask(idle, task);
                                        TaskManager.AddTask(task);
                                        OnRobotTaskChanged(task.RobotType);
                                        LogUtil.info($"创建待机任务 【{idle.Name}】空闲车有占用【{occupied.Name}】【{string.Join(",", occupied.Paths)}】。去目的待机点【{task.DestPoint}】");
                                        continue;
                                    }
                                }

                            }
                        }
                    }

                    var idleStand = MushinyManager.GetIdleCtuStand(usedPathways);
                    if (idleStand == null)//无可用待机点
                    {
                        sbRealtimeMsg.AppendLine($"【{idle.Name}】有占用，当前无可用待机点");
                    }
                    else
                    {
                        string flag = $"{idle.Name}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        //如果当前ctu为入料机构的待机，不清除
                        //if (MushinyManager.CtuIsInInletStandby(idle))
                        //{
                        //    if (MushinyManager.CtuIsInStandby(idle))//在待机点的入料机构ctu不动
                        //    {
                        //        // MushinyManager.ClearStandbyInfo(idle, true);
                        //        // LogUtil.info($"入料机构CTU【{idle.Name}】占用路线【{occupied.Name}】【{string.Join(",", occupied.Paths)}】,不清空待机点占用");
                        //        continue;
                        //    }
                        //    else //入料机构ctu在占用巷道，回待机点
                        //    {
                        //        if (inletStands != null && inletStands.Count() > 0)
                        //        {
                        //            var inletstand = inletStands.Find(s => idle.IP.Equals(s.OccupiedCtu));
                        //            if (inletstand != null)
                        //            {
                        //                flag = $"{inletstand.Name}";
                        //                task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        //                if (task == null)
                        //                {
                        //                    task = new RobotTask()
                        //                    {
                        //                        TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                        //                        CreateTime = DateTime.Now,
                        //                        RobotType = Id,
                        //                        TaskFlag = flag,
                        //                        TaskState = RobotTaskState.已分配车,
                        //                        DestPoint = inletstand.DstPoint,
                        //                        TaskType = RobotTaskType.Standby,
                        //                        TaskName = $"待机任务",
                        //                        Priority = 999
                        //                    };
                        //                    ctuBean.AddOrUpdateCtuStandTask(idle, task);
                        //                    TaskManager.AddTask(task);
                        //                    OnRobotTaskChanged(task.RobotType);
                        //                    LogUtil.info($"创建待机任务 【{idle.Name}】空闲车有占用【{occupied.Name}】【{string.Join(",", occupied.Paths)}】。去目的待机点【{task.DestPoint}】");
                        //                    continue;
                        //                }
                        //            }

                        //        }
                        //    }
                        //}
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已分配车,
                                DestPoint = idleStand.DstPoint,
                                TaskType = RobotTaskType.Standby,
                                TaskName = $"待机任务",
                                Priority = 999
                            };
                            MushinyManager.SetStandbyInfo(idle, idleStand);
                            ctuBean.AddOrUpdateCtuStandTask(idle, task);
                            TaskManager.AddTask(task);
                            OnRobotTaskChanged(task.RobotType);
                            LogUtil.info($"创建待机任务 【{idle.Name}】空闲车有占用【{occupied.Name}】【{string.Join(",", occupied.Paths)}】。去目的待机点【{task.DestPoint}】");
                        }

                    }
                }
                else //空闲车无占用
                {
                    if (MushinyManager.CurRobotType == 2)//半成品
                    {
                        //var inout = robotTasks.Find(s => (s.TaskType == RobotTaskType.Insotre || s.TaskType == RobotTaskType.Outstore)
                        //&& s.TaskState< RobotTaskState.已分配车);
                        //if (inout != null)//有未执行任务，不回待机点
                        //{
                        //    continue;
                        //}
                    }
                    else if (MushinyManager.CurRobotType == 3)//原材料
                    {

                    }
                    if (MushinyManager.CtuIsInStandby(idle))
                    {
                        continue;
                    }
                    if (inletStands != null && inletStands.Count() > 0)
                    {
                        var hasOccupy = inletStands.Find(s => s.IsOccupied() && idle.IP.Equals(s.OccupiedCtu));
                        if (hasOccupy != null)
                            continue;
                        //出料机构有占用，则不分配
                        if (ctuScopes != null && ctuScopes.Count > 0)
                        {
                            var hasCtu = ctuScopes.Find(s => idle.Name.Equals(s.CtuName));
                            if (hasCtu != null)
                            {
                                continue;
                            }
                        }
                        var inletIdleStand = inletStands.Find(s => !s.IsOccupied());
                        if (inletIdleStand != null)//待机未找到未占用的ctu
                        {
                            string flag = $"{idle.Name}";
                            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                            if (task == null)
                            {
                                task = new RobotTask()
                                {
                                    TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                                    CreateTime = DateTime.Now,
                                    RobotType = Id,
                                    TaskFlag = flag,
                                    TaskState = RobotTaskState.已分配车,
                                    DestPoint = inletIdleStand.DstPoint,
                                    TaskType = RobotTaskType.Standby,
                                    TaskName = $"待机任务",
                                    Priority = -1
                                };
                                MushinyManager.SetStandbyInfo(idle, inletIdleStand);
                                ctuBean.AddOrUpdateCtuStandTask(idle, task);
                                TaskManager.AddTask(task);
                                OnRobotTaskChanged(task.RobotType);
                                LogUtil.info($"创建待机任务 入料待机点【{inletIdleStand.Name}】无车，分配给【{idle.Name}】");
                                return;//先把入料机构的待机点设置
                            }
                        }

                        var occupiedInletStands = inletStands.FindAll(s => s.IsOccupied());
                        if (occupiedInletStands != null && occupiedInletStands.Count() > 0)
                        {
                            foreach (var item in occupiedInletStands)
                            {
                                if (!idle.IP.Equals(item.OccupiedCtu))//其他车不能使用该待机点
                                    continue;
                                else
                                {
                                    string flag = $"{idle.Name}";
                                    var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                                    if (task == null)
                                    {
                                        task = new RobotTask()
                                        {
                                            TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                                            CreateTime = DateTime.Now,
                                            RobotType = Id,
                                            TaskFlag = flag,
                                            TaskState = RobotTaskState.已分配车,
                                            DestPoint = item.DstPoint,
                                            TaskType = RobotTaskType.Standby,
                                            TaskName = $"待机任务",
                                            Priority = -1
                                        };
                                        MushinyManager.SetStandbyInfo(idle, item);
                                        ctuBean.AddOrUpdateCtuStandTask(idle, task);
                                        TaskManager.AddTask(task);
                                        OnRobotTaskChanged(task.RobotType);
                                        LogUtil.info($"创建待机任务 入料待机点【{item.Name}】为当前车【{idle.Name}】，分配");
                                    }
                                }
                            }

                        }
                    }

                    var idleStands = MushinyManager.GetIdleCtuStands(usedPathways);
                    if (idleStands == null || idleStands.Count == 0)//无可用待机点
                    {
                        sbRealtimeMsg.AppendLine($"当前无可用待机点");
                    }
                    else
                    {
                        if (!idle.Enabled) continue;
                        if (idle.RunState != RunState.Executing) continue;

                        if (MushinyManager.CtuIsInStandby(idle))
                        {
                            continue;
                        }
                        if (MushinyManager.CurRobotType == 3)
                        {
                            var occupiedInletStands = inletStands?.Find(s => s.IsOccupied() && idle.IP.Equals(s.OccupiedCtu));
                            if (occupiedInletStands != null) continue;

                        }

                        bool rtn = MushinyManager.GetNearStand(idle, idleStands, out CtuStandby idleStand, true);
                        if (!rtn) continue;

                        string flag = $"{idle.Name}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Standby.ToString()),
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已分配车,
                                DestPoint = idleStand.DstPoint,
                                TaskType = RobotTaskType.Standby,
                                TaskName = $"待机任务",
                                Priority = -1
                            };
                            MushinyManager.SetStandbyInfo(idle, idleStand);
                            ctuBean.AddOrUpdateCtuStandTask(idle, task);
                            TaskManager.AddTask(task);
                            OnRobotTaskChanged(task.RobotType);
                            LogUtil.info($"创建待机任务 【{idle.Name}】空闲车无占用。【{task.DestPoint}】");
                        }

                    }
                }
            }
        }
        int startChargeMinPow { get { return ConfigHelper.Config.Get(Mushiny.Common.Mushiny_ + "StartChargeMinPower", 80); } }
        bool enableAutoRequestChargeStation { get { return ConfigHelper.Config.Get(Mushiny.Common.Mushiny_ + "EnableAutoRequestChargeStation", false); } }
        /// <summary>
        /// 出料机构无出库任务时的充电电量
        /// </summary>
        int noOutEqipOutTaskStartChargeMinPow { get { return ConfigHelper.Config.Get(Mushiny.Common.Mushiny_ + "StartChargeMinPowerWithNoOutstore", 80); } }
        /// <summary>
        /// 充电检查
        /// </summary>
        protected void checkCharge()
        {
            var minCtu = ctuBean.GetEnabledRunningNoTaskMinPowerCTU();
            if (minCtu == null) return;
            int chargeminPower = startChargeMinPow;
            if (!MushinyManager.HasOutEquipOutStore())
            {
                chargeminPower = noOutEqipOutTaskStartChargeMinPow;
            }
            if (minCtu.SOC > chargeminPower)
            {
                return;
            }
            string taskname = "充电";
            string flag = "";
            if (enableAutoRequestChargeStation)
            {
                if (manager.HttpManager.RequestChargeStation(minCtu.Name, out string chargeName))
                {
                    flag = chargeName;
                    LogUtil.info($"[{minCtu.Name}] 请求到充电桩[{chargeName}]");
                }
                else
                {
                    return;
                }
            }
            else
            {
                if (MushinyManager.CurRobotType == 2)
                {
                    flag = Setting_Init.ChargeStation_01;
                }
                else if (MushinyManager.CurRobotType == 3)
                {
                    flag = Setting_Init.ChargeStation_02;
                }
                else
                    return;
            }
            if (string.IsNullOrEmpty(flag))
            {
                return;
            }
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                task = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Charge.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = "",
                    DestPoint = flag,
                    TaskType = RobotTaskType.Charge,
                    CtuName = minCtu.Name
                };
                LogUtil.info($"创建任务 充电任务[{task.TaskId}] [{minCtu?.SOC}]");
                AddTask(task);
                MushinyManager.ClearStandbyInfo(minCtu, true);
                ctuBean.AddOrUpdateCtuChargeTask(minCtu, task);
            }
        }

        #region 原材料
        /// <summary>
        /// 创建入料机构入库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateInletInstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Insotre,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_InEquip,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建入料机构-入库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 创建出料机构入库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateOutletInstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Insotre,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_OutEquip,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建出料机构-入库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 创建入料机构出库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateInletOutstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Outstore,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_InEquip,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建入料机构-出库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 创建出料机构出库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateOutletOutstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Outstore,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_OutEquip,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建出料机构-出库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;

        }
        /// <summary>
        /// 创建手动线出库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateManualLineOutstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Outstore,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_ManualLine,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建手动线-出库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 创建手动线入库
        /// </summary>
        /// <param name="finishedTask"></param>
        public bool CreateManualLineInstore(finishedOutTask finishedTask, CTU ctu, out RobotTask robotTask)
        {
            robotTask = null;
            if (finishedTask == null) return false;
            var ctuTask = finishedTask.OutTask;
            string containerCode = ctuTask.boxCode;
            var toLoc = ctuTask.toLoc;
            var fromLoc = ctuTask.fromLoc;
            var taskname = ctuTask.id;
            var inoutType = ctuTask.taskType;
            string flag = $"{containerCode}";
            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
            if (task == null)
            {
                robotTask = new RobotTask()
                {
                    TaskId = RobotTask.GenTaskId(flag, inoutType.ToString()),
                    TaskName = taskname,
                    CreateTime = DateTime.Now,
                    RobotType = Id,
                    TaskFlag = flag,
                    TaskState = RobotTaskState.已分配车,
                    SrcPoint = fromLoc,
                    DestPoint = toLoc,
                    TaskType = RobotTaskType.Insotre,
                    ContainerCode = containerCode,
                    NeedReAssignTarget = true,
                    Priority = finishedTask.Priority,
                    TaskGroup = RobotTaskGroup.Finished_ManualLine,
                    CtuName = ctu.Name
                };
                LogUtil.info($"创建手动线-入库[{JsonHelper.SerializeObject(robotTask)}]：{JsonHelper.SerializeObject(finishedTask)}");
                AddTask(robotTask);
                return true;
            }
            return false;
        }
        #endregion
    }

    public class RobotStatus
    {
        public bool Enabled { get; set; }
        /// <summary>
        /// 机器人名
        /// </summary>
        public string Name { get; set; }
        public float X { get; set; }
        public float Y { get; set; }
        public float Theta { get; set; }
        /// <summary>
        /// 电量
        /// </summary>
        public float Power { get; set; }
        /// <summary>
        /// 是否背货
        /// </summary>
        public bool Cargo { get; set; }
        /// <summary>
        /// 异常消息
        /// </summary>
        public string ErrMsg { get; set; }
        /// <summary>
        /// 位置
        /// </summary>
        public string Loc { get; set; }
        public object Data { get; set; }
        /// <summary>
        /// 运行状态
        /// </summary>
        public RunState RunState { get; set; }
        public string[] ToDataGridData()
        {
            List<string> list = new List<string>()
            {
                Enabled?"启用":"关闭",
                Name,
              $"{Power}%",
              $"{(Cargo?"有":"无")}",
              $"{Loc}",
              RunState.ToString(),
              Theta.ToString(),
              ErrMsg,
              JsonHelper.SerializeObject(Data)
            };
            return list.ToArray();
        }

        public string[] ToSummaryData()
        {
            List<string> list = new List<string>()
            {
                Enabled?"启用":"关闭",
                Name,
              $"{Power}%",
              $"{Loc}",
              RunState.ToString(),
              ErrMsg,
            };
            return list.ToArray();
        }
    }
}