using Admin.NET.Application;
using iWareCC.Common.Helper;
using iWareCC.DeviceThreadFactory;
using iWareCC.Forms;
using iWareCC.RgvService;
using iWareCC.SrmService;
using iWareCC.StationService;
using iWareCC.ThreadService;
using iWareCC.ThreadService._03_BZ12_机器人码包工位_;
using iWareCC.ThreadService._04_BZ21_搬运整垛机器人_;
using iWareCC.WCF;
using iWareCommon.Common.Globle;
using iWareCommon.Utils;
using iWareModel;
using iWareModel.Entity.AGV;
using iWareSql.DataAccess;
using iWareSql.DBModel;
using iWareSql.WmsDBModel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity.Core.Metadata.Edm;
using System.Drawing;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.ServiceModel;
using System.Threading;
using System.Windows.Forms;
using XiGang.Core.Model;
using XiGang.Core.Model.ViewModels;
using static WZ.Useful.Commons.NativeMethods;


namespace iWareCC
{
    public partial class FormCC : Form
    {

        /// <summary>
        /// 全局-配置报警信息列表
        /// </summary>
        public static DeviceWarningOutput configDeviceWarningList = DeviceWarningHandler.GetConfigWarningList();

        /// <summary>
        /// 全局—是否可以运行执行出库模式
        /// </summary>
        public static bool IsAllowRunOutMode = false;

        /// <summary>
        /// 当前下发出库任务的包号
        /// </summary>
        public static string currHandlerPackageCodeForIssueOutboundTask = "";

        /// <summary>
        /// 1号堆垛机入库口扫码强制验证通过
        /// </summary>
        public static bool Srm1_IN_SMQZYZTG = false;
        /// <summary>
        /// 2号堆垛机入库口扫码强制验证通过
        /// </summary>
        public static bool Srm2_IN_SMQZYZTG = false;
        /// <summary>
        /// 3号堆垛机入库口扫码强制验证通过
        /// </summary>
        public static bool Srm3_IN_SMQZYZTG = false;
        /// <summary>
        /// 4号堆垛机入库口扫码强制验证通过
        /// </summary>
        public static bool Srm4_IN_SMQZYZTG = false;

        AutoSizeFormClass asc_panel_DeviceTaskList = new AutoSizeFormClass();
        AutoSizeFormClass asc_panel_DeviceTaskList_dgvPartTask_Finished = new AutoSizeFormClass();
        AutoSizeFormClass asc_panel_dataGridView__OutTaskList = new AutoSizeFormClass();
        AutoSizeFormClass asc_panel_WaitPlanDetail = new AutoSizeFormClass();
        AutoSizeFormClass asc_panel_DeviceTaskList_dataGridView_RgvStore = new AutoSizeFormClass();
        AutoSizeFormClass asc_panel_dg_OutTaskRetryToMes = new AutoSizeFormClass();

        public static string current_rgv_stationName;
        /// <summary>
        /// 1012站点持续有货的持续计数,一旦没有货了，就重置为0
        /// </summary>
        public static int RGV_1012_HasCategory_COUNT = 0;

        /// <summary>
        /// 1011站点持续有货的持续计数,一旦没有货了，就重置为0
        /// </summary>
        public static int RGV_1011_HasCategory_COUNT = 0;

        /// <summary>
        /// 1020持续无货时间，一旦有货了，就重置为0
        /// </summary>
        public static int RGV_1020_NoHasCategory_COUNT = 0;


        public static int RGV_1001_HasCategory_COUNT = 0;
        public static int RGV_1003_HasCategory_COUNT = 0;
        public static int RGV_1005_HasCategory_COUNT = 0;
        public static int RGV_1008_HasCategory_COUNT = 0;

        /// <summary>
        /// 是否模拟PLC
        /// </summary>
        public static bool IsSimulationPLC = ConfigHelper.GetConfigBool("IsSimulationPLC");

        private string currentCheckModelText = "";

        const int cycleDelay_Device = 1000;//各个线程的延迟毫秒数
        const int cycleDelay_Task = 1000;

        Thread startModelTipsThread;//启动线程提示
        private bool isStartModelTipsThread = false;//是否启动了线程提示
        private Color default_btn_Start_Color = Color.FromArgb(0, 192, 0);//默认的开始模拟按钮颜色
        private Color ss_btn_Start_Color1 = Color.FromArgb(255, 255, 192);//开始模拟按钮后闪烁的颜色1
        private Color ss_btn_Start_Color2 = Color.FromArgb(192, 192, 255);//开始模拟按钮后闪烁的颜色1

        #region 信息获取线程
        Thread tskSetSrmLable;//各种堆垛机工作状态的显示的控制线程  

        //Thread tskGetSrmTransStationInfo;//获取立库输送机信息的线程
        Thread tskGetSrmConveyorInfo;//获取立库输送线的任务完成等信息的线程
        Thread tskSetSrmTransLable;//各种立库输送机工作状态的显示的控制线程 

        Thread tskGetRgv1Info;//获取RGV信息的线程
        Thread tskSetRgvLable;//各种Rgv工作状态的显示的控制线程 
        #endregion

        #region 堆垛机变量
        /// <summary>
        /// 堆垛机的枚举变量列表
        /// </summary>
        public static List<EDevice> SrmDeviceList;
        /// <summary>
        /// 堆垛机的实时数据对象字典
        /// key：EDevice的Int值， Value：SrmView
        /// </summary>
        public static IDictionary<int, SrmView> srmViewDict;
        #endregion

        public static RgvView rgvView;//Rgv实体类
        public static RgvService.RgvServiceClient rgvServiceClient = null;

        public static StationView stationView;//站点实体类
        public static StationServiceClient stationServiceClient = null;
        public FormCC()
        {
            InitializeComponent();

            SrmDeviceList = BusinessHelper.GetSrmDeviceList();

            //初始化数据
            InitSrmDict();

            //暂时注释
            //tp_Thread.Parent = null;//隐藏标签[线程控制] 

            CheckForIllegalCrossThreadCalls = false;

            //设置界面初始化的选项
            //暂时注释
            /*
            this.rBNormal.Checked = SystemValue.rBNormal_Checked = true;
            this.rBPrepare.Checked = SystemValue.rBPrepare_Checked = false;
            this.rBDebug.Checked = SystemValue.rBDebug_Checked = false;
            this.ckBRgv上料任务.Checked = SystemValue.ckBRgv上料任务 = true;
            this.ckBRgv提前配板任务.Checked = SystemValue.ckBRgv提前配板任务 = false;
            //*/
            //暂时 默认就选中自动模式
            this.rBNormal.Checked = SystemValue.rBNormal_Checked = true;
            this.rbHand.Checked = SystemValue.rbHand_Checked = false;
            this.rBDebug.Checked = SystemValue.rBDebug_Checked = false;



            SetModelCheckBoxToSystemValue();

            startModelTipsThread = new Thread(ShowTipsWhenStartModel);
            startModelTipsThread.Start();

            #region 获取设备数据

            var tskGetStationInfo = new Thread(GetStationInfo);
            tskGetStationInfo.Start();

            var _GetStationWarningInfo = new Thread(GetStationWarningInfo);
            _GetStationWarningInfo.Start();


            tskSetSrmLable = new Thread(SrmRead_Label);
            tskSetSrmLable.Start();

            #endregion

            #region 设置显示UI


            #endregion

            #region 服务线程启动

            //堆垛机任务服务线程启动
            //var srmService = DeviceThreadServiceFactory.GetHandle(EDeviceType.堆垛机);
            //  srmService.StartService();
            //RGV任务服务线程启动
            //var rgvService = DeviceThreadServiceFactory.GetHandle(EDeviceType.RGV);
            // rgvService.StartService();



            new Thread(DataProcess_RobotBuffer_ModeChange.Handler).Start();

            new Thread(DataProcess_RobotBuffer_IssueOutboundTask.Handler).Start();


            new Thread(DataProcess_RobotBuffer_AutoQiTaoOutbound.Handler).Start();

            new Thread(DataProcess_RobotBuffer_FinishTaskForOutbound.Handler).Start();

            new Thread(DataProcess_RobotBuffer_ForceOutbound.Handler).Start();

            new Thread(DataProcess_RobotBuffer_FinishTask.Handler).Start();

            new Thread(DataProcess_BZ01.Handler).Start();


            new Thread(DataProcess_269.Handler).Start();


            new Thread(DataProcess_BZ39.Handler).Start();
            new Thread(DataProcess_BZ39_IssueInboundTask.Handler).Start();
            new Thread(DataProcess_BZ12.Hander).Start();
            new Thread(DataProcess_BZ12_IssueTask.Handler).Start();


            new Thread(DataProcess_BZ12_FinishTask.Handler).Start();

            new Thread(DataProcess_BZ21.Hander).Start();
            new Thread(DataProcess_BZ21_IssueTask.Handler).Start();

            new Thread(DataProcess_BZ21_FinishTask.Handler).Start();
            new Thread(DeleteData).Start();

            new Thread(PushPackageCodeToMes.Handler).Start();
            new Thread(PushPaperCutToMes.Handler).Start();

            new Thread(DataProcess_ValidateQiTao.Handler).Start();

            //*/
            #endregion

            // new Thread(GetAgvVehicles).Start();//AGV车辆信息

            // new Thread(OutTaskRetryToMes.Handler).Start();

            //暂时不启用虚拟出入库功能
            // new Thread(VirtualTaskNoOutPlanTaskHandler.Handler).Start();
        }
        private void FormCC_Load(object sender, EventArgs e)
        {
            dateTimePicker_Start.Value = DateTime.Now;
            dateTimePicker_End.Value = DateTime.Now;


            /*
            trCancelBatchBackToStore = new Thread(CancelBatchBackToStore);
            trCancelBatchBackToStore.Start();
            //*/

            /*
            var tr_reverseSplitFinishProdOutStoreThread = new Thread(ReverseSplitFinishProdOutStoreThread);
            tr_reverseSplitFinishProdOutStoreThread.Start();
            //*/


            #region 对外发布WCF形式数据访问服务
            try
            {
                #region 对外发布WCF形式数据访问服务
                var lineServiceHost = new ServiceHost(typeof(CCWcfService));
                lineServiceHost.Open();
                lbl_WCFMsg.Text = "发布WCF成功," + lineServiceHost.BaseAddresses[0].AbsoluteUri;
                lbl_WCFMsg.ForeColor = Color.Green;
                #endregion

            }
            catch (Exception ex)
            {
                Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "发布WCF失败", ex);
                lbl_WCFMsg.Text = "发布WCF失败：" + ex.Message;
                lbl_WCFMsg.ForeColor = Color.Red;
            }

            #endregion


            this.lbl_IsSimulationPLC.Text = "是否模拟PLC：" + (IsSimulationPLC ? "是" : "否");
            if (IsSimulationPLC)
            {

                this.panel_Model.BackColor = Color.Tomato;
            }
            else
            {//正式模式 
                stationServiceClient = new StationServiceClient();
            }

            this.lbl_IsSimulationPLC.BackColor = IsSimulationPLC ? Color.Red : Color.Green;

            //此处快速启动 调试模式，用于开发用
            //btn_Start_Click(null, null);
        }

        /// <summary>
        /// 设置1/2号堆垛机的前端显示
        /// </summary>
        private void SrmRead_Label()
        {
            while (true)
            {
                Thread.Sleep(1000);
                try
                {

                    var showNowTime = "(" + DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + ")";
                    //设置堆垛机任务下发和任务确认线程消息
                    this.lbl_Alert_DataProcess_BZ39_IssueInboundTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ39_IssueInboundTask;
                    this.lbl_Alert_DataProcess_RobotBuffer_ForceOutbound.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_ForceOutbound;
                    this.lbl_Alert_DataProcess_BZ12.Text = showNowTime + SystemWarningMsg._lbl_alert_DataProcess_BZ12;

                    //设置堆垛机任务下发和任务完成确认线程消息

                    this.lbl_Alert_DataProcess_BZ12_FinishTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ12_FinishTask;
                    this.lbl_Alert_DataProcess_BZ21_FinishTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ21_FinishTask;



                    this.lbl_Alert_PushPaperCutToMes.Text = showNowTime + SystemWarningMsg._lbl_Alert_PushPaperCutToMes;
                    this.lbl_Alert_PushPackageCodeToMes.Text = showNowTime + SystemWarningMsg._lbl_Alert_PushPackageCodeToMes;

                    this.lbl_Alert_DataProcess_BZ12_IssueTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ12_IssueTask;

                    this.lbl_DataProcess_ValidateQiTao.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_ValidateQiTao;

                    this.lbl_Alert_DataProcess_RobotBuffer_FinishTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_FinishTask;

                    this.lbl_DataProcess_BZ21_IssueTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ21_IssueTask;

                    this.lbl_DataProcess_RobotBuffer_ModeChange.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_ModeChange;

                    this.lbl_Alert_DataProcess_RobotBuffer_FinishTaskForOutbound.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_FinishTaskForOutbound;

                    this.lbl_Alert_DeleteData.Text = showNowTime + SystemWarningMsg._lbl_Alert_DeleteData;

                    this.lbl_Alert_DataProcess_RobotBuffer_AutoQiTaoOutbound.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_AutoQiTaoOutbound;

                    this.lbl_Alter_DataProcess_BZ21.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_BZ21;

                    this.lbl_alert_DataProcess_BZ39.Text = showNowTime + SystemWarningMsg._lbl_alert_DataProcess_BZ39;

                    this.lbl_alert_DataProcess_BZ01.Text = showNowTime + SystemWarningMsg._lbl_alert_DataProcess_BZ01;

                    this.lbl_alert_DataProcess_269.Text = showNowTime + SystemWarningMsg._lbl_alert_DataProcess_269;

                    this.lbl_Alert_DataProcess_RobotBuffer_IssueOutboundTask.Text = showNowTime + SystemWarningMsg._lbl_Alert_DataProcess_RobotBuffer_IssueOutboundTask;



                    //this.lblSrmPosX1.Text="111";
                }
                catch (Exception ex)
                {
                    continue;
                }
            }
        }

        #region 堆垛机线程和UI处理






        #endregion

        #region RGV线程和UI处理

        /// <summary>
        /// 设置Rgv的UI显示
        /// </summary>
        /// <param name="obj"></param>
        private void SetRgvLable(object obj)
        {
            while (true)
            {
                Thread.Sleep(cycleDelay_Device);
                try
                {

                    //lbRgv_Y.Text = "当前行走位置: " + rgv.R_RgvPosition;
                    //lbRgv_X.Text = "当前区域位置: " + rgv.R_RgvPosition;
                    //ERgvState _ERgvState = (ERgvState)Enum.Parse(typeof(ERgvState), rgv.R_State.ToString());
                    //lbRgvWorkState.Text = "工作状态: " + _ERgvState.ToString();
                    //lbRgvTaskId.Text = "任务号: " + rgv.R_TaskNo;
                    //lbRgvIsAuto.Text = "工作模式: " + (rgv.ModeName);
                    //lbRgvAlert.Text = rgv.R_AlarmCode.ToString();
                    //if (rgv.R_Alarm == false)
                    //{
                    //    //检测是否有心跳
                    //    using (var rgvService = new RgvService.RgvServiceClient())
                    //    {
                    //        //检测是否有心跳
                    //        var isRgvHandShare = RgvBLL.IsRgvHandShare(rgvService);
                    //        if (!isRgvHandShare)
                    //        {
                    //            lbRgvAlert.Text = "RGV没有心跳";
                    //        }
                    //    }
                    //}
                    //else
                    //{
                    //    lbRgvAlert.Text = rgv.R_AlarmCode.ToString();
                    //}

                    //// ERgvEvent _ERgvEvent = (ERgvEvent)Enum.Parse(typeof(ERgvEvent), rgv.r_ev.ToString());
                    ////lbRgvEvent.Text = "事  件：" + _ERgvEvent.ToString();
                    //lbRgvTaskFinish.Text = "任务完成：" + rgv.R_TaskFinish;

                }
                catch (Exception)
                {
                    continue;
                }
            }
        }






        #endregion

        #region 站点线程和UI处理

        /// <summary>
        /// 设置站点的UI显示
        /// </summary>
        /// <param name="obj"></param>
        private void SetStationLable(object obj)
        {
            while (true)
            {
                Thread.Sleep(cycleDelay_Device);
                try
                {

                    //lbRgv_Y.Text = "当前行走位置: " + rgv.R_RgvPosition;
                    //lbRgv_X.Text = "当前区域位置: " + rgv.R_RgvPosition;
                    //ERgvState _ERgvState = (ERgvState)Enum.Parse(typeof(ERgvState), rgv.R_State.ToString());
                    //lbRgvWorkState.Text = "工作状态: " + _ERgvState.ToString();
                    //lbRgvTaskId.Text = "任务号: " + rgv.R_TaskNo;
                    //lbRgvIsAuto.Text = "工作模式: " + (rgv.ModeName);
                    //lbRgvAlert.Text = rgv.R_AlarmCode.ToString();
                    //if (rgv.R_Alarm == false)
                    //{
                    //    //检测是否有心跳
                    //    using (var rgvService = new RgvService.RgvServiceClient())
                    //    {
                    //        //检测是否有心跳
                    //        var isRgvHandShare = RgvBLL.IsRgvHandShare(rgvService);
                    //        if (!isRgvHandShare)
                    //        {
                    //            lbRgvAlert.Text = "RGV没有心跳";
                    //        }
                    //    }
                    //}
                    //else
                    //{
                    //    lbRgvAlert.Text = rgv.R_AlarmCode.ToString();
                    //}

                    //// ERgvEvent _ERgvEvent = (ERgvEvent)Enum.Parse(typeof(ERgvEvent), rgv.r_ev.ToString());
                    ////lbRgvEvent.Text = "事  件：" + _ERgvEvent.ToString();
                    //lbRgvTaskFinish.Text = "任务完成：" + rgv.R_TaskFinish;

                }
                catch (Exception)
                {
                    continue;
                }
            }
        }

        /// <summary>
        /// 获取Station信息
        /// </summary>
        /// <param name="obj"></param>
        private void GetStationInfo(object obj)
        {
            while (true)
            {
                Thread.Sleep(1000);//1秒钟读取一次
                try
                {
                    if (stationServiceClient == null)
                    {
                        continue;
                    }
                    stationView = stationServiceClient.GetStationInfo((int)EDevice.Station);


                    this.lbl_Mode_FJ.Text = "设备模式:" + PlcHelper.GetModeName(stationView.R_Mode_FJ);
                    this.lbl_XinTiao_FJ.Text = "心跳:" + stationView.R_HandShake_FJ;
                    this.lbl_Warning_FJ.Text = "报警类型:" + PlcHelper.GetWarningTypeName(stationView.R_Warning_FJ);

                    this.lbl_Mode_MB.Text = "设备模式:" + PlcHelper.GetModeName(stationView.R_Mode_MB);
                    this.lbl_XinTiao_MB.Text = "心跳:" + stationView.R_HandShake_MB;
                    this.lbl_Warning_MB.Text = "报警类型:" + PlcHelper.GetWarningTypeName(stationView.R_Warning_MB);

                    this.lbl_Mode_HB.Text = "设备模式:" + PlcHelper.GetModeName(stationView.R_Mode_HB);
                    this.lbl_XinTiao_HB.Text = "心跳:" + stationView.R_HandShake_HB;
                    this.lbl_Warning_HB.Text = "报警类型:" + PlcHelper.GetWarningTypeName(stationView.R_Warning_HB);

                    this.lbl_Mode_FX.Text = "设备模式:" + PlcHelper.GetModeName(stationView.R_Mode_FX);
                    this.lbl_XinTiao_FX.Text = "心跳:" + stationView.R_HandShake_FX;
                    this.lbl_Warning_FX.Text = "报警类型:" + PlcHelper.GetWarningTypeName(stationView.R_Warning_FX);

                    ////显示RGV任务完成和完成确认信号
                    //this.lbl_R_RGV_Finish.Text = "RGV任务完成:" + rgvView.R_RGV_Finish;
                    //this.lbl_W_RGV_FinishACK.Text = "RGV任务完成确认:" + rgvView.W_RGV_FinishACK;

                    //this.lbl_RgvCoordinate.Text = "RGV实时坐标:" + rgvView.R_RGV_Coordinate;

                    /*
                    //解析RGV对象
                    foreach (var item in rgvView.R_RgvForReadCommList)
                    {
                        var control = ControlHelper.GetControlInstance(this.tPTransAsrs, "btn_" + item.StationCode);
                        if (item.R_AlarmCode > 0)
                        {//有报警
                            if (control != null)
                            {
                                var btn = control as Button;
                                btn.BackColor = Color.Red;
                            }
                        }
                        else
                        {
                            if (control != null)
                            {
                                var btn = control as Button;
                                if (item.StationCode == ((int)EDevice.RGV1040).ToString())
                                {
                                    btn.BackColor = Color.Gold;
                                }
                                else if (item.StationCode == ((int)EDevice.拆盘机1020).ToString())
                                {
                                    btn.BackColor = Color.DodgerBlue;
                                }
                                else if (item.StationCode == ((int)EDevice.提升机1030).ToString())
                                {
                                    btn.BackColor = Color.SteelBlue;
                                }
                                else
                                {
                                    btn.BackColor = Color.SeaGreen;
                                }
                            }
                        }
                    }

                    //显示RGV报警信息
                    List<String> warningAddressList = new List<string>();
                    if (rgvView.R_Rgv_WarningDBList != null && rgvView.R_Rgv_WarningDBList.Length > 0)
                    {
                        tb_Rgv_Alter.Text = String.Join(",", rgvView.R_Rgv_WarningDBList.Select(x => x.Contextk__BackingField).ToArray());
                        //保存报警
                        var waringList = rgvView.R_Rgv_WarningDBList.ToList();
                        if (waringList != null && waringList.Count > 0)
                        {
                            for (int i = 0; i < waringList.Count; i++)
                            {
                                DeviceWarningHandler.SaveWarning(EDevice.RGV, iWareCommon.Utils.LogType.RgvThreadService,
                                    waringList[i].Codek__BackingField, waringList[i].Addressk__BackingField, waringList[i].Contextk__BackingField);//新增报警
                                warningAddressList.Add(waringList[i].Addressk__BackingField);
                            }
                        }
                    }
                    else
                    {
                        tb_Rgv_Alter.Text = "";
                    }
                    DeviceWarningHandler.AutoCloseWarning(EDevice.RGV, iWareCommon.Utils.LogType.RgvThreadService, warningAddressList);//自动关闭报警

                    //*/
                }
                catch (Exception ex)
                {
                    rgvView = null;
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.StationThreadService, "获取站点信息出现异常:" + ex.Message, ex);
                    continue;
                }
            }
        }


        /// <summary>
        /// 获取Station 报警信息
        /// </summary>
        /// <param name="obj"></param>
        private async void GetStationWarningInfo(object obj)
        {
            while (true)
            {
                Thread.Sleep(2000);//1秒钟读取一次
                try
                {
                    if (stationServiceClient == null)
                    {
                        continue;
                    }
                    /*
                    iWareCC.StationService.DeviceWarningInfo[] waringList = await stationServiceClient.GetWaringInfoListAsync((int)EDevice.Station, configDeviceWarningList.wmsConfigDeviceWarnings.ToArray());

                    //显示报警信息
                    List<String> warningCodeList = new List<string>();
                    if (waringList != null && waringList.Length > 0)
                    {
                        for (int i = 0; i < waringList.Length; i++)
                        {
                            var findObj = configDeviceWarningList.wms_config_device_warning_list.Where(x => x.WarningCode == waringList[i].Codek__BackingField).FirstOrDefault();
                            DeviceWarningHandler.SaveWarning(EDevice.Station, iWareCommon.Utils.LogType.StationThreadService,
                                findObj.WarningCode, findObj.DeviceAreaCode, findObj.WarningContent, findObj.DeviceWarningType);//新增报警
                            warningCodeList.Add(findObj.WarningCode);
                        }

                    }
                    else
                    {

                    }
                    DeviceWarningHandler.AutoCloseWarning(EDevice.Station, iWareCommon.Utils.LogType.StationThreadService, warningCodeList);//自动关闭报警

                    //*/
                }
                catch (Exception ex)
                {
                    rgvView = null;
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.StationThreadService, "获取站点信息出现异常:" + ex.Message, ex);
                    continue;
                }
            }
        }



        #endregion


        #region 其他线程

        #region 定时删除数据

        /// <summary>
        /// 定时删除数据
        /// </summary>
        public void DeleteData()
        {
            while (true)
            {
                try
                {
                    if (SystemValue.isAllowRuning_DeleteData && SystemValue.isStartedModel)
                    {
                        ClearDataHandler.Delete_Base_SysExceptionInfo(7);
                        ClearDataHandler.Delete_Task_RequestLog(7);
                        ClearDataHandler.Delete_Task_Part(10);
                        ClearDataHandler.Delete_Device_Warning(30);
                        ClearDataHandler.Delete_HttpRequestRecord(14);

                        ClearDataHandler.Delete_MES_BTJReceiveReq(30);
                        ClearDataHandler.Delete_MES_OnLineReq(30);

                        LogTextHelper.BatchDeleteLog();

                        Thread.Sleep(8 * 60 * 60 * 1000);//每天8小时一次 
                    }
                    else
                    {
                        Thread.Sleep(6 * 1000);
                    }
                }
                catch (Exception ex)
                {
                    SystemWarningMsg._lbl_Alert_DeleteData = "出现异常:" + ex.Message;
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "定时删除数据 出现异常", ex);
                }
                finally
                {

                }
            }
        }

        #endregion

        #endregion

        #region 私有方法


        /// <summary>
        /// 初始化实时堆垛机的字典
        /// </summary>
        private static void InitSrmDict()
        {
            srmViewDict = new Dictionary<int, SrmView>();
            SrmDeviceList.ForEach(singeDevice =>
            {
                srmViewDict.Add((int)singeDevice, new SrmView());
            });
        }



        #endregion



        #region 公共

        /// <summary>
        /// 公共堆垛机急停命令
        /// </summary>
        private void CommonSrmEStop(EDevice _EDevice)
        {
            try
            {
                using (var opcClinet = new SrmService.SrmServiceClient())
                {
                    var result = opcClinet.SendEStop((int)_EDevice);
                    Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.DataProcess_BZ39_IssueInboundTask, "字符串：" + JsonConvert.SerializeObject(result));
                    if (result.result)
                    {
                        WZ.Useful.Commons.MessageUtil.ShowTips("发送" + _EDevice.ToString() + "急停指令成功");
                    }
                    else
                    {
                        WZ.Useful.Commons.MessageUtil.ShowTips("发送" + _EDevice.ToString() + "急停指令失败:" + result.resMsg);
                    }
                }
            }
            catch (Exception ex)
            {
                WZ.Useful.Commons.MessageUtil.ShowError("发送" + _EDevice.ToString() + "急停指令异常:" + ex.Message);
            }
        }




        /// <summary>
        /// 堆垛机任务确认
        /// </summary>
        /// <param name="device"></param>
        /// <param name="tbTaskId"></param>
        private void CommonSrmConfirm(EDevice device, TextBox tbTaskId)
        {
            try
            {
                if (SystemValue.isStartedModel)
                {
                    WZ.Useful.Commons.MessageUtil.ShowError("手动堆垛机任务确认，需要将模式关闭！");
                    return;
                }

                iWareCC.SrmService.SdaResEntity sdaResult = new SrmService.SrmServiceClient().ConfirmTaskFinish
                        ((int)device, int.Parse(tbTaskId.Text.Trim()));
                if (sdaResult.result)
                {
                    //tbSrm1TaskId.Clear();
                    Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.CCWCFService, "手动堆垛机任务确认成功，任务号:" + tbTaskId);
                }
                else
                {
                    WZ.Useful.Commons.MessageUtil.ShowError("手动堆垛机任务确认失败:" + sdaResult.resMsg + "！");
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "手动堆垛机任务确认失败:" + sdaResult.resMsg + "！，任务号:" + tbTaskId, null);
                }
            }
            catch (Exception ex)
            {
                WZ.Useful.Commons.MessageUtil.ShowError("手动堆垛机任务确认异常：" + ex.Message);
                Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.CCWCFService, "手动堆垛机任务确认异常：" + ex.Message, ex);
            }
        }


        private void CommonDeleteSrmTask(EDevice device)
        {
            if (SystemValue.isStartedModel)
            {
                WZ.Useful.Commons.MessageUtil.ShowError("手动删除堆垛机任务，需要将模式关闭！");
                return;
            }
            MessageBoxButtons messButton = MessageBoxButtons.OKCancel;
            DialogResult dr = MessageBox.Show("确定要删除" + device.ToString() + "任务吗?", "确认", messButton);
            if (dr == DialogResult.OK)//如果点击“确定”按钮
            {
                using (var opcClinet = new SrmService.SrmServiceClient())
                {
                    opcClinet.SendSrmDelete((int)device);
                }
            }
            else//如果点击“取消”按钮
            {

            }
        }


        #endregion


        private void rBNormal_CheckedChanged(object sender, EventArgs e)
        {
            SetModelCheckBoxToSystemValue();
        }

        private void rBDebug_CheckedChanged(object sender, EventArgs e)
        {
            SetModelCheckBoxToSystemValue();
        }


        /// <summary>
        /// 根据选择的模式配置不同的值
        /// </summary>
        private void SetModelCheckBoxToSystemValue()
        {
            SystemValue.rBNormal_Checked = this.rBNormal.Checked ? true : false;
            SystemValue.rbHand_Checked = this.rbHand.Checked ? true : false;
            SystemValue.rBDebug_Checked = this.rBDebug.Checked ? true : false;


            var title = "当前模式: ";
            if (SystemValue.rBNormal_Checked)
            {//选中了 自动模式
                currentCheckModelText = "自动模式";
                this.lbl_ModelText.Text = title + currentCheckModelText;
                this.gBoxThread.Enabled = false;
                SetAllCheckBoxChecked(true);
            }
            else if (SystemValue.rbHand_Checked)
            {
                currentCheckModelText = "手动模式";
                this.lbl_ModelText.Text = title + currentCheckModelText;
                this.gBoxThread.Enabled = false;
                SetAllCheckBoxChecked(false);

            }
            else if (SystemValue.rBDebug_Checked)
            {
                currentCheckModelText = "调试模式";
                this.lbl_ModelText.Text = title + currentCheckModelText;
                SetAllCheckBoxChecked(false);
                this.gBoxThread.Enabled = true;
            }
            else if (SystemValue.rBOnlyIn_Checked)
            {
                currentCheckModelText = "入库模式";
                this.lbl_ModelText.Text = title + currentCheckModelText;
                SetAllCheckBoxChecked(true);
                //将特殊的取消
                this.ck_DataProcess_BZ12_IssueTask.Checked = false;
                this.ck_DataProcess_BZ21_IssueTask.Checked = false;

                this.gBoxThread.Enabled = true;
            }
            else
            {
                currentCheckModelText = "无效模式";
            }
        }

        /// <summary>
        /// 遍历所有的Checkbox,并配置是否被选中
        /// </summary>
        /// <param name="enabled"></param>
        private void SetAllCheckBoxChecked(bool _checked)
        {
            var contorls = this.groupBox1.Controls;
            foreach (var control in contorls)
            {
                if (control is CheckBox)
                {
                    CheckBox c = (CheckBox)control;
                    c.Checked = _checked;
                }
            }
        }


        /// <summary>
        /// 通用的checkbox改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CommonCheckedChanged(object sender, EventArgs e)
        {
            //堆垛机1任务下发
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_SrmTaskThreadService_1, ckB_DataProcess_BZ39_IssueInboundTask);


            //堆垛机2任务下发
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_SrmTaskThreadService_2, ckBDataProcess_RobotBuffer_ForceOutbound);
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_SrmTaskThreadService_2_Finish, ckBDataProcess_BZ12_FinishTask);

            //堆垛机3任务下发
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_SrmTaskThreadService_3, ckBDataProcess_BZ12);
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_SrmTaskThreadService_3_Finish, ckBDataProcess_BZ21_FinishTask);




            //RGV任务下发

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_RgvThreadService_Finish, ckB_PushPaperCutToMes);
            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_RgvThreadService_Finish_BuChang, ck_PushPackageCodeToMes);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_HandlerIssuingTask, ck_DataProcess_BZ12_IssueTask);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_RobotBuffer_FinishTask, ck_DataProcess_RobotBuffer_FinishTask);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_MainTaskDecompose, ck_DataProcess_BZ21_IssueTask);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_RobotBuffer_ModeChange, ck_DataProcess_RobotBuffer_ModeChange);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_ValidateQiTao, ck_DataProcess_ValidateQiTao);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_RobotBuffer_FinishTaskForOutbound, checkBox_DataProcess_RobotBuffer_FinishTaskForOutbound);


            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DeleteData, ckDeleteData);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_RobotBuffer_AutoQiTaoOutbound, ckDataProcess_RobotBuffer_AutoQiTaoOutbound);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_BZ39, ck_DataProcess_BZ39);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_BZ01, ck_AutoIssueInStoreTask);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_269, ck_DataProcess_269);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_DataProcess_RobotBuffer_IssueOutboundTask, ck_DataProcess_RobotBuffer_IssueOutboundTask);

            DoCommonCheckedChanged(ref SystemValue.isAllowRuning_OutTaskRetryToMes, checkBox_DataProcess_BZ21);
        }

        private void DoCommonCheckedChanged(ref bool isAllowValue, CheckBox cb)
        {
            isAllowValue = cb.Checked ? true : false;
        }

        private void FormCC_SizeChanged(object sender, EventArgs e)
        {


        }

        /// <summary>
        /// 停止
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_End_Click(object sender, EventArgs e)
        {
            //首先确认下，是不是选择的是 自动模式或者是 提前配板模式
            //注意：这里增加模式时，要处理的 ！！！！
            if (!(SystemValue.rBNormal_Checked
                 || SystemValue.rbHand_Checked
                 || SystemValue.rBDebug_Checked
                 || SystemValue.rBOnlyIn_Checked
                ))
            {
                WZ.Useful.Commons.MessageUtil.ShowError("当前没有选择模式，停止动作无效!");
                return;
            }
            if (isStartModelTipsThread == false)
            {
                WZ.Useful.Commons.MessageUtil.ShowError("当前没有模式在运行，停止动作无效!");
                return;
            }

            MessageBoxButtons messButton = MessageBoxButtons.OKCancel;
            DialogResult dr = MessageBox.Show("确定要停止【" + currentCheckModelText + "】模式吗?", "停止模式", messButton);
            if (dr == DialogResult.OK)//如果点击“确定”按钮
            {
                var doResult = CommonStopService();
                if (!doResult)
                {
                    return;
                }


                this.btn_Start.Text = "启动模式";
                this.btn_Start.Enabled = true;
                SystemValue.isStartedModel = false;

                //启用选择模式的checkbox
                SetEnableForModelRadioButton(true);
                //this.rBNormal.Enabled = true;
                //this.rBClose.Enabled = true;
                //this.rBDebug.Enabled = true;
                //this.rBPrepare.Enabled = true;
                //this.rBPersonRaw.Enabled = true;
                //this.rBInOutStore.Enabled = true;
                //this.rBCancelBatchBackToStore.Enabled = true;

                //不需要重新关闭checkbox
                //SetAllCheckBoxChecked(false);

                isStartModelTipsThread = false;
                this.btn_Start.BackColor = default_btn_Start_Color;//还原颜色
            }
            else//如果点击“取消”按钮
            {

            }
        }

        /// <summary>
        /// 控制模式中的RadioButton禁启用
        /// </summary>
        /// <param name="enabled"></param>
        private void SetEnableForModelRadioButton(bool enabled)
        {
            var ctls = this.panel_Model.Controls;
            foreach (var item in ctls)
            {
                if (item is RadioButton)
                {
                    RadioButton rb = (RadioButton)item;
                    rb.Enabled = enabled;
                }
            }
        }

        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_Start_Click(object sender, EventArgs e)
        {
            //首先确认下，是不是选择的是 自动模式或者是 提前配板模式
            if (!(SystemValue.rBNormal_Checked
                || SystemValue.rbHand_Checked
                || SystemValue.rBDebug_Checked
                || SystemValue.rBOnlyIn_Checked
                ))
            {
                WZ.Useful.Commons.MessageUtil.ShowError("请选择其中一个模式!");
                return;
            }

            MessageBoxButtons messButton = MessageBoxButtons.OKCancel;
            DialogResult dr = MessageBox.Show("确定要启动【" + currentCheckModelText + "】模式吗?", "启动模式", messButton);
            if (dr == DialogResult.OK)//如果点击“确定”按钮
            {
                using (WmsDBModel edm = new WmsDBModel())
                {
                    var ccSystem = BasicDataSetHandler.GetCCSystem(edm);
                    if (ccSystem == null)
                    {
                        WZ.Useful.Commons.MessageUtil.ShowError("请联系管理员维护系统调度相关的数据!");
                        return;
                    };
                    //判断是否是自己开启的软件
                    if (!string.IsNullOrEmpty(ccSystem.Machine) && ccSystem.Machine != Dns.GetHostName())
                    {//默认的空值
                        WZ.Useful.Commons.MessageUtil.ShowError(string.Format("调度系统已经在其他地方启动配板模式,机器名:{0},启动时间:{1}!"
                            , ccSystem.Machine, DateTimeHelper.ConvertToString(ccSystem.OnLineTime)));
                        return;
                    }

                    ccSystem.BasicDataValue = SystemValue.SystemStartGuid = Guid.NewGuid().ToString();
                    ccSystem.OnLineTime = DateTime.Now;
                    ccSystem.Machine = Dns.GetHostName();

                    int i = edm.SaveChanges();
                    if (i <= 0)
                    {
                        WZ.Useful.Commons.MessageUtil.ShowError("保存系统调度相关的数据失败!");
                        return;
                    }
                }

                this.btn_Start.Text = "【" + currentCheckModelText + "】模式运行中...";
                this.btn_Start.Enabled = false;
                this.btn_End.Enabled = true;
                SystemValue.isStartedModel = true;

                //禁用选择模式的checkbox
                SetEnableForModelRadioButton(false);
                //this.rBNormal.Enabled = false;
                //this.rBClose.Enabled = false;
                //this.rBDebug.Enabled = false;
                //this.rBPersonRaw.Enabled = false;
                //this.rBPrepare.Enabled = false;
                //this.rBInOutStore.Enabled = false;


                isStartModelTipsThread = true;

            }
            else//如果点击“取消”按钮
            {

            }

        }

        /// <summary>
        /// 公共停止服务的处理
        /// </summary>
        /// <returns></returns>
        private bool CommonStopService()
        {
            using (WmsDBModel edm = new WmsDBModel())
            {
                var ccSystem = BasicDataSetHandler.GetCCSystem(edm);
                if (ccSystem == null)
                {
                    WZ.Useful.Commons.MessageUtil.ShowError("请联系管理员维护系统调度相关的数据!");
                    return false;
                };
                //判断是否是自己开启的软件模式
                if (SystemValue.SystemStartGuid == ccSystem.BasicDataValue)
                {
                    ccSystem.BasicDataValue = "000000";//默认的空值
                    ccSystem.OnLineTime = null;
                    ccSystem.Machine = string.Empty;
                    ccSystem.LastMachine = Dns.GetHostName();
                    ccSystem.LastUnLineTime = DateTime.Now;
                    ccSystem.UpdateTime = DateTime.Now;

                    int i = edm.SaveChanges();
                    if (i <= 0)
                    {
                        WZ.Useful.Commons.MessageUtil.ShowError("保存系统调度相关的数据失败!");
                        return false;
                    }
                }
            }
            return true;
        }

        private void FormCC_FormClosing(object sender, FormClosingEventArgs e)
        {
            MessageBoxButtons messButton = MessageBoxButtons.OKCancel;
            DialogResult dr = MessageBox.Show("确定要退出吗?", "确认", messButton);
            if (dr == DialogResult.OK)//如果点击“确定”按钮
            {
                try
                {
                    var doResult = CommonStopService();
                    if (!doResult)
                    {
                        e.Cancel = true;
                        return;
                    }
                    e.Cancel = false;
                }
                catch (Exception ex)
                {
                    WZ.Useful.Commons.MessageUtil.ShowError("出现错误!" + ex.Message);
                    e.Cancel = true;
                }
            }
            else//如果点击“取消”按钮
            {
                e.Cancel = true;
            }
        }
        private void FormCC_FormClosed(object sender, FormClosedEventArgs e)
        {
            try
            {
                Dispose();
            }
            catch (Exception)
            {
            }
            Environment.Exit(0);
        }


        /// <summary>
        /// 模式启动后，按钮闪烁
        /// </summary>
        /// <param name="obj"></param>
        private void ShowTipsWhenStartModel(object obj)
        {
            while (true)
            {
                Thread.Sleep(1000);
                if (isStartModelTipsThread)
                {
                    try
                    {
                        this.btn_Start.BackColor = ss_btn_Start_Color2;
                        Thread.Sleep(1000);
                        this.btn_Start.BackColor = ss_btn_Start_Color1;
                    }
                    catch (Exception)
                    {
                        continue;
                    }
                }
                else
                {
                    if (this.btn_Start.BackColor != default_btn_Start_Color)
                    {
                        this.btn_Start.BackColor = default_btn_Start_Color;//还原颜色
                    }
                }

                this.lbl_RobotMode.Text = "缓存岛机器人模式:" + (IsAllowRunOutMode ? "出库模式" : "入库模式");
                this.lbl_currHandlerPackageCodeForIssueOutboundTask.Text = "当前下发出库任务的包号:" + currHandlerPackageCodeForIssueOutboundTask;
            }
        }

        private void panel27_Paint(object sender, PaintEventArgs e)
        {

        }



        private void button5_Click(object sender, EventArgs e)
        {
            if (SystemValue.isStartedModel)
            {
                WZ.Useful.Commons.MessageUtil.ShowError("手动库位维护，需要将模式关闭！");
                return;
            }
            //手动库位维护
            SrmStockForm frm = new SrmStockForm();
            frm.ShowDialog();
        }




        private void btn_TongJi_Click(object sender, EventArgs e)
        {
            //统计

            int store_FDJ = 0;//现有发动机数
            int store_EmptySalver = 0;//空托盘数量
            int store_EmptySalver_TS = 0;//空托盘托数

            int count_In_FDJ = 0;//查询某天入库了多少发动机
            int count_In_EmptySalver = 0;//查询某天入库了多少 空托盘
            int count_In_EmptySalver_TS = 0;//查询某天入库了多少 空托盘托数

            int count_Out_FDJ = 0;//查询某天出库了多少发动机
            int count_Out_EmptySalver = 0;//查询某天出库了多少 空托盘
            int count_Out_EmptySalver_TS = 0;//查询某天出库了多少 空托盘托数

            int count_ZY_EmptySalver = 0;//查询某天转运了多少 空托盘
            int count_ZY_EmptySalver_TS = 0;//查询某天转运了多少 空托盘托数

            //某段时间的统计
            var str_start = this.dateTimePicker_Start.Value.ToString("yyyy-MM-dd" + " " + "00:00:00");
            var str_end = this.dateTimePicker_End.Value.ToString("yyyy-MM-dd" + " " + "23:59:59");
            var start = Convert.ToDateTime(str_start);
            var end = Convert.ToDateTime(str_end);

            int allPlacesCount = 0;
            using (DbModel edm = new DbModel())
            {

                var queryMaterialType_一般物料 = (int)MaterialTypeEnum.一般物料;
                var queryMaterialType_托盘 = (int)MaterialTypeEnum.托盘;
                var queryInOutFlag_In = (int)MainInOutFlagEnum.入库;
                var queryInOutFlag_Out = (int)MainInOutFlagEnum.出库;
                var queryInOutFlag_ZY = (int)MainInOutFlagEnum.转运;

                var allPlaces = edm.Base_Station.Where(x => x.IsSrmStation == true).ToList();
                allPlaces = StationHandler.FindCommonFilter(allPlaces);
                allPlacesCount = allPlaces.Count;

                store_FDJ = edm.V_Store.Where(x => x.MaterialType == queryMaterialType_一般物料).Count();


                store_EmptySalver_TS = edm.V_Store.Where(x => x.MaterialType == queryMaterialType_托盘).Count();
                store_EmptySalver = store_EmptySalver_TS == 0 ? 0 : edm.V_Store.Where(x => x.MaterialType == queryMaterialType_托盘).Sum(x => (int)x.Qty);



                //查询某天入库了多少发动机
                var taskState = (int)MainTaskStatusEnum.已完成;
                count_In_FDJ = edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_一般物料 && x.InOutFlag == queryInOutFlag_In && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Count();

                //查询某天入库了多少托盘
                count_In_EmptySalver_TS = edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_In && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Count();
                count_In_EmptySalver = count_In_EmptySalver_TS == 0 ? 0 : edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_In && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Sum(x => (int)x.Qty);

                //查询某天出库了多少发动机
                count_Out_FDJ = edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_一般物料 && x.InOutFlag == queryInOutFlag_Out && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Count();

                //查询某天入库了多少托盘
                count_Out_EmptySalver_TS = edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_Out && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Count();
                count_Out_EmptySalver = count_Out_EmptySalver_TS == 0 ? 0 : edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_Out && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end)).Sum(x => (int)x.Qty);

                //查询某天转运了多少托盘（注意：只查询去1014位置的）
                count_ZY_EmptySalver_TS = edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_ZY && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end) && x.RealToPlace == "1014").Count();
                count_ZY_EmptySalver = count_ZY_EmptySalver_TS == 0 ? 0 : edm.Task_Main.Where(x => x.MaterialType == queryMaterialType_托盘 && x.InOutFlag == queryInOutFlag_ZY && x.TaskState == taskState && (x.FinishTime >= start && x.FinishTime <= end) && x.RealToPlace == "1014").Sum(x => (int)x.Qty);

            }

            //显示
            //var aa = "\r\n";
            var str = "";
            str += "时间范围: " + str_start + "至" + str_end + " \r\n";
            str += "==================【库存】========================= \r\n";
            str += "现有发动机数: " + store_FDJ + "  \r\n";
            str += "现有空托盘数: " + store_EmptySalver + " \r\n";
            str += "现有空托盘托数: " + store_EmptySalver_TS + " \r\n";
            str += "总库位" + allPlacesCount + ",有发动机或托盘库位" + (store_FDJ + store_EmptySalver_TS) + ",库存占比: " + CSharpHelper.ExecPercent((store_FDJ + store_EmptySalver_TS), allPlacesCount) + " \r\n";
            str += "\r\n";

            str += "==================【入库】========================= \r\n";
            str += "入库发动机数: " + count_In_FDJ + " \r\n";
            str += "入库空托盘数: " + count_In_EmptySalver + " \r\n";
            str += "入库空托盘托数: " + count_In_EmptySalver_TS + " \r\n";
            str += "\r\n";

            str += "==================【出库】========================= \r\n";
            str += "出库发动机数: " + count_Out_FDJ + " \r\n";
            str += "出库空托盘数: " + count_Out_EmptySalver + " \r\n";
            str += "出库空托盘托数: " + count_Out_EmptySalver_TS + " \r\n";
            str += "\r\n";

            str += "==================【转运托盘】========================= \r\n";
            str += "转运空托盘数: " + count_ZY_EmptySalver + " \r\n";
            str += "转运空托盘托数: " + count_ZY_EmptySalver_TS + " \r\n";
            str += "\r\n";

            this.tb_TongJi.Text = str;
        }

        private void checkBox_NowDay_CheckedChanged(object sender, EventArgs e)
        {
            if (this.checkBox_NowDay.Checked)
            {
                dateTimePicker_Start.Value = DateTime.Now;
                dateTimePicker_End.Value = DateTime.Now;
            }
        }

        private void rBOnlyIn_CheckedChanged(object sender, EventArgs e)
        {
            SetModelCheckBoxToSystemValue();
        }

        private void btnSMQZYZTG1_Click(object sender, EventArgs e)
        {
            DobtnSMQZYZTG(EDevice.一号堆垛机);
        }

        private void DobtnSMQZYZTG(EDevice device)
        {
            MessageBoxButtons messButton = MessageBoxButtons.OKCancel;
            DialogResult dr = MessageBox.Show("注意：入库口扫码强制验证通过功能，仅适用于扫码器没有扫到码，但是实际托盘码和堆垛机要执行的任务托盘码一致的情况！如果堆垛机要执行的任务跟实际托盘码不符，请不要点击该按钮，及时联系管理员过来处理。您确定要操作吗?", "确认", messButton);
            if (dr == DialogResult.OK)//如果点击“确定”按钮
            {
                var stationCode = MyExtendHelper.GetRgvStationCodeBySrm(device);
                var srm = FormCC.srmViewDict[(int)device];
                //只有当堆垛机有任务执行时，并且是入库任务的时候才判断
                var realSrmSourcePlace = (int)device + "-" + srm.SrmSourcePlace;
                if (srm.R_TaskNo > 0 && (srm.R_State == (int)ESrmState.取货中 || srm.R_State == (int)ESrmState.取货定位中)
                   && SysGloble.Dict_SpecialPlace_IN.ContainsKey(realSrmSourcePlace))
                {
                    var result = MyExtendHelper.WriteScanValidateACK(false, "入库口扫码强制验证通过", stationCode, srm.R_TaskNo, true, "", "");
                    if (result)
                    {
                        MyExtendHelper.SetSrm_IN_SMQZYZTG(device, true);
                        MessageBox.Show("入库口扫码强制验证通过 成功！");
                    }
                    else
                    {
                        MessageBox.Show("入库口扫码强制验证通过 失败！");
                    }
                }
                else
                {
                    MessageBox.Show(device.ToString() + "任务号不是大于0，或者 状态不是 '取货中'或'取货定位中'，不允许操作");
                }
            }
            else//如果点击“取消”按钮
            {

            }
        }


        private void button22_Click(object sender, EventArgs e)
        {
            var cargNo = this.tb_wlm.Text.Trim();
            var ret = WmsRequestHelper.test_getEngineInfo(cargNo);


            //转换后
            MesRetModel2<MesRetProductModel> retModel = JsonConvert.DeserializeObject<MesRetModel2<MesRetProductModel>>(ret);

            this.tb_TongJi.Text = "MES返回：" + ret + "\r\n" +
                "转换后:" + "\r\n" +
                JsonConvert.SerializeObject(retModel)
                ;
        }

        private void button23_Click(object sender, EventArgs e)
        {
            var cargNo = this.tb_wlm.Text.Trim();
            var ret = WmsRequestHelper.test_btjReceive(cargNo);


            //转换后
            MessageModel<string> retModel = JsonConvert.DeserializeObject<MessageModel<string>>(ret);

            this.tb_TongJi.Text = "WMS返回：" + ret + "\r\n" +
                "转换后:" + "\r\n" +
                JsonConvert.SerializeObject(retModel);
        }

        private void lbl_Alert_Place1014ClearStoreTask_Click(object sender, EventArgs e)
        {

        }

        private void button24_Click(object sender, EventArgs e)
        {
            //强制该包号出库
            var packageCode = this.tb_PackageCode.Text.Trim();

            var alertMsg = "";
            CC_DataProcess_RobotBuffer_ForceOutbound.Handler(packageCode, ref alertMsg);
            if (!string.IsNullOrEmpty(alertMsg))
            {
                MessageBox.Show("错误:" + alertMsg);
            }
            else
            {
                MessageBox.Show("已处理");
            }
        }

        private void button25_Click(object sender, EventArgs e)
        {
            var packageCode = this.tb_PackageCode.Text.Trim();

            var alertMsg = "";
            using (WmsDBModel db = new WmsDBModel())
            {
                var upiList = db.mes_batchOrderUPI_new.Where(x => x.PackageCode == packageCode).ToList();
                foreach (var item in upiList)
                {
                    item.AreaCode = (int)AreaCodeEnum.无区域;
                    item.UpiStatus = (int)UpiStatusEnum.初始;
                }

                var pList = db.mes_package_gather.Where(x => x.PackageCode == packageCode).ToList();
                foreach (var item in pList)
                {
                    item.AreaCode = (int)AreaCodeEnum.无区域;
                    item.UpiStatus = (int)UpiStatusEnum.初始;
                }

                //清空队列数据
                var list = db.mes_upi_linequeue.ToList();
                db.mes_upi_linequeue.RemoveRange(list);

                db.SaveChanges();
            }
            if (!string.IsNullOrEmpty(alertMsg))
            {
                MessageBox.Show("错误:" + alertMsg);
            }
            else
            {
                MessageBox.Show("已处理");
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {


            var alertMsg = "";
            using (WmsDBModel db = new WmsDBModel())
            {
                //查询立体库中的upi列表
                var quanList = db.wms_stock_quan.ToList().Select(x => x.Upi).ToList();
                var upiList = db.mes_batchOrderUPI_new.Where(x => !quanList.Contains(x.UPI)).ToList();
                foreach (var item in upiList)
                {
                    item.AreaCode = (int)AreaCodeEnum.无区域;
                    item.UpiStatus = (int)UpiStatusEnum.初始;
                }

                var packageCodeList = upiList.Select(x => x.PackageCode).ToList();
                var pList = db.mes_package_gather.Where(x => packageCodeList.Contains(x.PackageCode)).ToList();
                foreach (var item in pList)
                {
                    item.AreaCode = (int)AreaCodeEnum.无区域;
                    item.UpiStatus = (int)UpiStatusEnum.初始;
                }
                //清空队列数据
                var list = db.mes_upi_linequeue.ToList();
                db.mes_upi_linequeue.RemoveRange(list);

                db.SaveChanges();
            }
            if (!string.IsNullOrEmpty(alertMsg))
            {
                MessageBox.Show("错误:" + alertMsg);
            }
            else
            {
                MessageBox.Show("已处理");
            }
        }

        private void btn1_Click(object sender, EventArgs e)
        {
            var taskNo = this.tb_taskNo.Text.Trim();

            var alertMsg = "";
            using (WmsDBModel wmsDB = new WmsDBModel())
            {
                var task = wmsDB.wms_rbline_task.Where(x => x.TaskNo == taskNo && x.RbTaskType == (int)RbTaskTypeEnum.入库任务 && x.TaskStatus == (int)TaskStatusEnum.已下发).FirstOrDefault();
                if (task == null)
                {
                    MessageBox.Show("没找到任务");
                    return;
                }

                var upiCode = task.Upi;
                var upiObj = wmsDB.mes_batchOrderUPI_new.Where(x => x.UPI == upiCode).FirstOrDefault();
                if (upiObj == null)
                {
                    MessageBox.Show($"根据UPI:{upiCode}没有找到对象 ");
                    return;
                }
                //增加库存
                wms_stock_quan qun = new wms_stock_quan()
                {
                    Id = Yitter.IdGenerator.YitIdHelper.NextId(),
                    Upi = upiCode,
                    PlanNo = task.PlanNo,
                    DetailName = upiObj.DetailName,
                    OrderId = task.OrderId,
                    CreateTime = DateTime.Now,
                    CreateUserName = "CC",
                    InTime = DateTime.Now,
                    OperReason = "入库",
                    PackageCode = task.PackageCode,
                    Length = task.Length,
                    Width = task.Width,
                    Thk = task.Thk,
                    PlaceCode = task.PlaceCode,
                    StockStatus = (int)StockStatusEnum.在库,
                    StockStatusName = StockStatusEnum.在库.ToString(),

                };
                wmsDB.wms_stock_quan.Add(qun);

                task.TaskStatus = (int)TaskStatusEnum.已完成;
                task.FinishedTime = DateTime.Now;


                var place = StationHandler.GetPlaceByPlaceCode(task.PlaceCode, wmsDB);
                place.PlaceStatus = (int)PlaceStatusEnum.正常;


                WmsRecordUpiProcessHandler.SaveWmsRecordUpiProcess(wmsDB, upiObj, task.PlaceCode, "缓存入库完成:" + task.PlaceCode);

                wmsDB.SaveChanges();
            }
            if (!string.IsNullOrEmpty(alertMsg))
            {
                MessageBox.Show("错误:" + alertMsg);
            }
            else
            {
                MessageBox.Show("已处理");
            }
        }
    }
}