using BarTenderPrint;
using GeBoShi.ImageDefect;
using HZH_Controls.Forms;
using MaiMuControl.Device;
using MaiMuControl.Device.IOCardDev;
using MaiMuControl.Device.IOCardDev.Advantech;
using MaiMuControl.Device.LightDev;
using MaiMuControl.Device.LightDev.CST;
using MaiMuControl.Device.LightDev.Rsee;
using MaiMuControl.SysStatusMgr.CloudMgr;
using MaiMuControl.SysStatusMgr.StatusMgr;
using MaiMuControl.SysStatusMgr.UserMgr;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using ToolKits.Disk;

namespace GeBoShi.SysCtrl
{
    /// <summary>
    /// 主系统控制
    /// </summary>
    public class SysMgr
    {
        #region singleton实例化
        private static SysMgr _instance;
        private static readonly object _lock = new object();
        public static SysMgr Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            _instance = new SysMgr();
                        }
                    }
                }
                return _instance;
            }
        }
        #endregion

        #region 私有
        //系统状态
        private StatusMgr statusMgr;
        public StatusMgr StatusMgr { get { return statusMgr; } }
        //用户管理
        private UserMgr userMgr;
        public UserMgr UserMgr { get { return userMgr; } }

        //系统配置管理
        private ConfMgr confMgr;

        //图像处理
        private DefectLib defectLib;
        public DefectLib DefectLib { get { return defectLib; } }

        //产品检测列表
        private List<string> productCodeList = new List<string>();
        public List<string> ProductCodeList { get { return productCodeList; } }

        //产品ID列表
        private List<int> productIdList = new List<int>();
        public List<int> ProductIdList { get { return productIdList; } }

        Service.ProductService PdtService = new Service.ProductService();
        #endregion

        #region 公开字段
        private bool _isInit;
        /// <summary>
        /// 是否初始化完成
        /// </summary>
        public bool IsInit { get { return _isInit; } }
        private bool _isRuning;
        /// <summary>
        /// 设备正在运行
        /// </summary>
        public bool IsRuning { get { return _isRuning; } }

        private bool _isAuto;
        /// <summary>
        /// 设备正在自动化流程中
        /// </summary>
        public bool IsAuto { get { return _isAuto; } }
        #endregion

        #region 私有流程
        //主流程
        private Thread _mainThread;
        private CancellationTokenSource _cts;
        #endregion

        #region 云端
        //局域网云端
        private bool init_Cloud;
        private CloudMgr cloudMgr;
        private int DailyOutput;
        #endregion
        private SysMgr()
        {
            _isInit = false;
            _isRuning = false;
            _isAuto = false;

            statusMgr = StatusMgr.Instance;
            confMgr = ConfMgr.Instance;

            userMgr = new UserMgr(statusMgr.MySqlIP);

            _cts = new CancellationTokenSource();

            init_Cloud = false;
            cloudMgr = new CloudMgr();
            DailyOutput = 0;
        }

        #region 本地云上传
        /// <summary>
        /// 上传当日产量
        /// </summary>
        private void SendDailyOutput()
        {
            //开启云端
            if (init_Cloud)
            {
                try
                {
                    if (!cloudMgr.SendTopic("device/attributes", $"{{ \"DailyOutput\": \"{DailyOutput}\"}}"))
                        Log("云端", $"上传失败", WarningEnum.Low);
                }
                catch (Exception e)
                {
                    Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);
                }
            }
        }
        /// <summary>
        /// 上传正常状态
        /// </summary>
        public void SendStatus()
        {
            //开启云端
            if (init_Cloud)
            {
                //上传报警状态和信息
                string statusStr = "正常";
                switch (StatusMgr.Status)
                {
                    case SystemStsEnum.Manual:
                        statusStr = "人工操作";
                        break;
                    case SystemStsEnum.Standby:
                        statusStr = "正常待机";
                        break;
                    case SystemStsEnum.Initial:
                        statusStr = "初始化";
                        break;
                    case SystemStsEnum.Auto:
                        statusStr = "自动运行";
                        break;
                    case SystemStsEnum.Pause:
                        statusStr = "自动暂停";
                        break;
                    case SystemStsEnum.SetParams:
                        statusStr = "参数设置";
                        break;
                    case SystemStsEnum.Debug:
                        statusStr = "调试";
                        break;
                    case SystemStsEnum.Warning:
                        statusStr = "系统报警";
                        break;
                    case SystemStsEnum.Bootload:
                        statusStr = "Bootload";
                        break;
                    default:
                        statusStr = "未知";
                        break;
                }
                try
                {
                    if (!cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"无报警信息\", " +
                    $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}"))
                        Log("云端", $"上传失败", WarningEnum.Low);
                }
                catch (Exception e)
                {
                    Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);
                }
            }
        }
        #endregion

        #region 用户+登入+管理
        /// <summary>
        /// 登入
        /// </summary>
        /// <returns></returns>
        public bool LoginSystem()
        {
            return userMgr.UserLoginDialog();
        }
        /// <summary>
        /// 用户权限
        /// </summary>
        public void UserPermissiomMgr()
        {
            userMgr.RightManageDialog();
        }
        /// <summary>
        /// 用户管理
        /// </summary>
        public void UserListMgr()
        {
            userMgr.UserManagerDialog();
        }
        #endregion

        #region 系统初始化&&运行
        /// <summary>
        /// 系统初始化
        /// </summary>
        /// <returns></returns>
        public bool Initial()
        {
            try
            {
                bool ret = false;
                string err = "";
                InitLog("系统开始初始化...");
                //Thread.Sleep(200);

                // 加载系统配置
                InitLog("加载系统参数...");
                ret = confMgr.LoadSystemConfig();

                if (!ret)
                {
                    throw new Exception("系统参数加载失败...");
                }
                InitLog("系统参数加载完成！");
                //根据llog路径，开始记录日志
                statusMgr.StartLog(confMgr.SysConfigParams.LogPath);
                statusMgr.GotoInitial();
                SendStatus();
                //Thread.Sleep(200);

                // 硬件初始化
                if (!InitAllDev())
                {
                    throw new Exception("硬件初始化失败...");
                }
                InitLog("硬件初始化完成！");

                // 加载硬件配置
                InitLog("加载硬件驱动参数...");
                if (!LoadDevConfig())
                {
                    throw new Exception("加载硬件驱动参数失败...");
                }
                InitLog("加载硬件驱动参数完成！");
                //Thread.Sleep(200);

                // 处理运行
                InitLog("AI算法核心初始化...");
                
                if (!defectLib.start())
                    throw new Exception("外观检测核心初始化失败...");
                InitLog("AI算法核心初始化完成！");

                LedReady();

                //初始化成功
                _isInit = true;
                statusMgr.GotoNormalStandby();
                SendStatus();

                OnInitRuning(new InitEventArgs("系统初始化完成...", this.IsInit));

                Run();

                return ret;
            }
            catch (Exception ex)
            {
                InitLog(ex.Message, "初始化", WarningEnum.High);
                InitLog("系统初始化失败！", "初始化", WarningEnum.High);
                //statusMgr.GotoWarning(MaiMuControl.Device.WarningEnum.High, "初始化", ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 初始化图像处理报警
        /// </summary>
        /// <returns></returns>
        public bool InitDefectEvent()
        {
            defectLib.WarningEvent = (warning, msg) =>
            {
                Log("缺陷检测", msg, warning);
            };
            return true;
        }

        public bool InitCloudConnect()
        {
            if (confMgr.SysConfigParams.OpenCloud)
            {
                if (cloudMgr.ConnectCloud(confMgr.SysConfigParams.CloudServerIP, confMgr.SysConfigParams.CloudServerPort,
                    confMgr.SysConfigParams.CloudUser, confMgr.SysConfigParams.CloudPassword))
                {
                    init_Cloud = true;
                    Log("云端数据", "开启云端连接");
                    return true;
                }
                Log("云端数据", "云端连接失败！", WarningEnum.Low);
                return false;
            }
            return true;
        }
        /// <summary>
        /// 运行主线程
        /// </summary>
        private void Run()
        {
            _mainThread = new Thread(() =>
            {
                MainThreadFunction();
            });
            _mainThread.IsBackground = true;
            _mainThread.Start();
        }
        #endregion

        #region 后台
        /// <summary>
        /// 中断工序运行
        /// </summary>
        /// <returns></returns>
        private bool isBreakProcessRun()
        {
            return statusMgr.Status == SystemStsEnum.Pause || statusMgr.Warning == WarningEnum.High;
        }
        /// <summary>
        /// 后台运行主线程
        /// </summary>
        private void MainThreadFunction()
        {
            while (true)
            {
                try
                {
                    if (_cts.IsCancellationRequested)
                        break;

                    if (IsRuning)
                    {
                        ////暂停开始
                        //stopWatch.Start();
                        //do
                        //{
                        //    CurrProcessIndex = nextProcess(CurrProductModel, CurrProcessIndex);
                        //} while (CurrProcessIndex >= 0 && !isBreakProcessRun());
                        ////暂停中断
                        //stopWatch.Stop();

                        _isRuning = false;
                    }
                    Thread.Sleep(10);
                }
                catch (Exception e)
                {
                    _isRuning = false;

                    Log("运行报警", "流程运行出错：" + e.Message + "\n", WarningEnum.High);
                }
            }
        }
        #endregion

        #region IO解析
        private int GetIOPortIndex(int DIDOEnum)
        {
            return DIDOEnum / 8;
        }
        private int GetIOBitIndex(int DIDOEnum)
        {
            return DIDOEnum % 8;
        }
        #endregion

        #region 三色灯
        /// <summary>
        /// 三色灯初始化
        /// </summary>
        public void LedReady()
        {
            if (confMgr.SysConfigParams.OpenIO)
            {
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
            }
        }
        /// <summary>
        /// 运行状态三色灯
        /// </summary>
        public void LedRun()
        {
            if (confMgr.SysConfigParams.OpenIO)
            { 
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
            }
        }
        /// <summary>
        /// 暂停状态三色灯
        /// </summary>
        public void LedPause()
        {
            if (confMgr.SysConfigParams.OpenIO)
            {
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
            }
        }
        //控制黄灯闪烁
        private bool Blink;
        private int BlinkCnt = 0;
        //控制蜂鸣间隔
        private int BuzzCnt = 0;
        /// <summary>
        /// 回原状态三色灯
        /// </summary>
        /// <param name="val"></param>
        public void LedRset(bool val)
        {
            if (confMgr.SysConfigParams.OpenIO)
            { 
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), val);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), val);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
                Blink = val;
                BlinkCnt = 0;
            }
        }
        #endregion

        #region 系统关闭
        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            _isInit = false;
            _isRuning = false;
            if (null != _cts)
            {
                _cts.Cancel();
            }
            if (null != _mainThread)
            {
                _mainThread.Join(1000);
            }


            //关闭相机


            //关闭光源
            for (int i = 0; i < LightChCount; i++)
            {
                lightDev.CloseLight(i + 1);
            }

            lightDev.CloseDev();


            //关闭io
            if (confMgr.SysConfigParams.OpenIO)
            {
                ioCardDev.ResetAllDO();

                ioCardDev.CloseBoard();
            }

        }
        #endregion

        #region 日志报警
        /// <summary>
        /// 初始化记录报警和显示
        /// </summary>
        /// <param name="tag">标头</param>
        /// <param name="msg">内容</param>
        /// <param name="warning">报警状态</param>
        private void InitLog(string msg, string tag = "初始化", WarningEnum warning = WarningEnum.Normal)
        {
            OnInitRuning(new InitEventArgs(msg));
            statusMgr.GotoWarning(warning, tag, msg);
        }
        /// <summary>
        /// 记录报警和显示
        /// </summary>
        /// <param name="tag">标头</param>
        /// <param name="msg">内容</param>
        /// <param name="warning">报警状态</param>
        private void Log(string tag, string msg, WarningEnum warning = WarningEnum.Normal)
        {
            OnMainRuning(new MainEventArgs(tag, msg, warning));
            statusMgr.GotoWarning(warning, tag, msg);
            //开启云端
            if ((init_Cloud) && (warning != WarningEnum.Normal))
            {
                //上传报警状态和信息
                string statusStr = warning == WarningEnum.Normal ? "正常" : warning == WarningEnum.Low ? "警告" : "系统报警";
                cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"{tag}-{msg}\", " +
                $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}");
            }
        }
        #endregion

        #region 硬件 

        #region 硬件型号配置
        public LightDevNameEnum SysUseLight = LightDevNameEnum.CST;
        #endregion

        #region 硬件字段

        private IOCardDev ioCardDev;
        /// <summary>
        /// io控制卡
        /// </summary>
        public IOCardDev IOCardDev { get { return ioCardDev; } }

        private LightDev lightDev;
        /// <summary>
        /// 光源控制
        /// </summary>
        public LightDev LightDev { get { return lightDev; } }
        public string LightName { get { return "Light"; } }
        public int LightChCount = 6;//美尚4通道，其他6通道

        private PrintControl printControl;
        /// <summary>
        /// 打印机模块
        /// </summary>
        public PrintControl PrintControl { get { return printControl; } }
        #endregion

        #region 初始化和基本电机IO操作
        private void InitDev()
        { 
            ioCardDev = new AdvantechIO();
            if (SysUseLight == LightDevNameEnum.CST)
                lightDev = new CSTLight(LightName, LightChCount);
            else
                lightDev = new RseeLight(SysUseLight, LightName);

            defectLib = new DefectLib();
        }
        /// <summary>
        /// 初始化硬件
        /// </summary>
        /// <returns></returns>
        private bool InitAllDev()
        {
            bool ret = false;
            InitDev();

            //打印机模块初始化
            InitLog("打印机模块初始化...");
            try
            {
                printControl = new PrintControl();
                InitLog("初始化打印机模块成功！");
            }
            catch (Exception ex)
            {
                printControl = null;
                InitLog($"初始化打印机模块失败！ {ex.Message}");
            }

            if (confMgr.SysConfigParams.OpenPLC)
            {
                //PLC初始化
                InitLog("PLC连接初始化...");

                InitLog("PLC连接成功！");
            }
            if (confMgr.SysConfigParams.OpenIO)
            {
                //IO初始化
                InitLog("IO板卡初始化...");
                if (ioCardDev.InitBoard(MaiMuControl.Device.IOBordType.Advantech) < 0)
                {
                    InitLog("IO板卡初始化失败！", "初始化", WarningEnum.High);
                    return ret;
                }
                if (ioCardDev.OpenBoard(confMgr.SysConfigParams.IODevName, confMgr.SysConfigParams.IOCfgPath) < 0)
                {
                    InitLog("打开IO板卡失败！", "初始化", WarningEnum.High);
                    return ret;
                }
                if (ioCardDev.ResetAllDO() < 0)
                {
                    InitLog("IO Reset失败！", "初始化", WarningEnum.High);
                    return ret;
                }
                InitLog("初始化IO板卡成功！");
            }

            //光源初始化
            InitLog("光源控制器初始化...");
            int com_num = int.Parse(confMgr.SysConfigParams.LightCom.Remove(0, 3));
            if (lightDev.InitDev(com_num, confMgr.SysConfigParams.LightComBaud) < 0)
            {
                InitLog("光源控制器初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化光源控制器成功！");
            //关闭光源
            for (int i = 0; i < LightChCount; i++)
            {
                lightDev.CloseLight(i + 1);
            }        

            ret = true;
            return ret;
        }
        /// <summary>
        /// 读取硬件配置
        /// </summary>
        private bool LoadDevConfig()
        {
            LightParams lightParams = new LightParams(LightName, LightChCount);
            //LightChCount = 6;
            //lightParams.DevName = LightName;
            lightParams.ComName = confMgr.SysConfigParams.LightCom;
            lightParams.Buad = confMgr.SysConfigParams.LightComBaud;
            //lightParams.ChCount = LightChCount;
            lightDev.WriteCfgInfo(confMgr.DevConfigPath, lightParams);
            return true;
        }

        #endregion
        #endregion

        #region 硬盘检测
        public static bool CheckDisk(IWin32Window owner, int max = 10)
        {
            if (!string.IsNullOrEmpty(ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath))
            { 
                string path = ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath;
                string volume = path.Substring(0, path.IndexOf(':'));
                long freespace = DiskAPI.GetHardDiskSpace(volume);
                if (freespace < max)
                {
                    string tip = $"当前{volume}硬盘容量：{freespace}GB，小于{max}GB。注意清理！！";
                    FrmDialog.ShowDialog(owner, tip, "警告", true);
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 初始化事件
        /// <summary>
        /// 初始化回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void InitEventHandler(Object sender, InitEventArgs e);
        public event InitEventHandler InitRuning;
        protected virtual void OnInitRuning(InitEventArgs e)
        {
            if (null != InitRuning)
            {
                InitRuning(this, e);
            }
        }
        #endregion

        #region 主窗体显示事件
        /// <summary>
        /// 主窗体回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void MainEventHandler(Object sender, MainEventArgs e);
        public event MainEventHandler MainRuning;
        protected virtual void OnMainRuning(MainEventArgs e)
        {
            if (null != MainRuning)
            {
                MainRuning(this, e);
            }
        }
        #endregion

        #region 加载测试列表
        /// <summary>
        /// 加载产品列表
        /// </summary>
        public void LoadProductCodeList()
        {
            try
            {
                productCodeList = PdtService.GetList().Select(m => m.Code).ToList();
                productIdList = PdtService.GetList().Select(m => m.Id).ToList();
            }
            catch (Exception ex)
            {
                OnMainRuning(new MainEventArgs("启动", "加载检测标准失败:" + ex.Message, WarningEnum.High));
                statusMgr.GotoWarning(WarningEnum.High, "启动", "加载检测标准失败:" + ex.Message);
                SendStatus();
            }
        }
        #endregion

        #region 界面显示
        public static void showRowNum_onDataGrid_RowPostPaint(DataGridView dgv, object sender, DataGridViewRowPostPaintEventArgs e)
        {
            Rectangle rectangle = new Rectangle(e.RowBounds.Location.X, e.RowBounds.Location.Y, dgv.RowHeadersWidth - 4, e.RowBounds.Height);
            TextRenderer.DrawText(e.Graphics, (e.RowIndex + 1).ToString(), dgv.RowHeadersDefaultCellStyle.Font, rectangle, dgv.RowHeadersDefaultCellStyle.ForeColor, TextFormatFlags.VerticalCenter | TextFormatFlags.Right);
        }
        /// <summary>
        /// IO二进制数据格式化到8位 XXXX10X0
        /// </summary>
        /// <param name="datas"></param>
        /// <returns></returns>
        public static string[] IODataFormatBinaryStr(string[] datas, bool clone, char defaultPadChar = 'X')
        {
            string[] datas2 = new string[datas.Length];
            for (int i = 0; i < datas.Length; i++)
            {
                if (clone)
                {
                    datas2[i] = datas[i].Replace(" ", "");
                    if (datas2[i].Length > 8)
                        datas2[i] = datas2[i].Substring(datas2[i].Length - 8);
                    else if (datas2[i].Length < 8)
                        datas2[i] = datas2[i].PadLeft(8, defaultPadChar);
                }
                else
                {
                    datas[i] = datas[i].Replace(" ", "");
                    if (datas[i].Length > 8)
                        datas[i] = datas[i].Substring(datas[i].Length - 8);
                    else if (datas[i].Length < 8)
                        datas[i] = datas[i].PadLeft(8, defaultPadChar);

                    datas2 = datas;
                }
            }

            return datas2;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="op_show_list">[XXHL XXXX,XXXX XXXX,...]</param>
        /// <param name="currIoDatas">[byte,byte,byte,byte]</param>
        /// <returns></returns>
        public static bool compareIOInput(string[] op_show_list, byte[] currIoDatas)
        {
            int isok = 0;//1-true 2-false
            string IN_OP_SHOW;
            for (int i = 0; i < currIoDatas.Length; i++)
            {
                IN_OP_SHOW = op_show_list[i].Replace(" ", "").PadLeft(8, 'X');
                if (IN_OP_SHOW.IndexOf('H') < 0 && IN_OP_SHOW.IndexOf('L') < 0)
                    continue;

                for (int j = 7; j >= 0; j--)
                {
                    byte bit = (byte)(1 << 7 - j);
                    if (IN_OP_SHOW[j] == 'H')
                    {
                        if ((bit & currIoDatas[i]) > 0)
                            isok = 1;
                        else
                        {
                            isok = 2;
                            break;
                        }
                    }
                    else if (IN_OP_SHOW[j] == 'L')
                    {
                        if ((currIoDatas[i] ^ (currIoDatas[i] | bit)) > 0)
                            isok = 1;
                        else
                        {
                            isok = 2;
                            break;
                        }
                    }
                }

                //已经不符
                if (isok == 2) break;
            }

            //
            return isok == 1;
        }

        #endregion
    }
    #region 系统事件
    /// <summary>
    /// 显图事件
    /// </summary>
    public class ImgEventArgs : EventArgs
    {
        //private Bitmap[] _bmps;
        //public Bitmap[] Bitmaps { get { return _bmps; } }

        //private Mat[] _bmps_cut;
        //public Mat[] Bmps_cut { get { return _bmps_cut; } }

        //private double _x;
        //public double X { get { return _x; } }
        //private double _y;
        //public double Y { get { return _y; } }

        //private List<Dictionary<int, List<string>[]>> _info;
        //public List<Dictionary<int, List<string>[]>> Info
        //{
        //    get { return _info; }
        //}

        //public ImgEventArgs(Bitmap[] bmps, Mat[] bmps_cut, double Xmm, double Ymm, List<Dictionary<int, List<string>[]>> info)
        //{
        //    this._bmps = new Bitmap[bmps.Length];
        //    for (int i = 0; i < bmps.Length; i++)
        //    {
        //        this._bmps[i] = (Bitmap)bmps[i].Clone();
        //    }
        //    this._bmps_cut = new Mat[bmps_cut.Length];
        //    for (int i = 0; i < bmps_cut.Length; i++)
        //    {
        //        this._bmps_cut[i] = bmps_cut[i].Clone();
        //    }
        //    this._x = Xmm;
        //    this._y = Ymm;
        //    this._info = info;
        //}
    }
    /// <summary>
    /// 主窗体事件
    /// </summary>
    public class MainEventArgs : EventArgs
    {
        private string _tag;
        public string Tag { get { return _tag; } }

        private string _message;
        public string Message { get { return _message; } }

        private int _showIndex;
        public int ShowIndex { get { return _showIndex; } }

        private WarningEnum _warning;
        public WarningEnum Warning { get { return _warning; } }
        public MainEventArgs(int index)
        {
            this._showIndex = index;
        }
        public MainEventArgs(int index, string message)
        {
            this._message = message;
            this._showIndex = index;
        }
        public MainEventArgs(string tag, string message, WarningEnum warning = WarningEnum.Normal)
        {
            this._tag = tag;
            this._message = message;
            this._showIndex = 0;
            this._warning = warning;
        }
    }
    /// <summary>
    /// 初始化事件
    /// </summary>
    public class InitEventArgs : EventArgs
    {
        private string _message;
        public string Message { get { return _message; } }

        private bool _isInitialized;
        public bool IsInitialized { get { return _isInitialized; } }
        public InitEventArgs()
        {

        }
        public InitEventArgs(string message, bool isInitialized = false)
        {
            this._message = message;
            this._isInitialized = isInitialized;
        }
    }
    #endregion
}