using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using HH.WCS.JingyuNongfu.util;
using HH.WCS.JingyuNongfu.wms;
using static HH.WCS.JingyuNongfu.util.Settings;

namespace HH.WCS.JingyuNongfu.process
{
    /// <summary>
    /// 瓶坯流程
    /// </summary>
    internal class ProcessHelperPP
    {
        private static object _lockKkzy1 = new object();
        // private static object _lockKkzy2 = new object();

        private static object _lockMkzy = new object();
        private static object _lockPGFDJ = new object();
        private static object _lockPG = new object();
        private static object _lockPPFDJSX = new object();
        private static object _lockPPFDJXX = new object();
        private static object _lockPPZSJSX = new object();
        private static object _lockPPZSJXX = new object();

        internal static void PpAuto()
        {

            //int a = 111;
            EmptyBagTransport();


            FullLineTransportByWord();
            FullBagTransportPGFDJ();
            DdqTransport();
            WjpTransport();
            var list = Settings.Gettransport.ToList();
            foreach (var item in list)
            {
                immobilizationLocTask(item.startloc, item.endloc);
            }


        }


        //---------------------------------20240619版本---------------------------------

        /// <summary>
        /// 瓶盖翻斗机上满
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        internal static void PgEmpty1(WorkOrder workOrder, Location location)
        {

            lock (_lockPG)
            {
                try
                {
                    Location start = null; int startLayer = 1;
                    // var cntrCode = string.Empty;
                    //var iron = false;

                    zoneInfo startZone = new zoneInfo();

                    var bussType = "";
                    LogHelper.Info($"瓶盖翻斗机上满：当前工单产线:{workOrder.S_PLineNo}无可用货位");
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "翻斗机即产满筐上线（瓶盖）";
                        if (workOrder.S_PLineNo.Contains("二期"))
                        {
                            bussType = "二期翻斗机即产满筐上线（瓶盖）";
                            if (workOrder.S_LinkLineNO.Contains("水盖"))
                            {
                                startZone = Settings.ppZones.Where(a => a.zoneType == 15 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                            }
                            else
                            {
                                startZone = Settings.ppZones.Where(a => a.zoneType == 15 && a.deviceName == workOrder.S_LinkLineNO).FirstOrDefault();
                            }
                        }
                        else
                        {
                            startZone = Settings.ppZones.Where(a => a.zoneType == 0 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                        }

                    }
                    else
                    {
                        bussType = "翻斗机库存满筐上线（瓶盖）";
                        if (workOrder.S_PLineNo.Contains("二期"))
                        {
                            bussType = "二期翻斗机库存满筐上线（瓶盖）";
                            startZone = Settings.ppZones.Where(a => a.zoneType == 13 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                        }
                        else
                        {
                            LogHelper.Info($"当前产线:{workOrder.S_PLineNo}没有非即产急用库区");
                        }
                    }
                    if (startZone != null)
                    {
                        LogHelper.Info($"瓶盖翻斗机上满：当前库区:{startZone}，计算货位");
                        //计算开始货位
                        var StartLocList = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                        if (StartLocList.Count > 0)
                        {
                            start = FindStartcolByLoclistAndCol(StartLocList);
                        }
                        else
                        {
                            LogHelper.Info($"瓶盖翻斗机上满:根据库区{startZone.zone}找不到对应货位");
                        }
                        //start = FindStartcolByLoclist(StartLocList);

                    }
                    else
                    {
                        LogHelper.Info($"瓶盖翻斗机上满:根据工单{workOrder.S_WorkNo}找不到对应库区");
                    }
                    //二期即产即用库区无货位 找非即产即用库区
                    if (start == null && workOrder.S_PLineNo.Contains("二期") && workOrder.S_UsingNow.Trim() == "Y")
                    {
                        LogHelper.Info($"瓶盖翻斗机上满：当前库区:{startZone}无可用货位，二期即产急用，切换非即产即用库区");
                        bussType = "二期翻斗机库存满筐上线（瓶盖）";
                        startZone = Settings.ppZones.Where(a => a.zoneType == 13).FirstOrDefault();
                        if (startZone != null)
                        {
                            //计算开始货位
                            var StartLocList = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                            if (StartLocList.Count > 0)
                            {
                                start = FindStartcolByLoclistAndCol(StartLocList);
                            }
                        }
                    }
                    if (start != null)
                    {
                        var shelf1Info = LocationHelper.GetLocCntrRel(start.S_LOC_CODE);
                        if (bussType == "二期翻斗机即产满筐上线（瓶盖）")
                        {
                            if (shelf1Info[0].Container.S_TYPE != "铁托盘")
                            {
                                LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                return;
                            }
                        }
                        else
                        {
                            if (shelf1Info[0].Container.S_TYPE != "塑料托盘")
                            {
                                LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                return;
                            }
                        }
                        if (shelf1Info.Count > 0)
                        {
                            if (start.N_CURRENT_NUM == 2)
                            {
                                startLayer = 2;
                            }
                            TaskProcess.CreateTransport(start.S_LOC_CODE, location.S_LOC_CODE, bussType, new List<string> { shelf1Info[0].S_CNTR_CODE }, startLayer, 1, 1, 80);

                        }
                    }
                    else
                    {
                        LogHelper.Info($"当前库区:{startZone}无可用货位");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjEmpty " + ex.Message);
                }
            }
        }
        /// <summary>
        /// 瓶坯翻斗机上满
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        internal static void PpFdjEmpty(WorkOrder workOrder, Location location)
        {
            lock (_lockPPFDJSX)
            {
                try
                {
                    Location start = null; int startLayer = 1; //Location end = null;
                    var cntrCode = string.Empty;
                    //var iron = false;
                    zoneInfo startZone;
                    //zoneInfo EndZone;
                    List<Location> locLists = null;
                    var bussType = "瓶坯注塑机下满";
                    LogHelper.Info($"瓶坯翻斗机上满：当前工单产线:{workOrder.S_PLineNo}无可用货位");
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        if (workOrder.S_UsingNow.Trim() == "Y")
                        {
                            bussType = "二期翻斗机即产满筐上线（瓶胚）";
                        }
                        else
                        {
                            bussType = "翻斗机即产满筐上线（瓶胚）";
                        }

                    }
                    else
                    {
                        if (workOrder.S_UsingNow.Trim() == "Y")
                        {
                            bussType = "二期翻斗机库存满筐上线（瓶胚）";
                        }
                        else
                        {
                            bussType = "翻斗机库存满筐上线（瓶胚）";
                        }

                    }
                    //即产即用和非即产即用流程一样
                    //找瓶坯线边满框缓存区

                    startZone = Settings.ppZones.Where(a => a.zoneType == 2 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();


                    if (!string.IsNullOrEmpty(startZone.zone))
                    {
                        //根据货位编码获取货位信息
                        locLists = LocationHelper.GetLocListAny(startZone.zone).Where(a => a.N_CURRENT_NUM == 1).OrderBy(a => a.N_ROW).ToList();
                    }


                    //找开始货位
                    if (locLists.Count > 0)
                    {
                        #region MyRegion
                        //判断空框出库区同排有没有锁
                        //var rowsStart = locLists.Select(a => a.N_ROW).Distinct().ToList();
                        //for (int i = 0; i < rowsStart.Count; i++)
                        //{
                        //    var rowList = locLists.Where(r => r.N_ROW == rowsStart[i]).ToList().OrderByDescending(a => a.N_COL);
                        //    if (rowList.Count(a => a.S_LOCK_STATE.Trim() != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM == 1) > 0)
                        //    {
                        //        Location other = null;
                        //        //当前排没有锁并且有空位置
                        //        //找到最大的空位（先找满位，然后后面一位要么是空，要么不存在）
                        //        var full = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 1).FirstOrDefault();
                        //        if (full != null)
                        //        {
                        //            other = full;
                        //        }

                        //        if (other != null)
                        //        {
                        //            if (start == null)
                        //            {
                        //                var time = LocationHelper.GetLocListAnybycode(start.S_LOC_CODE).FirstOrDefault();
                        //                var t = int.Parse(Time);
                        //                if (DateTime.Now.Subtract(time.T_MODIFY).TotalSeconds > 60 * t)
                        //                {
                        //                    start = other;
                        //                    break;
                        //                }
                        //            }

                        //        }
                        //    }
                        //}
                        #endregion

                        //计算开始货位
                        start = FindStartcolByTime(locLists);
                        if (start != null)
                        {

                            //根据货位编码查货位容器表
                            var shelf1Info = LocationHelper.GetLocCntrRel(start.S_LOC_CODE);
                            if (shelf1Info.Count > 0)
                            {

                                cntrCode = shelf1Info[0].S_CNTR_CODE;
                                TaskProcess.CreateTransport(start.S_LOC_CODE, location.S_LOC_CODE, bussType, new List<string> { cntrCode }, startLayer, 1, 1, 90);
                            }
                            else
                            {

                                LogHelper.Info($"根据货位{start.S_LOC_CODE}找不到货位容器表", "瓶坯");
                            }


                        }

                    }
                    else
                    {

                        LogHelper.Info($"{workOrder.S_PLineNo}上满找不到满框区货位", "瓶坯");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjEmpty " + ex.Message);
                }
            }


        }
        /// <summary>
        /// 瓶盖注塑机上空
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        internal static void PgZsjEmpty(WorkOrder workOrder, Location location)
        {

            lock (_lockPG)
            {
                try
                {
                    Location start = null; int startLayer = 1;
                    // var cntrCode = string.Empty;
                    //var iron = false;

                    zoneInfo startZone = new zoneInfo();

                    var bussType = "";
                    LogHelper.Info($"瓶盖翻斗机上满：当前工单产线:{workOrder.S_PLineNo}无可用货位");
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "二期注塑机即产空筐上线（瓶盖）";

                        startZone = Settings.ppZones.Where(a => a.zoneType == 16).FirstOrDefault();
                    }
                    else
                    {
                        bussType = "二期注塑机库存空筐上线（瓶盖）";

                        startZone = Settings.ppZones.Where(a => a.zoneType == 17).FirstOrDefault();

                    }
                    //计算开始货位
                    if (startZone != null)
                    {
                        LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone}，计算货位");
                        var StartLocList = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                        if (StartLocList.Count > 0)
                        {
                            start = FindStartcolByLoclistAndCol(StartLocList);
                        }
                    }
                    else
                    {
                        LogHelper.Info($"瓶盖翻斗机上满:根据工单{workOrder.S_WorkNo}找不到对应库区");
                    }

                    //start = FindStartcolByLoclist(StartLocList);
                    //二期即产即用库区无货位 找非即产即用库区
                    if (start == null && workOrder.S_PLineNo.Contains("二期") && workOrder.S_UsingNow.Trim() == "Y")
                    {
                        LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone}无可用货位，二期即产急用，切换非即产即用库区");
                        bussType = "二期注塑机库存空筐上线（瓶盖）";
                        startZone = Settings.ppZones.Where(a => a.zoneType == 14).FirstOrDefault();
                        if (startZone != null)
                        {
                            //计算开始货位
                            var StartLocListqh = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                            if (StartLocListqh.Count > 0)
                            {
                                start = FindStartcolByLoclistAndCol(StartLocListqh);
                            }
                        }
                    }

                    if (start != null)
                    {
                        var shelf1Info = LocationHelper.GetLocCntrRel(start.S_LOC_CODE);
                        if (bussType.Contains("二期"))
                        {

                            if (bussType == "二期注塑机即产空筐上线（瓶盖）")
                            {
                                if (shelf1Info[0].Container.S_TYPE != "铁托盘")
                                {
                                    LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                    return;
                                }
                            }
                            else
                            {
                                if (shelf1Info[0].Container.S_TYPE != "塑料托盘")
                                {
                                    LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                    return;
                                }
                            }
                        }
                        if (shelf1Info.Count > 0)
                        {
                            TaskProcess.CreateTransport(start.S_LOC_CODE, location.S_LOC_CODE, bussType, new List<string> { shelf1Info[0].S_CNTR_CODE }, startLayer, 1, 1, 80);
                        }
                    }
                    else
                    {
                        LogHelper.Info($"当前库区:{startZone}无可用货位");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjEmpty " + ex.Message);
                }
            }
        }
        /// <summary>
        /// 瓶盖无菌坯上空
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        internal static void WjEmpty(WorkOrder workOrder, Location location)
        {

            lock (_lockPG)
            {
                try
                {
                    Location start = null; int startLayer = 1;
                    // var cntrCode = string.Empty;
                    //var iron = false;

                    zoneInfo startZone = new zoneInfo();

                    var bussType = "";
                    LogHelper.Info($"二期无菌上空：当前工单产线:{workOrder.S_PLineNo}无可用货位");
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "二期无菌即产空筐上线（瓶盖）";

                        startZone = Settings.ppZones.Where(a => a.zoneType == 21).FirstOrDefault();
                    }
                    else
                    {
                        bussType = "二期无菌库存空筐上线（瓶盖）";

                        startZone = Settings.ppZones.Where(a => a.zoneType == 14).FirstOrDefault();
                    }

                    LogHelper.Info($"二期无菌上空：当前库区:{startZone}，计算货位");
                    //计算开始货位
                    var StartLocList = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                    if (StartLocList.Count > 0)
                    {
                        start = FindStartcolByLoclistAndCol(StartLocList);
                    }
                    //start = FindStartcolByLoclist(StartLocList);

                    if (start == null && workOrder.S_PLineNo.Contains("二期") && workOrder.S_UsingNow.Trim() == "Y")
                    {
                        LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone}无可用货位，二期即产急用，切换非即产即用库区");
                        bussType = "二期无菌库存空筐上线（瓶盖）";
                        startZone = Settings.ppZones.Where(a => a.zoneType == 14).FirstOrDefault();
                        if (startZone != null)
                        {
                            //计算开始货位
                            var StartLocListqh = LocationHelper.GetLocListAny(startZone.zone).OrderBy(a => a.N_ROW).ToList();

                            if (StartLocListqh.Count > 0)
                            {
                                start = FindStartcolByLoclistAndCol(StartLocListqh);
                            }
                        }
                    }
                    if (start != null)
                    {
                        var shelf1Info = LocationHelper.GetLocCntrRel(start.S_LOC_CODE);
                        if (shelf1Info.Count > 0)
                        {
                            if (bussType == "二期无菌即产空筐上线（瓶盖）")
                            {
                                if (shelf1Info[0].Container.S_TYPE != "铁托盘")
                                {
                                    LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                    return;
                                }
                            }
                            else
                            {
                                if (shelf1Info[0].Container.S_TYPE != "塑料托盘")
                                {
                                    LogHelper.Info($"瓶盖注塑机上空：当前库区:{startZone.zone},托盘类型{shelf1Info[0].Container.S_TYPE},托盘类型不对，不生成任务");
                                    return;
                                }
                            }
                            TaskProcess.CreateTransport(start.S_LOC_CODE, location.S_LOC_CODE, bussType, new List<string> { shelf1Info[0].S_CNTR_CODE }, startLayer, 1, 1, 80);

                        }
                    }
                    else
                    {
                        LogHelper.Info($"当前库区:{startZone}无可用货位");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjEmpty " + ex.Message);
                }
            }
        }

        /// <summary>
        /// 瓶盖注塑机下满
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        /// <param name="lcr"></param>
        internal static void PgZsjFull(WorkOrder workOrder, Location location, LocCntrRel lcr)
        {
            try
            {

                Location end = null; var endLayer = 1;
                var bussType = "注塑机即产满筐下线（瓶盖）";
                zoneInfo zone = new zoneInfo();
                if (lcr.Container.S_TYPE == "铁托盘")
                {
                    bussType = "注塑机即产满筐下线（瓶盖）";

                    zone = Settings.ppZones.Where(a => a.zoneType == 15 && a.deviceName == workOrder.S_LinkLineNO).FirstOrDefault();

                }
                else
                {
                    bussType = "注塑机库存满筐下线（瓶盖）";
                    zone = Settings.ppZones.Where(a => a.zoneType == 18 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();

                }
                //找空框入库区

                if (zone != null)
                {
                    //按排进行排序，优先入库 低排低列
                    var list = LocationHelper.GetLocListAny(zone.zone).OrderBy(a => a.N_ROW).ToList();

                    end = FindEndcolByLocList(list);

                }
                else
                {
                    LogHelper.Info($"瓶盖注塑机下满:根据工单{workOrder.S_WorkNo}找不到对应库区");
                }

                if (end != null)
                {
                    TaskProcess.CreateTransport(location.S_LOC_CODE, end.S_LOC_CODE, bussType, new List<string> { lcr.S_CNTR_CODE }, 1, endLayer, 1, 80);
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("ZsjFull " + ex.Message);
            }
        }

        /// <summary>
        /// 瓶盖无菌坯下满
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        /// <param name="lcr"></param>
        internal static void WjpFull(WorkOrder workOrder, Location location, LocCntrRel lcr)
        {
            try
            {

                Location end = null; var endLayer = 1;
                var bussType = "瓶盖无菌坯下满";
                zoneInfo zone = new zoneInfo();
                if (lcr.Container.S_TYPE == "铁托盘")
                {
                    zone = Settings.ppZones.Where(a => a.zoneType == 19).FirstOrDefault();

                }
                else
                {
                    zone = Settings.ppZones.Where(a => a.zoneType == 18 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                }
                //找空框入库区

                if (zone != null)
                {
                    //按排进行排序，优先入库 低排低列
                    var list = LocationHelper.GetLocListAny(zone.zone).OrderBy(a => a.N_ROW).ToList();

                    end = FindEndcolByLocList2(list);

                }


                if (end != null)
                {
                    if (end.N_CURRENT_NUM == 1)
                    {
                        endLayer = 2;
                    }
                    TaskProcess.CreateTransport(location.S_LOC_CODE, end.S_LOC_CODE, bussType, new List<string> { lcr.S_CNTR_CODE }, 1, endLayer, 1, 80);
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("ZsjFull " + ex.Message);
            }
        }

        /// <summary>
        /// 瓶坯注塑机上空
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        internal static void PpZsjEmpty(WorkOrder workOrder, Location location)
        {
            lock (_lockPPZSJSX)
            {
                try
                {
                    Location start = null; int startLayer = 1;// Location end = null;
                    var cntrCode = string.Empty;
                    // var iron = false;
                    //zoneInfo startZone;
                    zoneInfo EndZone = new zoneInfo();
                    //List<Location> locLists = null;
                    List<Location> locendLists = null;
                    var bussType = "瓶坯注塑机上空";

                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "注塑即产空筐上线（瓶胚）";
                    }
                    else
                    {
                        bussType = "注塑库存空筐上线（瓶胚）";
                    }


                    //找空框套袋转运区
                    EndZone = Settings.ppZones.Where(a => a.zoneType == 11).FirstOrDefault();
                    locendLists = LocationHelper.GetLocListAny(EndZone.zone).Where(a => a.N_CURRENT_NUM == 1).OrderBy(a => a.N_ROW).ToList();
                    if (locendLists.Count <= 0)
                    {
                        //找瓶坯下空专用空框套袋区
                        EndZone = Settings.ppZones.Where(a => a.zoneType == 10).FirstOrDefault();
                        locendLists = LocationHelper.GetLocListAny(EndZone.zone).Where(a => a.N_CURRENT_NUM == 1).OrderBy(a => a.N_ROW).ToList();
                    }

                    //找空框套袋货位
                    if (locendLists.Count > 0)
                    {
                        start = FindStartcolByTime(locendLists);

                    }


                    if (start != null)
                    {

                        var shelf1Info = LocationHelper.GetLocCntrRel(start.S_LOC_CODE);
                        if (shelf1Info.Count <= 0)
                        {
                            Console.WriteLine($"根据{start.S_LOC_CODE}未找到空托盘，请检查货位容器表");
                        }
                        else
                        {
                            //托盘绑定本来送去区域
                            var startCntr = LocationHelper.GetLocCntr(start.S_LOC_CODE).FirstOrDefault();
                            if (startCntr != null)
                            {
                                // ProcessHelper.SetTrayInfoFull1(workOrder, startCntr.Container, start.S_LOC_CODE, location.S_LOC_CODE);

                                TaskProcess.CreateTransport(start.S_LOC_CODE, location.S_LOC_CODE, bussType, new List<string> { shelf1Info[0].S_CNTR_CODE }, startLayer, 1, 1, 80);
                            }
                            else
                            {
                                LogHelper.Info($"根据货位编码{start.S_LOC_CODE}，未找到托盘，请检查货位容器表", "任务");
                            }

                        }

                    }
                    else
                    {
                        LogHelper.Info($"未找到空框套袋区货位", "任务");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }


        }

        /// <summary>
        /// 瓶盖翻斗机下空
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        /// <param name="lcr"></param>
        internal static void PgFdFull(WorkOrder workOrder, Location location, LocCntrRel lcr)
        {
            try
            {

                Location end = null; var endLayer = 1;
                var bussType = "翻斗机即产空筐下线（瓶盖）";
                zoneInfo zone = new zoneInfo();
                if (lcr.Container.S_TYPE == "铁托盘")
                {
                    bussType = "翻斗机即产空筐下线（瓶盖）";
                    if (workOrder.S_PLineNo.Contains("二期"))
                    {
                        zone = Settings.ppZones.Where(a => a.zoneType == 16 && a.deviceName == workOrder.S_LinkLineNO).FirstOrDefault();
                    }
                }
                else
                {
                    if (workOrder.S_PLineNo.Contains("二期"))
                    {
                        bussType = "翻斗机库存空筐下线（瓶盖）";
                        zone = Settings.ppZones.Where(a => a.zoneType == 14).FirstOrDefault();
                    }
                }
                //找空框入库区

                if (zone != null)
                {
                    //按排进行排序，优先入库 低排低列
                    var list = LocationHelper.GetLocListAny(zone.zone).OrderBy(a => a.N_ROW).ToList();
                    if (list.Count > 0)
                    {
                        end = FindEndcolByLocList(list);
                    }
                    else
                    {
                        LogHelper.Info($"翻斗机下空，根据库区编码{zone.zone}找不到对应货位+");
                    }
                }
                else
                {
                    LogHelper.Info($"翻斗机下空，找不到对应库区");
                }
                if (end != null)
                {
                    TaskProcess.CreateTransport(location.S_LOC_CODE, end.S_LOC_CODE, bussType, new List<string> { lcr.S_CNTR_CODE }, 1, endLayer, 1, 80);
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("ZsjFull " + ex.Message);
            }
        }
        /// <summary>
        /// 瓶坯翻斗机下空
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        /// <param name="lcr"></param>
        internal static void PpFdFull(WorkOrder workOrder, Location location, LocCntrRel lcr)
        {
            lock (_lockPPFDJXX)
            {
                try
                {
                    LogHelper.Info($"{workOrder.S_PLineNo}下线货位计算", "任务");
                    Location end = null; var endLayer = 1;// Location endtd = null;
                    zoneInfo zone = null; zoneInfo EndZone = null;
                    List<Location> list = null; List<Location> locendLists = null;
                    LogHelper.Info($"瓶坯翻斗机下空：当前工单产线:{workOrder.S_PLineNo}");
                    var bussType = "瓶坯翻斗机下空入放置区";
                    //即产即用
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "翻斗机即产空筐下线（瓶胚）";

                    }
                    //非即产即用
                    else
                    {
                        bussType = "翻斗机库存空筐下线（瓶胚）";

                    }

                    //找空框套袋区
                    if (workOrder.S_PLineNo.Contains("二期"))
                    {
                        EndZone = Settings.ppZones.Where(a => a.zoneType == 12).FirstOrDefault();
                        locendLists = LocationHelper.GetLocListAny(EndZone.zone).Where(a => a.N_CURRENT_NUM == 0).OrderBy(a => a.N_ROW).ToList();
                        list = LocationHelper.GetLocListAny(EndZone.zone).OrderBy(a => a.N_ROW).ToList();
                        end = FindEndcolByLocList(list);
                    }
                    else
                    {
                        EndZone = Settings.ppZones.Where(a => a.zoneType == 11).FirstOrDefault();
                        //计算线边是否有可下空货位
                        locendLists = LocationHelper.GetLocListAny(EndZone.zone).Where(a => a.N_CURRENT_NUM == 0).OrderBy(a => a.N_ROW).ToList();
                        list = LocationHelper.GetLocListAny(EndZone.zone).OrderBy(a => a.N_ROW).ToList();
                        end = FindEndcolByLocList(list);
                        //空框套袋区无可下空货位 找空框入库区
                        if (end == null)
                        {
                            //找瓶坯下空专用空框套袋区
                            EndZone = Settings.ppZones.Where(a => a.zoneType == 6).FirstOrDefault();
                            locendLists = LocationHelper.GetLocListAny(EndZone.zone).Where(a => a.N_CURRENT_NUM == 0).OrderBy(a => a.N_ROW).ToList();
                            if (locendLists.Count > 0)
                            {

                                //根据终点库区找下线货位
                                list = LocationHelper.GetLocListAny(EndZone.zone).OrderBy(a => a.N_ROW).ToList();
                                if (list.Count > 0)
                                {
                                    end = FindEndcolByLocList(list);
                                }

                            }

                        }

                    }



                    if (end != null)
                    {
                        LogHelper.Info($"{workOrder.S_PLineNo}下线货位计算终点{end.S_LOC_CODE}", "任务");
                        TaskProcess.CreateTransport(location.S_LOC_CODE, end.S_LOC_CODE, bussType, new List<string> { lcr.S_CNTR_CODE }, 1, endLayer, 1, 90);
                    }
                    else
                    {
                        LogHelper.Info($"{workOrder.S_PLineNo}下空无可用货位，请检查空框线边区和入库区", "任务");
                    }

                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjFull " + ex.Message);
                }
            }

        }
        /// <summary>
        /// 瓶坯注塑机下满
        /// </summary>
        /// <param name="workOrder"></param>
        /// <param name="location"></param>
        /// <param name="lcr"></param>
        internal static void PpZsFull(WorkOrder workOrder, Location location, LocCntrRel lcr, int deviceNo)
        {
            lock (_lockPPZSJXX)
            {
                try
                {
                    Location end = null; var endLayer = 1;
                    zoneInfo zone = null;
                    List<Location> list = null;
                    var bussType = "瓶坯注塑机下满";
                    //即产即用
                    if (workOrder.S_UsingNow.Trim() == "Y")
                    {
                        bussType = "注塑即产满筐下线（瓶胚）";
                        zone = Settings.ppZones.Where(a => a.zoneType == 2 && a.deviceName == workOrder.S_LinkLineNO).FirstOrDefault();
                        //根据终点库区找下线货位
                        list = LocationHelper.GetLocListAny(zone.zone).OrderBy(a => a.N_ROW).ToList();

                    }
                    //非即产即用
                    else
                    {
                        bussType = "注塑库存满筐下线（瓶胚）";
                        zone = Settings.ppZones.Where(a => a.zoneType == 7 && a.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                        //根据终点库区找下线货位
                        list = LocationHelper.GetLocListAny(zone.zone).Where(a => a.N_ROW == deviceNo).ToList();
                    }


                    //找终点入库区域
                    if (list.Count > 0)
                    {
                        end = FindEndcolByLocList(list);

                    }
                    else
                    {
                        LogHelper.Info($"{workOrder.S_PLineNo}找不到满框线边区", "瓶坯");

                    }
                    //找转运货位
                    //var Zyzone = Settings.ppZones.Where(a => a.zoneType == 7).FirstOrDefault();
                    if (end != null)
                    {

                        //托盘绑定本来送去区域
                        //ProcessHelper.SetTrayInfoZone(lcr.Container, location.S_LOC_CODE, Zyzone.zone);


                        TaskProcess.CreateTransport(location.S_LOC_CODE, end.S_LOC_CODE, bussType, new List<string> { lcr.S_CNTR_CODE }, 1, endLayer, 1, 80);


                    }
                    else
                    {
                        LogHelper.Info($"{workOrder.S_PLineNo}容器找不到目的地，请检查满框入库区和瓶坯满框入库区", "瓶坯");

                    }

                }
                catch (Exception ex)
                {
                    Console.WriteLine("ZsjFull " + ex.Message);
                }
            }

        }

        /// <summary>
        /// 找终点空货位
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindEndcolByLocList(List<Location> locations)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                Location end = null;
                //根据终点货位找空闲货位
                var rows = locations.Select(a => a.N_ROW).Distinct().ToList();
                for (int i = 0; i < rows.Count; i++)
                {
                    var rowList = locations.Where(r => r.N_ROW == rows[i]).ToList();
                    if (rowList.Count(a => a.S_LOCK_STATE != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM == 0) > 0)
                    {
                        Location other = null;
                        //当前排没有锁并且有空位置
                        //先找满位，然后后面一位要么是空，要么不存在
                        var full = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 1).FirstOrDefault();
                        if (full == null)
                        {
                            //没有满位，那就找最小的空位
                            other = rowList.OrderBy(a => a.N_COL).FirstOrDefault();
                        }
                        else
                        {
                            other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_COL > full.N_COL).FirstOrDefault();
                        }
                        if (other != null && (!string.IsNullOrEmpty(other.C_ENABLE) && other.C_ENABLE == "禁用"))
                        {
                            //禁用了选择后面一个货位
                            other = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE.Trim() != "禁用") && a.S_AREA_CODE == other.S_AREA_CODE && a.N_ROW == other.N_ROW && a.N_COL > other.N_COL).First();

                            //LogHelper.Info($"禁用选择后一个货位{result}", "成品");
                        }
                        if (other != null)
                        {
                            end = other;
                            break;

                        }

                    }
                }
                return end;
            }
            catch (Exception)
            {

                throw;
            }

        }

        /// <summary>
        /// 找终点空货位（两层货位）
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindEndcolByLocList2(List<Location> locations)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                Location end = null;
                //根据终点货位找空闲货位
                var rows = locations.Select(a => a.N_ROW).Distinct().ToList();
                for (int i = 0; i < rows.Count; i++)
                {
                    var rowList = locations.Where(r => r.N_ROW == rows[i]).ToList();
                    if (rowList.Count(a => a.S_LOCK_STATE != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM < 2) > 0)
                    {
                        Location other = null;
                        //当前排没有锁并且有空位置
                        //找空货位
                        var full = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM < 2).FirstOrDefault();
                        if (full != null)
                        {
                            other = full;
                        }


                        if (other != null)
                        {
                            end = other;
                            break;

                        }

                    }
                }
                return end;
            }
            catch (Exception)
            {

                throw;
            }

        }

        /// <summary>
        /// 上线任务找起点满货位 计算套袋时间
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindStartcolByLoclistAndTime(List<Location> locations)
        {
            try
            {
                Location start = new Location();
                var rowsStart = locations.Select(a => a.N_ROW).Distinct().ToList();
                for (int i = 0; i < rowsStart.Count; i++)
                {
                    var rowList = locations.Where(r => r.N_ROW == rowsStart[i]).ToList().OrderByDescending(a => a.N_COL);
                    //当前排没有锁并且有满货位
                    if (rowList.Count(a => a.S_LOCK_STATE.Trim() != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM == 1) > 0)
                    {
                        Location other = null;

                        //找到最大的满位，如果有就直接出
                        var full = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 1).FirstOrDefault();
                        if (full != null)
                        {
                            other = full;
                        }

                        if (other != null)
                        {

                            var time = LocationHelper.GetLocListAnybycode(start.S_LOC_CODE).FirstOrDefault();
                            var t = int.Parse(Time);
                            if (DateTime.Now.Subtract(time.T_MODIFY).TotalSeconds > 60 * t)
                            {
                                start = other;
                                break;
                            }

                        }
                    }
                }
                return start;
            }
            catch (Exception)
            {

                throw;
            }

        }


        /// <summary>
        /// 找起点满货位
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindStartcolByLoclist(List<Location> locations)
        {
            try
            {
                Location start = null;
                var rowsStart = locations.Select(a => a.N_ROW).Distinct().ToList();
                for (int i = 0; i < rowsStart.Count; i++)
                {
                    var rowList = locations.Where(r => r.N_ROW == rowsStart[i]).ToList().OrderByDescending(a => a.N_COL);
                    //当前排没有锁并且有满货位
                    if (rowList.Count(a => a.S_LOCK_STATE.Trim() != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM >= 1) > 0)
                    {
                        Location other = null;

                        //找到最大的满位，如果有就直接出
                        var full = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM >= 1).FirstOrDefault();
                        if (full != null)
                        {
                            other = full;
                        }

                        if (other != null)
                        {


                            start = other;
                            break;


                        }
                    }
                }
                return start;
            }
            catch (Exception)
            {

                throw;
            }

        }

        /// <summary>
        /// 找货位修改时间最小的货位
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindStartcolByTime(List<Location> locations)
        {
            try
            {
                Location start = null;
                start = locations.FindAll(a => a.N_CURRENT_NUM == 1 && a.S_LOCK_STATE.Trim() == "无").OrderBy(a => a.T_MODIFY).FirstOrDefault();
                return start;
            }
            catch (Exception)
            {

                throw;
            }

        }

        /// <summary>
        /// 找起点满货位按列优化
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        internal static Location FindStartcolByLoclistAndCol(List<Location> locations)
        {
            try
            {
                Location start = null;
                var rowsStart = locations.Select(a => a.N_ROW).Distinct().ToList();
                for (int i = 0; i < rowsStart.Count; i++)
                {
                    var rowList = locations.Where(r => r.N_ROW == rowsStart[i]).ToList().OrderByDescending(a => a.N_COL);
                    //当前排有锁并且没有货位，排除
                    if (rowList.Count(a => a.S_LOCK_STATE.Trim() != "无") > 0 || rowList.Count(a => a.N_CURRENT_NUM >= 1) == 0)
                    {
                        locations.RemoveAll(a => a.N_ROW == rowsStart[i]);
                    }
                }
                start = locations.FindAll(a => a.N_CURRENT_NUM >= 1 && a.S_LOCK_STATE == "无").OrderByDescending(a => a.N_COL).FirstOrDefault();
                return start;
            }
            catch (Exception)
            {

                throw;
            }

        }

        /// <summary>
        /// 空框转运
        /// </summary>
        internal static void EmptyBagTransport()
        {

            //线边空框区自动转运
            try
            {
                Monitor.Enter(_lockKkzy1);
                Location start = null;
                var XbshelfInfo = Settings.ppZones.Where(a => a.zoneType == 10).ToList();
                if (XbshelfInfo != null)
                {
                    foreach (var item in XbshelfInfo)
                    {
                        //找空框套袋位
                        var Kknone = LocationHelper.GetLocListAny(item.zone).OrderByDescending(b => b.N_ROW).ToList();

                        var Kzone = Settings.ppZones.Where(c => c.zoneType == 3).FirstOrDefault();
                        //找线边空框区
                        var shelfInfo = LocationHelper.GetLocListAny(Kzone.zone).FindAll(b => b.N_CURRENT_NUM == 1).OrderBy(b => b.N_ROW).ToList();

                        var suo = shelfInfo.FindAll(a => a.S_LOCK_STATE == "无");


                        //线边空框区数量为1全部被锁，找空框入库区
                        if (suo.Count <= 0)
                        {
                            Kzone = Settings.ppZones.Where(c => c.zoneType == 5).FirstOrDefault();
                            shelfInfo = LocationHelper.GetLocListAny(Kzone.zone).FindAll(b => b.N_CURRENT_NUM == 1).OrderBy(b => b.N_ROW).ToList();

                        }
                        if (shelfInfo.Count > 0)
                        {
                            //计算起点货位
                            start = FindStartcolByLoclist(shelfInfo);

                            if (start != null)
                            {
                                var list = LocationHelper.GetLocCntrItem(start.S_LOC_CODE);

                                if (list.Count > 0)
                                {

                                    Location end = null;

                                    //计算终点货位
                                    end = FindEndcolByLocList(Kknone);

                                    if (end != null)
                                    {

                                        TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "空框套袋区转运", new List<string> { list[0].S_CNTR_CODE }, 1, 1, 1, 80);
                                    }

                                }

                            }


                        }


                    }
                }

                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Monitor.Exit(_lockKkzy1);
            }
        }

        /// <summary>
        /// 满框线边区根据工单转运
        /// </summary>
        internal static void FullLineTransportByWord()
        {
            //线边满框区自动转运
            try
            {
                Monitor.Enter(_lockMkzy);
                //线边满框区有工单开始转运
                var MkCkshelfInfo = Settings.ppZones.Where(a => a.zoneType == 8).ToList();
                WorkOrder workOrder = null; //zoneInfo Xb = null;
                foreach (var item in MkCkshelfInfo)
                {
                    workOrder = MESHelper.GetWorkOrderN(item.deviceName);

                    if (workOrder != null)
                    {
                        var MkCkzone = Settings.ppZones.Where(c => c.zoneType == 8 && c.deviceName == workOrder.S_PLineNo).FirstOrDefault();
                        //找满框出库区
                        var shelfInfo = LocationHelper.GetLocListAny(MkCkzone.zone).OrderBy(b => b.N_ROW).ToList();
                        Location start = null;
                        if (shelfInfo.Count > 0)
                        {
                            //计算起点货位
                            start = FindStartcolByLoclistAndCol(shelfInfo);

                            //start = FindStartcolByLoclist(shelfInfo);

                            if (start != null)
                            {
                                //根据起点货位招托盘
                                var list = LocationHelper.GetLocCntrItem(start.S_LOC_CODE);

                                if (list.Count > 0)
                                {
                                    var XbMkshelfInfo = Settings.ppZones.Where(a => a.zoneType == 2 && a.deviceName == workOrder.S_PLineNo).ToList().FirstOrDefault();
                                    //找满框线边区
                                    var Mknone = LocationHelper.GetLocListAny(XbMkshelfInfo.zone).OrderByDescending(b => b.N_ROW).ToList();
                                    Location end = null;
                                    //计算终点货位
                                    end = FindEndcolByLocList(Mknone);
                                    if (end != null)
                                    {
                                        //Console.WriteLine($"{end.S_AREA_CODE}满框线边区可以转运");

                                        TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "瓶坯满框转运", new List<string> { list[0].S_CNTR_CODE }, 1, 1, 1, 80);
                                    }


                                }
                                else
                                {
                                    LogHelper.Info($"当前货位{start.S_LOC_CODE}找不到托盘，请检查货位容器表", "瓶坯");
                                }
                            }

                        }

                    }
                }
                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Monitor.Exit(_lockMkzy);
            }
        }

        private static object _immobilization = new object();
        /// <summary>
        /// 固定点对点任务创建
        /// </summary>
        internal static void immobilizationLocTask(string startloc, string endloc)
        {
            Location end = null;
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                lock (_immobilization)
                {
                    var loc = db.Queryable<Location>().Where(a => a.S_LOC_CODE.Trim() == startloc).First();

                    if (loc != null)
                    {
                        if (loc.N_CURRENT_NUM > 0 && loc.S_LOCK_STATE == "无")
                        {
                            var endlist = LocationHelper.GetLocListAny(endloc).OrderByDescending(b => b.N_ROW).ToList();
                            //计算终点货位
                            end = FindEndcolByLocList(endlist);
                            if (end != null)
                            {
                                //根据起点货位招托盘
                                var list = LocationHelper.GetLocCntrItem(loc.S_LOC_CODE);

                                TaskProcess.CreateTransport(loc.S_LOC_CODE, end.S_LOC_CODE, "废料下线", new List<string> { list[0].S_CNTR_CODE }, 1, 1, 1, 80);
                            }
                            else
                            {
                                LogHelper.Info($"immobilizationLocTask：终点库区：{endloc}无可用排");
                            }
                        }
                        else
                        {
                            // LogHelper.Info($"immobilizationLocTask：货位{loc.S_LOC_CODE}数量为0或者货位有锁");
                        }
                    }
                    else
                    {
                        LogHelper.Info($"immobilizationLocTask：根据货位：{startloc}找不货位表数据，请检查货位表");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info($"immobilizationLocTask Error：{ex.ToString()}");

            }
            //线边满框区自动转运

        }

        /// <summary>
        /// 瓶盖翻斗机退空框区转运
        /// </summary>
        internal static void FullBagTransportPGFDJ()
        {

            try
            {
                Monitor.Enter(_lockPGFDJ);
                Location start = null;
                Location end = null;
                List<Location> EndInfo = new List<Location>();
                List<Location> StartInfo = new List<Location>();
                //找瓶盖翻斗机空框入库区
                var XbshelfInfo = Settings.ppZones.Where(a => a.zoneType == 1).FirstOrDefault();
                if (XbshelfInfo != null)
                {
                    EndInfo = LocationHelper.GetLocListAny(XbshelfInfo.zone).OrderByDescending(b => b.N_ROW).ToList();
                }
                //找瓶盖翻斗机退空框区
                var Kzone = Settings.ppZones.Where(c => c.zoneType == 4).FirstOrDefault();
                if (Kzone != null)
                {
                    StartInfo = LocationHelper.GetLocListAny(Kzone.zone).FindAll(b => b.N_CURRENT_NUM == 1).OrderBy(b => b.N_ROW).ToList();

                }

                if (StartInfo.Count > 0)
                {
                    //计算起点货位
                    start = FindStartcolByLoclist(StartInfo);
                    if (start != null)
                    {
                        //计算终点货位
                        end = FindEndcolByLocList(EndInfo);
                        var list = LocationHelper.GetLocCntrItem(start.S_LOC_CODE);
                        if (list.Count > 0)
                        {
                            if (end != null)
                            {
                                TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "瓶盖翻斗机退空框区转运", new List<string> { list[0].S_CNTR_CODE }, 1, 1, 1, 80);
                            }
                        }
                    }
                }
                else
                {
                    LogHelper.Info($"根据起点库区{Kzone.zone}找不到对应货位，请检查货位表", "转运");
                }


                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Monitor.Exit(_lockPGFDJ);
            }
        }

        private static object _lockDdq = new object();
        /// <summary>
        /// 二期满框堆叠区转运
        /// </summary>
        internal static void DdqTransport()
        {

            //二期堆叠区转运
            try
            {
                Monitor.Enter(_lockDdq);
                Location start = null;
                var XbshelfInfo = Settings.ppZones.Where(a => a.zoneType == 19).ToList();
                if (XbshelfInfo != null)
                {
                    foreach (var item in XbshelfInfo)
                    {

                        //判断堆叠区数量
                        var shelfInfo = LocationHelper.GetLocListAny(item.zone).FindAll(b => b.N_CURRENT_NUM == 2).OrderBy(b => b.N_ROW).ToList();


                        if (shelfInfo.Count > 0)
                        {
                            var endarea = Settings.ppZones.Where(a => a.zoneType == 20).FirstOrDefault();
                            var endlocs = LocationHelper.GetLocListAny(endarea.zone).ToList();
                            //计算起点货位
                            start = FindStartcolByLoclist(shelfInfo);

                            if (start != null)
                            {
                                var list = LocationHelper.GetLocCntrItem(start.S_LOC_CODE);

                                if (list.Count > 0)
                                {

                                    Location end = null;

                                    //计算终点货位
                                    end = FindEndcolByLocList(endlocs);

                                    if (end != null)
                                    {
                                        TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "二期堆叠区搬运", new List<string> { list[0].S_CNTR_CODE, list[1].S_CNTR_CODE }, 1, 1, 1, 80);
                                    }

                                }

                            }
                        }


                    }
                }

                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Monitor.Exit(_lockDdq);
            }
        }

        /// <summary>
        /// 二期无菌坯空框堆叠区转运
        /// </summary>
        internal static void WjpTransport()
        {

            //二期堆叠区转运
            try
            {
                //  Monitor.Enter(_lockDdq);
                Location start = null;
                var XbshelfInfo = Settings.ppZones.Where(a => a.zoneType == 16 && a.deviceName.Contains("无菌")).ToList();
                if (XbshelfInfo.Count > 0)
                {
                    foreach (var item in XbshelfInfo)
                    {

                        //判断堆叠区数量
                        var shelfInfo = LocationHelper.GetLocListAny(item.zone).FindAll(b => b.N_CURRENT_NUM == 1).OrderBy(b => b.N_ROW).ToList();


                        if (shelfInfo.Count > 0)
                        {
                            var endarea = Settings.ppZones.Where(a => a.zoneType == 21).FirstOrDefault();
                            var endlocs = LocationHelper.GetLocListAny(endarea.zone).ToList();
                            //计算起点货位
                            start = FindStartcolByLoclist(shelfInfo);

                            if (start != null)
                            {
                                var list = LocationHelper.GetLocCntrItem(start.S_LOC_CODE);

                                if (list.Count > 0)
                                {

                                    Location end = null;

                                    //计算终点货位
                                    end = FindEndcolByLocList(endlocs);

                                    if (end != null)
                                    {
                                        TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "二期无菌空框搬运", new List<string> { list[0].S_CNTR_CODE }, 1, 1, 1, 80);
                                    }

                                }

                            }
                        }


                    }
                }

                Thread.Sleep(500);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            //finally
            //{
            //    Monitor.Exit(_lockKkzy1);
            //}
        }
    }
}