using Arction.Wpf.SignalProcessing;
using LiveCharts.Defaults;
using log4net;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NPOI.SS.Formula.Functions;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Media;
using System.Reflection;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using Txgy.EWS.Client.Common;
using Txgy.EWS.Client.Common.MessageEvents;
using Txgy.EWS.Client.Entity;
using Txgy.EWS.Client.IBLL;
using Txgy.EWS.Client.ILog;
using Txgy.EWS.Client.Models;
using Txgy.EWS.Client.PageModule.Models;
using Txgy.EWS.Client.PageModule.Services;
using Txgy.Microseismic.BaseLib.Entitys;
using Txgy.Microseismic.BaseLib.Models;
using Unity;
using static Txgy.EWS.Client.Common.GlobalConfig;

namespace Txgy.EWS.Client.PageModule.ViewModels
{
    public class EventListViewModel : BindableBase
    {
        private readonly IEventAggregator ea;
        private readonly ISearchMsEventBLL searchMsEventBLL;
        private readonly ILogHelper _logHelper;

        //private readonly IRemoteDownloadDataBLL remoteDownloadDataBLL;
        Dispatcher _dispatcher;
        IFreeSql fsqlTencent = FreeSqlTencent.tencentRemoteMySQL;
        IFreeSql fsqlSqLite = FreeSqlLocalSqLite.freeLocalSqLite;
        private bool isCanRun = true;

        public bool IsCanRun
        {
            get { return isCanRun; }
            set 
            { 
                SetProperty(ref isCanRun, value);
            }
        }

        /// <summary>
        /// 刷新间隔(s)
        /// </summary>
        private int refreshInterval = 3;
        public int RefreshInterval
        {
            get { return refreshInterval; }
            set
            {
                SetProperty(ref refreshInterval, value);
            }
        }
        private string runSpan = "0";

        public string RunSpan
        {
            get { return runSpan; }
            set
            {
                SetProperty(ref runSpan, value);
            }
        }

        private double alarmThreshold = 1;
        /// <summary>
        /// 报警阈值：J
        /// </summary>
        public double AlarmThreshold
        {
            get { return alarmThreshold; }
            set
            {
                SetProperty(ref alarmThreshold, value);
            }
        }
        public DateTime SystemRunTime { get; set; }
        /// <summary>
        /// 报警等级列表
        /// </summary>
        public List<AlarmLevelModel> ListAlarmLevel;
        public List<string> ListAlramMusic { get; set; }

        SoundPlayer alarmPlayer = new SoundPlayer();
        private bool canPlayAlarmSound = true;

        public bool CanPlayAlarmSound
        {
            get { return canPlayAlarmSound; }
            set
            {
                SetProperty(ref canPlayAlarmSound, value);
            }
        }
        private GridItemEventResult selectGirdItem;

        public GridItemEventResult SelectGirdItem
        {
            get { return selectGirdItem; }
            set
            {
                SetProperty(ref selectGirdItem, value);
                if (selectGirdItem != null)
                {
                    this.ea.GetEvent<ShowWavesEvent>().Publish(selectGirdItem.EventTime);
                }
            }
        }

        private string curAlarmMusic;

        public string CurAlarmMusic
        {
            get { return curAlarmMusic; }
            set
            {
                SetProperty(ref curAlarmMusic, value);
                alarmPlayer.SoundLocation = AppDomain.CurrentDomain.BaseDirectory + "audio\\" + curAlarmMusic;
                alarmPlayer.LoadAsync();
            }
        }

        private int _runEventCnt = 0;


        public int RunEventCnt
        {
            get { return _runEventCnt; }
            set
            {
                SetProperty(ref _runEventCnt, value);
            }
        }
        private int _resultCount = 0;
        /// <summary>
        /// 查询结果数量
        /// </summary>
        public int ResultCount
        {
            get { return _resultCount; }
            set
            {
                SetProperty(ref _resultCount, value);
            }
        }
        private float _searchMaxML = 0f;

        public float SearchMaxML
        {
            get { return _searchMaxML; }
            set
            {
                SetProperty(ref _searchMaxML, value);
            }
        }
        private float _searchMinML = -2.0f;

        public float SearchMinML
        {
            get { return _searchMinML; }
            set
            {
                SetProperty(ref _searchMinML, value);
            }
        }
        private int pageIndex = 1;

        public int PageIndex
        {
            get { return pageIndex; }
            set
            {
                SetProperty(ref pageIndex, value);
                //PageIndexChanged();
            }
        }
        private int maxPageCount = 5;
        public int MaxPageCount
        {
            get { return maxPageCount; }
            set
            {
                SetProperty(ref maxPageCount, value);
            }
        }
        private int perPageCount = 15;

        public int PerPageCount
        {
            get { return perPageCount; }
            set
            {
                SetProperty(ref perPageCount, value);
            }
        }
        private DateTime _startTime;
        /// <summary>
        /// 起始时间
        /// </summary>
        public DateTime StartTime
        {
            get { return _startTime; }
            set
            {
                SetProperty(ref _startTime, value);
            }
        }
        private DateTime _endTime;
        public DateTime EndTime
        {
            get { return _endTime; }
            set { SetProperty(ref _endTime, value); }
        }
        private ObservableCollection<GridItemEventResult> _searchEvents = new ObservableCollection<GridItemEventResult>();

        public ObservableCollection<GridItemEventResult> SearchEvents
        {
            get { return _searchEvents; }
            set
            {
                SetProperty(ref _searchEvents, value);
            }
        }
        private AlarmSetting alarmSetting;

        public AlarmSetting AlarmSettingConfig
        {
            get { return alarmSetting; }
            set
            {
                SetProperty(ref alarmSetting, value);
            }
        }

        private AlarmLevelModel curAlarmLevel;

        public AlarmLevelModel CurAlarmLevel
        {
            get { return curAlarmLevel; }
            set
            {
                SetProperty(ref curAlarmLevel, value);
            }
        }
        public ICommand ProcessAlarmCommand
        {
            get => new DelegateCommand<GridItemEventResult>((i) =>
        {

        });
        }

        public ICommand SearchCommand
        {
            get => new Prism.Commands.DelegateCommand(() =>
            {
                //2023-02-04，已重写
                //var mmes = fsqlTencent.Select<RemoteRealtimeResultEntity>()
                //        .Where(pp => DateTime.Parse(pp.EventTime).Ticks > StartTime.Ticks &&
                //        DateTime.Parse(pp.EventTime).Ticks <= EndTime.Ticks)
                //        .ToList()
                //        .OrderByDescending(po => po.RTEventID).ToList();
                var mme = searchMsEventBLL.GetEvents(StartTime, EndTime, SearchMinML, SearchMaxML);

                if (mme?.Count > 0)
                {
                    ResultCount = mme.Count;
                    GlobalData.GridEvents.Clear();
                    if (!GlobalData.AppendEvent)
                    {
                        GlobalData.SearchEvents.Clear();
                    }
                    mme.ForEach(me =>
                    {
                        GridItemEventResult ger = new GridItemEventResult(me);
                        ger.SetEnergy();
                        GlobalData.GridEvents.Add(ger);

                        LocalRealtimeResultEntity lrre = new LocalRealtimeResultEntity();
                        lrre.RTEventID = me.EventID;
                        lrre.WorkAreaID = me.WorkAreaID;
                        lrre.EventTime = me.EventTimeStr;
                        lrre.OriginTime = me.EventTimeStr;
                        lrre.X = me.Y;
                        lrre.Y = me.X;
                        lrre.Z = me.Z;
                        lrre.ML = Math.Round(me.ML, 2);
                        lrre.RMS = Math.Round(me.RMS, 3);
                        lrre.LocSta = me.LocSta;
                        lrre.MLSta = me.MLSta;
                        lrre.SetEnergy();

                        var re = fsqlSqLite.Select<LocalRealtimeResultEntity>().Where(rel => rel.RTEventID == lrre.RTEventID).ToOne();

                        if (re == null)
                        {
                            fsqlSqLite.Insert<LocalRealtimeResultEntity>(lrre).ExecuteIdentityAsync();
                        }

                        RemoteRealtimeResultEntity rrre = new RemoteRealtimeResultEntity(lrre);
                        if (!GlobalData.SearchEvents.Contains(rrre))
                        {
                            GlobalData.SearchEvents.Add(rrre);
                        }
                    });

                }

                //查询事件更新
                this.ea.GetEvent<UpdateSearchEventMessage>().Publish("查询事件更新");
                //PageIndexChanged();
            });
        }
        public ICommand ChangeMusicCommand
        {
            get => new Prism.Commands.DelegateCommand(() =>
            {
                LogObject.Log(MethodBase.GetCurrentMethod().Name).Info("===========End==============>>>");
                //AlarmRecordEntity arent = new AlarmRecordEntity();
                //arent.EventId = 2;
                //arent.AlarmLevel = 1;
                //arent.Energy = 10;
                //arent.AlarmTime = "1";
                //arent.ProcessTime = "1";
                //long id = fsqlSqLite.Insert(arent).ExecuteIdentity();
                //var t1 = fsqlSqLite.Insert(arent).ExecuteAffrows();

                //Stopwatch watch = new Stopwatch();
                //watch.Start();

                ////MmEventEntity mmEvent= searchMsEventBLL.GetLastEvent();
                ////var mme = fsqlTencent.Select<RemoteRealtimeResultEntity>()
                ////.Where(re => DateTime.Parse(re.EventTime).Ticks <= dateTime.Ticks)
                ////.OrderByDescending(re => re.RTEventID).First();
                //var mms = searchMsEventBLL.GetLastNewEvents(10);
                //watch.Stop();
                //TimeSpan timespan = watch.Elapsed;

                //Console.WriteLine("BLL,数量:" + mms.Count + " ++++++++++++++++时长：" + timespan.TotalMilliseconds);
            });
        }
        public ICommand StartMonitoringCommand
        {
            //2023-02-21
            get => new Prism.Commands.DelegateCommand(StartMonitorning);
            #region 2023-02-20
            //get => new Prism.Commands.DelegateCommand(() =>
            //{
            //    int num = 0;
            //    RunEventCnt = 0;
            //    SystemRunTime = DateTime.Now;
            //    DateTime alarmEndTime = DateTime.Now;
            //    GlobalData.ListAlarmEventId = new List<int>();
            //    if (GlobalData.IsDesign)
            //    {
            //        alarmEndTime = GlobalData.DStartTime;
            //        RefreshInterval = GlobalData.DRefreshInterval;
            //    }

            //    var taskAlarm = Task.Factory.StartNew(new System.Action(async () =>
            //    {
            //        while (GlobalData.IsRunning)
            //        {
            //            TaskFactory taskfactory = new TaskFactory();
            //            List<Task> taskList = new List<Task>();
            //            #region BLL模式
            //            int StatCount = searchMsEventBLL.GetEvents(alarmEndTime.AddHours(-1), alarmEndTime).Count();
            //            if (StatCount > 0)
            //            {
            //                //通知更新一小时前事件数量
            //                this.ea.GetEvent<UpdateEventFrequencyEvent>().Publish(StatCount);
            //            }
            //            //DateTime deadlineTime = alarmEndTime.AddSeconds(1);
            //            //Console.WriteLine(deadlineTime.ToString());
            //            //MmEventEntity mmee = searchMsEventBLL.GetLastEvent(deadlineTime);
            //            //MmEventEntity mmee = searchMsEventBLL.GetLastEvent();

            //            var mms = searchMsEventBLL.GetEvents(alarmEndTime.AddMinutes(-10), alarmEndTime);
            //            //var mms = searchMsEventBLL.GetLastNewEvents(3);
            //            Stopwatch watch = new Stopwatch();
            //            watch.Start();
            //            if (mms != null)
            //            {
            //                foreach (var mmee in mms)
            //                {
            //                    if (GlobalData.ListAlarmEventId.Contains(mmee.EventID))
            //                    {
            //                        continue;
            //                    }
            //                    GlobalData.ListAlarmEventId.Add(mmee.EventID);
            //                    if (mmee.EventTimeStr != GlobalData.LastEvent.EventTimeStr)
            //                    {
            //                        //Stopwatch watch = new Stopwatch();
            //                        //watch.Start();
            //                        GlobalData.LastEvent = new MmEvent();
            //                        GlobalData.LastEvent.WorkAreaID = mmee.WorkAreaID;
            //                        GlobalData.LastEvent.EventID = mmee.EventID;
            //                        GlobalData.LastEvent.EventTime = mmee.EventTime;
            //                        GlobalData.LastEvent.EventTimeStr = mmee.EventTimeStr;
            //                        GlobalData.LastEvent.X = mmee.X;
            //                        GlobalData.LastEvent.Y = mmee.Y;
            //                        GlobalData.LastEvent.Z = mmee.Z;
            //                        GlobalData.LastEvent.ML = mmee.ML;
            //                        GlobalData.LastEvent.LocSta = mmee.LocSta;
            //                        GlobalData.LastEvent.MLSta = mmee.MLSta;
            //                        GlobalData.LastEvent.RMS = mmee.RMS;
            //                        GlobalData.LastEvent.Energy = mmee.Energy;

            //                        LocalRealtimeResultEntity lrre = new LocalRealtimeResultEntity();
            //                        lrre.RTEventID = mmee.EventID;
            //                        lrre.WorkAreaID = mmee.WorkAreaID;
            //                        lrre.EventTime = mmee.EventTimeStr;
            //                        lrre.OriginTime = mmee.EventTimeStr;
            //                        lrre.X = mmee.X;
            //                        lrre.Y = mmee.Y;
            //                        lrre.Z = mmee.Z;
            //                        lrre.ML = Math.Round(mmee.ML, 2);
            //                        lrre.RMS = Math.Round(mmee.RMS, 3);
            //                        lrre.LocSta = mmee.LocSta;
            //                        lrre.MLSta = mmee.MLSta;
            //                        lrre.SetEnergy();

            //                        taskList.Add(taskfactory.StartNew(() =>
            //                        {
            //                            Console.WriteLine($"=============>{lrre.EventTime}开始下载!\t{DateTime.Now.ToString("o")}");
            //                            DownloadWaveDataTask(lrre.EventTime, GlobalConfig.UseWaveDataTable);

            //                        }));

            //                        await taskfactory.ContinueWhenAny(taskList.ToArray(), t =>
            //                        {
            //                            this.ea.GetEvent<UpdateEventDominFreqMessage>().Publish(num++);
            //                            Console.WriteLine($"------------->{lrre.EventTime}发送下载完成通知!\t{DateTime.Now.ToString("o")}");
            //                        });

            //                        //检查本地数据库是否有此事件
            //                        var re = fsqlSqLite.Select<LocalRealtimeResultEntity>().Where(rel => rel.RTEventID == lrre.RTEventID).ToOne();
            //                        //如果没有，添加到本地库
            //                        if (re == null)
            //                        {
            //                            //下载波形文件，Json文件
            //                            //待修改为多线程下载，下载完成后回调计算震源机制、主频、插入本地数据库操作，2023-02-04；
            //                            //DownloadWaveDataTask(lrre.EventTime, GlobalConfig.UseWaveDataTable);
            //                            //taskList.Add(taskfactory.StartNew(() =>
            //                            //{
            //                            //    Console.WriteLine($"=============>{lrre.EventTime}开始下载!\t{DateTime.Now.ToString("o")}");
            //                            //    DownloadWaveDataTask(lrre.EventTime, GlobalConfig.UseWaveDataTable);

            //                            //}));

            //                            //await taskfactory.ContinueWhenAny(taskList.ToArray(), t =>
            //                            //{
            //                            //    this.ea.GetEvent<UpdateEventDominFreqMessage>().Publish(num++);
            //                            //    Console.WriteLine($"------------->{lrre.EventTime}发送下载完成通知!\t{DateTime.Now.ToString("o")}");
            //                            //});

            //                            int dominFreq = GetDominFreq(lrre.EventTime);

            //                            if (dominFreq < 5)
            //                            {
            //                                dominFreq = new Random((int)DateTime.Now.Ticks).Next(15, 60);
            //                            }
            //                            lrre.DominantFreq = dominFreq;
            //                            await fsqlSqLite.Insert<LocalRealtimeResultEntity>(lrre).ExecuteIdentityAsync();

            //                        }
            //                        //查询本地库realtimefocalmechanism是否有此记录，如果没有新增记录
            //                        var rf = fsqlSqLite.Select<RealtimeFocalmechanismEntity>().Where(rel => rel.EventID == lrre.RTEventID).ToOne();
            //                        if (rf == null)
            //                        {
            //                            RealtimeFocalmechanismEntity rfe = new RealtimeFocalmechanismEntity();
            //                            rfe.DominantFreq = lrre.DominantFreq;
            //                            rfe.EventID = lrre.RTEventID;
            //                            await fsqlSqLite.Insert<RealtimeFocalmechanismEntity>(rfe).ExecuteIdentityAsync();
            //                        }

            //                        RemoteRealtimeResultEntity rrre = new RemoteRealtimeResultEntity(lrre);

            //                        //如果大于设定
            //                        if (lrre.Energy >= alarmThreshold)
            //                        {
            //                            //通知预警页面图表变化
            //                            this.ea.GetEvent<UpdateLastAlarmEvent>().Publish(new AlarmEventPayload(rrre));


            //                            //添加预警事件到右侧列表
            //                            _dispatcher.Invoke(new System.Action(() =>
            //                            {
            //                                //GlobalData.DisplayEventResults.Add(new GridItemEventResult(realEvent));
            //                                GlobalData.GridEvents.Insert(0, new GridItemEventResult(rrre));
            //                            }));

            //                            //通知显示更新，线程有问题
            //                            if (!GlobalData.AlarmEvents.Contains(rrre))
            //                            {
            //                                GlobalData.AlarmEvents.Add(rrre);
            //                            }
            //                            //GlobalData.DisplayEvents.Add(realEvent);

            //                            this.ea.GetEvent<UpdateEventsMessage>().Publish("更新事件");

            //                            ResultCount = GlobalData.GridEvents.Count();
            //                            CurAlarmLevel = ListAlarmLevel.First(lal => lal.MaxEnergy >= rrre.Energy && lal.MinEnergy <= lrre.Energy);
            //                            AlarmRecordEntity arent = new AlarmRecordEntity();
            //                            arent.EventId = lrre.RTEventID;
            //                            arent.AlarmTime = lrre.OriginTime;
            //                            arent.AlarmLevel = CurAlarmLevel.Level;
            //                            arent.Energy = lrre.Energy;

            //                            //写入报警记录
            //                            var haveAre = fsqlSqLite.Select<AlarmRecordEntity>().Where(are => are.EventId == arent.EventId).ToOne();
            //                            if (haveAre == null)
            //                            {
            //                                await fsqlSqLite.Insert(arent).ExecuteIdentityAsync();
            //                            }

            //                            //声音报警
            //                            if (canPlayAlarmSound)
            //                            {
            //                                alarmPlayer.PlaySync();
            //                            }

            //                            //报警数量
            //                            RunEventCnt++;
            //                        }
            //                        //watch.Stop();
            //                        //TimeSpan timespan = watch.Elapsed;
            //                        //Console.WriteLine("++++++++++++++++时长：" + timespan.TotalMilliseconds);
            //                    }
            //                }
            //            }
            //            watch.Stop();
            //            TimeSpan timespan = watch.Elapsed;
            //            if (GlobalData.IsDesign)
            //            {
            //                await Task.Delay(2000);
            //                alarmEndTime = alarmEndTime.AddMinutes(10);
            //            }
            //            else
            //            {
            //                int delayMillSec = (int)(RefreshInterval * 1000 - timespan.TotalMilliseconds);
            //                Console.WriteLine($"运行时长：{timespan.TotalMilliseconds}\t延迟时长：{delayMillSec}");
            //                if (delayMillSec < 0)
            //                {
            //                    delayMillSec = 0;
            //                }
            //                await Task.Delay(delayMillSec);
            //                alarmEndTime = DateTime.Now;
            //            }
            //            #endregion                       
            //        }
            //    }));
            //    var taskRunTime = Task.Factory.StartNew(new System.Action(async () =>
            //    {
            //        while (GlobalData.IsRunning)
            //        {
            //            TimeSpan ts = DateTime.Now - SystemRunTime;
            //            RunSpan = ts.Hours.ToString() + "小时" + ts.Minutes.ToString() + "分" + ts.Seconds.ToString() + "秒";
            //            await Task.Delay(1000);
            //        }

            //    }));

            //    GlobalData.TaskList.Add(taskAlarm);
            //    GlobalData.TaskList.Add(taskRunTime);

            //});
            #endregion
        }
        public EventListViewModel(IUnityContainer unityContainer, IEventAggregator ea, ISearchMsEventBLL searchMsEventBLL,ILogHelper logHelper)
        {
            _dispatcher = unityContainer.Resolve<Dispatcher>();
            this.ea = ea;
            this.searchMsEventBLL = searchMsEventBLL;
            this._logHelper = logHelper;
            //this.remoteDownloadDataBLL = remoteDownloadDataBLL;
            this.StartTime = DateTime.Now.AddDays(-1);
            this.EndTime = DateTime.Now;
            //StartMonitoringCommand=new Prism.Commands.DelegateCommand(test,)
            //ProcessAlarmCommand=new COMMAND
            //AlarmSettingConfig = new AlarmSetting();
            using (System.IO.StreamReader sr = new System.IO.StreamReader(AppDomain.CurrentDomain.BaseDirectory +
                System.Configuration.ConfigurationManager.AppSettings["AlarmSetting"].ToString()))
            {
                AlarmSettingConfig = JsonConvert.DeserializeObject<AlarmSetting>(sr.ReadToEnd());
            }

            AlarmThreshold = AlarmSettingConfig.AlarmThreshold;
            RefreshInterval = AlarmSettingConfig.RefreshInterval;
            //RefreshInterval = int.Parse(System.Configuration.ConfigurationManager.AppSettings["RefreshInterval"].ToString());
            CurAlarmMusic = AlarmSettingConfig.AlarmSound;

            ListAlarmLevel = new List<AlarmLevelModel>();
            using (System.IO.StreamReader sr = new System.IO.StreamReader(AppDomain.CurrentDomain.BaseDirectory +
                System.Configuration.ConfigurationManager.AppSettings["AlarmLevelConfig"].ToString()))
            {
                ListAlarmLevel = JsonConvert.DeserializeObject<List<AlarmLevelModel>>(sr.ReadToEnd());
            }
            CurAlarmLevel = ListAlarmLevel.First(la => la.Level == 1);
            ListAlramMusic = new List<string>();
            string[] alarmTmpArray = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + "audio", "*.wav");
            for (int i = 0; i < alarmTmpArray.Length; i++)
            {
                ListAlramMusic.Add(Path.GetFileName(alarmTmpArray[i]));
            }
            //CurAlarmMusic = ListAlramMusic[0];

        }
        
        void StartMonitorning()
        {
            
            if (!GlobalData.IsRunning)
            {
                this._logHelper.Debug(this, "===========End==============>>>");
                //LogObject.Log(MethodBase.GetCurrentMethod().Name).Info("===========End==============>>>");
                Task.WaitAll(GlobalData.TaskList.ToArray());
                Task.Delay(2000);               
            }
            else
            {
                this._logHelper.Debug(this,"===========Startup==============>>>");
                //LogObject.Log(MethodBase.GetCurrentMethod().Name).Info("===========Startup==============>>>");
                RunEventCnt = 0;
                SystemRunTime = DateTime.Now;
                DateTime alarmTime= DateTime.Now;
                DateTime eventFreqTime = DateTime.Now;
                DateTime alarmEndTime = DateTime.Now;
                GlobalData.ListAlarmEventId = new List<int>();
                GlobalData.AlarmEvents = new List<RemoteRealtimeResultEntity>();
                GlobalData.ReceivedEvents = new List<RemoteRealtimeResultEntity>();
                GlobalData.GridEvents = new ObservableCollection<GridItemEventResult>();
              
                if (GlobalConfig.IsDesign)
                {
                    alarmEndTime = GlobalConfig.DStartTime;
                    RefreshInterval = GlobalConfig.DRefreshInterval;
                }
                
                //新事件查询，每10秒查询一次，如果有新事件，需要下载二进制数据，数据大小：5m左右，因为是远程数据库，下载需要5秒左右。
                var taskAlarm = Task.Factory.StartNew(new System.Action(async () =>
                {
                    while (GlobalData.IsRunning)
                    {
                        try
                        {
                            if (GlobalConfig.IsDesign)
                            {
                                await Task.Delay(3000);
                                alarmEndTime = alarmEndTime.AddMinutes(10);
                                //Console.WriteLine($"运行时长：{timespan.TotalMilliseconds}\t");
                            }
                            else if ((DateTime.Now - alarmTime).TotalMilliseconds >= RefreshInterval * 1000)
                            {
                                TaskFactory taskfactory = new TaskFactory();
                                List<Task> taskList = new List<Task>();
                                #region BLL模式
                                alarmTime = DateTime.Now;
                                //int StatCount = searchMsEventBLL.GetEvents(alarmEndTime.AddHours(-1), alarmEndTime).Count();
                                //if (StatCount > 0)
                                //{
                                //    //通知更新一小时前事件数量
                                //    this.ea.GetEvent<UpdateEventFrequencyEvent>().Publish(StatCount);
                                //}
                                //DateTime deadlineTime = alarmEndTime.AddSeconds(1);
                                //Console.WriteLine(deadlineTime.ToString());
                                //MmEventEntity mmee = searchMsEventBLL.GetLastEvent(deadlineTime);
                                //MmEventEntity mmee = searchMsEventBLL.GetLastEvent();

                                //var mms = searchMsEventBLL.GetEvents(alarmEndTime.AddMinutes(-10), alarmEndTime);
                                //Stopwatch watch = new Stopwatch();
                                //watch.Start();
                                var mms = searchMsEventBLL.GetLastNewEvents(2);
                                
                                if (mms != null)
                                {
                                    foreach (var mmee in mms)
                                    {
                                        //if ((DateTime.Now- mmee.EventTime).TotalSeconds<720)
                                        {
                                            if (GlobalData.ListAlarmEventId.Contains(mmee.EventID))
                                            {
                                                continue;
                                            }
                                            GlobalData.ListAlarmEventId.Add(mmee.EventID);
                                            if (mmee.EventTimeStr != GlobalData.LastEvent.EventTimeStr)
                                            {
                                                //Stopwatch watch = new Stopwatch();
                                                //watch.Start();
                                                GlobalData.LastEvent = new MmEvent();
                                                GlobalData.LastEvent.WorkAreaID = mmee.WorkAreaID;
                                                GlobalData.LastEvent.EventID = mmee.EventID;
                                                GlobalData.LastEvent.EventTime = mmee.EventTime;
                                                GlobalData.LastEvent.EventTimeStr = mmee.EventTimeStr;
                                                GlobalData.LastEvent.X = mmee.X;
                                                GlobalData.LastEvent.Y = mmee.Y;
                                                GlobalData.LastEvent.Z = mmee.Z;
                                                GlobalData.LastEvent.ML = mmee.ML;
                                                GlobalData.LastEvent.LocSta = mmee.LocSta;
                                                GlobalData.LastEvent.MLSta = mmee.MLSta;
                                                GlobalData.LastEvent.RMS = mmee.RMS;
                                                GlobalData.LastEvent.Energy = mmee.Energy;

                                                LocalRealtimeResultEntity lrre = new LocalRealtimeResultEntity();
                                                lrre.RTEventID = mmee.EventID;
                                                lrre.WorkAreaID = mmee.WorkAreaID;
                                                lrre.EventTime = mmee.EventTimeStr;
                                                lrre.OriginTime = mmee.EventTimeStr;
                                                lrre.X = mmee.X;
                                                lrre.Y = mmee.Y;
                                                lrre.Z = mmee.Z;
                                                lrre.ML = Math.Round(mmee.ML, 2);
                                                lrre.RMS = Math.Round(mmee.RMS, 3);
                                                lrre.LocSta = mmee.LocSta;
                                                lrre.MLSta = mmee.MLSta;
                                                lrre.SetEnergy();

                                                string eventTimeStr = mmee.EventTimeStr;
                                                string datePath = eventTimeStr.Substring(0, 4) + eventTimeStr.Substring(5, 2) + eventTimeStr.Substring(8, 2);
                                                string dataFilePath = GlobalConfig.ProjectConfig.MseedFilePath + "\\" + datePath + "\\";
                                                string dataFileName = "HA." + eventTimeStr.Substring(0, 4) + eventTimeStr.Substring(5, 2)
                                                   + eventTimeStr.Substring(8, 2) + eventTimeStr.Substring(10, 3)
                                                   + eventTimeStr.Substring(14, 2) + eventTimeStr.Substring(17, 2) + ".01" + GlobalConfig.DataTypeString;
                                                string jsonStr = ".json";
                                                string mseedStr = ".mseed";
                                                if (!Directory.Exists(dataFilePath))
                                                {
                                                    Directory.CreateDirectory(dataFilePath);
                                                }
                                                //设置事件默认主频为15Hz;
                                                lrre.DominantFreq = 15;
                                                //查询事件Json文件是否已下载
                                                if (File.Exists(dataFilePath + dataFileName + jsonStr))
                                                {
                                                    FileInfo fileInfo = new FileInfo(dataFilePath + dataFileName + jsonStr);
                                                    if (fileInfo.Length > 2000)
                                                    {
                                                        lrre.DominantFreq = GlobalData.GetDominFreq(eventTimeStr);
                                                    }
                                                    else
                                                    {
                                                        #region 同步方式
                                                        int res = new DownloadJsonFile().Download(eventTimeStr, dataFilePath, dataFileName + jsonStr, GlobalConfig.UseWaveDataTable);
                                                        if (res > -1)
                                                        {
                                                            FileInfo fileInfo2 = new FileInfo(dataFilePath + dataFileName + jsonStr);
                                                            if (fileInfo2.Length > 2000)
                                                            {
                                                                //目前提取的为半周期
                                                                lrre.DominantFreq = GlobalData.GetDominFreq(eventTimeStr);

                                                            }
                                                            //else
                                                            //{
                                                            //    lrre.DominantFreq = 15;

                                                            //}
                                                        }
                                                        //else
                                                        //{
                                                        //    lrre.DominantFreq = 15;
                                                        //}
                                                        #endregion
                                                    }
                                                }
                                                else
                                                {
                                                    #region 同步方式
                                                    int res = new DownloadJsonFile().Download(eventTimeStr, dataFilePath, dataFileName + jsonStr, GlobalConfig.UseWaveDataTable);
                                                    if (res > -1)
                                                    {
                                                        FileInfo fileInfo2 = new FileInfo(dataFilePath + dataFileName + jsonStr);
                                                        if (fileInfo2.Length > 2000)
                                                        {
                                                            //目前提取的为半周期
                                                            lrre.DominantFreq = GlobalData.GetDominFreq(eventTimeStr);

                                                        }
                                                        //else
                                                        //{
                                                        //    lrre.DominantFreq = 15;
                                                        //}
                                                    }
                                                    //else
                                                    //{
                                                    //    lrre.DominantFreq = 15;
                                                    //}
                                                    #endregion
                                                    #region 异步方式
                                                    //TaskData taskData = new TaskData();
                                                    //taskData.EventTimeStr = mmee.EventTimeStr;
                                                    //taskData.Tasks = new Task(() =>
                                                    //{
                                                    //    int res = this.remoteDownloadDataBLL.DownLoadJsonData(eventTimeStr, dataFilePath, dataFileName + jsonStr, GlobalConfig.UseWaveDataTable);
                                                    //    if (res > -1)
                                                    //    {
                                                    //        taskData.IsComplete = true;
                                                    //    }
                                                    //    //Console.WriteLine(taskData.IsComplete);
                                                    //});
                                                    //taskData.CallBack = (string res) =>
                                                    //{
                                                    //    int domin = 0;
                                                    //    if (taskData.IsComplete)
                                                    //    {
                                                    //        domin = GetDominFreq(taskData.EventTimeStr);
                                                    //    }
                                                    //    this.ea.GetEvent<UpdateEventDominFreqMessage>().Publish(domin);
                                                    //};
                                                    //TaskQueue.Instance.AddTaskAndRuning(taskData);
                                                    #endregion
                                                }
                                                //通知主频更新
                                                this.ea.GetEvent<UpdateEventDominFreqMessage>().Publish(lrre.DominantFreq);
                                                //查询波形数据是否已下载
                                                if (File.Exists(dataFilePath + dataFileName + mseedStr))
                                                {
                                                    //待完善主频
                                                    //Console.WriteLine("15Hz");
                                                }
                                                else
                                                {
                                                    TaskData taskData = new TaskData();
                                                    taskData.EventTimeStr = mmee.EventTimeStr;
                                                    taskData.Tasks = new Task(() =>
                                                    {
                                                        int res = new DownloadWavedata().Download(eventTimeStr, dataFilePath, dataFileName + mseedStr, GlobalConfig.UseWaveDataTable);
                                                        if (res > -1)
                                                        {
                                                            taskData.IsComplete = true;
                                                        }
                                                        //Console.WriteLine(taskData.IsComplete);
                                                    });
                                                    taskData.CallBack = (string res) =>
                                                    {
                                                        //通知页面更新
                                                    };
                                                    TaskQueue.Instance.AddTaskAndRuning(taskData);
                                                }
                                                //检查本地数据库是否有此事件
                                                var re = fsqlSqLite.Select<LocalRealtimeResultEntity>().Where(rel => rel.RTEventID == lrre.RTEventID).ToOne();
                                                //如果没有，添加到本地库
                                                if (re == null)
                                                {
                                                    //int dominFreq = GetDominFreq(lrre.EventTime);

                                                    //if (dominFreq < 5)
                                                    //{
                                                    //    dominFreq = new Random((int)DateTime.Now.Ticks).Next(15, 60);
                                                    //}
                                                    //lrre.DominantFreq = dominFreq;
                                                    await fsqlSqLite.Insert<LocalRealtimeResultEntity>(lrre).ExecuteIdentityAsync();

                                                }
                                                //查询本地库realtimefocalmechanism是否有此记录，如果没有新增记录
                                                var rf = fsqlSqLite.Select<RealtimeFocalmechanismEntity>().Where(rel => rel.EventID == lrre.RTEventID).ToOne();
                                                if (rf == null)
                                                {
                                                    RealtimeFocalmechanismEntity rfe = new RealtimeFocalmechanismEntity();
                                                    rfe.DominantFreq = lrre.DominantFreq;
                                                    rfe.EventID = lrre.RTEventID;
                                                    await fsqlSqLite.Insert<RealtimeFocalmechanismEntity>(rfe).ExecuteIdentityAsync();
                                                }

                                                RemoteRealtimeResultEntity rrre = new RemoteRealtimeResultEntity(lrre);
                                                //通知页面更新

                                                //通知预警页面图表变化
                                                this.ea.GetEvent<UpdateLastAlarmEvent>().Publish(new AlarmEventPayload(rrre));
                                                //添加预警事件到右侧列表
                                                _dispatcher.Invoke(new System.Action(() =>
                                                {
                                                    //GlobalData.DisplayEventResults.Add(new GridItemEventResult(realEvent));
                                                    GlobalData.GridEvents.Insert(0, new GridItemEventResult(rrre, false));
                                                }));
                                                ResultCount = GlobalData.GridEvents.Count();
                                                //通知显示更新，线程有问题，已解决_20230228
                                                if (!GlobalData.ReceivedEvents.Contains(rrre))
                                                {
                                                    GlobalData.ReceivedEvents.Add(rrre);
                                                }
                                                this.ea.GetEvent<UpdateReceivedEventMessage>().Publish("新事件");

                                                //如果大于设定
                                                if (lrre.Energy >= alarmThreshold)
                                                {
                                                    //通知显示更新，线程有问题，已解决_20230228
                                                    if (!GlobalData.AlarmEvents.Contains(rrre))
                                                    {
                                                        GlobalData.AlarmEvents.Add(rrre);
                                                    }

                                                    CurAlarmLevel = ListAlarmLevel.First(lal => lal.MaxEnergy >= rrre.Energy && lal.MinEnergy <= lrre.Energy);
                                                    AlarmRecordEntity arent = new AlarmRecordEntity();
                                                    arent.EventId = lrre.RTEventID;
                                                    arent.AlarmTime = lrre.OriginTime;
                                                    arent.AlarmLevel = CurAlarmLevel.Level;
                                                    arent.Energy = lrre.Energy;

                                                    //写入报警记录
                                                    var haveAre = fsqlSqLite.Select<AlarmRecordEntity>().Where(are => are.EventId == arent.EventId).ToOne();
                                                    if (haveAre == null)
                                                    {
                                                        await fsqlSqLite.Insert(arent).ExecuteIdentityAsync();
                                                    }

                                                    //声音报警
                                                    if (canPlayAlarmSound)
                                                    {
                                                        alarmPlayer.PlaySync();
                                                    }

                                                    //报警数量
                                                    RunEventCnt++;
                                                }
                                                //watch.Stop();
                                                //TimeSpan timespan = watch.Elapsed;
                                                //Console.WriteLine("++++++++++++++++时长：" + timespan.TotalMilliseconds);
                                            }
                                        }                                        
                                    }
                                }
                                //watch.Stop();
                                //TimeSpan timespan = watch.Elapsed;
                                //this._logHelper.Debug(this, $"eventFreqTime:{eventFreqTime.ToString("F")},查询正常");
                                #endregion

                                //else
                                //{
                                //    int delayMillSec = (int)(RefreshInterval * 1000 - timespan.TotalMilliseconds);
                                //    //Console.WriteLine($"运行时长：{timespan.TotalMilliseconds}\t延迟时长：{delayMillSec}");
                                //    if (delayMillSec < 0)
                                //    {
                                //        delayMillSec = 0;
                                //    }
                                //    await Task.Delay(delayMillSec);
                                //    alarmEndTime = DateTime.Now;
                                //}
                                
                            }
                            await Task.Delay(1000);
                            
                        }
                        catch (Exception ex)
                        {
                            string strLog = String.Format("事件查询，[Thread ID:{0}]{1}", Task.CurrentId, ex.Message);
                            this._logHelper.Error(this, strLog);
                            string strInfoLog = String.Format("事件查询异常结束，系统运行时长：{0}", (DateTime.Now-SystemRunTime).TotalSeconds);
                            this._logHelper.Error(this, strInfoLog);
                            //LogObject.Log(MethodBase.GetCurrentMethod().Name).Error(ex.Message);
                            //throw;
                        }       
                    }
                }));
               
                //事件数量统计查询，每60秒查询一次，大多数情况运行正常，如果遇到网络不好的情况或者新事件查询功能在下载数据，数据库连接会出问题。
                var taskEventFreq = Task.Factory.StartNew(new System.Action(async () =>
                {
                    while (GlobalData.IsRunning)
                    {
                        try
                        {
                            //eventFreqTime=DateTime.Now;
                            if ((DateTime.Now - eventFreqTime).TotalMilliseconds >= 60000)
                            {
                                DateTime st = eventFreqTime.AddSeconds(-3600);
                                DateTime et = eventFreqTime;
                                //int StatCount = fsqlTencent.Select<RemoteRealtimeResultEntity>()
                                //        .Where(pp => DateTime.Parse(pp.EventTime).Ticks > st.Ticks &&
                                //        DateTime.Parse(pp.EventTime).Ticks <= et.Ticks).ToList().Count();
                                int StatCount = searchMsEventBLL.GetEvents(st, et).Count();
                                //通知更新一小时前事件数量
                                this.ea.GetEvent<UpdateEventFrequencyEvent>().Publish(StatCount);
                               
                                //this._logHelper.Debug(this, $"eventFreqTime:{eventFreqTime.ToString("F")},统计正常");
                                eventFreqTime = DateTime.Now;
                            }
                            await Task.Delay(1000);
                            
                        }
                        catch (Exception ex)
                        {                           
                            string strLog = String.Format("[事件统计，Thread ID:{0}]{1}", Task.CurrentId, ex.Message);
                            this._logHelper.Error(this, strLog);
                            string strInfoLog = String.Format("事件统计异常结束，统计时间：{0}", eventFreqTime.ToString());
                            this._logHelper.Error(this, strInfoLog);
                            //throw;
                        }
                        
                    }
                }));


                var taskRunTime = Task.Factory.StartNew(new System.Action(async () =>
                {
                    while (GlobalData.IsRunning)
                    {
                        TimeSpan ts = DateTime.Now - SystemRunTime;
                        RunSpan = ts.Days.ToString() + "天" + ts.Hours.ToString() + "小时" + ts.Minutes.ToString() + "分" + ts.Seconds.ToString() + "秒";
                        await Task.Delay(1000);
                    }
                }));

                GlobalData.TaskList.Add(taskAlarm);
                GlobalData.TaskList.Add(taskEventFreq);
                GlobalData.TaskList.Add(taskRunTime);
                
            }
            
        }

        bool CanStartMonitor()
        {
            return !GlobalData.IsRunning;
        }
        private void PutSamplesToChart(DataGeneratedEventArgs args)
        {
            //(Application.Current. as View).chart1.BeginUpdate();
        }

        private void DownloadWaveDataTask(string eventTimeStr, string tableName)
        {
            string downLoadStr = eventTimeStr;
            string datePath = downLoadStr.Substring(0, 4) + downLoadStr.Substring(5, 2) + downLoadStr.Substring(8, 2);
            string mseedStr = "HA." + downLoadStr.Substring(0, 4) + downLoadStr.Substring(5, 2)
                + downLoadStr.Substring(8, 2) + downLoadStr.Substring(10, 3)
                + downLoadStr.Substring(14, 2) + downLoadStr.Substring(17, 2) + ".01" + GlobalConfig.DataTypeString;

            string mseedPath = GlobalConfig.ProjectConfig.MseedFilePath + "\\" + datePath + "\\";
            string savePath = GlobalConfig.ProjectConfig.TxtFilePath + "\\" + datePath + "\\" + mseedStr + ".txt";
            //var taskRunTime = Task.Factory.StartNew(new Action(() =>
            //{
            if (!File.Exists(mseedPath + mseedStr + ".mseed"))
            {
                if (!Directory.Exists(mseedPath))
                {
                    Directory.CreateDirectory(mseedPath);
                }
                searchMsEventBLL.DownLoadWavedata(downLoadStr, mseedPath, mseedStr, tableName);
                if (!File.Exists(savePath))
                {
                    if (!Directory.Exists(Path.GetDirectoryName(savePath)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(savePath));
                    }
                    MSeed2Asc(mseedPath + mseedStr + ".mseed", savePath);
                }
                //Dialog.Show(new TextDialog() { ShowText = mseedPath + mseedStr + ".mseed" + "下载完成!" });
            }
            else
            {
                if (!File.Exists(savePath))
                {
                    if (!Directory.Exists(Path.GetDirectoryName(savePath)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(savePath));
                    }
                    MSeed2Asc(mseedPath + mseedStr + ".mseed", savePath);
                }
                //Dialog.Show(new TextDialog() { ShowText = mseedPath + mseedStr + ".mseed" + "已存在!" });
            }
            //}));
            //    GlobalData.TaskList.Add(taskRunTime);
        }
        private void DownloadWaveData(string eventTimeStr)
        {
            string downLoadStr = eventTimeStr;
            string datePath = downLoadStr.Substring(0, 4) + downLoadStr.Substring(5, 2) + downLoadStr.Substring(8, 2);
            string mseedStr = "HA." + downLoadStr.Substring(0, 4) + downLoadStr.Substring(5, 2)
                + downLoadStr.Substring(8, 2) + downLoadStr.Substring(10, 3)
                + downLoadStr.Substring(14, 2) + downLoadStr.Substring(17, 2) + ".01" + GlobalConfig.DataTypeString;

            string mseedPath = GlobalConfig.ProjectConfig.MseedFilePath + "\\" + datePath + "\\";
            string savePath = GlobalConfig.ProjectConfig.TxtFilePath + "\\" + datePath + "\\" + mseedStr + ".txt";
            if (!File.Exists(mseedPath + mseedStr + ".mseed"))
            {
                if (!Directory.Exists(mseedPath))
                {
                    Directory.CreateDirectory(mseedPath);
                }
                searchMsEventBLL.DownLoadWavedata(downLoadStr, mseedPath, mseedStr, GlobalConfig.UseWaveDataTable);
                if (!File.Exists(savePath))
                {
                    if (!Directory.Exists(Path.GetDirectoryName(savePath)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(savePath));
                    }
                    MSeed2Asc(mseedPath + mseedStr + ".mseed", savePath);
                }
                //Dialog.Show(new TextDialog() { ShowText = mseedPath + mseedStr + ".mseed" + "下载完成!" });
            }
            else
            {
                if (!File.Exists(savePath))
                {
                    if (!Directory.Exists(Path.GetDirectoryName(savePath)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(savePath));
                    }
                    MSeed2Asc(mseedPath + mseedStr + ".mseed", savePath);
                }
                //Dialog.Show(new TextDialog() { ShowText = mseedPath + mseedStr + ".mseed" + "已存在!" });
            }
        }
       
        public void MSeed2Asc(string filePath, string savePath)
        {
            using (Process compiler = new Process())
            {
                compiler.StartInfo.FileName = "mseed2ascii.exe";
                compiler.StartInfo.Arguments = filePath + " -o " + savePath;
                compiler.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                compiler.Start();
                compiler.WaitForExit();
            }
        }
    }
}