using HH.WCS.JingyuNongfu.device;
using HH.WCS.JingyuNongfu.dispatch;
using HH.WCS.JingyuNongfu.util;
using HH.WCS.JingyuNongfu.wms;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SqlSugar;
using System.Security.Policy;
using Newtonsoft.Json;

namespace HH.WCS.JingyuNongfu.process
{
    /// <summary>
    /// 设备信号处理
    /// </summary>
    internal class DeviceProcess
    {
        private static Dictionary<string, DateTime> times = new Dictionary<string, DateTime>();
        private static Dictionary<string, statemodel> LineState = new Dictionary<string, statemodel>();




        public class statemodel
        {
            public int status { get; set; }

            public int Zf { get; set; }
            public DateTime modify { get; set; }
        }
        internal static void Analysis(string data, string ip)
        {
            if (data.Length >= 6)
            {
                //去掉消息头3F 00

                string xh = data;
                data = data.Substring(4);
                //Console.WriteLine($"{ip}-{data}");
                var plc = Settings.deviceInfos.Where(a => a.address == ip && a.enable == 1).ToList();
                foreach (var item in plc)
                {
                    if (plc != null)
                    {
                        if (item.enable == 1)
                        {
                            if (item.deviceType == 1)
                            {
                                AnalysisDoor(xh, data, item);
                            }
                            else if (item.deviceType == 2)
                            {
                                AnalysisPgFdj(xh, data, item);
                            }
                            else if (item.deviceType == 3)//一期二期瓶坯翻斗机
                            {
                                AnalysisPpFdj(data, item);
                            }
                            else if (item.deviceType == 4)
                            {
                                AnalysisPpZsj(data, item);
                            }
                            else if (item.deviceType == 5)
                            {
                                AnalysisCp(data, item);
                            }
                            else if (item.deviceType == 6)
                            {
                                DingShengji(data, item);
                            }
                            else if (item.deviceType == 8)
                            {
                                AnalysisPgZsj(data, item);
                            }
                            LogHelper.Info($"接收信号：{xh},地址:{item.address}", "信号");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"TCP信号处理：未查询到IP为{ip}的数据，请检查deviceInfo配置中心是否存在该IP的数据！");
                    }
                }

            }

        }


        #region 复位信号

        internal static void QuLiao(WMSTask mst, bool v)
        {
            try
            {
                LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
                var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_START_LOC)).FirstOrDefault();
                if (info != null)
                {
                    LogHelper.Info($"安全交互开始 任务号={mst.S_TASK_NO}", "安全请求");
                    LogHelper.Info($"安全交互开始 设备名={info.deviceName},设备编码={info.deviceType}", "安全请求");
                    if (v)
                    {
                        if (LineState.Keys.Contains(mst.S_START_LOC.Trim()))
                        {
                            LogHelper.Info($"查询输送线允许取满信号 允许取满信号={LineState[mst.S_START_LOC.Trim()].status} 时间间隔={DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds}", "安全交互");
                            // var xh = LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 4);
                            // Console.WriteLine($"xh:{xh}");

                            if (info.deviceName.Contains("翻斗机"))
                            {
                                LogHelper.Info($"翻斗机1101安全流程判断:", "安全请求");
                                //翻斗机
                                if (info.deviceName.Contains("瓶盖"))
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 6) == "112100" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        //PlcHelper.SendHex(info.address, "3F0012210D0A");
                                        LogHelper.Info($"瓶盖翻斗机安全交互1101成功", "安全请求");
                                    }
                                    else
                                    {
                                        Console.WriteLine("1101发送信号为flase");
                                    }
                                }

                                else
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 6) == "112200" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F0012210D0A");
                                        LogHelper.Info($"瓶胚翻斗机安全交互1101成功", "安全请求");

                                    }
                                    else
                                    {
                                        Console.WriteLine("1101发送信号为flase");
                                    }

                                }

                            }
                            //顶升机
                            else if (info.deviceType == 6)
                            {
                                LogHelper.Info($"顶升机1101安全流程判断:", "安全请求");
                                LogHelper.Info($"顶升机1101信号:{LineState[mst.S_START_LOC.Trim()].status.ToString()}", "安全请求");

                                if (mst.S_TYPE == "顶升机废料下线")
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 6) == "112030" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {


                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00110D0A");

                                        LogHelper.Info($"成功安全交互1101成功", "安全请求");
                                    }
                                }
                                else if (mst.S_TYPE == "顶升机空托下线")
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 6) == "102130" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {


                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00110D0A");

                                        LogHelper.Info($"成功安全交互1101成功", "安全请求");
                                    }
                                }
                                else if (mst.S_TYPE == "顶升机留样品下线")
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 6) == "102031" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {


                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00110D0A");

                                        LogHelper.Info($"成功安全交互1101成功", "安全请求");
                                    }
                                }
                                else
                                {
                                    LogHelper.Info($"顶升机信号 {LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 6)}", "安全请求");
                                }
                            }
                            else if (info.deviceType == 5)
                            {
                                LogHelper.Info($"成品1101安全流程判断:", "安全请求");
                                if (info.deviceName.Trim() == "靖宇成品仓E11输送线")
                                {
                                    //E11成品
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 2) == "11" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00110D0A");
                                        // LogHelper.Info($"取料发送3F00110D0A");
                                        LogHelper.Info($"成品安全交互1101成功", "安全请求");
                                    }
                                }
                                else if (info.deviceName.Trim() == "靖宇成品仓E12输送线")
                                {
                                    //E12成品
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(2, 2) == "21" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00210D0A");
                                        LogHelper.Info($"成品安全交互1101成功", "安全请求");
                                    }
                                }
                                else
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 4) == "1220" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        PlcHelper.SendHex(info.address, "3F00110D0A");
                                        LogHelper.Info($"成品安全交互1101成功", "安全请求");
                                    }
                                }
                            }
                            //注塑机
                            else if (info.deviceType == 4)
                            {
                                LogHelper.Info($"注塑1101安全流程判断:信号{LineState[mst.S_START_LOC.Trim()].status}", "安全请求");
                                if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(0, 2) == "11" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10)
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(4, 2) == "01")
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        // PlcHelper.SendHex(info.address, "3F00110D0A");
                                        // LogHelper.Info($"取料发送3F00110D0A");
                                        LogHelper.Info($"注塑机安全交互1101成功", "安全请求");
                                    }

                                }
                                else if ((LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(2, 2) == "21" && DateTime.Now.Subtract(LineState[mst.S_START_LOC.Trim()].modify).TotalSeconds < 10))
                                {
                                    if (LineState[mst.S_START_LOC.Trim()].status.ToString().Substring(6, 2) == "02")
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1101, 18);
                                        // PlcHelper.SendHex(info.address, "3F00110D0A");
                                        // LogHelper.Info($"取料发送3F00110D0A");
                                        LogHelper.Info($"注塑机安全交互1101成功", "安全请求");
                                    }
                                }
                            }
                            else
                            {
                                Console.WriteLine("1101发送信号为flase");
                            }
                        }
                        else
                        {
                            LogHelper.Info("LineState.Keys.Contains(mst.S_START_LOC.Trim())flase", "安全请求");
                        }
                    }
                    else
                    {
                        if (info.deviceName.Trim() == "靖宇成品仓E12输送线")
                        {
                            PlcHelper.SendHex(info.address, "3F00200D0A");
                            LogHelper.Info($"成品安全交互1102成功", "安全请求");
                        }
                        else if (info.deviceName.Contains("翻斗机"))
                        {
                            if (info.deviceName.Contains("瓶盖"))
                            {

                            }
                            else
                            {
                                PlcHelper.SendHex(info.address, "3F0010200D0A");
                                LogHelper.Info($"瓶胚翻斗机安全交互1102成功", "安全请求");
                            }

                        }
                        else if (info.deviceType == 6)
                        {
                            PlcHelper.SendHex(info.address, "3F00100D0A");
                            LogHelper.Info($"顶升机安全交互1102成功", "安全请求");
                        }
                        else if (info.deviceType == 5)
                        {
                            PlcHelper.SendHex(info.address, "3F00100D0A");
                            LogHelper.Info($"成品安全交互1102成功", "安全请求");
                        }


                    }
                }
                else
                {
                    LogHelper.Info($"任务号 {mst.S_TASK_NO} 找不到起点{mst.S_START_LOC} 对应的IP配置文件", "安全请求");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                LogHelper.Info($"取料异常{ex.Message}", "安全请求");
            }
        }

        internal static void Xieliao(WMSTask mst, bool v = false)
        {
            try
            {
                LogHelper.Info("卸料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
                var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_END_LOC)).FirstOrDefault();
                if (info != null)
                {
                    LogHelper.Info($"安全交互开始 任务号={mst.S_TASK_NO}", "安全交互");
                    if (v)
                    {
                        if (LineState.Keys.Contains(mst.S_END_LOC.Trim()))
                        {
                            LogHelper.Info($"查询输送线允许补空信号 允许补空信号={LineState[mst.S_END_LOC.Trim()].status} 时间间隔={DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds}", "安全交互");
                            if (info.deviceName.Contains("翻斗机"))
                            {
                                //瓶坯翻斗机

                                if (info.deviceName.Contains("瓶盖"))
                                {
                                    if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 6) == "112100" && DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1103, 18);
                                        //PlcHelper.SendHex(info.address, "3F0012210D0A");
                                        LogHelper.Info($"瓶盖翻斗机安全交互1103成功", "安全请求");
                                    }
                                    else
                                    {
                                        Console.WriteLine("1103发送信号为flase");
                                    }
                                }
                                else
                                {
                                    if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 6) == "112200" && DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds < 10)
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1103, 18);
                                        PlcHelper.SendHex(info.address, "3F0012210D0A");
                                        LogHelper.Info($"瓶胚翻斗机安全交互1103成功", "安全请求");
                                    }
                                    else
                                    {
                                        Console.WriteLine("1103发送信号为flase");
                                    }
                                }


                            }

                            else if (info.deviceType == 5)
                            {
                                //成品
                                if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 4) == "1021" && DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds < 10)
                                {


                                    NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1103, 18);
                                    PlcHelper.SendHex(info.address, "3F00210D0A");

                                    LogHelper.Info($"成功安全交互1103成功", "安全请求");
                                }
                                else
                                {
                                    Console.WriteLine("1103发送信号为flase");
                                }
                            }
                            //注塑机
                            else if (info.deviceType == 4)
                            {
                                LogHelper.Info($"注塑1103安全流程判断:信号{LineState[mst.S_END_LOC.Trim()].status}", "安全请求");

                                LogHelper.Info($"注塑1103安全流程判断:截取信号{LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 2)}", "安全请求");
                                if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(0, 2) == "11" && DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds < 10)
                                {
                                    LogHelper.Info($"注塑1103安全流程判断:截取信号{LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(4, 2)}", "安全请求");
                                    if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(4, 2) == "01")
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1103, 18);
                                        // PlcHelper.SendHex(info.address, "3F00110D0A");
                                        // LogHelper.Info($"取料发送3F00110D0A");
                                        LogHelper.Info($"注塑机安全交互1103成功", "安全请求");
                                    }

                                }
                                else if ((LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(2, 2) == "21" && DateTime.Now.Subtract(LineState[mst.S_END_LOC.Trim()].modify).TotalSeconds < 10))
                                {
                                    if (LineState[mst.S_END_LOC.Trim()].status.ToString().Substring(6, 2) == "02")
                                    {
                                        NDCHelper.ChangeParam(mst.S_TASK_NO.Trim(), 1103, 18);
                                        // PlcHelper.SendHex(info.address, "3F00110D0A");
                                        // LogHelper.Info($"取料发送3F00110D0A");
                                        LogHelper.Info($"注塑机安全交互1103成功", "安全请求");
                                    }
                                }
                                else
                                {
                                    LogHelper.Info($"注塑1103安全流程判断:信号判断问题", "安全请求");
                                }
                            }

                        }
                    }
                    else
                    {
                        if (info.deviceName.Contains("翻斗机"))
                        {
                            if (info.deviceName.Contains("瓶盖"))
                            {

                            }
                            else
                            {
                                PlcHelper.SendHex(info.address, "3F0010200D0A");
                                LogHelper.Info($"瓶胚翻斗机安全交互1104成功", "安全请求");
                            }

                        }

                        else if (info.deviceType == 5)
                        {
                            PlcHelper.SendHex(info.address, "3F00200D0A");
                            LogHelper.Info($"成品安全交互1104成功", "安全请求");
                        }

                    }
                }
                else
                {
                    LogHelper.Info($"任务号 {mst.S_TASK_NO} 找不到终点{mst.S_END_LOC} 对应的IP配置文件");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                LogHelper.Info($"卸料异常{ex.Message}");
            }
        }

        #region  成品信号安全交互（未启用）
        ///// <summary>
        ///// 成品取料复位信号
        ///// </summary>
        ///// <param name="mst"></param>
        //internal static void QuLiaoCp(WMSTask mst)
        //{
        //    try
        //    {
        //        LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
        //        var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_START_LOC)).FirstOrDefault();
        //        if (info != null)
        //        {
        //            if (LineState.Keys.Contains(mst.S_START_LOC.Trim()))
        //            {
        //                var key = LineState.First(a => a.Key == mst.S_START_LOC);

        //                if (mst.S_B_STATE == "开始取货")
        //                {
        //                    if (key.Value.Zf == 1)
        //                    {
        //                        PlcHelper.SendHex(info.address, "3F00110D0A");
        //                    }
        //                    else if (key.Value.Zf == 2)
        //                    {
        //                        PlcHelper.SendHex(info.address, "3F00210D0A");
        //                    }
        //                }
        //                else if (mst.S_B_STATE == "取货完成")
        //                {
        //                    if (key.Value.Zf == 1)
        //                    {
        //                        PlcHelper.SendHex(info.address, "3F00100D0A");
        //                    }
        //                    else if (key.Value.Zf == 2)
        //                    {
        //                        PlcHelper.SendHex(info.address, "3F00200D0A");
        //                    }
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        Console.WriteLine(ex.Message);
        //        LogHelper.Info($"取料异常{ex.Message}");
        //    }
        //}

        ///// <summary>
        ///// 成品卸料复位信号
        ///// </summary>
        ///// <param name="mst"></param>
        //internal static void XieliaoCp(WMSTask mst)
        //{
        //    try
        //    {
        //        LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
        //        var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_START_LOC)).FirstOrDefault();
        //        if (info != null)
        //        {
        //            if (LineState.Keys.Contains(mst.S_START_LOC.Trim()))
        //            {
        //                var key = LineState.First(a => a.Key == mst.S_START_LOC);
        //                if (mst.S_B_STATE == "开始卸货")
        //                {

        //                    PlcHelper.SendHex(info.address, "3F00110D0A");


        //                }
        //                else if (mst.S_B_STATE == "卸货完成")
        //                {

        //                    PlcHelper.SendHex(info.address, "3F00100D0A");


        //                }
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        Console.WriteLine(ex.Message);
        //        LogHelper.Info($"卸料料异常{ex.Message}");
        //    }
        //}
        #endregion 


        /// <summary>
        /// 翻斗机复位信号
        /// </summary>
        /// <param name="mst"></param>
        internal static void XieliaoFdj1(WMSTask mst)
        {
            try
            {
                LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
                var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_END_LOC)).FirstOrDefault();
                if (info != null)
                {
                    LogHelper.Info($"翻斗机发送复位信号", "发送信号");
                    PlcHelper.SendHex(info.address, "3F00100D0A");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                LogHelper.Info($"取料异常{ex.Message}");
            }
        }

        internal static void XieliaoFdj(WMSTask mst)
        {
            try
            {
                LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
                var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_END_LOC)).FirstOrDefault();
                //if (info == null)
                //{
                //    info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_START_LOC)).FirstOrDefault();
                //}
                if (info != null)
                {
                    LogHelper.Info($"瓶坯翻斗机发送复位信号", "发送信号");
                    PlcHelper.SendHex(info.address, "3F0010200D0A");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                LogHelper.Info($"取料异常{ex.Message}");
            }
        }
        /// <summary>
        /// 注塑机复位信号
        /// </summary>
        /// <param name="mst"></param>
        internal static void XieliaoPpzsj(WMSTask mst)
        {
            try
            {
                LogHelper.Info("取料任务信息 Request：" + JsonConvert.SerializeObject(mst), "HosttoagvTask");
                var info = Settings.deviceInfos.Where(a => a.location.Contains(mst.S_END_LOC)).FirstOrDefault();
                if (info != null)
                {
                    if (info.location[0] == mst.S_END_LOC)
                    {
                        LogHelper.Info($"瓶坯注塑机发送复位信号", "发送信号");
                        PlcHelper.SendHex(info.address, "3F00100D0A");
                    }
                    else if (info.location[1] == mst.S_END_LOC)
                    {
                        LogHelper.Info($"瓶坯注塑机发送复位信号", "发送信号");
                        PlcHelper.SendHex(info.address, "3F00200D0A");
                    }
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                LogHelper.Info($"卸料料异常{ex.Message}");
            }
        }
        #endregion

        #region 自动门

        private static Dictionary<string, signalInfo> doorStatus = new Dictionary<string, signalInfo>();
        /// <summary>
        /// 自动门
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        internal static void AnalysisDoor(string xh, string data, Settings.deviceInfo plc)
        {
            LogHelper.Info($"自动门状态：{xh},地址为：{plc.address},门号：{plc.deviceName}", "自动门");
            if (data.Length / 2 == plc.deviceNo.Length)//2 2
            {
                for (int i = 0; i < plc.deviceNo.Length; i++)
                {
                    var state = data.Substring(i * 2 + 1, 1);
                    //Console.WriteLine($"门{plc.deviceNo[i]}的状态{state}");
                    if (doorStatus.Keys.Contains(plc.deviceNo[i]))
                    {
                        doorStatus[plc.deviceNo[i]].info = state;
                        doorStatus[plc.deviceNo[i]].modify = DateTime.Now;
                    }
                    else
                    {
                        doorStatus.Add(plc.deviceNo[i], new signalInfo { info = state, modify = DateTime.Now });
                    }
                }
            }
        }

        public class signalInfo
        {
            public string info { get; set; }
            public DateTime modify { get; set; }
        }

        private static Dictionary<string, DateTime> doorRecord = new Dictionary<string, DateTime>();
        /// <summary>
        /// 交管请求
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="zone"></param>
        /// <param name="occupy"></param>
        internal static void Traffic(string agv, string zone, bool occupy)
        {
            Console.WriteLine("交管请求");
            var plc = Settings.deviceInfos.Where(a => a.deviceNo.Contains(zone)).FirstOrDefault();
            if (plc != null)
            {
                if (plc.deviceType == 7)
                {
                    LogHelper.Info($"声光报警请求:门号：{zone}");
                    if (occupy)
                    {

                        PlcHelper.SendHex(plc.address, "01 06 04 0E 00 03 A9 38");

                    }
                    else
                    {
                        PlcHelper.SendHex(plc.address, "01 06 04 0E 00 00 E9 39");
                    }
                }
                else
                {
                    var index = 1;
                    for (int i = 0; i < plc.deviceNo.Length; i++)
                    {
                        if (plc.deviceNo[i] == zone)
                        {
                            index = i + 1;
                            break;
                        }
                    }
                    LogHelper.Info($"安全门开门请求,门号：{zone},index:{index}");
                    if (occupy)
                    {

                        //开门请求 3F 00 11 20 0d 0a（ 3F 00 10 21 0d 0a）

                        var req = $"3f 00 {index}1 0d 0a";
                        PlcHelper.SendHex(plc.address, req);
                        var msg = $"安全门开门请求,门号：{zone},index:{index}，ip={plc.address}, data={req}";
                        LogHelper.Info(msg, "发送信号");

                        //车子请求一次就发一次开门请求
                        if (doorStatus.Keys.Contains(zone) && DateTime.Now.Subtract(doorStatus[zone].modify).TotalSeconds < 5)
                        {
                            if (doorStatus[zone].info == "1")
                            {
                                LogHelper.Info($"安全门已经打开：门号：{zone},index:{index}", "自动门");
                                NDCHelper.Traffic(zone, agv);
                            }
                        }


                    }
                    else
                    {



                        //关门信号 3F 00 10 20 0d 0a
                        var req = $"3f 00 {index}0 0d 0a";
                        PlcHelper.SendHex(plc.address, req);
                        var msg = $"安全门关门请求,门号：{zone},index:{index}，ip={plc.address}, data={req}";
                        LogHelper.Info(msg, "发送信号");
                    }
                }

            }
        }

        /*
         IO模块1	只用02功能码读取
         1x0000	一楼开门到位信号
         1x0001	二楼开门到位信号
	
	
         IO模块2	只用05功能码写入
         0x0000	一楼楼层按钮信号
         0x0001	二楼楼层按钮信号

         */

        private static Dictionary<string, DateTime> elevatorRecord = new Dictionary<string, DateTime>();



        #endregion

        #region 瓶盖翻斗机
        /// <summary>
        /// 判断plc下哪台设备
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        internal static void AnalysisPgFdj(string xh, string data, Settings.deviceInfo plc)
        {

            //3F 00 11 22 32 42 0d 0a
            //一个plc对应1个瓶盖机,一个门

            try
            {
                #region 信号记录



                if (LineState.Keys.Contains(plc.location[0]))
                {
                    LineState[plc.location[0]].modify = DateTime.Now;
                    LineState[plc.location[0]].status = int.Parse(data);

                }
                else
                {
                    LineState.Add(plc.location[0], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                }

                #endregion

                if (data.Substring(1, 1) == "1")
                {
                    if (BottleCapBody(plc.deviceName, plc.location[0], plc.address, 0 * 2 + 1))
                    {
                        PlcHelper.SendHex(plc.address, $"3F00{0 * 2 + 1}10d0a");

                    }
                }
                if (data.Length >= 4)
                {
                    var state = data.Substring(3, 1);
                    LogHelper.Info($"信号：{xh},地址为：{plc.address},门号：{plc.deviceName},状态{state}", "自动门");
                    //Console.WriteLine($"门{plc.deviceNo[i]}的状态{state}");
                    if (doorStatus.Keys.Contains(plc.deviceNo[1]))
                    {
                        doorStatus[plc.deviceNo[1]].info = state;
                        doorStatus[plc.deviceNo[1]].modify = DateTime.Now;
                    }
                    else
                    {
                        doorStatus.Add(plc.deviceNo[1], new signalInfo { info = state, modify = DateTime.Now });
                    }
                }
               
            }
            catch (Exception)
            {

                throw;
            }





        }

        /// <summary>
        /// 瓶盖机信号处理，取满送空
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="location"></param>
        /// <returns></returns>
        private static bool BottleCapBody(string deviceName, string bit, string ip, int index)
        {
            var result = false;

            if (bit != "")
            {

                if (LocationHelper.CheckLocFree(bit))
                {
                    //查询工单
                    var workOrder = MESHelper.GetWorkOrder(deviceName);
                    //  string start = null; string end = null;//用来查询任务表，作任务创建限制
                    #region 计算起点终点判断有无执行中的任务 弃用
                    //if (deviceName == "瓶盖翻斗机E9")
                    //{
                    //    start = "PGFDJ_E9";
                    //    end = "PGFDJ_E9";
                    //}
                    //else if (deviceName == "瓶盖翻斗机E8")
                    //{
                    //    start = "PGFDJ_E8";
                    //    end = "PGFDJ_E8";
                    //}
                    //if (start == null)
                    //{
                    //    Console.WriteLine("工单号错误");
                    //}
                    #endregion

                    if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                    {
                        //查询货位表
                        var locList = LocationHelper.GetLocListAny(new List<string> { bit });
                        if (locList.Count > 0)
                        {
                            var location = locList[0];

                            //要判断当前位置是空托盘，还是满托盘
                            if (location.N_CURRENT_NUM == 0 && location.S_LOCK_STATE.Trim() == "无")
                            {


                                //判断上空任务终点有无未完成的任务，如果无 则生产任务
                                // var e = TaskHelper.GetTaskByEndLOC(end);

                                //if (e.Count <= 0)
                                //{

                                ProcessHelperPP.PgEmpty1(workOrder, location);
                                //}
                                //else
                                // {
                                //  Console.WriteLine($"终点{end}有未完成任务，请检查任务表");
                                // }

                            }
                            else if (location.N_CURRENT_NUM == 1 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                //查货位容器表
                                var last = LocationHelper.GetLocCntrRel(location.S_LOC_CODE).OrderByDescending(x => x.T_CREATE).FirstOrDefault();
                                if (last != null)
                                {
                                    if (workOrder.S_PLineNo.Contains("二期"))
                                    {
                                        // 判断时间（卸货完成60s内的请求判定为重复请求）
                                        if (DateTime.Now.Subtract(last.T_CREATE).TotalSeconds < 60)
                                        {
                                            LogHelper.Info($"一分钟判定发送信号", "发送信号");
                                            PlcHelper.SendHex(ip, $"3f00{index}00d0a");
                                        }
                                        else
                                        {
                                            //超过1分钟，可能是新的满托取货请求，再生成取满任务 
                                            var startCntr = LocationHelper.GetLocCntr(location.S_LOC_CODE).FirstOrDefault();
                                            if (startCntr != null)
                                            {
                                                //空托盘请求
                                                ProcessHelperPP.PgFdFull(workOrder, location, startCntr);
                                            }
                                            else
                                            {
                                                LogHelper.Info($"瓶盖机{location.S_LOC_CODE}未找到绑定的托盘信息，请检查【货位容器表】");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        //一期瓶盖翻斗机目前不生成下空任务

                                        //瓶盖翻斗机货位上有货，直接删除托盘
                                        var startCntr = LocationHelper.GetLocCntr(location.S_LOC_CODE).FirstOrDefault();
                                        if (startCntr != null)
                                        {
                                            //删除货位容器绑定
                                            LocationHelper.UnBindingLoc(location.S_LOC_CODE, startCntr.S_CNTR_CODE.Split(',').ToList());
                                            //删除容器表
                                            if (ContainerHelper.delCntr(startCntr.S_CNTR_CODE))
                                            {
                                                LogHelper.Info($"瓶盖机{location.S_LOC_CODE}设备有托盘{startCntr.S_CNTR_CODE}，删除托盘", "瓶盖");
                                            }

                                        }
                                        else
                                        {
                                            LogHelper.Info($"瓶盖机{location.S_LOC_CODE}未找到绑定的托盘信息，请检查【货位容器表】");
                                        }
                                    }


                                }
                                else
                                {
                                    LogHelper.Info($"瓶盖机{location.S_LOC_CODE}未找到绑定的托盘信息，请检查【货位容器表】");
                                }
                            }


                        }
                        else
                        {
                            Console.WriteLine($"获取瓶盖机货位信息{bit}失败");
                        }

                    }
                    else
                    {
                        Console.WriteLine($"瓶盖机：{deviceName}  未找到工单");
                    }
                }
                else
                {
                    Console.WriteLine("货位已上锁");
                }


            }



            return result;

        }
        #endregion

        #region 瓶盖注塑机

        /// <summary>
        /// 判断plc下哪台设备
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        internal static void AnalysisPgZsj(string data, Settings.deviceInfo plc)
        {

            //3F 00 11 22 32 42 0d 0a
            //一个plc对应1个注塑机
            try
            {

                for (int i = 0; i < 1; i++)
                {
                    LogHelper.Info($"信号：{data},地址为：{plc.address}", "瓶坯");

                    if (data.Substring(i * 4 + 1, 1) == "1")
                    {
                        //Console.WriteLine("信号正常");
                        if (BottlePreformBodyPgZsj(plc.deviceName, plc.location[i * 2], plc.address, i * 2 + 1, int.Parse(plc.deviceNo[i * 0])))
                        {
                            PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 1}10d0a");

                        }

                        if (LineState.Keys.Contains(plc.location[i * 2]))
                        {
                            LineState[plc.location[i * 2]].modify = DateTime.Now;
                            LineState[plc.location[i * 2]].status = int.Parse(data);

                        }
                        else
                        {
                            LineState.Add(plc.location[i * 2], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                    }

                    if (data.Substring(i * 4 + 3, 1) == "1")
                    {
                        //Console.WriteLine("信号正常");
                        if (BottlePreformBodyPgZsj(plc.deviceName, plc.location[i * 2 + 1], plc.address, i * 2 + 2, int.Parse(plc.deviceNo[i * 0])))
                        {
                            PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 2}10d0a");
                        }

                        if (LineState.Keys.Contains(plc.location[i * 2 + 1]))
                        {
                            LineState[plc.location[i * 2 + 1]].modify = DateTime.Now;
                            LineState[plc.location[i * 2 + 1]].status = int.Parse(data);

                        }
                        else
                        {
                            LineState.Add(plc.location[i * 2 + 1], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                    }



                }
            }
            catch (Exception ex)
            {

                throw;
            }



        }

        /// <summary>
        /// 瓶坯注塑机信号处理，取空下满
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="location"></param>
        /// <returns></returns>
        private static bool BottlePreformBodyPgZsj(string deviceName, string bit, string ip, int index, int deviceNo)
        {
            var result = false;

            if (bit != "")
            {

                if (LocationHelper.CheckLocFree(bit))
                {
                    var workOrder = MESHelper.GetWorkOrder(deviceName);
                    if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                    {
                        var locList = LocationHelper.GetLocListAny(new List<string> { bit });
                        if (locList.Count > 0)
                        {
                            var location = locList[0];
                            // LogHelper.Info($"数量：{location.N_CURRENT_NUM}，锁：{location.S_LOCK_STATE}", "任务");
                            if (location.N_CURRENT_NUM == 0 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                if (workOrder.S_PLineNo.Contains("无菌"))
                                {
                                    ProcessHelperPP.WjEmpty(workOrder, location);
                                }
                                else
                                {
                                    ProcessHelperPP.PgZsjEmpty(workOrder, location);
                                }
                                
                            }
                            else if (location.N_CURRENT_NUM == 1 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                var last = LocationHelper.GetLocCntrRel(location.S_LOC_CODE).OrderByDescending(x => x.T_CREATE).FirstOrDefault();
                                if (last != null)
                                {
                                    if (DateTime.Now.Subtract(last.T_CREATE).TotalSeconds < 60)
                                    {
                                        LogHelper.Info($"一分钟判定发送信号", "发送信号");
                                        PlcHelper.SendHex(ip, $"3f00100d0a");
                                    }
                                    else
                                    {
                                        //超过1分钟，可能是新的满托取货请求，再生成取满任务
                                        //Console.WriteLine("超过1分钟，可能是新的满托取货请求，生成取满任务");
                                        var startCntr = LocationHelper.GetLocCntr(location.S_LOC_CODE).FirstOrDefault();
                                        if (startCntr != null)
                                        {
                                            if (workOrder.S_PLineNo.Contains("无菌"))
                                            {
                                                ProcessHelperPP.WjpFull(workOrder, location, startCntr);
                                            }
                                            else
                                            {
                                                ProcessHelperPP.PgZsjFull(workOrder, location, startCntr);
                                            }
                                                //ProcessHelper.SetTrayInfoFull(workOrder, startCntr.Container);
                                               
                                        }
                                        else
                                        {
                                            // Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                            LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                        }
                                    }
                                }
                                else
                                {
                                    //Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                    LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                }
                            }
                        }
                        else
                        {
                            Console.WriteLine($"获取瓶坯机货位信息{bit}失败");
                        }

                    }
                    else
                    {
                        Console.WriteLine($"瓶坯机：{deviceName}  未找到工单");
                    }
                }
                else
                {
                    LogHelper.Info($"{bit}货位有锁", "任务");
                }



            }



            return result;

        }


        #endregion

        #region 瓶坯翻斗机

        /// <summary>
        /// 判断plc下哪台设备
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        internal static void AnalysisPpFdj(string data, Settings.deviceInfo plc)
        {

            //3F 00 11 22 32 42 0d 0a
            //一个plc对应1个瓶盖机
            try
            {
                #region 信号记录



                if (LineState.Keys.Contains(plc.location[0]))
                {
                    LineState[plc.location[0]].modify = DateTime.Now;
                    LineState[plc.location[0]].status = int.Parse(data);

                }
                else
                {
                    LineState.Add(plc.location[0], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                }

                #endregion

                for (int i = 0; i < 1; i++)
                {
                    LogHelper.Info($"信号：{data},地址为：{plc.address}", "瓶坯");
                    if (i < plc.deviceNo.Length)
                    {
                        if (data.Substring(i * 4 + 1, 1) == "1")
                        {
                            if (BottlePreformBody(plc.deviceName, plc.location[i * 2], plc.address, i * 2 + 1))
                            {
                                PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 1}10d0a");
                                if (LineState.Keys.Contains(plc.location[i * 2]))
                                {
                                    LineState[plc.location[i * 2]].modify = DateTime.Now;
                                    LineState[plc.location[i * 2]].status = int.Parse(data);

                                }
                                else
                                {
                                    LineState.Add(plc.location[i * 2], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                                }
                            }
                        }
                        if (data.Substring(i * 4 + 3, 1) == "1")
                        {
                            if (BottlePreformBody(plc.deviceName, plc.location[i * 2 + 1], plc.address, i * 2 + 2))
                            {
                                PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 2}10d0a");
                            }
                        }
                    }

                }
            }
            catch (Exception)
            {

                throw;
            }



        }
        /// <summary>
        /// 瓶坯翻斗机信号处理，取满送空
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="location"></param>
        /// <returns></returns>
        private static bool BottlePreformBody(string deviceName, string bit, string ip, int index)
        {
            var result = false;

            if (bit != "")
            {

                if (LocationHelper.CheckLocFree(bit))
                {
                    var workOrder = MESHelper.GetWorkOrder(deviceName.Trim());
                    if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                    {

                        var locList = LocationHelper.GetLocListAny(new List<string> { bit });
                        if (locList.Count > 0)
                        {
                            var location = locList[0];
                            if (location.N_CURRENT_NUM == 0 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                ProcessHelperPP.PpFdjEmpty(workOrder, location);
                            }
                            else if (location.N_CURRENT_NUM == 1 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                var last = LocationHelper.GetLocCntrRel(location.S_LOC_CODE).OrderByDescending(x => x.T_CREATE).FirstOrDefault();
                                if (last != null)
                                {
                                    if (DateTime.Now.Subtract(last.T_CREATE).TotalSeconds < 60)
                                    {
                                        LogHelper.Info($"一分钟判定发送信号", "发送信号");
                                        PlcHelper.SendHex(ip, $"3f00{index}00d0a");
                                    }
                                    else
                                    {
                                        //超过1分钟，可能是新的满托取货请求，再生成取满任务
                                        //Console.WriteLine("超过1分钟，可能是新的满托取货请求，生成取满任务");
                                        var startCntr = LocationHelper.GetLocCntr(location.S_LOC_CODE).FirstOrDefault();
                                        if (startCntr != null)
                                        {
                                            //ProcessHelper.SetTrayInfoFull(workOrder, startCntr.Container);
                                            ProcessHelperPP.PpFdFull(workOrder, location, startCntr);
                                        }
                                        else
                                        {
                                            // Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                            LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                        }
                                    }
                                }
                                else
                                {
                                    //Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                    LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                }
                            }
                        }
                        else
                        {
                            // Console.WriteLine($"获取瓶坯机货位信息{bit}失败");
                            LogHelper.Info($"获取瓶坯机货位信息{bit}失败");
                        }

                    }
                    else
                    {
                        // Console.WriteLine($"瓶坯机：{deviceName}  未找到工单");
                        LogHelper.Info($"瓶坯机：{deviceName}  未找到工单");
                    }
                }



            }



            return result;

        }

        #endregion

        #region 瓶坯注塑机

        /// <summary>
        /// 判断plc下哪台设备
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        internal static void AnalysisPpZsj(string data, Settings.deviceInfo plc)
        {

            //3F 00 11 22 32 42 0d 0a
            //一个plc对应1个注塑机
            try
            {

                for (int i = 0; i < 1; i++)
                {
                    LogHelper.Info($"信号：{data},地址为：{plc.address}", "瓶坯");

                    if (data.Substring(i * 4 + 1, 1) == "1")
                    {
                        //Console.WriteLine("信号正常");
                        if (BottlePreformBodyZsj(plc.deviceName, plc.location[i * 2], plc.address, i * 2 + 1, int.Parse(plc.deviceNo[i * 0])))
                        {
                            PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 1}10d0a");

                        }

                        if (LineState.Keys.Contains(plc.location[i * 2]))
                        {
                            LineState[plc.location[i * 2]].modify = DateTime.Now;
                            LineState[plc.location[i * 2]].status = int.Parse(data);

                        }
                        else
                        {
                            LineState.Add(plc.location[i * 2], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                    }

                    if (data.Substring(i * 4 + 3, 1) == "1")
                    {
                        //Console.WriteLine("信号正常");
                        if (BottlePreformBodyZsj(plc.deviceName, plc.location[i * 2 + 1], plc.address, i * 2 + 2, int.Parse(plc.deviceNo[i * 2 + 1])))
                        {
                            PlcHelper.SendHex(plc.address, $"3F00{i * 2 + 2}10d0a");
                        }

                        if (LineState.Keys.Contains(plc.location[i * 2 + 1]))
                        {
                            LineState[plc.location[i * 2 + 1]].modify = DateTime.Now;
                            LineState[plc.location[i * 2 + 1]].status = int.Parse(data);

                        }
                        else
                        {
                            LineState.Add(plc.location[i * 2 + 1], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                    }



                }
            }
            catch (Exception)
            {

                throw;
            }



        }
        /// <summary>
        /// 瓶坯注塑机信号处理，取空下满
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="location"></param>
        /// <returns></returns>
        private static bool BottlePreformBodyZsj(string deviceName, string bit, string ip, int index, int deviceNo)
        {


            var result = false;

            if (bit != "")
            {

                if (LocationHelper.CheckLocFree(bit))
                {
                    Console.WriteLine("货位正常");
                    var workOrder = MESHelper.GetWorkOrder(deviceName);
                    if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                    {
                        Console.WriteLine("工单正常");
                        var locList = LocationHelper.GetLocListAny(new List<string> { bit });
                        if (locList.Count > 0)
                        {
                            var location = locList[0];
                            // LogHelper.Info($"数量：{location.N_CURRENT_NUM}，锁：{location.S_LOCK_STATE}", "任务");
                            if (location.N_CURRENT_NUM == 0 && location.S_LOCK_STATE.Trim() == "无")
                            {
                                ProcessHelperPP.PpZsjEmpty(workOrder, location);
                            }

                            else if (location.N_CURRENT_NUM == 1 && location.S_LOCK_STATE.Trim() == "无")
                            {

                                var last = LocationHelper.GetLocCntrRel(location.S_LOC_CODE).OrderByDescending(x => x.T_CREATE).FirstOrDefault();
                                if (last != null)
                                {

                                    if (DateTime.Now.Subtract(last.T_CREATE).TotalSeconds < 60)
                                    {
                                        LogHelper.Info($"一分钟判定发送信号", "发送信号");
                                        PlcHelper.SendHex(ip, $"3f00100d0a");
                                    }
                                    else
                                    {
                                        //超过1分钟，可能是新的满托取货请求，再生成取满任务
                                        //Console.WriteLine("超过1分钟，可能是新的满托取货请求，生成取满任务");
                                        var startCntr = LocationHelper.GetLocCntr(location.S_LOC_CODE).FirstOrDefault();
                                        if (startCntr != null)
                                        {
                                            //ProcessHelper.SetTrayInfoFull(workOrder, startCntr.Container);
                                            ProcessHelperPP.PpZsFull(workOrder, location, startCntr, deviceNo);
                                        }
                                        else
                                        {
                                            // Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                            LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                        }
                                    }
                                }
                                else
                                {
                                    //Console.WriteLine($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                    LogHelper.Info($"瓶坯机{bit}未找到绑定的托盘信息，请检查【货位容器表】");
                                }
                            }
                        }
                        else
                        {
                            Console.WriteLine($"获取瓶坯机货位信息{bit}失败");
                        }

                    }
                    else
                    {
                        Console.WriteLine($"瓶坯机：{deviceName}  未找到工单");
                    }
                }
                else
                {
                    LogHelper.Info($"{bit}货位有锁", "任务");
                }



            }
            //}


            return result;

        }


        #endregion

        private static Dictionary<string, DateTime> upLimitRecord = new Dictionary<string, DateTime>();
        #region 成品
        private static Dictionary<string, DateTime> emptyCall = new Dictionary<string, DateTime>();
        /// <summary>
        /// 成品下线信号处理
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        /// 
        internal static void AnalysisCp(string data, Settings.deviceInfo plc)
        {

            try
            {

                if (data.Length == 4)
                {
                    if (plc.deviceNo[0] == "1")
                    {
                        AnalysisFinishedProductXx(data, plc);
                    }
                    else if (plc.deviceNo[0] == "2")
                    {
                        AnalysisFinishedProductSx(data, plc);
                    }
                }
            }
            catch (Exception ex)
            {

                throw ex;
            }





        }
        /// <summary>
        /// 成品下线
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        private static void AnalysisFinishedProductXx(string data, Settings.deviceInfo plc)
        {
            #region 信号记录
            if (data.Length == 4)
            {
                int a = 1;
                if (plc.deviceName == "E12成品")
                {
                    a = 2;
                }
                if (LineState.Keys.Contains(plc.location[0]))
                {
                    LineState[plc.location[0]].modify = DateTime.Now;
                    LineState[plc.location[0]].status = int.Parse(data);
                    LineState[plc.location[0]].Zf = a;
                }
                else
                {
                    LineState.Add(plc.location[0], new statemodel { modify = DateTime.Now, status = int.Parse(data), Zf = a });
                }
            }
            #endregion
            try
            {

                if (plc.deviceName == "靖宇成品仓E11输送线")
                {
                    if (data.Substring(0, 2) == "11")
                    {

                        var start = LocationHelper.GetLoc(plc.location[0]);
                        //Console.WriteLine($"成品满托位{plc.location[0]}下线");
                        LogHelper.Info($"成品满托位{plc.location[0]}下线,deviceName:{plc.deviceName},address:{plc.address}", "成品");
                        if (start != null && start.S_LOCK_STATE == "无" && DateTime.Now.Subtract(start.T_MODIFY).TotalSeconds > 20)
                        {
                            var workOrder = MESHelper.GetWorkOrder1(plc.deviceName.Trim());
                            if (workOrder != null)
                            {
                                // int height = 0;
                                // height = ProcessHelperCP.GetTrayHeight(workOrder.S_ItemCode, workOrder.S_ItemLayer, workOrder.S_TrayType);

                                ProcessHelperCP.InStock(workOrder, plc.location[0]);
                            }
                            else
                            {
                                //Console.WriteLine($"未获取到成品设备执行中工单 {plc.deviceName}");
                            }
                        }
                        else
                        {
                            Console.WriteLine($"未获取到货位信息或起点终点有锁");
                        }
                    }

                }
                else if (plc.deviceName == "靖宇成品仓E12输送线")
                {
                    if (data.Substring(2, 2) == "21")
                    {
                        var start = LocationHelper.GetLoc(plc.location[0]);

                        //Console.WriteLine($"成品满托位{plc.location[0]}下线");
                        LogHelper.Info($"成品满托位{plc.location[0]}下线,deviceName:{plc.deviceName},address:{plc.address}", "成品");
                        if (start != null && start.S_LOCK_STATE == "无" && DateTime.Now.Subtract(start.T_MODIFY).TotalSeconds > 20)
                        {
                            var workOrder = MESHelper.GetWorkOrder1(plc.deviceName.Trim());
                            if (workOrder != null)
                            {
                                //int height = 0;

                                //height = ProcessHelperCP.GetTrayHeight(workOrder.S_ItemCode, workOrder.S_ItemLayer, workOrder.S_TrayType);

                                ProcessHelperCP.InStock(workOrder, plc.location[0]);
                            }
                            else
                            {
                                //Console.WriteLine($"未获取到成品设备执行中工单 {plc.deviceName}");
                            }
                        }
                        else
                        {
                            Console.WriteLine($"未获取到货位信息或起点终点有锁");
                        }
                    }



                }
                else
                {
                    if (data == "1220")
                    {
                        var start = LocationHelper.GetLoc(plc.location[0]);

                        //Console.WriteLine($"成品满托位{plc.location[0]}下线");
                        LogHelper.Info($"成品满托位{plc.location[0]}下线,deviceName:{plc.deviceName},address:{plc.address}", "成品");
                        if (start != null && start.S_LOCK_STATE == "无" && DateTime.Now.Subtract(start.T_MODIFY).TotalSeconds > 20)
                        {
                            var workOrder = MESHelper.GetWorkOrder1(plc.deviceName.Trim());
                            if (workOrder != null)
                            {
                                //int height = 0;

                                //height = ProcessHelperCP.GetTrayHeight(workOrder.S_ItemCode, workOrder.S_ItemLayer, workOrder.S_TrayType);

                                ProcessHelperCP.InStock(workOrder, plc.location[0]);
                            }
                            else
                            {
                                LogHelper.Info($"未获取到成品设备执行中工单 {plc.deviceName}", "成品");
                            }
                        }
                        else
                        {
                            LogHelper.Info($"未获取到货位信息或起点终点有锁", "成品");
                        }
                    }

                }
            }
            catch (Exception ex)
            {

                throw ex;
            }







        }

        /// <summary>
        /// 成品上线
        /// </summary>
        /// <param name="data"></param>
        /// <param name="plc"></param>
        private static void AnalysisFinishedProductSx(string data, Settings.deviceInfo plc)
        {
            #region 信号记录
            if (data.Length == 4)
            {
                if (LineState.Keys.Contains(plc.location[0]))
                {
                    LineState[plc.location[0]].modify = DateTime.Now;
                    LineState[plc.location[0]].status = int.Parse(data);

                }
                else
                {
                    LineState.Add(plc.location[0], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                }
            }
            #endregion
            var emptyCallOk = false;
            if (data == "1021")
            {

                if (emptyCall.Keys.Contains(plc.address))
                {
                    if (DateTime.Now.Subtract(emptyCall[plc.address]).TotalSeconds > 10)
                    {
                        emptyCallOk = true;
                        //Console.WriteLine($"{plc.deviceName}连续10s收到成功空托请求，可以呼叫空托");
                    }
                }
                else
                {
                    emptyCall.Add(plc.address, DateTime.Now);
                }
            }




            //空托上线 if (data.Substring(5, 1) == "1" && (plc.deviceType == 12 || data.Substring(3, 1) == "1")) {
            if (emptyCallOk)
            {
                //从空托线边出库一个托盘
                var end = LocationHelper.GetLoc(plc.location[0]);
                if (end != null && end.S_LOCK_STATE == "无" && DateTime.Now.Subtract(end.T_MODIFY).TotalSeconds > 20)
                {
                    var workOrder = MESHelper.GetWorkOrder1(plc.deviceName);
                    bool outStock = false;
                    if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                    {
                        //var size = workOrder.S_TrayType == "超托板" ? "集化板" : workOrder.S_TrayType;
                        //Console.WriteLine($"{plc.deviceName}成品空托双托呼叫");
                        var area = Settings.cpZones.Where(a => a.zoneType == 3).FirstOrDefault();
                        if (area != null)
                        {
                            //Console.WriteLine($"空托起点区域{area.zone[0]}");
                            var trayType = "";
                            if (plc.deviceType == 5)
                            {
                                trayType = workOrder.S_TrayType;
                            }
                            if (trayType == "集化板前后超托" || trayType == "集化板四面超托")
                            {
                                trayType = "集化板";
                            }
                            else if (trayType == "大板前后超托")
                            {
                                trayType = "大板";
                            }
                            else if (trayType == "小板前后超托")
                            {
                                trayType = "小板";
                            }

                            var start = LocationHelper.GetLocation4OutEmptyNotStack(area.zone[0], trayType);
                            //if (start == null)
                            //{
                            //    //从仓库叫空托
                            //    start = ProcessHelperCP.GetLocation4EmptyCntrOut(size);
                            //    if (start != null)
                            //    {
                            //        outStock = true;
                            //    }
                            //}
                            if (start != null)
                            {
                                LogHelper.Info($"空托上线{plc.location[0]},address:{plc.address}", "成品");
                                //创建出库库搬运任务
                                var cntrList = LocationHelper.GetLocCntr(start.S_LOC_CODE);
                                var bussType = outStock ? "栈板上线" : "栈板上线";
                                TaskProcess.CreateTransport(start.S_LOC_CODE, plc.location[0], bussType, new List<string> { cntrList[0].S_CNTR_CODE.Trim() }, cntrList.Count, 1, 1, 80);
                            }
                        }
                    }
                }
                else
                {
                    //Console.WriteLine($"成品空托位{plc.location[1]}有任务，或者状态更新不超过20s，不可生成任务");
                }
            }

        }

        #endregion

        #region 顶升机


        internal static void DingShengji(string data, Settings.deviceInfo plc)
        {

            try
            {
                var workOrder = MESHelper.GetWorkOrderdsj(plc.deviceName);
                if (workOrder != null && workOrder.S_WorkState.Trim() == "执行中")
                {
                    string[] DsjLocarea = new string[] { "FLZD", "ZXZD", "LYPZD" };//顶升级下线对应库区编码
                    string startloc = "";
                    string endloc = "";
                    // string cntrtype = "";
                    // string bussType = "";
                    if (data == "112030")
                    {
                        #region 信号记录
                        if (LineState.Keys.Contains(plc.location[0]))
                        {
                            LineState[plc.location[0]].modify = DateTime.Now;
                            LineState[plc.location[0]].status = int.Parse(data);
                        }
                        else
                        {
                            LineState.Add(plc.location[0], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                        #endregion
                        startloc = plc.location[0];
                        endloc = LocationHelper.GetLocListAny(DsjLocarea[0]).FindAll(a => a.N_CURRENT_NUM == 0).OrderBy(a => a.N_COL).First().S_LOC_CODE;
                        if (!string.IsNullOrEmpty(startloc) && !string.IsNullOrEmpty(endloc))
                        {
                            var locList = LocationHelper.GetLocListAny(new List<string> { startloc });
                            if (locList.Count > 0)
                            {
                                if (locList[0].S_LOCK_STATE.Trim() == "无")
                                {
                                    ProcessHelperCP.DsjStock(startloc, endloc);
                                }
                                else
                                {
                                    LogHelper.Info($"起点货位：{startloc}存在锁", "顶升机");
                                }
                            }
                        }
                        else
                        {
                            LogHelper.Info($"起点货位：{startloc},终点货位：{endloc}存在空值", "顶升机");
                        }

                    }
                    else if (data == "102130")
                    {
                        #region 信号记录
                        if (LineState.Keys.Contains(plc.location[1]))
                        {
                            LineState[plc.location[1]].modify = DateTime.Now;
                            LineState[plc.location[1]].status = int.Parse(data);
                        }
                        else
                        {
                            LineState.Add(plc.location[1], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                        #endregion
                        startloc = plc.location[1];
                        var endlocList = LocationHelper.GetLocListAny(DsjLocarea[1]).OrderBy(a => a.N_ROW).ToList();
                        // endloc = LocationHelper.GetLocListAny(DsjLocarea[1]).OrderBy(a => a.N_ROW).First().S_LOC_CODE;
                        if (endlocList.Count > 0)
                        {
                            var end = ProcessHelperPP.FindEndcolByLocList(endlocList);
                            if (end != null)
                            {
                                endloc = end.S_LOC_CODE;
                            }
                            if (!string.IsNullOrEmpty(startloc) && !string.IsNullOrEmpty(endloc))
                            {
                                var locList = LocationHelper.GetLocListAny(new List<string> { startloc });
                                if (locList.Count > 0)
                                {
                                    if (locList[0].S_LOCK_STATE.Trim() == "无")
                                    {
                                        ProcessHelperCP.DsjStock(startloc, endloc);
                                    }
                                    else
                                    {
                                        LogHelper.Info($"起点货位：{startloc}存在锁", "顶升机");
                                    }

                                }
                            }
                            else
                            {
                                LogHelper.Info($"起点货位：{startloc},终点货位：{endloc}存在空值", "顶升机");
                            }
                        }
                        else
                        {
                            LogHelper.Info($"根据库区：{DsjLocarea[1]}，未找到货位", "顶升机");
                        }
                    }
                    else if (data == "102031")
                    {
                        #region 信号记录
                        if (LineState.Keys.Contains(plc.location[2]))
                        {
                            LineState[plc.location[2]].modify = DateTime.Now;
                            LineState[plc.location[2]].status = int.Parse(data);
                        }
                        else
                        {
                            LineState.Add(plc.location[2], new statemodel { modify = DateTime.Now, status = int.Parse(data) });
                        }
                        #endregion
                        startloc = plc.location[2];
                        //  var endlocList = LocationHelper.GetLocListAny(DsjLocarea[2]).OrderBy(a => a.N_ROW).ToList();

                        endloc = LocationHelper.GetLocListAny(DsjLocarea[2]).FindAll(a => a.N_CURRENT_NUM == 0).OrderBy(a => a.N_COL).First().S_LOC_CODE;
                        if (endloc != null)
                        {
                            var locList = LocationHelper.GetLocListAny(new List<string> { startloc });
                            if (locList.Count > 0)
                            {
                                if (locList[0].S_LOCK_STATE.Trim() == "无")
                                {
                                    ProcessHelperCP.DsjStock(startloc, endloc);
                                }
                                else
                                {
                                    LogHelper.Info($"起点货位：{startloc}存在锁", "顶升机");
                                }

                            }
                        }
                        else
                        {
                            LogHelper.Info($"起点货位：{startloc},终点货位：{endloc}存在空值", "顶升机");
                        }
                    }

                }
                else
                {
                    LogHelper.Info($"未获取到顶升机执行中工单 {plc.deviceName}", "顶升机");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"DsjStock-Error:{ex.ToString()}", "顶升机");
            }
        }
        #endregion
    }





}