using BLL;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Threading;
using System.Web.UI.WebControls;
using System.Windows.Forms;

namespace AGVControl
{



    public static class SettingString
    {
        public const int AGVCNT = 6;
        public const string Move = "Move";
        //任务名称
        public const string Standby = "Standby";
        public const string CheckShelf = "CheckShelf";
        public const string DoorDToC = "DoorDToC";
        public const string DoorCToD = "DoorCToD";
        public const string DoorAirIn = "DoorAirIn";
        public const string DoorAirOut = "DoorAirOut";
        public const string DoubleLine_Name_Prefix = "A";
        public const string Wait = "Wait";
        public const string Done = "Done";
        public const string Aborted = "Aborted";
        public const string Invalid = "Invalid";
        public const string AutoCharge = "AutoCharge";
        public const string Executing = "Executing";

        public const string RandomCharge_IP1 = "10.85.199.80";
        public const string RandomCharge_IP2 = "10.85.199.81";
        public const string RandomCharge_IP3 = "10.85.199.71";
        public const string RandomCharge_IP4 = "10.85.199.74";
        public const string FileName_AGV = "AgvName.csv";
        public const string FileName_AgvMission = "AgvMission.csv";
        public const string FileName_AgvProductionLine = "AgvProductionLine.csv";
        public const string FileName_tempData = "tempData.ini";
        public const string IsUse = "IsUse";
        public const string RFID = "RFID";
        public const string EmptyShelfCnt = "EmptyShelfCnt";
        public const string EmptyShelfRFIDs = "EmptyShelfRFIDs";
        /// <summary>
        /// 去4C的3辆车IP
        /// </summary>
        public const string C4_AGV_IPs = "C4_AGV_IPs";

        public const string C4_STANDBY1 = "C4_STANDBY1";
        public const string C4_STANDBY2 = "C4_STANDBY2";
        public const string C4FeederIn = "C21";
        public const string D4FeederIn = "D21";
        public const string C4FeederOut = "C22";
        public const string D4FeederOut = "D22";
        /// <summary>   
        /// 上料区
        /// </summary>
        public const string A6 = "A6";
        /// <summary>
        /// 下料区
        /// </summary>
        public const string A5 = "A5";
        public const string D4_Name_Prefix = "D";
        public const string C4_Name_Prefix = "C";

        public const string IP_4D_Light = "IP_4D_Light";
        public const string IP_4C_Light = "IP_4C_Light";
        public const string IgnoreLightLines = "IgnoreLightLines";
        public const string Lines_In_Air_Door = "C8,C9,C14,C15";
    }



    /// <summary>
    /// 公共参数
    /// </summary>
    public static class Common
    {
        /// <summary>
        /// 节点信息
        /// </summary>
        public static List<ClientNode> nodeInfo;
        /// <summary>
        /// 小车信息
        /// </summary>
        public static List<Agv_Info> agvInfo;
        public static System.Windows.Forms.TextBox logTextBox;
        public static System.Windows.Forms.DataGridView missionView;
        public static AgvServer server;
        public static BLL.Control control;
        public static MiR_API mir;
        public static WebService web;
        public static ChargeStatus chargeStatus;
        public static string itsHttp;
        public static log4net.ILog log;
        public static Dictionary<string, string> agvMission;
        public static Dictionary<string, string> showNameMissionName;
        //public static Dictionary<string, string> agvProductionLine;
        public static System.Configuration.Configuration appConfig;
        public static UnlockMissionManager missionManager;
        public static StandbyStation StandbyStation = new StandbyStation() { C4_Station1 = "", C4_Station2 = "" };

        private static List<string> msg = new List<string>();
        private static string preLog = "";
        public static readonly string CONFIG_PATH = AppDomain.CurrentDomain.BaseDirectory + "Config\\";
        public static string C4_AGV_IPs = ConfigAppSettings.GetValue(SettingString.C4_AGV_IPs);
        #region 任务日志
        static log4net.ILog runLog = log4net.LogManager.GetLogger("RunLog");
        static Dictionary<string, RunInfo> runInfoMap = new Dictionary<string, RunInfo>();

        static List<string> IgnoreLightLines = ConfigAppSettings.GetValue(SettingString.IgnoreLightLines).Split(',').ToList();
        public static void RunLogInfo(RunInfo info)
        {
            if (runInfoMap == null)
                return;
            if (runInfoMap.Keys.Contains(info.AGVNum))
            {
                if (!runInfoMap[info.AGVNum].Equals(info))
                {
                    runLog.Info(info.ToString());
                }
            }
            else
            {
                runInfoMap.Add(info.AGVNum, info);
                runLog.Info(info.ToString());
            }
        }

        public static void ErrorLogRecord(ErrorInfo errorInfo)
        {
            runLog.Info(errorInfo.ToString());
        }
        #endregion
        public static string ReadIni(string section, string key)
        {
            return IniHelper.ReadValue(section, key, CONFIG_PATH + SettingString.FileName_tempData);
        }

        public static void WriteIni(string section, string key, string value)
        {
            IniHelper.WriteValue(section, key, value, CONFIG_PATH + SettingString.FileName_tempData);
        }
        public static bool GetNodeNameByLineName(string lineName, out string nodeName)
        {
            nodeName = "";
            int id = nodeInfo.FindIndex(s => s.LineName.Equals(lineName));
            if (id > -1)
            {
                nodeName = nodeInfo[id].Name;
                return true;
            }
            else
            {
                return false;
            }
        }

        public static bool GetLineNameByNodeName(string nodeName, out string lineName)
        {
            lineName = "";
            int id = nodeInfo.FindIndex(s => s.Name.Equals(nodeName));
            if (id > -1)
            {
                lineName = nodeInfo[id].LineName;
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 查找节点是否存在以及是否调用
        /// </summary>
        /// <param name="nodeName">节点名称</param>
        /// <returns></returns>
        public static int FindNode(string nodeName)
        {
            int idx = Common.nodeInfo.FindIndex(s => s.Name.Equals(nodeName) && s.IsUse);
            return idx;
        }

        /// <summary>
        /// 移动到节点位置
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="nodeName"></param>
        /// <returns></returns>
        public static bool MoveToNode(Agv_Info agv, string nodeName)
        {
            string log;
            //清除目的地
            agv.Place = "";
            //执行下一个任务

            bool rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.Move + nodeName]);
            if (rtn)
            {
                agv.Place = nodeName;
                log = string.Format("{0} {1} To Node {2}", agv.Name, SettingString.Move, nodeName);
                Common.LogInfo(log);
                Common.mir.State_Ready(agv);
            }
            else
            {
                log = string.Format("{0} {1} To Node {2} 失败", agv.Name, SettingString.Move, nodeName);
                Common.LogInfo(log);
            }

            return rtn;

        }

        /// <summary>
        /// 查看A5、A6需要料架的状况
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="node"></param>
        public static bool CheckA5A6State(Agv_Info agv, eShelfType shelfType, out string nodeName)
        {
            bool rtn = false;
            string place = agv.Place;
            nodeName = "";
            if (shelfType.Equals(eShelfType.SmallShelf))
            {
                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5
                            && (s.StateEquals(eNodeStatus.NeedD) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要小料架", agv.Name, SettingString.A5));
                }
                else
                {
                    tarIdx = Common.agvInfo.FindIndex(s => !s.IP.Equals(agv.IP) && s.CurJob != null && s.CurJob is EmptyShelfBackJob
                    && ((((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace) != null) && ((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace.Equals(SettingString.A5));
                    if (tarIdx == -1)
                    {
                        nodeName = SettingString.A5;
                        Common.log.Debug(string.Format("{0} {1}需要小料架", agv.Name, SettingString.A5));
                        return true;
                    }

                }

                tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A6 &&
                (s.StateEquals(eNodeStatus.NeedEnter) || s.StateEquals(eNodeStatus.NeedEnterLeave)) && s.IsUse);

                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要小料架", agv.Name, SettingString.A6));
                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.MoveStandby]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    agv.TaskSend = rtn ? SettingString.MoveStandby : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.MoveStandby);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.MoveStandby));
                    //}
                }
                else
                {
                    tarIdx = Common.agvInfo.FindIndex(s => !s.IP.Equals(agv.IP) && s.CurJob != null && s.CurJob is EmptyShelfBackJob
                                && ((((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace) != null) && ((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace.Equals(SettingString.A6));
                    if (tarIdx == -1)
                    {
                        nodeName = SettingString.A6;
                        Common.log.Debug(string.Format("{0} {1}需要小料架", agv.Name, SettingString.A6));
                        return true;
                    }

                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.Move + SettingString.A6]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    tarNodeName = SettingString.A6;
                    //    Common.nodeInfo[tarIdx].AgvName = agv.Name;
                    //    agv.TaskSend = rtn ? SettingString.Move + SettingString.A6 : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.A6);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.A6));
                    //    return true;
                    //}

                }
            }
            else if (shelfType.Equals(eShelfType.BigShelf))
            {
                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5
                            && (s.StateEquals(eNodeStatus.NeedC) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要大料架", agv.Name, SettingString.A5));
                }
                else
                {
                    tarIdx = Common.agvInfo.FindIndex(s => !s.IP.Equals(agv.IP) && s.CurJob != null && s.CurJob is EmptyShelfBackJob
                            && ((((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace) != null) && ((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace.Equals(SettingString.A5));
                    if (tarIdx == -1)
                    {
                        nodeName = SettingString.A5;
                        Common.log.Debug(string.Format("{0} {1}需要大料架", agv.Name, SettingString.A5));
                        return true;
                    }

                }

                tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A6 &&
                (s.StateEquals(eNodeStatus.NeedEnter) || s.StateEquals(eNodeStatus.NeedEnterLeave)) && s.IsUse);

                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要大料架", agv.Name, SettingString.A6));
                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.MoveStandby]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    agv.TaskSend = rtn ? SettingString.MoveStandby : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载大料架，送往{2}", agv.Name, place, SettingString.MoveStandby);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载大料架，送往{2}", agv.Name, place, SettingString.MoveStandby));
                    //}
                }
                else
                {
                    tarIdx = Common.agvInfo.FindIndex(s => !s.IP.Equals(agv.IP) && s.CurJob != null && s.CurJob is EmptyShelfBackJob
                               && ((((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace) != null) && ((EmptyShelfBackJob)s.CurJob).EmptyShelfTargetPlace.Equals(SettingString.A6));
                    if (tarIdx == -1)
                    {
                        nodeName = SettingString.A6;
                        Common.log.Debug(string.Format("{0} {1}需要大料架", agv.Name, SettingString.A6));
                        return true;
                    }

                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.Move + SettingString.A6]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    tarNodeName = SettingString.A6;
                    //    Common.nodeInfo[tarIdx].AgvName = agv.Name;
                    //    agv.TaskSend = rtn ? SettingString.Move + SettingString.A6 : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载大料架，送往{2}", agv.Name, place, SettingString.A6);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载大料架，送往{2}", agv.Name, place, SettingString.A6));
                    //    return true;
                    //}

                }
            }

            return false;
        }

        /// <summary>
        /// 查看A5料架的状况(A5当前料架小于2个)
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="node"></param>
        public static bool CheckA5State(Agv_Info agv, eShelfType shelfType, out string nodeName)
        {
            bool rtn = false;
            string place = agv.Place;
            nodeName = "";
            if (shelfType.Equals(eShelfType.SmallShelf))
            {
                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5 && s.ClientLevel.Equals(ClientLevel.High)
                            && (s.StateEquals(eNodeStatus.NeedD) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要小料架", agv.Name, SettingString.A5));
                }
                else
                {
                    nodeName = SettingString.A5;
                    Common.log.Debug(string.Format("{0} {1}需要小料架", agv.Name, SettingString.A5));
                    return true;
                }

            }
            else if (shelfType.Equals(eShelfType.BigShelf))
            {
                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5
                            && (s.StateEquals(eNodeStatus.NeedC) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要大料架", agv.Name, SettingString.A5));
                }
                else
                {
                    nodeName = SettingString.A5;
                    Common.log.Debug(string.Format("{0} {1}需要大料架", agv.Name, SettingString.A5));
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 查看A6料架的状况(A6主要用于Feeder)
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="node"></param>
        public static bool CheckA6State(Agv_Info agv, eShelfType shelfType, out string nodeName)
        {
            bool rtn = false;
            string place = agv.Place;
            nodeName = "";
            if (shelfType.Equals(eShelfType.SmallShelf))
            {
                //int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5 && s.ClientLevel.Equals(ClientLevel.High)
                //            && (s.StateEquals(eNodeStatus.NeedD) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                //if (tarIdx == -1)
                //{
                //    Common.log.Debug(string.Format("{0} {1}不需要小料架", agv.Name, SettingString.A5));
                //}
                //else
                //{
                //    nodeName = SettingString.A5;
                //    Common.log.Debug(string.Format("{0} {1}需要小料架", agv.Name, SettingString.A5));
                //    return true;
                //}

                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A6 &&
                (s.StateEquals(eNodeStatus.NeedEnter) || s.StateEquals(eNodeStatus.NeedEnterLeave)) && s.IsUse);

                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要小料架", agv.Name, SettingString.A6));
                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.MoveStandby]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    agv.TaskSend = rtn ? SettingString.MoveStandby : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.MoveStandby);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.MoveStandby));
                    //}
                }
                else
                {
                    nodeName = SettingString.A6;
                    Common.log.Debug(string.Format("{0} {1}需要小料架", agv.Name, SettingString.A6));
                    return true;
                    //rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.Move + SettingString.A6]);
                    //if (rtn)
                    //{
                    //    agv.NextPlace = "";
                    //    tarNodeName = SettingString.A6;
                    //    Common.nodeInfo[tarIdx].AgvName = agv.Name;
                    //    agv.TaskSend = rtn ? SettingString.Move + SettingString.A6 : "";
                    //    agv.Msg = string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.A6);
                    //    Common.LogInfo(string.Format("{0} 在{1}已装载小料架，送往{2}", agv.Name, place, SettingString.A6));
                    //    return true;
                    //}

                }
            }
            else if (shelfType.Equals(eShelfType.BigShelf))
            {
                int tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A5
                            && (s.StateEquals(eNodeStatus.NeedC) || s.StateEquals(eNodeStatus.NeedEnter)) && s.IsUse);
                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要大料架", agv.Name, SettingString.A5));
                }
                else
                {
                    nodeName = SettingString.A5;
                    Common.log.Debug(string.Format("{0} {1}需要大料架", agv.Name, SettingString.A5));
                    return true;
                }

                tarIdx = Common.nodeInfo.FindIndex(s => s.Name == SettingString.A6 &&
               (s.StateEquals(eNodeStatus.NeedEnter) || s.StateEquals(eNodeStatus.NeedEnterLeave)) && s.IsUse);

                if (tarIdx == -1)
                {
                    Common.log.Debug(string.Format("{0} {1}不需要料架", agv.Name, SettingString.A6));
                }
                else
                {
                    nodeName = SettingString.A6;
                    Common.log.Debug(string.Format("{0} {1}需要料架", agv.Name, SettingString.A6));
                    return true;

                }
            }

            return false;
        }


        /// <summary>
        /// 检查AGV是否有负载
        /// </summary>
        /// <returns></returns>
        public static bool CheckLoad(Agv_Info agv)
        {
            return Common.mir.Add_Mission_Fleet(agv, Common.agvMission["CheckShelf"]);
        }

        public static bool DoorMission(Agv_Info agv, string doorName)
        {
            agv.Place = doorName;
            return Common.mir.Add_Mission_Fleet(agv, Common.agvMission[SettingString.Move + doorName]);
        }
        /// <summary>
        /// 检查是否在4C风淋门内
        /// </summary>
        /// <param name="nodeName"></param>
        /// <returns></returns>
        public static bool CheckIsInAirDoor(string nodeName)
        {
            return SettingString.Lines_In_Air_Door.Split(',').Contains(nodeName);
        }
        /// <summary>
        /// 检查当前任务是否结束
        /// </summary>
        /// <param name="taskName">任务名称</param>
        /// <param name="taskGUID">任务GUID</param>
        /// <returns></returns>
        public static bool CheckTaskFinished(Agv_Info agv, string nodeName, string curTaskState)
        {
            string tmp = $"{agv.Name},{SettingString.Move + nodeName},{agv.CurTaskID},{curTaskState}";
            if (curTaskState.Equals(SettingString.Done) && !taskFiStr.Equals(tmp))
            {
                taskFiStr = tmp;
                log.Info(taskFiStr);
            }
            return Common.agvMission[SettingString.Move + nodeName].Equals(agv.CurTaskGUID) && curTaskState.Equals(SettingString.Done);
        }
        static string taskFiStr = "";
        /// <summary>
        /// 检查充电任务是否分配完成
        /// </summary>
        /// <param name="taskName"></param>
        /// <returns></returns>
        public static bool CheckTaskFinished(Agv_Info agv, string taskName)
        {
            return taskName.Contains(SettingString.AutoCharge) && agv.CurTaskState.Equals(SettingString.Executing);
        }
        static string elStr = "";
        public static bool CheckEnterOrLeaveFinished(Agv_Info agv, string actionName, string curTaskState)
        {
            string tmp = $"{agv.Name},{actionName},{agv.CurTaskID},{curTaskState}";
            if (curTaskState.Equals(SettingString.Done) && !elStr.Equals(tmp))
            {
                elStr = tmp;
                log.Info(elStr);
            }
            return Common.agvMission[actionName].Equals(agv.CurTaskGUID) && curTaskState.Equals(SettingString.Done);
        }
        //双层线工单信息
        public static string doubleLine_WO = "";
        public static string warnMsg = "";
        /// <summary>
        /// 查找空架任务
        /// </summary>
        /// <param name="curPlace">为空表示待机位</param>
        /// <param name="nodeName">出空料架的节点名</param>
        /// <param name="emptyAGVbACK">agv空车返回，带一个料架</param>
        /// <returns></returns>
        public static bool FindEmptyShelfNode(Agv_Info agv, out string nodeName, bool emptyAGVbACK = false)
        {

            nodeName = "";
            if (!Common.CheckCanExecuteMission(agv))
                return false;

            ///双层线出口检查
            int idx = nodeInfo.FindIndex(s => s.Name.Equals(SettingString.A6)
            && (s.StateEquals(eNodeStatus.NeedEnterLeave) || (s.StateEquals(eNodeStatus.NeedLeave))) && !s.RFID.Equals(""));
            if (idx > -1)
            {
                if (AGVManager.FindFullShelfTarget(Common.nodeInfo[idx].RFID, out AGVManager.BoxDestInfo FullShelfDestInfo))
                {
                    idx = nodeInfo.FindIndex(s => s.Name.Equals(FullShelfDestInfo.location) && s.EmptyShelfCnt > 0);
                    if (idx > -1)
                    {
                        if (FullShelfDestInfo.location.StartsWith(SettingString.C4_Name_Prefix) && C4_AGV_IPs.Contains(agv.IP))
                        {
                            nodeName = FullShelfDestInfo.location;
                            Common.GetLineNameByNodeName(nodeName, out string line);
                            Common.log.Info("A6出满料架的产线有空料架，优先处理 " + FullShelfDestInfo.ShowInfo(line));
                            return true;
                        }
                        else if (FullShelfDestInfo.location.StartsWith(SettingString.D4_Name_Prefix) && !C4_AGV_IPs.Contains(agv.IP))
                        {
                            nodeName = FullShelfDestInfo.location;
                            Common.GetLineNameByNodeName(nodeName, out string line);
                            Common.log.Info("A6出满料架的产线有空料架，优先处理 " + FullShelfDestInfo.ShowInfo(line));
                            return true;
                        }

                    }
                }
                else
                {
                    if (FullShelfDestInfo != null)
                    {
                        Common.log.Error("A6的出料信息不正确，请检查：" + FullShelfDestInfo.ShowInfo("ERROR"));
                        //return false;
                    }
                }
            }

            //查询双层线正在出的工单料
            if (AGVManager.FindCurSO(out AGVManager.WOData woData))
            {
                if (Common.GetNodeNameByLineName(woData.line, out string loc))
                {
                    nodeName = loc;
                    doubleLine_WO = woData.ToTxt(loc);
                    Common.log.Debug(doubleLine_WO);
                    idx = nodeInfo.FindIndex(s => s.Name.Equals(loc) && s.EmptyShelfCnt > 0);

                    if (idx > -1)
                    {
                        if (loc.StartsWith(SettingString.C4_Name_Prefix) && C4_AGV_IPs.Contains(agv.IP))
                        {
                            nodeName = loc;
                            Common.log.Info("双层线正在出的工单目标产线有空料架，优先处4C-" + loc);
                            return true;
                        }
                        else if (loc.StartsWith(SettingString.D4_Name_Prefix) && !C4_AGV_IPs.Contains(agv.IP))
                        {
                            nodeName = loc;
                            Common.log.Info("双层线正在出的工单目标产线有空料架，优先处理4D-" + loc);
                            return true;
                        }
                    }

                }
            }

            ///AGV出满料带回一个料架
            if (emptyAGVbACK)
            {
                //双层线是否需要小料架
                if (CheckA5A6State(agv, eShelfType.SmallShelf, out string lineNodeName))
                {

                    //4C车间寻找
                    if (SettingString.C4_AGV_IPs.Contains(agv.IP))
                    {
                        List<Agv_Info> agvs = Common.agvInfo.FindAll(s => C4_AGV_IPs.Contains(s.IP) && (s.CurJob is EmptyShelfBackJob || s.CurJob is GoEmptyShelfLineJob));
                        if (agvs != null && agvs.Count >= 1)
                            return false;
                        string nearNodeName = CalculateNearNode(agv, SettingString.C4_Name_Prefix);
                        if (nearNodeName.Equals(""))
                        {
                            return false;
                        }
                        nodeName = nearNodeName;
                        Common.log.Info(agv.Name + " 双层线需要小料架,准备去4C-" + nearNodeName);
                        return true;
                    }

                    //4D车间寻找
                    if (!C4_AGV_IPs.Contains(agv.IP))
                    {
                        List<Agv_Info> agvs = Common.agvInfo.FindAll(s => !C4_AGV_IPs.Contains(s.IP) && (s.CurJob is EmptyShelfBackJob || s.CurJob is GoEmptyShelfLineJob));
                        if (agvs != null && agvs.Count >= 1)
                            return false;
                        string nearNodeName = CalculateNearNode(agv, SettingString.D4_Name_Prefix);
                        if (nearNodeName.Equals(""))
                        {
                            return false;
                        }
                        nodeName = nearNodeName;
                        Common.log.Info(agv.Name + " 双层线需要小料架,准备去4D-" + nearNodeName);
                        return true;
                    }

                }

            }
            else//主动拉料架
            {
                //双层线是否需要小料架
                if (CheckA5State(agv, eShelfType.SmallShelf, out string lineNodeName2))
                {
                    //4C车间寻找
                    if (C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.C4FeederOut) && s.RFID.StartsWith("D") && s.IsUse);
                        if (idx > -1)
                        {
                            int idx1 = agvInfo.FindIndex(s => s.CurJob is EnterLeaveShelfJob && ((EnterLeaveShelfJob)s.CurJob).LineName.Equals(SettingString.C4FeederOut));
                            if (idx1 == -1)
                            {
                                nodeName = nodeInfo[idx].Name;
                                Common.log.Info(agv.Name + " 双层线左侧需要小料架,准备去4C-" + nodeName);
                                return true;
                            }

                        }
                        //string nearNodeName = CalculateNearNode(agv, SettingString.C4_Name_Prefix);
                        //if (!nearNodeName.Equals(""))
                        //{
                        //    nodeName = nearNodeName;
                        //    Common.log.Debug(agv.Name + " 双层线需要小料架,准备去4C-" + nearNodeName);
                        //    return true;
                        //}
                    }

                    //4D车间寻找
                    if (!C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.D4FeederOut) && s.RFID.StartsWith("D") && s.IsUse);
                        if (idx > -1)
                        {
                            nodeName = nodeInfo[idx].Name;
                            Common.log.Info(agv.Name + " 双层线左侧需要小料架,准备去4D-" + nodeName);
                            return true;
                        }

                        //string nearNodeName = CalculateNearNode(agv, SettingString.D4_Name_Prefix);
                        //if (!nearNodeName.Equals(""))
                        //{
                        //    nodeName = nearNodeName;
                        //    Common.log.Debug(agv.Name + " 双层线需要小料架,准备去4D-" + nearNodeName);
                        //    return true;
                        //}

                    }
                }
                else if (CheckA5State(agv, eShelfType.BigShelf, out string lineNodeName3))
                {
                    //4C车间寻找
                    if (C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.C4FeederOut) && s.RFID.StartsWith("C") && s.IsUse);
                        if (idx > -1)
                        {
                            int idx1 = agvInfo.FindIndex(s => s.CurJob is EnterLeaveShelfJob && ((EnterLeaveShelfJob)s.CurJob).LineName.Equals(SettingString.C4FeederOut));
                            if (idx1 == -1)
                            {
                                nodeName = nodeInfo[idx].Name;
                                Common.log.Info(agv.Name + " 双层线左侧需要大料架,准备去4C-" + nodeName);
                                return true;
                            }

                        }
                    }

                    //4D车间寻找
                    if (!C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.D4FeederOut) && s.RFID.StartsWith("C") && s.IsUse);
                        if (idx > -1)
                        {
                            nodeName = nodeInfo[idx].Name;
                            Common.log.Info(agv.Name + " 双层线左侧需要小料架,准备去4D-" + nodeName);
                            return true;
                        }
                    }
                }

                if (CheckA6State(agv, eShelfType.BigShelf, out string lineNodeName1))
                {
                    //4C车间备料区寻找
                    if (C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.C4FeederOut) && !s.RFID.StartsWith("0") && s.IsUse);
                        if (idx > -1)
                        {
                            int idx1 = agvInfo.FindIndex(s => s.CurJob is EnterLeaveShelfJob && ((EnterLeaveShelfJob)s.CurJob).LineName.Equals(SettingString.C4FeederOut));
                            if (idx1 == -1)
                            {
                                nodeName = nodeInfo[idx].Name;
                                Common.log.Info(agv.Name + " 双层线右侧需要料架,准备去4C-" + nodeName);
                                return true;
                            }
                        }
                        //string nearNodeName = CalculateNearNode(agv, SettingString.C4_Name_Prefix);
                        //if (!nearNodeName.Equals(""))
                        //{
                        //    nodeName = nearNodeName;
                        //    Common.log.Debug(agv.Name + " 双层线右侧需要料架,准备去4C-" + nearNodeName);
                        //    return true;
                        //}
                    }
                    //4D车间寻找
                    if (!C4_AGV_IPs.Contains(agv.IP))
                    {
                        idx = nodeInfo.FindIndex(s => s.EmptyShelfCnt > 0 && s.Name.Equals(SettingString.D4FeederOut) && !s.RFID.StartsWith("0") && s.IsUse);
                        if (idx > -1)
                        {
                            nodeName = nodeInfo[idx].Name;
                            Common.log.Info(agv.Name + " 双层线右侧需要料架,准备去4D-" + nodeName);
                            return true;
                        }
                        //string nearNodeName = CalculateNearNode(agv, SettingString.D4_Name_Prefix);
                        //if (!nearNodeName.Equals(""))
                        //{
                        //    nodeName = nearNodeName;
                        //    Common.log.Debug(agv.Name + " 双层线右侧需要料架,准备去4D-" + nearNodeName);
                        //    return true;
                        //}
                    }
                }
            }
            return false;

        }

        /// <summary>
        /// 查找出满料架任务
        /// </summary>
        /// <returns></returns>
        public static bool FindFullShelfTask(Agv_Info agv)
        {
            if (!Common.CheckCanExecuteMission(agv))
                return false;
            int idx = nodeInfo.FindIndex(s => s.Name.Equals(SettingString.A6)
                && (s.StateEquals(eNodeStatus.NeedEnterLeave) || (s.StateEquals(eNodeStatus.NeedLeave))) && !s.RFID.Equals(""));
            if (idx > -1)
            {
                if (AGVManager.FindFullShelfTarget(Common.nodeInfo[idx].RFID, out AGVManager.BoxDestInfo FullShelfDestInfo))
                {
                    if (FullShelfDestInfo.location.StartsWith(SettingString.C4_Name_Prefix) && C4_AGV_IPs.Contains(agv.IP))
                    {
                        int i = Common.agvInfo.FindIndex(s => s.CurJob is GoFullShelfStationJob && !s.IP.Equals(agv.IP));
                        if (i == -1)
                            return true;

                    }
                    else if (FullShelfDestInfo.location.StartsWith(SettingString.D4_Name_Prefix) && !C4_AGV_IPs.Contains(agv.IP))
                    {
                        int i = Common.agvInfo.FindIndex(s => s.CurJob is SendFullShelfToLineJob && !s.IP.Equals(agv.IP)
                                && ((SendFullShelfToLineJob)s.CurJob).FullShelfPlace.Equals(FullShelfDestInfo.location));
                        if (i > -1)
                            return false;
                        i = Common.agvInfo.FindIndex(s => s.CurJob is GoFullShelfStationJob && !s.IP.Equals(agv.IP));
                        if (i == -1)
                            return true;
                    }
                }
                else
                {
                    if (FullShelfDestInfo != null)
                    {
                        Common.log.Error("A6的出料信息不正确，请检查：" + FullShelfDestInfo.ShowInfo("ERROR"));
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 查找当前出料工单的产线是否有空料架
        /// </summary>
        /// <param name="agv"></param>
        /// <returns></returns>
        public static bool FindEmptyShelfBeforeSendFullShelf(out string nodeName)
        {
            nodeName = "";
            int idx = nodeInfo.FindIndex(s => s.Name.Equals(SettingString.A6)
            && (s.StateEquals(eNodeStatus.NeedEnterLeave) || (s.StateEquals(eNodeStatus.NeedLeave))) && !s.RFID.Equals("") && s.IsUse);
            if (idx > -1)
            {
                if (AGVManager.FindFullShelfTarget(Common.nodeInfo[idx].RFID, out AGVManager.BoxDestInfo FullShelfDestInfo))
                {
                    idx = nodeInfo.FindIndex(s => s.Name.Equals(FullShelfDestInfo.location) && s.EmptyShelfCnt > 0 && s.IsUse);
                    if (idx > -1)
                    {
                        nodeName = FullShelfDestInfo.location;
                        Common.GetLineNameByNodeName(nodeName, out string line);
                        Common.log.Debug("A6出满料架的产线有空料架，优先处理 " + FullShelfDestInfo.ShowInfo(line));
                        return true;
                    }
                }
                else
                {
                    if (FullShelfDestInfo != null)
                    {
                        Common.log.Error("A6的出料信息不正确，请检查：" + FullShelfDestInfo.ShowInfo("ERROR"));
                    }
                }
            }

            return false;
        }
        /// <summary>
        /// 检查接驳台状态
        /// </summary>
        /// <returns></returns>
        public static bool CheckStationState(ClientNode clientNode, out string rfid)
        {
            rfid = "";
            if(IgnoreLightLines.Contains(clientNode.Name)&&Common.missionManager.GetUnlockCnt(clientNode.Name)>0)
            {
                rfid = Common.missionManager.GetUnlockRfids(clientNode.Name)[0];
                warnMsg = "";
                return true;
            }
            if (!Common.missionManager.GetUnlockRfids(clientNode.Name).Contains(clientNode.RFID))
            {
                if (clientNode.Name.Equals(SettingString.C4FeederOut) || clientNode.Name.Equals(SettingString.D4FeederOut))
                {
                    warnMsg = string.Format("佳世达线体[{0}]外侧料架[{1}]未解绑,已解绑料架:{2}", clientNode.AliceName, clientNode.RFID, string.Join(",", Common.missionManager.GetUnlockRfids(clientNode.Name).ToArray()));
                    Common.log.Debug(warnMsg);
                }
                else
                {
                    string res = AGVManager.GetRFIDs(clientNode.Name);
                    warnMsg = string.Format("佳世达线体[{0}]外侧料架[{1}]未解绑,已解绑料架:{2}", clientNode.AliceName, clientNode.RFID, string.Join(",", Common.missionManager.GetUnlockRfids(clientNode.Name).ToArray()));
                    Common.log.Debug(warnMsg);
                }
                return false;
            }
            rfid = clientNode.RFID;
            warnMsg = "";
            return true;
        }

        /// <summary>
        /// 上报接驳台状态
        /// </summary>
        /// <param name="clientNode"></param>
        /// <returns>true:表示正常</returns>
        public static bool UpdateStationState(ClientNode clientNode)
        {
            if(IgnoreLightLines.Contains(clientNode.Name))
            {
                clientNode.WarnMsg = "";
                return true;
            }
            if (Common.missionManager.GetUnlockCnt(clientNode.Name) > 0 && !Common.missionManager.GetUnlockRfids(clientNode.Name).Contains(clientNode.RFID))
            {
                if (clientNode.Name.Equals(SettingString.C4FeederOut) || clientNode.Name.Equals(SettingString.D4FeederOut))
                {
                    // 外侧料架[D34]未解绑,已解绑料架:Dxx,Dxx,Dxx
                    clientNode.WarnMsg = string.Format("佳世达外侧料架[{0}]未解绑,已解绑料架:{1}", clientNode.RFID, string.Join(",", Common.missionManager.GetUnlockRfids(clientNode.Name).ToArray()));
                    return false;
                }
                else
                {
                    clientNode.WarnMsg = string.Format("佳世达外侧料架[{0}]未解绑,已解绑料架:{1}", clientNode.RFID, string.Join(",", Common.missionManager.GetUnlockRfids(clientNode.Name).ToArray()));
                    return false;
                }
            }
            clientNode.WarnMsg = "";
            return true;
        }
        /// <summary>
        /// 出料前检查接驳台状态
        /// </summary>
        /// <returns></returns>
        public static bool CheckStationState(ClientNode clientNode)
        {
            if (Common.missionManager.GetUnlockCnt(clientNode.Name) > 0)
            {
                // if (warnMsg.Equals(""))
                {
                    warnMsg = string.Format("接驳台[{1}]有空料架未回收完，无法出满料", clientNode.RFID, clientNode.Name);
                    //Common.LogInfo(warnMsg);
                }
                return false;
            }
            return true;
        }
        /// <summary>
        ///  计算当前小车距离最近的任务点(只针对产线)
        /// </summary>
        /// <param name="agv"></param>
        /// <returns>节点名称</returns>
        public static string CalculateNearNode(Agv_Info agv, string RoomProfix)
        {
            double minDis = Double.MaxValue;
            string nodeName = "";
            List<ClientNode> clientNodes = nodeInfo.FindAll(s => s.EmptyShelfCnt > 0 && s.Name.Substring(0, 1).Equals(RoomProfix) && s.IsUse);
            try
            {
                if (clientNodes.Count.Equals(0))
                    return nodeName;
                foreach (var item in clientNodes)
                {
                    double dis = Math.Sqrt(Math.Pow((agv.Position.x - item.position.X), 2) + Math.Pow((agv.Position.y - item.position.Y), 2));
                    Common.log.Debug(string.Format("{0} 距离{1}={2}", agv.Name, item.Name, dis.ToString("f2")));
                    if (dis < minDis && CheckStationState(item, out string rfid))
                    {
                        minDis = dis;
                        nodeName = item.Name;
                    }

                }
                Common.log.Debug(string.Format("{0} 准备运动到产线 {1} 回收空料架", agv.Name, nodeName));
                return nodeName;
            }
            catch (Exception e)
            {
                Common.log.Error("CalculateNearNode " + e.ToString());
            }
            return nodeName;
        }

        /// <summary>
        /// 充电
        /// </summary>
        /// <param name="agv"></param>
        /// <returns>充电任务结果</returns>
        public static bool StatusCharge(Agv_Info agv, bool isRemovePreMission = false)
        {
            bool rtn;
            string log;
            agv.Place = "";

            #region 指定充电位置
            if (agv.IP == "10.85.199.72")//1764
            {
                rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission["AutoCharge4"], isRemovePreMission);
                if (rtn)
                {
                    //agv.TaskSend = "AutoCharge5";
                    agv.Place = SettingString.AutoCharge;
                    Common.chargeStatus.charge4 = agv.Name;
                    Common.chargeStatus.chargeInterval = DateTime.Now.Ticks;
                    log = string.Format("{0} AutoCharge4", agv.Name);
                    agv.Msg = log;
                    Common.LogInfo(log);
                    Common.mir.State_Ready(agv);
                }
                else
                {
                    log = string.Format("{0} AutoCharge4 失败", agv.Name);
                    //防止上一个任务已执行但返回失败时，删除任务
                    //Common.mir.Del_Mission(agv);
                    Common.LogInfo(log);
                }
                return rtn;
            }
            else if (agv.IP == "10.85.199.73")//1767
            {
                rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission["AutoCharge5"], isRemovePreMission);
                if (rtn)
                {
                    //agv.TaskSend = "AutoCharge6";
                    agv.Place = SettingString.AutoCharge;
                    Common.chargeStatus.charge5 = agv.Name;
                    Common.chargeStatus.chargeInterval = DateTime.Now.Ticks;
                    log = string.Format("{0} AutoCharge5", agv.Name);
                    agv.Msg = log;
                    Common.LogInfo(log);
                    Common.mir.State_Ready(agv);
                }
                else
                {
                    log = string.Format("{0} AutoCharge5 失败", agv.Name);
                    //防止上一个任务已执行但返回失败时，删除任务
                    //Common.mir.Del_Mission(agv);
                    Common.LogInfo(log);
                }
                return rtn;
            }
            //随机充电
            if (Common.chargeStatus.charge3 == "")//1763 agv.IP == "10.85.199.71"
            {
                rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission["AutoCharge3"], isRemovePreMission);
                if (rtn)
                {
                    //agv.TaskSend = "AutoCharge3";
                    agv.Place = SettingString.AutoCharge;
                    Common.chargeStatus.charge3 = agv.Name;
                    Common.chargeStatus.chargeInterval = DateTime.Now.Ticks;
                    log = string.Format("{0} AutoCharge3", agv.Name);
                    agv.Msg = log;
                    Common.LogInfo(log);
                    Common.mir.State_Ready(agv);
                }
                else
                {
                    log = string.Format("{0} AutoCharge3 失败", agv.Name);
                    //防止上一个任务已执行但返回失败时，删除任务
                    Common.mir.Del_Mission(agv);
                    Common.LogInfo(log);
                }
                return rtn;
            }
            else if (Common.chargeStatus.charge6 == "")//1764 agv.IP == "10.85.199.72"
            {
                rtn = Common.mir.Add_Mission_Fleet(agv, Common.agvMission["AutoCharge6"], isRemovePreMission);
                if (rtn)
                {
                    //agv.TaskSend = "AutoCharge4";
                    agv.Place = SettingString.AutoCharge;
                    Common.chargeStatus.charge6 = agv.Name;
                    Common.chargeStatus.chargeInterval = DateTime.Now.Ticks;
                    log = string.Format("{0} AutoCharge6", agv.Name);
                    agv.Msg = log;
                    Common.LogInfo(log);
                    Common.mir.State_Ready(agv);
                }
                else
                {
                    log = string.Format("{0} AutoCharge6 失败", agv.Name);
                    //防止上一个任务已执行但返回失败时，删除任务
                    Common.mir.Del_Mission(agv);
                    Common.LogInfo(log);
                }
                return rtn;
            }
            else
            {

                return false;
            }
            #endregion
        }

        /// <summary>
        /// 判断电量是否够执行任务
        /// </summary>
        /// <param name="agv"></param>
        /// <returns></returns>
        public static bool CheckCanExecuteMission(Agv_Info agv)
        {
            if (agv.Battery <= Common.chargeStatus.chargeMin)
            {
                Common.log.Debug(agv.Name + " 电量小于20%,不执行任务");
                return false;
            }


            return true;
        }

        /// <summary>
        /// 判断小车是否空闲
        /// </summary>
        /// <param name="agv"></param>
        /// <returns></returns>
        public static bool CheckAGVStatusNone(Agv_Info agv)
        {
            if ((agv.CurJob is ChargeJob || agv.CurJob == null) && !agv.IsExistShelf)
                return true;
            else
                return false;
        }


        public static void LogInfo(string text, bool isShow = true)
        {
            if (logTextBox == null) return;

            if (logTextBox.InvokeRequired)
            {
                logTextBox.Invoke(new Action(() => LogInfo(text, isShow)));
                return;
            }

            if (preLog.Equals(text))//连续重复的日志只打印一次
                return;
            preLog = text;
            if (msg.Count > 255)
            {
                msg.RemoveRange(0, 10);
            }
            log.Info(text);
            string tmpStr = "";
            if (isShow)
            {
                msg.Add(string.Format("[{0}] {1}\r\n", DateTime.Now.ToString("HH:mm:ss"), text));
                msg.ForEach(s => tmpStr += s);
                logTextBox.Text = tmpStr;
                //logTextBox.AppendText(string.Format("[{0}] {1}\r\n", DateTime.Now.ToString("HH:mm:ss"), text));
                //logTextBox.ScrollToCaret();
            }
        }
        /// <summary>
        /// 读取料架解绑信息
        /// </summary>
        public static void ReadUnlockLineInfo()
        {
            if (!System.IO.File.Exists(Common.CONFIG_PATH + "UnlockInfo.json"))
            {
                File.Create(Common.CONFIG_PATH + "UnlockInfo.json");
                missionManager = new UnlockMissionManager(nodeInfo);
                return;
            }
            string s = File.ReadAllText(Common.CONFIG_PATH + "UnlockInfo.json");
            missionManager = JsonHelper.DeserializeJsonToObject<UnlockMissionManager>(s);
            if (missionManager == null)
                missionManager = new UnlockMissionManager(nodeInfo);
            missionManager.Init();
        }

        public static void GetNodesPosition()
        {
            Agv_Info agv = agvInfo[0];
            foreach (ClientNode clientNode in nodeInfo)
            {
                bool rtn = Common.mir.Get_Node_Pos(agv, clientNode, out MirPosition mirPosition);
                Thread.Sleep(50);
                if (rtn)
                {
                    clientNode.position.X = mirPosition.pos_x;
                    clientNode.position.Y = mirPosition.pos_y;
                    Common.log.Debug(string.Format("软件开启：{0} 获取节点位置({1},{2})", clientNode.Name, clientNode.position.X, clientNode.position.Y));
                }
                else
                {
                    Common.log.Error(clientNode.Name + " GetNodesPosition 获取节点位置失败");
                }
            }
        }

        /// <summary>
        /// 检查该目的地是否有车占用
        /// </summary>
        /// <param name="nodeName"></param>
        /// <returns>false:未被占用</returns>
        public static bool Check4CTarget(Agv_Info agv, string nodeName)
        {
            List<Agv_Info> agvs = agvInfo.FindAll(s => !s.IP.Equals(agv.IP) && (s.CurJob is GoEmptyShelfLineJob || s.CurJob is SendFullShelfToLineJob)
            ); //&& !s.Name.Equals(StandbyStation.C4_Station1) && !s.Name.Equals(StandbyStation.C4_Station2)
            if (agvs.Count.Equals(0))
                return false;
            else if (agvs.Count > 0)
            {
                foreach (Agv_Info item in agvs)
                {
                    if (item.CurJob is GoEmptyShelfLineJob)
                    {
                        if (((GoEmptyShelfLineJob)item.CurJob).EmptyShelfPlace.Equals(nodeName) && item.CurTaskName.Equals(SettingString.Move + nodeName))
                        {
                            log.Debug(item.Name + " 在目的地：" + ((GoEmptyShelfLineJob)item.CurJob).EmptyShelfPlace + " " + agv.Name + "暂不去" + nodeName);
                            return true;
                        }

                    }
                    else if (item.CurJob is SendFullShelfToLineJob)
                    {
                        if (((SendFullShelfToLineJob)item.CurJob).FullShelfPlace.Equals(nodeName) && item.CurTaskName.Equals(SettingString.Move + nodeName))
                        {
                            log.Debug(item.Name + " 在目的地：" + ((SendFullShelfToLineJob)item.CurJob).FullShelfPlace + " " + agv.Name + "暂不去" + nodeName);
                            return true;
                        }

                    }
                }
            }
            ClientNode clientNode = nodeInfo.Find(s => s.Name.Equals(nodeName));
            if (clientNode == null)
                return false;
            if (clientNode.IsOccupied())
                return true;
            return false;
        }

        public static void ClearNodeBuff(string agvname)
        {
            foreach (var item in nodeInfo)
            {
                item.ClearOccupied(agvname);
            }
        }
        public static void SetNodeOccupied(string nodename,string agvname)
        {
            ClearNodeBuff(agvname);
            ClientNode clientNode = nodeInfo.Find(s => s.Name.Equals(nodename));
            if(clientNode!=null)
            {
                clientNode.SetOccupy(agvname);
            }
        }
        /// <summary>
        /// 移动到4C待机位
        /// </summary>
        /// <param name="agv"></param>
        public static void MoveTo4CStandy(Agv_Info agv)
        {
            if (StandbyStation.C4_Station1.Equals(""))
            {
                StandbyStation.C4_Station1 = agv.Name;
                Common.MoveToNode(agv, SettingString.C4_STANDBY1);
            }
            else if (StandbyStation.C4_Station2.Equals(""))
            {
                StandbyStation.C4_Station2 = agv.Name;
                Common.MoveToNode(agv, SettingString.C4_STANDBY2);
            }

        }
        /// <summary>
        /// 清除该小车在待机位的信息
        /// </summary>
        public static void DeleteStandyInfo(Agv_Info agv)
        {
            if (StandbyStation.C4_Station1.Equals(agv.Name))
            {
                StandbyStation.C4_Station1 = "";
            }
            else if (StandbyStation.C4_Station2.Equals(agv.Name))
            {
                StandbyStation.C4_Station2 = "";
            }
        }

        /// <summary>
        /// 获取Job任务状态
        /// </summary>
        /// <param name="CurTaskID"></param>
        /// <returns></returns>
        public static string GetTakJobState(long CurTaskID)
        {
            if (!CurTaskID.Equals(-1) && Common.mir.Get_Task_State(CurTaskID, out string st))
                return st;
            return SettingString.Wait;
        }

    }
    public class RunInfo
    {
        /// <summary>
        /// AGV编号
        /// </summary>
        public string AGVNum { get; set; } = "";
        public string DeviceName { get; set; } = "";
        /// <summary>
        /// 任务名称
        /// </summary>
        public string TaskName { get; set; } = "";
        /// <summary>
        /// 目的地
        /// </summary>
        public string TargetPlace { get; set; } = "";
        /// <summary>
        /// 任务步骤
        /// </summary>
        public string TaskStep { get; set; } = "";
        /// <summary>
        /// 任务内容
        /// </summary>
        public string MissionInfo { get; set; } = "";
        /// <summary>
        /// 开始时间
        /// </summary>
        public string DateTime { get; set; } = "";
        /// <summary>
        /// 结束时间
        /// </summary>
        public string EndDateTime { get; set; } = "";
        /// <summary>
        /// 任务运行时长
        /// </summary>
        public string TaskRunTime { get; set; } = "";
        /// <summary>
        /// 类型
        /// </summary>
        public string Type { get; set; } = "Task";

        public RunInfo(string AGVNum, string taskName, string targetPlace, string taskStep, string missionInfo, DateTime startTime)
        {
            //开始时间 2006-01-02 15:04:05
            DateTime = startTime.ToString("yyyy-MM-dd HH:mm:ss");
            EndDateTime = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            this.AGVNum = AGVNum;
            MissionInfo = missionInfo;
            TaskName = taskName;
            TaskRunTime = (System.DateTime.Now - startTime).TotalMinutes.ToString("f2");
            TargetPlace = targetPlace;
            TaskStep = taskStep;
        }
        public RunInfo() { }
        public override bool Equals(object obj)
        {
            if (obj is RunInfo)
            {
                RunInfo info = (RunInfo)obj;
                if (this.MissionInfo.Equals(info.MissionInfo))
                    return true;
                this.MissionInfo = info.MissionInfo;
            }
            return false;
        }
        public override string ToString()
        {
            return JsonHelper.SerializeObject(this);
        }
    }

    public class ErrorInfo
    {
        /// <summary>
        /// AGV编号
        /// </summary>
        public string AGVNum
        {
            get { return agvname; }
            set
            {
                agvname = value.PadLeft(4, '0');
            }
        }
        private string agvname = "";
        public string DeviceName { get; set; } = "";
        /// <summary>
        /// 开始时间
        /// </summary>
        public string DateTime { get; set; } = "";
        /// <summary>
        /// 结束时间
        /// </summary>
        public string EndDateTime { get; set; } = "";
        /// <summary>
        /// 异常信息
        /// </summary>
        public string ErrorMsg { get; set; } = "";
        public string ErrorLastTime { get; set; } = "";
        /// <summary>
        /// 任务名称
        /// </summary>
        public string TaskName { get; set; } = "";
        /// <summary>
        /// AGV的当前任务
        /// </summary>
        public string AGVMissionName { get; set; } = "";

        public string MissionInfo { get; set; } = "";
        /// <summary>
        /// 目的地
        /// </summary>
        public string TargetPlace { get; set; } = "";
        /// <summary>
        /// 类型
        /// </summary>
        public string Type { get; set; } = "Error";
        public ErrorInfo(Agv_Info agv)
        {
            DateTime = agv.errStartTime.ToString("yyyy-MM-dd HH:mm:ss");
            AGVNum = agv.Name;
            EndDateTime = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            ErrorMsg = agv.ErrorMsg;
            ErrorLastTime = (System.DateTime.Now - agv.errStartTime).TotalMinutes.ToString("f2");
            if (agv.CurJob != null)
            {
                TaskName = agv.CurJob.JobName;
                MissionInfo = agv.CurJob.runInfo;
            }
            AGVMissionName = agv.CurTaskName;
            TargetPlace = agv.Place;
        }
        public override string ToString()
        {
            return JsonHelper.SerializeObject(this);
        }
    }
    public static class API
    {
        [DllImport("user32.dll", EntryPoint = "ShowWindow", CharSet = CharSet.Auto)]
        public static extern int ShowWindow(IntPtr hwnd, int nCmdShow);
        [DllImport("user32.dll ", SetLastError = true)]
        public static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);
        public const int SW_RESTORE = 9;

    }

    /// <summary>
    /// 客户端
    /// </summary>
    public class Client
    {
        /// <summary>
        /// 循环
        /// </summary>
        public bool Loop;
        /// <summary>
        /// IP地址
        /// </summary>
        public string IP;
        /// <summary>
        /// 是否连接
        /// </summary>
        public bool IsConn;
        /// <summary>
        /// 节点名称集合
        /// </summary>
        public List<string> nodeName;
        /// <summary>
        /// 套接字
        /// </summary>
        public Socket Socket;
        /// <summary>
        /// 接收数据线程
        /// </summary>
        public Thread ListenNet;



    }


    /// <summary>
    /// 地点状态
    /// </summary>
    public enum ePlaceState
    {
        /// <summary>
        /// 没有任务
        /// </summary>
        None = 0,
        /// <summary>
        /// 小车移动任务
        /// </summary>
        Move = 1,
        /// <summary>
        /// 小车移动任务完成
        /// </summary>
        MoveFinish = 2,
        /// <summary>
        /// 小车Enter任务
        /// </summary>
        Enter = 3,
        /// <summary>
        /// 小车Enter任务完成
        /// </summary>
        EnterFinish = 4,
        /// <summary>
        /// 小车Leave任务
        /// </summary>
        Leave = 5,
        /// <summary>
        /// 小车Leave任务完成
        /// </summary>
        LeaveFinish = 6,
        /// <summary>
        /// 出错
        /// </summary>
        Error = 9
    }

    public struct PositionStru
    {
        public double X;
        public double Y;
    }
    public class ChargeStatus
    {
        /// <summary>
        /// 1号充电桩的AGV名称
        /// </summary>
        public string charge3 = "";
        /// <summary>
        /// 1号充电桩的AGV名称
        /// </summary>
        public string charge4 = "";
        /// <summary>
        /// 1号充电桩的AGV名称
        /// </summary>
        public string charge5 = "";
        /// <summary>
        /// 1号充电桩的AGV名称
        /// </summary>
        public string charge6 = "";
        /// <summary>
        /// 1号充电桩的AGV名称
        /// </summary>
        public string charge7 = "";
        /// <summary>
        /// 充电最大电量，小于该值等待指定时间去充电
        /// </summary>
        public int chargeMax;
        /// <summary>
        /// 充电最小电量，小于该值直接去充电
        /// </summary>
        public int chargeMin;
        /// <summary>
        /// 两车充电间隔时间(ms)
        /// </summary>
        public long chargeInterval;

        private bool _autoCharge;

        public bool AutoCharge
        {
            set
            {
                _autoCharge = value;
                Common.appConfig.AppSettings.Settings["AutoCharge"].Value = value.ToString();
                Common.appConfig.Save();
            }
            get
            {
                return _autoCharge;
            }
        }

        public ChargeStatus()
        {
            _autoCharge = Convert.ToBoolean(Common.appConfig.AppSettings.Settings["AutoCharge"].Value);

            string s = Common.appConfig.AppSettings.Settings["ChargeThreshold"].Value;
            string[] arr = s.Split(',');
            chargeMin = Convert.ToInt32(arr[0]);
            chargeMax = Convert.ToInt32(arr[1]);

            chargeInterval = 0;
        }
        public void ClearRandomChargeInfo(Agv_Info agv)
        {
            if (Common.chargeStatus.charge3.Equals(agv.Name))
            {
                Common.chargeStatus.charge3 = "";
            }
            if (Common.chargeStatus.charge6.Equals(agv.Name))
            {
                Common.chargeStatus.charge6 = "";
            }
        }
    }

    /// <summary>
    /// 4C待机位
    /// </summary>
    public struct StandbyStation
    {
        public string C4_Station1;
        public string C4_Station2;
    }

}