using System;

using System.Data;

using System.Text;
using System.Windows.Forms;
using System.ServiceModel;
using WcfControlMonitorLib;
using CommonLib;
using System.Globalization;

using System.Threading;
using DBFactory;
using System.Threading.Tasks;
using System.Net.Sockets;
using OPCClient;
using System.Collections.Generic;
using System.Linq;

namespace wcfControlMonitorClient
{
    public partial class FrmHost : Form
    {
        public static event CSendDeviceOrderEventHandler SendDeviceOrder;
        public static event CUpdateDBEventHandler UpdateDB;
        public static void OnUpdateDB(CUpdateDBChangeEventArgs e)
        {
            if (UpdateDB != null)
            {
                UpdateDB(null, e);
            }
        }
        public static void OnSendDeviceOrder(CSendDeviceOrderEventArgs e)
        {
            if (SendDeviceOrder != null)
            {
                SendDeviceOrder(null, e);
            }
        }
        static DBOperator dbothread = new DBOperator();
        static object lockThis = new object();
        static Thread mythread;
        static bool exitThread = false;//20091107
        private static void BeginListen()
        {//20091107
            while (!exitThread)
            {
                try
                {
                    lock (lockThis)
                    {
                        IOModeSwitch();
                    }
                }
                catch (Exception ex)
                {
                    
                }
                finally
                {
                    Thread.Sleep(3000);
                }
            }
        }

        public static void EndListenIOModeSwitch()
        {//20091107
            exitThread = true;

            if (mythread != null)
            {

                mythread.Abort();
                mythread = null;
            }


        }
        public static void StartListenIOModeSwitch()
        {
           
            //20091107
            exitThread = false;
            mythread = new Thread(new ThreadStart(BeginListen));
            mythread.IsBackground = true;
            mythread.Start();

        }
        public static  void IOModeSwitch()
        {//20230815richard.liu定时检查T_BASE_IOMODE_SWITCH表数据，更新管理表IO_CONTROL_MODE_SWITCH的inout_switch_flag，inout_switch_remark不能转换原因
         //检查;分隔的多个检查条件，是否有任务U22003、有货开关状态D22003.0、运行状态I22003
            StaticProperty sp = new StaticProperty();
            CStaticClass.WcfControl.GetTurnOrder(sp);
            if (sp.TurnOrder == false) return;
            try
            {
                DataView dvman = dboMan.ExceSQL("select * from IO_CONTROL_MODE_SWITCH").Tables[0].DefaultView;
                if (dvman.Count > 0)
                {
                    StringBuilder sbUnswitchRemark = new StringBuilder("");
                    StringBuilder sBinput_station_codeNotUpdate = new StringBuilder("");
                    StringBuilder tmpsbUnswitchRemark = new StringBuilder("");

                    char[] cc = new char[1] { ';' };
                    string[] AheadDetect;
                    Model.MDevice tmpDevice;
                    DataView dv;
                    StringBuilder sql = new StringBuilder("");
                    List< StringBuilder> SqlArray = new List< StringBuilder>();
                    List<int>devArray = new List<int>();
                    List<int> senddArray = new List<int>();
                    for (int i = 0; i < dvman.Count; i++)
                    {//根据当前模式1入库，2出库，结合 switch_to_input_detect,switch_to_output_detect给管理更新inout_switch_flag
                     //同时判断是否需要转换本地的inout_switch_flag
                        dv = dbothread.ExceSQL(String.Format("select * from T_BASE_IOMODE_SWITCH where input_station_code={0}", dvman[i]["input_station_code"])).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            #region 提前检测
                            tmpsbUnswitchRemark.Clear();

                            if (dv[0]["station_inout_mode"].ToString() == "1")
                            {//入库1判断是否可以转换为出库2switch_to_output_detect
                                AheadDetect = dv[0]["switch_to_output_detect"].ToString().Split(cc);
                                splitAheadDetect(AheadDetect, out tmpsbUnswitchRemark);

                            }
                            else if (dv[0]["station_inout_mode"].ToString() == "2")
                            {//出库2判断是否可以转换为入库1switch_to_input_detect
                                AheadDetect = dv[0]["switch_to_input_detect"].ToString().Split(cc);
                                splitAheadDetect(AheadDetect, out tmpsbUnswitchRemark);
                            }
                            else
                            {//目前没有大于2出入库类型

                            }
                            if (tmpsbUnswitchRemark.ToString().Length > 0)
                            {
                                sBinput_station_codeNotUpdate.Append(",").Append(dv[0]["input_station_code"]);
                                sbUnswitchRemark.Append(tmpsbUnswitchRemark.ToString());
                            }
                            #endregion
                            #region 判断是否变换本地出入库类型station_inout_mode
                            if (dvman[i]["station_inout_mode"].ToString() != dv[0]["station_inout_mode"].ToString())
                            {
                                #region 组件车间
                                if (dv[0]["station_area"].ToString() == "1")
                                {//组件车间特殊流程
                                    if (dvman[i]["station_inout_mode"].ToString() == "1" && dv[0]["station_inout_mode"].ToString() == "2")
                                    {//入库变出库，伸缩皮带机伸出后有货:
                                     //方案1：向wms申请空托盘（入库）；
                                     //目前选方案2：模式入库变出库PLC自行到扫码检尺站台，去入库扫码检尺站台，扫码检尺后异常wms回退，否则叠盘
                                        
                                    }
                                    else if (dvman[i]["station_inout_mode"].ToString() == "2" && dv[0]["station_inout_mode"].ToString() == "1")
                                    {////方案1：出库变入库，是否需要自动拆空托盘去出库口：判断无拆盘机去出库口任务，且出口无货空闲
                                        //int outdevice = Convert.ToInt32(dv[0]["OUTPUT_STATION_CODE"]);
                                        //tmpDevice = Model.CGetInfo.GetDeviceInfo(outdevice);
                                        //int palletstacker = Convert.ToInt32(dv[0]["PALLET_STACKER"]);
                                        //if (tmpDevice.RunState == 0 && tmpDevice.SplitByte_0 == 0 && tmpDevice.SplitByte_1 == 0)
                                        //{//出口无货空闲
                                        //    sql.Clear();
                                        //    sql.Append(string.Format("select fid from T_MANAGE_TASK where fstartdevice={0} and fenddevice={1}", palletstacker, outdevice));
                                        //    dv = dbothread.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                        //    if (dv.Count == 0)
                                        //    {//无拆盘机去出库口任务，触发事件到主线程
                                        //        object[] ob1 = new object[16] { GetTempManageIdx(), 2, "-", 3, 3, 1, 0, 1, 1, "-", palletstacker, outdevice, "-", 0, DateTime.Now.ToString("u"), 0 };
                                        //        SqlArray.Add(new StringBuilder(string.Format("INSERT INTO T_Manage_Task(FID, F_ManageTaskKindIndex,FPALLETBARCODE,FMANAGETASKTYPE,FCONTROLTASKTYPE, FTASKLEVEL, FISRETURN,FSTARTWAREHOUSE,FENDWAREHOUSE, FSTARTCELL, FSTARTDEVICE, FENDDEVICE, FENDCELL, FSTATUS, FBEGTIME, FIntoStepOK)VALUES({0},{1},'{2}',{3},{4},{5},{6},'{7}','{8}','{9}',{10},{11},'{12}',{13},'{14}',{15})", ob1)));
                                                
                                        //    }
                                        //}

                                        ////现在选用 方案2：入库时人工在落地机按钮呼叫空托盘
                                    }
                                    else
                                    {

                                    }
                                }
                                #endregion

                                #region 修改本地出入库类型station_inout_mode，写给PLC
                                if (dvman[i]["input_station_code"].ToString() == "22337" && dvman[i]["station_inout_mode"].ToString() == "2" && dv[0]["station_inout_mode"].ToString() == "1")
                                {
                                    if (tmpsbUnswitchRemark.ToString() == string.Empty)
                                    {
                                        dbothread.ExecuteSql(string.Format("update T_BASE_IOMODE_SWITCH set station_inout_mode='{0}' where input_station_code='{1}'",
                                       dvman[i]["station_inout_mode"].ToString(), dv[0]["input_station_code"].ToString()));
                                        //出入库类型写给PLC，考虑多线程调用问题
                                        devArray.Add(Convert.ToInt32(dv[0]["inout_switch_device"]));
                                        senddArray.Add(Convert.ToInt32(dvman[i]["station_inout_mode"]));
                                    }
                                }
                                else
                                {
                                    //修改本地出入库类型station_inout_mode
                                    dbothread.ExecuteSql(string.Format("update T_BASE_IOMODE_SWITCH set station_inout_mode='{0}' where input_station_code='{1}'",
                                        dvman[i]["station_inout_mode"].ToString(), dv[0]["input_station_code"].ToString()));
                                    //出入库类型写给PLC，考虑多线程调用问题
                                    devArray.Add(Convert.ToInt32(dv[0]["inout_switch_device"]));
                                    senddArray.Add(Convert.ToInt32(dvman[i]["station_inout_mode"]));
                                }
                                
                               
                                #endregion

                            }
                            #endregion
                        }
                    }

                    #region 批量申请自动拆空托盘去出库口
                    //出库变入库，是否需要自动拆空托盘去出库口，插入本地任务
                    if (SqlArray.Count > 0)
                    {
                        StringBuilder[] dbFactoryArray = new StringBuilder[SqlArray.Count];
                        StringBuilder[] sbArray = new StringBuilder[SqlArray.Count];
                        Array.Copy(SqlArray.ToArray(), sbArray, SqlArray.Count);
                        for (int idb = 0; idb < dbFactoryArray.Length; idb++)
                        {
                            dbFactoryArray[idb] = new StringBuilder("DBFactory");
                        }
                        CUpdateDBChangeEventArgs e = new CUpdateDBChangeEventArgs(dbFactoryArray, sbArray);
                        OnUpdateDB(e);
                        //入库变出库，由电气控制到扫码站台向管理申请条码任务
                    }
                    #endregion

                    #region 按PLC连接发送输送机正反向出入库类型
                    if (devArray.Count > 0)
                    {
                        int[] deviceArray = new int[devArray.Count];
                        int[] sendDataArray = new int[devArray.Count];
                        Array.Copy(devArray.ToArray(), deviceArray, devArray.Count);
                        Array.Copy(senddArray.ToArray(), sendDataArray, senddArray.Count);
                        CSendDeviceOrderEventArgs se = new CSendDeviceOrderEventArgs(deviceArray, sendDataArray);
                        OnSendDeviceOrder(se);
                    }
                    #endregion
                    //所有路径循环后一起更新不能变更路径原因
                    if (sBinput_station_codeNotUpdate.ToString().Length > 0)
                    {
                        dboMan.ExecuteSql(String.Format("update IO_CONTROL_MODE_SWITCH set inout_switch_flag=0,inout_switch_remark='{0}' where inout_switch_flag<>0 and input_station_code in ({1})", "设备有任务或者不空闲不能切换路径", sBinput_station_codeNotUpdate.ToString().Substring(1)));
                        dboMan.ExecuteSql(String.Format("update IO_CONTROL_MODE_SWITCH set inout_switch_flag=1,inout_switch_remark='' where  inout_switch_flag<>1 and  input_station_code not in ({0})", sBinput_station_codeNotUpdate.ToString().Substring(1)));
                        dbothread.ExecuteSql(String.Format("update T_BASE_IOMODE_SWITCH set inout_switch_flag=0,inout_switch_remark='{0}' where inout_switch_flag<>0 and  input_station_code in ({1})", "设备有任务或者不空闲不能切换路径", sBinput_station_codeNotUpdate.ToString().Substring(1)));
                        dbothread.ExecuteSql(String.Format("update T_BASE_IOMODE_SWITCH set inout_switch_flag=1,inout_switch_remark='' where  inout_switch_flag<>1 and input_station_code not in ({0})", sBinput_station_codeNotUpdate.ToString().Substring(1)));
                    }
                    else
                    {//所有路径都可以转换
                        dboMan.ExecuteSql(String.Format("update IO_CONTROL_MODE_SWITCH set inout_switch_flag=1,inout_switch_remark='' where  inout_switch_flag<>1"));
                        dbothread.ExecuteSql(String.Format("update T_BASE_IOMODE_SWITCH set inout_switch_flag=1,inout_switch_remark=''  where  inout_switch_flag<>1"));
                    }


                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        StringBuilder sql = new StringBuilder("");
        Model.MonitorInfo mi;//20140824richard
        //20130122
        private static FrmHost _formInstance;
        //20130122
        public static FrmHost FormInstance
        {
            get
            {
                if (_formInstance == null)
                {
                    _formInstance = new FrmHost();
                }
                return _formInstance;
            }
            set { _formInstance = value; }
        }
        int timersum = 0;//20120513
        
        DBFactory.DBOperator dbo  ;
        static DBFactory.DBOperator dboMan;
        /// <summary>
        /// 
        /// </summary>
        public FrmHost()
        {
            try
            {
                dbo = CStaticClass.dbo;
                dboMan = CStaticClass.dboMJ;
                InitializeComponent();
                ContextMenuStrip listboxMenu = new ContextMenuStrip();
                //20230718richard.liu
                ToolStripMenuItem rightMenu = new ToolStripMenuItem("Copy");
                rightMenu.Click += new EventHandler(Copy_Click);
                listboxMenu.Items.AddRange(new ToolStripItem[] { rightMenu });
                listBox1.ContextMenuStrip = listboxMenu;

                CStaticClass.SystemName = CommonClassLib.AppSettings.GetValue("SystemName");
                this.notifyIcon1.Text = CStaticClass.SystemName;
                this.Text = CStaticClass.SystemName;
                //WCSServer.ControlMonitorClient aa = new WCSServer.ControlMonitorClient(new InstanceContext(new FrmSystemInit()));
                //Model.MonitorInfo mi=new Model.MonitorInfo();
                //if (aa.Heartbeat(out mi) == true)
                //{
                //    MessageBox.Show("网络中已经有WCS服务端工作，不要重复启动WCS服务!");
                //    this.Close();
                //    return;
                //}
                _host = new ServiceHost(typeof(WcfControlMonitorLib.SControlMonitor));
                _host.Open();
                //Silverlight跨域访问服务
                policyHost = ClientCrossDomainAccessPolicy.GetHost(_host.BaseAddresses[0].Host);
                policyHost.Open();
                CGetState.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CControl.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CDisassembleTask.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CObtainTask.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CParsePLCData.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                OPCClient.CCommonOPCClient.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                OPCClient.CSendDeviceOrder.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);

                SControlMonitor.RefreshMonitor += new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                
                SControlMonitor.ChannelOpen += new ClientLogEventHandler(SControlMonitor_ChannelOpen);
                SControlMonitor.ClientLogout += new ClientLogEventHandler(SControlMonitor_ClientLogout);
                OPCClient.CCommonOPCClient.DealSQLExe += new CUpdateDBEventHandler(SControlMonitor_SqlEXEUpdateDB);
                OPCClient.CCommonOPCClient.PublishDeviceState += new CUpdateDBEventHandler(SControlMonitor_PLCCommonUpdateDB);
                SocketsTCPIP.CClientTCPIP.UpdateDB += new CUpdateDBEventHandler(SControlMonitor_AGVUpdateDB);
                SocketsTCPIP.CClientTCPIP.SendDeviceOrder += new CSendDeviceOrderEventHandler(SControlMonitor_SendDeviceOrder);
                SocketsTCPIP.CClientTCPIP.WriteDarkCasket += new CWriteDarkCasketEventHandler(SControlMonitor_WriteDarkCasket);
                UpdateDB += new CUpdateDBEventHandler(SControlMonitor_SqlEXEUpdateDB);//20230718richard.liu
                SendDeviceOrder += new CSendDeviceOrderEventHandler(SControlMonitor_BatchSendDeviceData);
                CObtainTask.UpdateDB += new CUpdateDBEventHandler(SControlMonitor_SqlEXEUpdateDB);//20230718richard.liu
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message + ex.InnerException, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                this.Close();
            }
        }

        

        private void Copy_Click(object sender, System.EventArgs e)
        {
            try
            {
                Clipboard.SetText(listBox1.Items[listBox1.SelectedIndex].ToString());
            }
            catch { }

        }
        #region 主线程执行指定委托
        void SControlMonitor_AGVUpdateDB(object sender, CUpdateDBChangeEventArgs e)
        {//20120616
            this.BeginInvoke(new MethodInvoker(delegate()
            { CStaticClass.WcfControl.DealWithListenAGVState_UpdateDB(sender,e); }));
            
        }
        void SControlMonitor_SqlEXEUpdateDB(object sender, CUpdateDBChangeEventArgs e)
        {//20120616
            CUpdateDBChangeEventArgs newe = new CUpdateDBChangeEventArgs();//gjn 按边哥更改
            newe = e;
            lock (lockThis)
            {
                this.BeginInvoke(new MethodInvoker(delegate ()
            { CStaticClass.WcfControl.DealSqlEXE_UpdateDB(sender, newe); }));
            }
        }
       
        void SControlMonitor_PLCCommonUpdateDB(object sender, CUpdateDBChangeEventArgs e)
        {

            StringBuilder[] sb = new StringBuilder[e.DeviceStateInfos.Length];
            Array.Copy(e.DeviceStateInfos, sb, e.DeviceStateInfos.Length);
            string ss = "";
            for (int kk = 0; kk < e.DeviceStateInfos.Length; kk++)
            {
                ss += e.DeviceStateInfos[kk].ToString();
            }
            //CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "中间on", e.Deviceindex.ToString(), ss);
            string errtext = string.Empty;
            if (this.IsHandleCreated)
            {
                this.BeginInvoke(new MethodInvoker(delegate ()
                {
                    CStaticClass.WcfControl.DealWithDeviceState(e.Deviceindex,
                    sb, e.OPCItemNamesDicInfo, e.OPCItemValuesDicInfo);
                }));
            }

        }
        void SControlMonitor_SendBarcode(object sender, CStringInfoEventArgs e)
        {
            string errtext = string.Empty;
            this.BeginInvoke(new MethodInvoker(delegate()
            { 
                CStaticClass.WcfControl.WriteDBData(e.Deviceindex,"DB1",e.Barcode+","+e.Confirm.ToString(),out errtext);
                dbo.ExceSQL(string.Format(" update T_Base_PLC_Ask set F_TaskIndex={0} WHERE (F_DeviceIndex = {1})", e.Deviceindex,Convert.ToInt32(sender)));
            }));
            
        }
        void SControlMonitor_BatchSendDeviceData(object sender, CSendDeviceOrderEventArgs e)
        {
            this.BeginInvoke(new MethodInvoker(delegate ()
            { CStaticClass.WcfControl.DealBatchSendData(sender,e); }));
        }
        void SControlMonitor_SendDeviceOrder(object sender, CSendDeviceOrderEventArgs e)
        {
            this.BeginInvoke(new MethodInvoker(delegate ()
            { CStaticClass.WcfControl.DealWithSendDeviceOrder(sender, e); }));
        }
        void SControlMonitor_WriteDarkCasket(object sender, CWriteDarkCasketEventArgs e)
        {//20121108
            this.BeginInvoke(new MethodInvoker(delegate()
            { CStaticClass.WcfControl.DealWithWriteDarkCasket(sender, e); }));
        }

        void SControlMonitor_CDeviceState(object sender, CDeviceStateChangeEventArgs e)
        {
            try
            {
                SendDeviceInfosToClient(e.Devinfo);
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("SControlMonitor_CDeviceState：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "SControlMonitor_CDeviceState：" + ex.StackTrace + ex.Message;
                }
            }
        }

        void SControlMonitor_RefreshMonitor(RefreshMonitorEventArgs e)
        {
            try
            {
                this.BeginInvoke(new MethodInvoker(delegate()
                {
                    SendMessageToClient(e.RefreshObjectName + "@" + e.RefreshObjectInfo);
                }));
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("SControlMonitor_RefreshMonitor：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "SControlMonitor_RefreshMonitor：" + ex.StackTrace + ex.Message;
                }
            }
        }

        void SControlMonitor_DataChange(object sender, CDataChangeEventArgs e)
        {
            try
            {
                SendMessageToClient(sender.ToString());
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("SControlMonitor_DataChange：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "SControlMonitor_DataChange：" + ex.StackTrace + ex.Message;
                }
            }
        }

        void SControlMonitor_ClientLogout(ClientLogEventArgs e)
        {
            try
            {
                AddList1Info(e.clientInfo);//20120503
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("SControlMonitor_ClientLogout：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "SControlMonitor_ClientLogout：" + ex.StackTrace + ex.Message;
                }
            }
        }

        void SControlMonitor_ChannelOpen(ClientLogEventArgs e)
        {
            try
            {
                AddList1Info(e.clientInfo);//20120503
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("SControlMonitor_ChannelOpen：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "SControlMonitor_ChannelOpen：" + ex.StackTrace + ex.Message;
                }
            }
        }
        #endregion


        private ServiceHost _host = null;
        private ServiceHost policyHost = null;
        
        private void FrmHost_Load(object sender, EventArgs e)
        {
            
        }

       

        private void MIDataClear_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("您确认清空调度系统的调度队列和设备指令队列数据吗？这个操作将导致调度系统丢失当前记录的所有数据，并且使系统恢复到初始状态！", "操作提示：", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) != DialogResult.OK)
            {
                return;
            }
            string errtext=string.Empty;
            if (CStaticClass.WcfControl.DataClear(out errtext) == false)
            {
                MessageBox.Show(errtext, "操作提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

        }
       
        void SendMessageToClient(string strmessage)
        {
            
            IClient cl=null;
            try
            {
                if(AddList1Info(strmessage)==false)return ;//20130510
                var list = WcfControlMonitorLib.SControlMonitor.ClientCallbackLists;
                if (list == null || list.Count == 0)
                {
                    return;
                }
                
                lock (list)
                {
                    foreach (System.Collections.DictionaryEntry client in list)
                    {
                        // Broadcast
                        cl = (IClient)client.Key;
                        //string aa = client.Value.ToString();
                        //this.BeginInvoke(new MethodInvoker(delegate()
                        //{
                        //20140824richard
                        if (strmessage == "巡检客户端")
                        {
                            cl.BeginSendOrderMessage(mi, new AsyncCallback(SendOrderMessageCallback), mi);
                        }
                        else
                        {
                            cl.BeginSendMessage(strmessage, new AsyncCallback(sendMessageCallback), strmessage);

                        }
                        //20140824richard
                        //}));

                    }

                }
            }
            catch (Exception ex)
            {
                if (cl != null)
                {
                    WcfControlMonitorLib.SControlMonitor.ClientCallbackLists.Remove(cl);
                    WcfControlMonitorLib.SControlMonitor.ClientShowLists.Remove(cl);
                }
                AddList1Info(string.Format("SendMessageToClient时异常：{0}", ex.Message));//20120503
                //if (listBox1.Items.Count >= 100) listBox1.Items.Clear();
                //this.listBox1.Items.Add(string.Format("SendMessageToClient时异常：{0},{1}" , ex.Message,DateTime.Now.ToString("u")));
            }
        }
        void SendOrderMessageCallback(IAsyncResult ar)
        {

        }
        void sendMessageCallback(IAsyncResult ar)
        {
            try
            {
                this.BeginInvoke(new MethodInvoker(delegate()
                {

                    string sem = (string)ar.AsyncState;
                    AddList1Info(sem);//20120503
                    //if (listBox1.Items.Count >= 100) listBox1.Items.Clear();
                    //if (listBox1.Items.Count >= 1) 
                    //{
                    //    if (this.listBox1.Items[listBox1.Items.Count - 1].ToString().IndexOf(sem) >= 0) return;
                    //}
                    //if (sem == "巡检客户端") return;
                    //listBox1.Items.Add(DateTime.Now.ToLongTimeString()+sem);

                }));
            }
            catch (Exception ex)
            {
                this.BeginInvoke(new MethodInvoker(delegate()
                {
                    if (tsStatus.Text.IndexOf("巡检客户端sendMessageCallback：" + ex.StackTrace + ex.Message) < 0)
                    {
                        tsStatus.Text += "巡检客户端sendMessageCallback：" + ex.StackTrace + ex.Message;
                    }
                }));
            }
        }
        void SendDeviceInfosToClient(Model.MDevice devinfo)
        {
            IClient cl = null;
            try
            {
                var list = WcfControlMonitorLib.SControlMonitor.ClientCallbackLists;
                if (list == null || list.Count == 0)
                    return;
                lock (list)
                {
                    foreach (System.Collections.DictionaryEntry client in list)
                    {
                        // Broadcast
                        cl = (IClient)client.Key;
                        cl.BeginSendDeviceInfo(devinfo, new AsyncCallback(sendDeviceInfosCallback), null);

                    }

                }
            }
            catch (Exception ex)
            {
                if (cl != null)
                {
                    WcfControlMonitorLib.SControlMonitor.ClientCallbackLists.Remove(cl);
                    WcfControlMonitorLib.SControlMonitor.ClientShowLists.Remove(cl);
                }
                AddList1Info(string.Format("SendDeviceInfosToClient时异常：{0}", ex.Message));//20120503
                //if (listBox1.Items.Count >= 100) listBox1.Items.Clear();
                //this.listBox1.Items.Add(string.Format("SendDeviceInfosToClient时异常：{0},{1}" , ex.Message , DateTime.Now.ToString("u")));
            }
        }

        void sendDeviceInfosCallback(IAsyncResult ar)
        {
            
        }
        private void FrmHost_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (MessageBox.Show("您确认要关闭"+CStaticClass.SystemName+"吗？", "操作提示：", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) != DialogResult.OK)
            {
                e.Cancel = true;
                return;
            }
            if (_host != null)
            {
               
                CGetState.RefreshMonitor -= new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CControl.RefreshMonitor -= new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CDisassembleTask.RefreshMonitor -= new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CObtainTask.RefreshMonitor -= new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                CParsePLCData.RefreshMonitor -= new RefreshMonitorEventHandler(SControlMonitor_RefreshMonitor);
                SControlMonitor.ChannelOpen -= new ClientLogEventHandler(SControlMonitor_ChannelOpen);
                SControlMonitor.ClientLogout -= new ClientLogEventHandler(SControlMonitor_ClientLogout);
                OPCClient.CCommonOPCClient.PublishDeviceState -= new CUpdateDBEventHandler(SControlMonitor_PLCCommonUpdateDB);
                SocketsTCPIP.CClientTCPIP.UpdateDB -= new CUpdateDBEventHandler(SControlMonitor_AGVUpdateDB);
                SocketsTCPIP.CClientTCPIP.SendDeviceOrder -= new CSendDeviceOrderEventHandler(SControlMonitor_SendDeviceOrder);
                SocketsTCPIP.CClientTCPIP.WriteDarkCasket -= new CWriteDarkCasketEventHandler(SControlMonitor_WriteDarkCasket);
                
                UpdateDB -= new CUpdateDBEventHandler(SControlMonitor_SqlEXEUpdateDB);//20230718richard.liu
                CObtainTask.UpdateDB -= new CUpdateDBEventHandler(SControlMonitor_SqlEXEUpdateDB);//20230718richard.liu


                _host.Close();
                IDisposable host = _host as IDisposable;
                host.Dispose();
            }
            CommonClassLib.AppSettings.dbo.Close();
            CommonClassLib.AppSettings.dboM.Close();
        }

        private void MIStartRetrieveTask_Click(object sender, EventArgs e)
        {
            if (MITurnOn.Checked == true)
            {
                this.Text = CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】";//20120510
            }
            else
            {
                this.Text = CStaticClass.SystemName + "【开始获取任务！】";//20120510
            }
            CStaticClass.WcfControl.ObtainTask("", "UPDATE");
            MIStopRetrieveTask.Enabled = true;
            //CStaticClass.ObtainManageTask = true;
            MIStartRetrieveTask.Checked = true;
            MIStopRetrieveTask.Checked = false;
        }

        private void MIStopRetrieveTask_Click(object sender, EventArgs e)
        {
            if (MITurnOn.Checked == true)
            {
                this.Text = CStaticClass.SystemName + "【正在执行自动命令！】";//20120510
            }
            else
            {
                this.Text = CStaticClass.SystemName;//20120510
            }
            CStaticClass.WcfControl.StopObtainTask();
            //CStaticClass.ObtainManageTask = false;
            //20120510CStaticClass.WcfControl.StopObtainTask();
            ToolStripMenuItem tsm;
            for (int i = 0; i < MIStartRetrieveTask.DropDown.Items.Count; i++)
            {
                tsm = (ToolStripMenuItem)MIStartRetrieveTask.DropDown.Items[i];
                tsm.Checked = false;
            }
            MIStartRetrieveTask.Checked = false;
            MIStartRetrieveTask.Enabled = true;
            
            MIStopRetrieveTask.Enabled = false;
            MIStopRetrieveTask.Checked = true;
        }
        void ToolStripMenu_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem tsm; bool ifget = false;

            DataView dv;
            char[] cc = new char[1] { ':' };
            int laneway = 0; StringBuilder minz = new StringBuilder(); StringBuilder maxz = new StringBuilder();
            StringBuilder wherez = new StringBuilder();
            ToolStripMenuItem aa = (ToolStripMenuItem)sender;

            if (aa.Name == "MCAll")
            {
                if (aa.Checked == true)
                {
                    aa.Checked = false;
                    CStaticClass.WcfControl.ObtainTask("", "UPDATE");

                }
                else
                {
                    aa.Checked = true;
                    CStaticClass.WcfControl.ObtainTask(" or (1=1) ", "UPDATE");

                }
                //20100625修正不能获取站台到站台的任务

                for (int i = 0; i < MIStartRetrieveTask.DropDown.Items.Count; i++)
                {

                    tsm = (ToolStripMenuItem)MIStartRetrieveTask.DropDown.Items[i];
                    if (tsm.Name != "MCAll")
                    {

                        tsm.Checked = aa.Checked;

                    }

                }

                //20100625修正不能获取站台到站台的任务

            }
            else
            {
                laneway = Convert.ToInt32(aa.Text.Split(cc)[1]);
                dv = dbo.ExceSQL("select min(f_z) as minZ from st_cell where flaneway=" + laneway + "").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    if (dv[0]["minZ"].ToString().Length == 1)
                    {
                        minz = minz.Append("'0").Append(dv[0]["minZ"].ToString()).Append("-00-00'");
                    }
                    else
                    {
                        minz = minz.Append("'" + dv[0]["minZ"].ToString()).Append("-00-00'");
                    }

                }
                dv = dbo.ExceSQL("select max(f_z) as maxZ from st_cell where flaneway=" + laneway + "").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    if (dv[0]["maxZ"].ToString().Length == 1)
                    {
                        maxz = maxz.Append("'0").Append(dv[0]["maxZ"].ToString()).Append("-99-99'");
                    }
                    else
                    {
                        maxz = maxz.Append("'" + dv[0]["maxZ"].ToString()).Append("-99-99'");
                    }
                }
                wherez.Append(" or ((START_DEVICE_CODE between ").Append(minz).Append(" and ").Append(maxz).Append(" ) or  (END_DEVICE_CODE between ").Append(minz).Append(" and ").Append(maxz).Append("))");
                if (aa.Checked == true)
                {
                    aa.Checked = false;
                    //20100625修正不能获取站台到站台的任务
                    CStaticClass.WcfControl.ObtainTask(wherez.ToString(), "REPLACE");
                    

                    ToolStripMenuItem cm = new ToolStripMenuItem();
                    ToolStripMenuItem all = (ToolStripMenuItem)MIStartRetrieveTask.DropDown.Items["MCAll"];
                    CStaticClass.WcfControl.ObtainTask(" or (1=1) ", "REPLACE");
                    all.Checked = false;
                    StringBuilder wherez1 = new StringBuilder();

                    for (int ii = 0; ii < MIStartRetrieveTask.DropDown.Items.Count; ii++)
                    {
                        //20101208
                        minz.Remove(0, minz.Length);
                        maxz.Remove(0, maxz.Length);

                        cm = (ToolStripMenuItem)MIStartRetrieveTask.DropDown.Items[ii];
                        if ((cm.Checked == true) && (cm.Name != aa.Name) && (cm.Name != "MCAll"))
                        {
                            laneway = Convert.ToInt32(cm.Text.Split(cc)[1]);
                            dv = dbo.ExceSQL("select min(f_z) as minZ from st_cell where flaneway=" + laneway + "").Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                if (dv[0]["minZ"].ToString().Length == 1)
                                {
                                    minz = minz.Append("'0").Append(dv[0]["minZ"].ToString()).Append("-00-00'");
                                }
                                else
                                {
                                    minz = minz.Append("'" + dv[0]["minZ"].ToString()).Append("-00-00'");
                                }

                            }
                            dv = dbo.ExceSQL("select max(f_z) as maxZ from st_cell where flaneway=" + laneway + "").Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                if (dv[0]["maxZ"].ToString().Length == 1)
                                {
                                    maxz = maxz.Append("'0").Append(dv[0]["maxZ"].ToString()).Append("-99-99'");
                                }
                                else
                                {
                                    maxz = maxz.Append("'" + dv[0]["maxZ"].ToString()).Append("-99-99'");
                                }
                            }
                            wherez1.Append(" or ((START_DEVICE_CODE between ").Append(minz).Append(" and ").Append(maxz).Append(" ) or  (END_DEVICE_CODE between ").Append(minz).Append(" and ").Append(maxz).Append("))");

                        }

                    }
                    CStaticClass.WcfControl.ObtainTask(wherez1.ToString(), "APPEND");
                    
                    //20100625修正不能获取站台到站台的任务
                }
                else
                {
                    aa.Checked = true;

                    CStaticClass.WcfControl.ObtainTask(wherez.ToString(), "APPEND");
                }
            }

            MIStartRetrieveTask_Click(sender, e);

            for (int i = 0; i < MIStartRetrieveTask.DropDown.Items.Count; i++)
            {
                tsm = (ToolStripMenuItem)MIStartRetrieveTask.DropDown.Items[i];
                if (tsm.Checked == true)
                {
                    ifget = true;
                }
            }
            if (ifget == false)
            {
                MIStopRetrieveTask_Click(sender, e);

            }
        }

        private void MITurnOn_Click(object sender, EventArgs e)
        {
            MITurnOff.Enabled = true;
            MITurnOn.Enabled = false;
            tsmTurnOff.Enabled = true;
            tsmTurnOn.Enabled = false;

            tsmTurnOff.Checked = false;
            tsmTurnOn.Checked = true;
            MITurnOff.Checked = false;
            MITurnOn.Checked = true;
            //CStaticClass.Order = true;
            CStaticClass.WcfControl.OrderTurnOn();
            StartListenIOModeSwitch();
            if (MIStartRetrieveTask.Checked == true)
            {
                this.Text = CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】";
            }
            else
            {
                this.Text = CStaticClass.SystemName + "【正在执行自动命令！】";
            }
            
        }

        private void MITurnOff_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("您确认要“关闭命令开关”吗？如果“关闭命令开关”将导致调度计算机与所有设备通讯中断！", "操作提示：", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) != DialogResult.OK)
            {
                return;
            }
            CStaticClass.WcfControl.OrderTurnOff();
            EndListenIOModeSwitch();
            MITurnOff.Enabled = false;
            MITurnOn.Enabled = true;
            tsmTurnOff.Enabled = false;
            tsmTurnOn.Enabled = true;

            tsmTurnOn.Checked = false;
            tsmTurnOff.Checked = true;
            MITurnOn.Checked = false;
            MITurnOff.Checked = true;
            
            if (MIStartRetrieveTask.Checked == true)
            {
                this.Text = CStaticClass.SystemName + "【开始获取任务！】";
            }
            else
            {
                this.Text = CStaticClass.SystemName;
            }
           
        }

        int ObtCount = 0;
        private void timerObtainTask_Tick(object sender, EventArgs e)
        {
            timerObtainTask.Enabled = false;
            ObtCount += 1;
            try
            //if (CStaticClass.ObtainManageTask == true)
            {
                string errtext = string.Empty;

                if (CStaticClass.WcfControl.GetAllManageTask(out errtext) == false)
                {
                    if (tsStatus.Text.IndexOf(errtext) < 0)
                    {
                        tsStatus.Text += errtext;
                    }
                }
                #region AGV任务没响应，任务重发
                
                //int DeviceIdx;
                //int TaskIdx = 0;
                //StringBuilder sql = new StringBuilder();
                //DataView  dvmo =new DataView();
                //sql.Remove(0, sql.Length);
                //sql.Append("SELECT F_DeviceIndex,F_DeviceKindIndex,F_MaxSendCount,F_SendInterval FROM T_Base_Device WHERE F_DeviceKindIndex = 6");
                //DataView  dd = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                //for (int j = 0; j < dd.Count; j++)
                //{
                //    DeviceIdx = Convert.ToInt32(dd[j]["F_DeviceIndex"]);
                //    #region 发送后规定时间内没报开始或者读取数据成功需要进行超时重发，重发超限时报错
                //    sql.Remove(0, sql.Length);
                //    sql.Append("select F_MonitorIndex,F_DeviceIndex,F_SendCount,F_StartTime,F_Status,F_AgvNo from T_Monitor_Task where F_DeviceIndex=").Append(DeviceIdx).Append(" and f_status=1 and F_SendFlag='1'");
                //    dvmo= dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20100905只重发主任务
                //    if (dvmo.Count > 0)
                //    {//20110510
                //        TaskIdx = Convert.ToInt32(dvmo[0]["F_MonitorIndex"]);
                //        int scount = Convert.ToInt32(dvmo[0]["F_SendCount"]);
                //        scount++;
                //        if (scount > Convert.ToInt32(dd[j]["F_MaxSendCount"]))
                //        {
                //            //发送次数超限报警
                //            sql.Remove(0, sql.Length);
                //            sql.Append("update T_Monitor_Task set F_Status=999 where F_Status!=999 and F_MonitorIndex=").Append(TaskIdx);//20110505
                //            dbo.ExceSQL(sql.ToString());

                //        }
                //        else
                //        {
                //            //DateTime.Now.AddMilliseconds
                //            if (dvmo[0]["F_StartTime"].ToString() != "-")
                //            {
                //                if (Convert.ToDateTime(dvmo[0]["F_StartTime"].ToString().Substring(0, 19), CultureInfo.CurrentCulture).AddMilliseconds(Convert.ToDouble(dd[j]["F_SendInterval"])) <= DateTime.Now)
                //                {

                //                    if (dvmo[0]["F_AgvNo"] == DBNull.Value)
                //                    {
                //                        sql.Remove(0, sql.Length);
                //                        sql.Append("update T_Base_Device set F_LockedState=0 where F_DeviceIndex=").Append(DeviceIdx);
                //                        dbo.ExceSQL(sql.ToString());
                //                        sql.Remove(0, sql.Length);
                //                        sql.Append("update T_Monitor_Task set F_SendCount=").Append(scount).Append(",F_Status=0 where F_MonitorIndex=").Append(TaskIdx);
                //                        dbo.ExceSQL(sql.ToString());
                //                    }
                //                    CommonClassLib.CCarryConvert.WriteDarkCasket("GetDeviceState", "超时重发", DeviceIdx.ToString(), "设备指令索引：" + TaskIdx.ToString() + "发送后，一直没有报告执行或者完成，重新发送命令！");
                //                }
                //            }
                //        }
                //    }
                    
                //    #endregion
                //}
                #endregion
                //if (ObtCount == 2)//扬州晶澳5S更新一次
                //{
                //    for (int g = 11001; g <= 11010; g++)
                //    {
                //        if (stackUcodeJA.IndexOf(g.ToString()) >= 0)
                //        {
                //            CStaticClass.WcfControl.ChangeFlane(g);
                //        }
                //    }
                //    ObtCount = 0;
                //}
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf(ex.Message) < 0)
                {
                    tsStatus.Text += ex.Message;
                }
            }
            finally
            {
                timerObtainTask.Enabled = true;
            }
        }

        private void timerDisassembleTask_Tick(object sender, EventArgs e)
        {
            timerDisassembleTask.Enabled = false;
            try
            //if (CStaticClass.Order == true)
            {
                string errtext = string.Empty;
                if (CStaticClass.WcfControl.DisassembleTask(out errtext) == false)
                {
                    if (tsStatus.Text.IndexOf(errtext) < 0)
                    {
                        tsStatus.Text += errtext;
                    }
                }
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf(ex.Message ) < 0)
                {
                    tsStatus.Text += ex.Message;
                }
            }
            finally
            {
                timerDisassembleTask.Enabled = true;
            }
        }

        private void timerSendOrder_Tick(object sender, EventArgs e)
        {
            timerSendOrder.Enabled = false;
            try
            //if (CStaticClass.Order == true)
            {
                string errtext = string.Empty;
                if (CStaticClass.WcfControl.StartSendDeviceOrder(out errtext) == false)
                {
                    if (tsStatus.Text.IndexOf(errtext) < 0)
                    {
                        tsStatus.Text += errtext;
                    }
                }
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf(ex.Message) < 0)
                {
                    tsStatus.Text += ex.Message;
                }
            }
            finally
            {
                timerSendOrder.Enabled = true;
            }
        }

        private void MISeeDarket_Click(object sender, EventArgs e)
        {
            FrmBrowseDarkCasket.FormInstance.Show();
        }

        private void MIDarketFileSet_Click(object sender, EventArgs e)
        {
            FrmDarkCasket.FormInstance.Show();
        }

        private void MIAutoTaskHistory_Click(object sender, EventArgs e)
        {
            FrmBrowseAotoTaskLog.FormInstance.Show();
        }

        

        private void MMExitSystem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void MISystemInit_Click(object sender, EventArgs e)
        {
            FrmSystemInit.FormInstance.Show();
        }

        private void toolStripMenuItem13_Click(object sender, EventArgs e)
        {
            MITurnOn_Click(sender, e);
        }

        private void toolStripMenuItem14_Click(object sender, EventArgs e)
        {
            MITurnOff_Click(sender, e);
        }

        private void toolStripMenuItem9_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void toolStripMenuItem8_Click(object sender, EventArgs e)
        {
            this.Visible = true;
            this.WindowState = FormWindowState.Maximized;
        }

        private void toolStripMenuItem10_Click(object sender, EventArgs e)
        {
            this.Visible = false;
        }

        

        private void notifyIcon1_DoubleClick(object sender, EventArgs e)
        {
          
            this.TopMost = true;
            this.Visible = true;
            this.TopMost = false;
            this.WindowState = FormWindowState.Maximized;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            listBox1.Items.Clear();
        }
        
        /// <summary>
        /// 20120503向列表框增加显示内容
        /// </summary>
        /// <param name="txtinfo"></param>
        /// <returns></returns>
        bool AddList1Info(string txtinfo)
        {
            try
            {
                if (txtinfo.IndexOf("巡检客户端") >= 0) return true;
                if (listBox1.Items.Count >= 700) listBox1.Items.Clear();
                foreach (object li in listBox1.Items)
                {
                    if (li.ToString().IndexOf(txtinfo) >= 0)
                    {
                        if (li.ToString().Contains("警告") && (!li.ToString().Contains("手动")) && (Convert.ToDateTime(li.ToString().Substring(0, 19)).AddSeconds(3)) > DateTime.Now)
                        {

                        }
                        else
                        {
                            return false;
                        }
                        //listBox1.Items.Remove(li);
                        //listBox1.Items.Add(DateTime.Now.ToLongTimeString() + txtinfo);
                        return false;
                    }
                }
                listBox1.Items.Add(DateTime.Now.ToString("u") + txtinfo);
                return true;
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("巡检客户端AddList1Info：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "巡检客户端AddList1Info：" + ex.StackTrace + ex.Message;
                }
                return false;
            }
        }

        

        private void button4_Click(object sender, EventArgs e)
        {
            try
            {
                this.listBox2.Items.Clear();
                var list = WcfControlMonitorLib.SControlMonitor.ClientCallbackLists;
                if (list == null || list.Count == 0)
                    return;
                lock (list)
                {
                    foreach (System.Collections.DictionaryEntry client in list)
                    {
                        listBox2.Items.Add(client.Value.ToString());

                    }

                }
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("刷新客户端时：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "刷新客户端时：" + ex.StackTrace + ex.Message;
                }
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            try
            {
                if (listBox2.SelectedItem == null) return;
                var list = WcfControlMonitorLib.SControlMonitor.ClientCallbackLists;
                foreach (System.Collections.DictionaryEntry client in list)
                {
                    if (client.Value.ToString() == listBox2.SelectedItem.ToString())
                    {
                        WcfControlMonitorLib.SControlMonitor.ClientShowLists.Remove(client.Key);
                        WcfControlMonitorLib.SControlMonitor.ClientCallbackLists.Remove(client.Key);
                        button4_Click(sender, e);
                        return;
                    }

                }
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("注销客户端时：" + ex.StackTrace + ex.Message) < 0)
                {
                    tsStatus.Text += "注销客户端时：" + ex.StackTrace + ex.Message;
                }
            }
        }
        void ClickObtainTask()
        {
            if (MITurnOn.Checked == true)
            {
                if (this.Text != CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】")
                {
                    this.Text = CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】";
                }
            }
            else
            {
                if (this.Text != CStaticClass.SystemName + "【开始获取任务！】")
                {
                    this.Text = CStaticClass.SystemName + "【开始获取任务！】";
                }
            }
            MIStartRetrieveTask.Checked = true;
            MIStartRetrieveTask.Enabled = false;
            MIStopRetrieveTask.Checked = false;
            MIStopRetrieveTask.Enabled = true;
        }
        void ClickStopObtainTask()
        {
            if (MITurnOn.Checked == true)
            {
                if (this.Text != CStaticClass.SystemName + "【正在执行自动命令！】")
                {
                    this.Text = CStaticClass.SystemName + "【正在执行自动命令！】";
                }
            }
            else
            {
                if (this.Text != CStaticClass.SystemName)
                {
                    this.Text = CStaticClass.SystemName;
                }
            }

            MIStartRetrieveTask.Checked = false;
            MIStartRetrieveTask.Enabled = true;
            MIStopRetrieveTask.Enabled = false;
            MIStopRetrieveTask.Checked = true;
        }
        void ClickOrderTurnOn()
        {
            if (MIStartRetrieveTask.Checked == true)
            {
                if (this.Text != CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】")
                {
                    this.Text = CStaticClass.SystemName + "【开始获取任务！】" + "【正在执行自动命令！】";
                }
            }
            else
            {
                if (this.Text != CStaticClass.SystemName + "【正在执行自动命令！】")
                {
                    this.Text = CStaticClass.SystemName + "【正在执行自动命令！】";
                }
            }
            MITurnOff.Enabled = true;
            MITurnOn.Enabled = false;
            MITurnOff.Checked = false;
            MITurnOn.Checked = true;
        }
        void ClickOrderTurnOff()
        {

            if (MIStartRetrieveTask.Checked == true)
            {
                if (this.Text != CStaticClass.SystemName + "【开始获取任务！】")
                {
                    this.Text = CStaticClass.SystemName + "【开始获取任务！】";
                }
            }
            else
            {
                if (this.Text != CStaticClass.SystemName)
                {
                    this.Text = CStaticClass.SystemName;
                }
            }

            MITurnOff.Enabled = false;
            MITurnOn.Enabled = true;
            MITurnOn.Checked = false;
            MITurnOff.Checked = true;
        }
        private void timerS7Connection_Tick(object sender, EventArgs e)
        {
            DataView dv = new DataView();
            try
            {//20121203
                //20130817richard
                //扬州晶澳  添加弯道垛机入库路径可用控制
                
                DBFactory.DBOperator dboM = CommonClassLib.AppSettings.dboM;

                
                CStaticClass.WcfControl.Heartbeat(out mi);
                if (mi.S7connectOnline.Count > 0)
                {
                    foreach (PictureBox ctrl in pS7conn.Controls.OfType<PictureBox>())
                    {
                        if (mi.S7connectOnline.ContainsKey(ctrl.Name.Substring(2)) && (mi.S7connectOnline[ctrl.Name.Substring(2)] == 0))
                        {
                            ctrl.Image = wcfControlMonitorClient.Properties.Resources.ProgressSuccess;
                        }
                        else
                        {
                            ctrl.Image = wcfControlMonitorClient.Properties.Resources.ProgressError;
                        }
                    }

                }

            
                if (mi.Orderturnon == true)
                {
                    ClickOrderTurnOn();
                }
                else
                {
                    ClickOrderTurnOff();
                }
                if (mi.Obtaintask == true)
                {
                    ClickObtainTask();
                }
                else
                {
                    ClickStopObtainTask();
                }
                timersum++;//20120513
                
                if (timersum > 60)//20120513
                {
                    //listBox1.Items.Clear();
                    timersum = 0;
                    if (WcfControlMonitorLib.CStaticClass.DBFactory == "OracleDBFactory")
                    {
                        //todo
                    }
                    else
                    {
                        dv = dbo.ExceSQL("SELECT  T_Monitor_Task.F_MonitorIndex,T_Base_Device.F_DeviceIndex FROM T_Base_Device,T_Monitor_Task where T_Base_Device.F_DeviceIndex = T_Monitor_Task.F_DeviceIndex and (T_Base_Device.F_DeviceKindIndex = 1 OR T_Base_Device.F_DeviceKindIndex = 4) and F_Status>0  and F_StartTime!='-' and (datediff(MINUTE,CONVERT(datetime,SUBSTRING( F_StartTime,1,19),120),GETDATE()) >720)").Tables[0].DefaultView;

                        for (int i = 0; i < dv.Count; i++)
                        {
                            CStaticClass.WcfControl.ActionError(Convert.ToInt32(dv[i][1]), Convert.ToInt32(dv[i][0]), 999);
                            CStaticClass.dbo.ExecuteSql(string.Format("update T_Base_Device set F_ErrorTaskNo=0 where F_ErrorTaskNo={0}", Convert.ToInt32(dv[i][0])));
                        }
                    }
                }
                //timerefesh++;//20150103增加断网恢复//20151120取消断网恢复
                //if (timerefesh > 1)
                //{//20150103增加断网恢复
                //    CStaticClass.WcfControl.RefreshMonitoringMode();
                //    timerefesh = 0;
                //}


                SendMessageToClient("巡检客户端");
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf("巡检客户端时："+ex.StackTrace+ex.Message) < 0)
                {
                    tsStatus.Text += "巡检客户端时：" + ex.StackTrace + ex.Message;
                }
            }
            finally
            {
                dv.Dispose();
            }
            
        }

        private void timerResend_Tick(object sender, EventArgs e)
        {
            // 20150319 AGV重发计时器
            #region 发送后规定时间内没报开始或者读取数据成功需要进行超时重发，重发超限时报错
            //CommonClassLib.CCarryConvert.WriteDarkCasket("Resend", "进入AGV重发任务黑匣子:", "进入AGV重发任务黑匣子:", "进入AGV重发任务黑匣子:");//lyyyyy0928
            StringBuilder sql = new StringBuilder();
            //sql.Remove(0, sql.Length);
            //sql.Append("SELECT F_DeviceIndex,F_DeviceKindIndex,F_MaxSendCount,F_SendInterval FROM T_Base_Device WHERE (F_DeviceKindIndex = 1) OR (F_DeviceKindIndex = 2) OR (F_DeviceKindIndex = 4) OR (F_DeviceKindIndex = 7) OR (F_DeviceKindIndex = 6) OR (F_DeviceKindIndex = 30)");
            //DataView dd = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;

            sql.Remove(0, sql.Length);
            sql.Append("select F_MonitorIndex,F_DeviceIndex,F_SendCount,F_StartTime,F_Status,F_AgvNo from T_Monitor_Task where (F_DeviceIndex in (select F_DeviceIndex from T_Base_Device where F_DeviceKindIndex = 6)) and f_status=1 and F_SendFlag='1'");
            DataView dvmo = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20100905只重发主任务
            if (dvmo.Count > 0)
            {//20110510
                int TaskIdx = Convert.ToInt32(dvmo[0]["F_MonitorIndex"]);
                int scount = Convert.ToInt32(dvmo[0]["F_SendCount"]);
                scount++;
                if (scount > 5)
                {
                    //发送次数超限报警
                    sql.Remove(0, sql.Length);//lyyyyy0928
                    sql.Append("update T_Monitor_Task set F_Status=999 where F_Status!=999 and F_MonitorIndex=").Append(TaskIdx);//20110505
                    dbo.ExceSQL(sql.ToString());

                }
                else
                {
                    //DateTime.Now.AddMilliseconds
                    if (dvmo[0]["F_StartTime"].ToString() != "-")
                    {
                        if (Convert.ToDateTime(dvmo[0]["F_StartTime"].ToString().Substring(0, 19), CultureInfo.CurrentCulture).AddMilliseconds(Convert.ToDouble(300000)) <= DateTime.Now)
                        {

                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_LockedState=0 where F_DeviceIndex= '").Append(dvmo[0]["F_DeviceIndex"].ToString()).Append("'");
                            dbo.ExceSQL(sql.ToString());
                            sql.Remove(0, sql.Length);
                            //sql.Append("update T_Monitor_Task set F_SendCount=").Append(scount).Append(",F_Status=0 where F_MonitorIndex=").Append(TaskIdx);
                            sql.Append("update T_Monitor_Task set F_Status=0 where F_MonitorIndex=").Append(TaskIdx);
                            dbo.ExceSQL(sql.ToString());
                            //CommonClassLib.CCarryConvert.WriteDarkCasket("timerResend_Tick", DBFactory.DBOperator.MultiLanguageRes["CGetState_GetDeviceState_timeOutResend"], "13001", DBFactory.DBOperator.MultiLanguageRes["Host_DeviceTask"] + TaskIdx.ToString() + DBFactory.DBOperator.MultiLanguageRes["CGetState_GetDeviceState_TaskSendedWaitTimeoutReSend"]);
                        }
                    }
                }
            }
            //CommonClassLib.CCarryConvert.WriteDarkCasket("Resend", "离开AGV重发任务黑匣子:", "离开AGV重发任务黑匣子:", "离开AGV重发任务黑匣子:");//lyyyyy0928
            #endregion
        }

        private void timerAGVReConnect_Tick(object sender, EventArgs e)
        {
            timerAGVReConnect.Enabled = false;
            try
            {
                string errtext = string.Empty;
                if (CStaticClass.WcfControl.ReConnectAGVPC(out errtext) == false)
                {
                    if (tsStatus.Text.IndexOf(errtext) < 0)
                    {
                        tsStatus.Text += errtext;
                    }
                }
            }
            catch (Exception ex)
            {
                if (tsStatus.Text.IndexOf(ex.Message) < 0)
                {
                    tsStatus.Text += ex.Message;
                }
            }
            finally
            {
                timerAGVReConnect.Enabled = true;
            }
        }

        
        /// <summary>
        /// 获取调度生成的调度任务的索引
        /// </summary>
        /// <returns></returns>
        static public int GetTempManageIdx()
        {
            //20100108
            DataSet ds = new DataSet();
            try
            {
                int maxIdx = 10001;

                ds = dbothread.ExceSQL("SELECT F_ManageTaskIndex FROM T_Base_Task_Index_Temp_Task");
                if (ds.Tables[0].DefaultView.Count > 0)
                {
                    if ((Convert.ToInt32(ds.Tables[0].DefaultView[0]["F_ManageTaskIndex"]) + 1) >= 19998)
                    {
                        maxIdx = 10001;
                    }
                    else
                    {
                        maxIdx = (Convert.ToInt32(ds.Tables[0].DefaultView[0]["F_ManageTaskIndex"]) + 1);
                    }
                }
                else
                {
                    maxIdx = 10001;
                }
                //判断临时调度任务表是否有重复值
                if (IFExitTempManageIndex(maxIdx) == true)
                {
                    RecordMaxTempManageTaskFID(maxIdx);
                    maxIdx = GetTempManageIdx();
                    return maxIdx;
                }

                RecordMaxTempManageTaskFID(maxIdx);
                return maxIdx;
            }
            catch (Exception ex)
            {//20100108
                
                throw ex;
                //return 0;
            }
            finally
            {//20100108
                ds.Dispose();
            }

        }
        static public void RecordMaxTempManageTaskFID(int fid)
        {//20100108
            DataView dv = new DataView();
            StringBuilder sql = new StringBuilder();
            try
            {//20100108
                dv = dbothread.ExceSQL("select F_ManageTaskIndex from T_Base_Task_Index_Temp_Task").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    
                    sql.Remove(0, sql.Length);
                    sql.Append("UPDATE T_Base_Task_Index_Temp_Task SET F_ManageTaskIndex =").Append(fid);
                    dbothread.ExceSQL(sql.ToString());
                    return;
                    //}
                }
                else
                {
                    //20101124
                    sql.Remove(0, sql.Length);
                    sql.Append("INSERT INTO T_Base_Task_Index_Temp_Task (F_ManageTaskIndex)VALUES (").Append(fid).Append(")");
                    dbothread.ExceSQL(sql.ToString());
                    return;
                }
            }
            catch (Exception ex)
            {//20100108
               
                throw ex;
                //return 0;
            }
            finally
            {//20100108
                dv.Dispose();
            }
        }
        static public bool IFExitTempManageIndex(int fid)
        {
            StringBuilder sql = new StringBuilder();
            //20100108
            DataView dv = new DataView();
            try
            {
                //20101124
                sql.Remove(0, sql.Length);
                sql.Append("SELECT fid FROM T_Manage_Task WHERE (F_ManageTaskKindIndex=2 and fid = ").Append(fid).Append(")");
                dv = dbothread.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {//20100108
                throw ex;
            }
            finally
            {//20100108
                dv.Dispose();
            }
        }
        private static void splitAheadDetect(string[] AheadDetect,out  StringBuilder outSBUnswitchRemark)
        {
            StringBuilder sBinput_station_codeNotUpdate = new StringBuilder("");
            StringBuilder sbUnswitchRemark = new StringBuilder("");
            StringBuilder sql = new StringBuilder();
            string[] DS;
            char[] dd = new char[1] { '.' };
            int tempdevice = 0;
            Model.MDevice mDevice;
            try
            {
                for (int k = AheadDetect.GetLowerBound(0); k <= AheadDetect.GetUpperBound(0); k++)
                {
                    if (AheadDetect[k].Trim().Length <= 0) continue;
                    
                    if (AheadDetect[k].Trim().Substring(0, 1).ToUpper() == "I")//是否空闲
                    {
                        tempdevice = Convert.ToInt32(AheadDetect[k].Trim().Substring(1));
                        mDevice = Model.CGetInfo.GetDeviceInfo(tempdevice);
                        if (mDevice == null) continue;
                        #region 是否空闲
                        if (mDevice.RunState != 0)
                        {//不空闲
                            
                            sbUnswitchRemark.Append(tempdevice).Append("不空闲；"); ;
                           
                        }
                        #endregion
                    }
                    else if (AheadDetect[k].Trim().Substring(0, 1).ToUpper() == "D")//是否无货
                    {
                        #region 是否无货
                        int devicebyte = 0, devbit = 0;
                        DS = AheadDetect[k].Trim().Substring(1).Split(dd);
                        int.TryParse(DS[0], out devicebyte);
                        int.TryParse(DS[1], out devbit);
                        //判断是否检测正数索引值（正数代表是否满足开关量＝0无货）
                        if (devicebyte > 0)
                        {
                            mDevice = Model.CGetInfo.GetDeviceInfo(devicebyte);
                            if (mDevice == null) continue;
                            switch (devbit)
                            {
                                case 0:
                                    if (mDevice.SplitByte_0 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".0检测开关被遮挡；");
                                    }
                                    break;

                                case 1:
                                    if (mDevice.SplitByte_1 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".1检测开关被遮挡；");
                                    }
                                    break;
                                case 2:
                                    if (mDevice.SplitByte_2 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".2检测开关被遮挡；");
                                    }
                                    break;
                                case 3:
                                    if (mDevice.SplitByte_3 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".3检测开关被遮挡");
                                    }
                                    break;
                                case 4:
                                    if (mDevice.SplitByte_4 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".4检测开关被遮挡；");
                                    }
                                    break;
                                case 5:
                                    if (mDevice.SplitByte_5 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".5检测开关被遮挡；");
                                    }
                                    break;
                                case 6:
                                    if (mDevice.SplitByte_6 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".6检测开关被遮挡；");
                                    }
                                    break;
                                case 7:
                                    if (mDevice.SplitByte_7 == 1)
                                    {
                                        sbUnswitchRemark.Append(tempdevice).Append(".7检测开关被遮挡；");
                                    }
                                    break;
                            }
                        }
                        else
                        {//判断是否检测负数索引值（负数代表是否满足开关量＝1），不应该出现

                        }
                        #endregion
                    }
                    else if (AheadDetect[k].Trim().Substring(0, 1).ToUpper() == "U")//是否有任务
                    {
                        tempdevice = Convert.ToInt32(AheadDetect[k].Trim().Substring(1));
                        mDevice = Model.CGetInfo.GetDeviceInfo(tempdevice);
                        if (mDevice == null) continue;
                        #region 是否有任务
                        sql.Clear();
                        sql.Append(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_NumParam1 = {0} or F_NumParam4 = {0}) ", tempdevice));
                        DataView  dv= dbothread.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            sbUnswitchRemark.Append(tempdevice).Append("有任务；");
                        }
                        #endregion
                    }
                    else if (AheadDetect[k].Trim().Substring(0, 1).ToUpper() == "V")//是否有任务
                    {
                        tempdevice = Convert.ToInt32(AheadDetect[k].Trim().Substring(1));
                        mDevice = Model.CGetInfo.GetDeviceInfo(tempdevice);
                        if (mDevice == null) continue;
                        #region 是否有任务
                        sql.Clear();
                        sql.Append(string.Format("SELECT fid FROM T_Manage_Task WHERE fenddevice={0} ", tempdevice));
                        DataView dv = dbothread.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            sbUnswitchRemark.Append(tempdevice).Append("有任务；");
                        }
                        #endregion
                    }
                    else if (AheadDetect[k].Trim().Substring(0, 1).ToUpper() == "W")//是否有任务
                    {
                        tempdevice = Convert.ToInt32(AheadDetect[k].Trim().Substring(1));
                        mDevice = Model.CGetInfo.GetDeviceInfo(tempdevice);
                        if (mDevice == null) continue;
                        #region 是否有任务
                        sql.Clear();
                        sql.Append(string.Format("SELECT fid FROM T_Manage_Task WHERE fenddevice={0} or fstartdevice={0} ", tempdevice));
                        DataView dv = dbothread.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            sbUnswitchRemark.Append(tempdevice).Append("有任务；");
                        }
                        #endregion
                    }
                    else
                    {

                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                outSBUnswitchRemark = sbUnswitchRemark;

            }
        }

        

        //private void button2_Click(object sender, EventArgs e)
        //{
        //    DataView dvtmp = null; string pp;
        //    DataView dv = dbo.ExceSQL("select f_lanegatedeviceindex,f_laneindex,f_zxy from T_BASE_LANE_GATE").Tables[0].DefaultView;
        //    for (int i = 0; i < dv.Count; i++)
        //    {
        //        if (dv[i]["f_zxy"].ToString().Substring(0,2) == "01" || dv[i]["f_zxy"].ToString().Substring(0,2) == "02")
        //        {
        //            pp = string.Format("02") + dv[i]["f_zxy"].ToString().Substring(2);
        //        }
        //        else
        //        {
        //            pp = string.Format("03") + dv[i]["f_zxy"].ToString().Substring(2);
        //        }

        //        dbo.ExecuteSql(string.Format("update T_BASE_LANE_GATE set f_zxy='{0}' where f_lanegatedeviceindex={1}", pp, dv[i]["f_lanegatedeviceindex"]));

        //    }

        //}
    }

}