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.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; } }
        #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()
        {
            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()
        {
            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()
        {
            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)
        {
            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
            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);
        }
        /// <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.IsPLC)
            {
                //PLC初始化
                InitLog("PLC连接初始化...");

                InitLog("PLC连接成功！");
            }
            else
            {
                //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)
        {
            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 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
}