using System;
using System.Collections.ObjectModel;
using System.Globalization;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Threading;
using Correlator.DataService;
using Correlator.Events;
using Correlator.Model;
using Correlator.SensorHubTag;
using Correlator.Util;
using Correlator.Views;
using HandyControl.Controls;
using MathWorks.MATLAB.NET.Arrays;
using Newtonsoft.Json;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using ComboBox = System.Windows.Controls.ComboBox;

namespace Correlator.ViewModels
{
    public class MainWindowViewModel : BindableBase
    {
        #region 变量

        private readonly DispatcherTimer _checkSerialPortTimer = new DispatcherTimer
        {
            Interval = new TimeSpan(0, 0, 7)
        };

        private readonly DispatcherTimer _timer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(1)
        };

        private readonly DispatcherTimer _batteryTimer = new DispatcherTimer
        {
            Interval = TimeSpan.FromMinutes(5)
        };

        //计算时间
        private int _runningSeconds;

        //运行时间Timer
        private readonly DispatcherTimer _runningTimer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(1)
        };

        private bool _isResetParam;

        private readonly IEventAggregator _eventAggregator;
        private readonly IApplicationDataService _soundSpeedDataService;
        private readonly IDialogService _dialogService;
        private readonly ISerialPortService _serialPortService;

        //加速度计下发指令Timer
        private readonly DispatcherTimer _accelerometerCommandTimer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(10)
        };

        private MainWindow _mainWindow;
        private byte _devId = 0x02;
        private string _locateDataDir;
        private int _locateTimes;
        private string _snapShotPath = string.Empty;
        private ParamConfigModel _paramConfig;

        //自动截屏倒计时
        private readonly DispatcherTimer _snapShotTimer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(3)
        };

        //Matlab算法
        private static readonly Lazy<CorrelatorSingle.Correlator> LazyCorrelator =
            new Lazy<CorrelatorSingle.Correlator>(() => new CorrelatorSingle.Correlator());

        #endregion

        #region VM属性

        private string _currentTime;

        public string CurrentTime
        {
            get => _currentTime;
            private set
            {
                _currentTime = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 红色发射机信号强度0-5
        /// </summary>
        private int _redTransmitterSignal;

        public int RedTransmitterSignal
        {
            get => _redTransmitterSignal;
            private set
            {
                _redTransmitterSignal = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 蓝色发射机信号强度0-5
        /// </summary>
        private int _blueTransmitterSignal;

        public int BlueTransmitterSignal
        {
            get => _blueTransmitterSignal;
            private set
            {
                _blueTransmitterSignal = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 绑定干扰频段值
        /// </summary>
        private string _interferenceFrequency = "无";

        public string InterferenceFrequency
        {
            get => _interferenceFrequency;
            private set
            {
                _interferenceFrequency = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 绑定过信噪比
        /// </summary>
        private string _snr = "无";

        public string Snr
        {
            get => _snr;
            private set
            {
                _snr = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 绑定过滤器值
        /// </summary>
        private string _filterValue = " ~ Hz";

        public string FilterValue
        {
            get => _filterValue;
            private set
            {
                _filterValue = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 绑定声速值
        /// </summary>
        private string _soundSpeed = "0";

        public string SoundSpeed
        {
            get => _soundSpeed;
            private set
            {
                _soundSpeed = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 红色发射机是否故障
        /// </summary>
        private bool _redTransmitterState;

        public bool RedTransmitterState
        {
            get => _redTransmitterState;
            set
            {
                _redTransmitterState = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 蓝色发射机是否故障
        /// </summary>
        private bool _blueTransmitterState;

        public bool BlueTransmitterState
        {
            get => _blueTransmitterState;
            private set
            {
                _blueTransmitterState = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 红色发射机距离 
        /// </summary>
        private double _redTransmitterDistance;

        public double RedTransmitterDistance
        {
            get => _redTransmitterDistance;
            private set
            {
                _redTransmitterDistance = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 蓝色发射机距离
        /// </summary>
        private double _blueTransmitterDistance;

        public double BlueTransmitterDistance
        {
            get => _blueTransmitterDistance;
            private set
            {
                _blueTransmitterDistance = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 红色发射机电量 0-100
        /// </summary>
        private int _redTransmitterBattery;

        public int RedTransmitterBattery
        {
            get => _redTransmitterBattery;
            set
            {
                _redTransmitterBattery = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 蓝色发射机电量 0-100
        /// </summary>
        private int _blueTransmitterBattery;

        public int BlueTransmitterBattery
        {
            get => _blueTransmitterBattery;
            set
            {
                _blueTransmitterBattery = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 电脑电量 0-100
        /// </summary>
        private int _computerBattery;

        public int ComputerBattery
        {
            get => _computerBattery;
            set
            {
                _computerBattery = value;
                RaisePropertyChanged();
            }
        }

        /// <summary>
        /// 绑定经过了值
        /// </summary>
        private string _elapseTime = "0";

        public string ElapseTime
        {
            get => _elapseTime;
            private set
            {
                _elapseTime = value;
                RaisePropertyChanged();
            }
        }

        private string _connectColorBrush = "LightGray";

        public string ConnectColorBrush
        {
            get => _connectColorBrush;
            private set
            {
                _connectColorBrush = value;
                RaisePropertyChanged();
            }
        }

        private ObservableCollection<string> _pipeMaterialsArray;

        public ObservableCollection<string> PipeMaterialsArray
        {
            get => _pipeMaterialsArray;
            set
            {
                _pipeMaterialsArray = value;
                RaisePropertyChanged();
            }
        }

        private string _materialName = string.Empty;

        public string MaterialName
        {
            get => _materialName;
            set
            {
                _materialName = value;
                RaisePropertyChanged();
            }
        }

        private string _pipeDiameter = string.Empty;

        public string PipeDiameter
        {
            get => _pipeDiameter;
            set
            {
                _pipeDiameter = value;
                RaisePropertyChanged();
            }
        }

        private string _pipeLength = string.Empty;

        public string PipeLength
        {
            get => _pipeLength;
            set
            {
                _pipeLength = value;
                RaisePropertyChanged();
            }
        }

        private string _frequencyInterval = "100 ~ 3000Hz";

        public string FrequencyInterval
        {
            get => _frequencyInterval;
            private set
            {
                _frequencyInterval = value;
                RaisePropertyChanged();
            }
        }

        private string _lowFrequency = string.Empty;

        public string LowFrequency
        {
            get => _lowFrequency;
            set
            {
                _lowFrequency = value;
                RaisePropertyChanged();
            }
        }

        private string _highFrequency = string.Empty;

        public string HighFrequency
        {
            get => _highFrequency;
            set
            {
                _highFrequency = value;
                RaisePropertyChanged();
            }
        }

        //是否已开始采集或者计算数据
        private bool _startButtonIsEnabled = true;

        public bool StartButtonEnabled
        {
            get => _startButtonIsEnabled;
            private set
            {
                _startButtonIsEnabled = value;
                RaisePropertyChanged();
            }
        }

        private CorrelatorDataModel _correlatorData = new CorrelatorDataModel();

        public CorrelatorDataModel CorrelatorData
        {
            get => _correlatorData;
            set
            {
                _correlatorData = value;
                RaisePropertyChanged();
            }
        }

        #endregion

        #region PC电量状态

        [DllImport("kernel32.dll", EntryPoint = "GetSystemPowerStatus")]
        private static extern void GetSystemPowerStatus(ref SystemConfig.SystemPowerStatus lpSystemPowerStatus);

        #endregion

        #region DelegateCommand

        public DelegateCommand<MainWindow> WindowLoadedCommand { set; get; }
        public DelegateCommand CloseWindowCommand { private set; get; }
        public DelegateCommand<Popup> OpenFolderCommand { private set; get; }
        public DelegateCommand<Popup> OpenImageFileCommand { private set; get; }
        public DelegateCommand<Popup> OpenAudioFileCommand { private set; get; }
        public DelegateCommand OpenListenAudioCommand { private set; get; }
        public DelegateCommand ShowWaveCommand { private set; get; }
        public DelegateCommand OpenNumericKeypadCommand { private set; get; }
        public DelegateCommand<ComboBox> PipeItemSelectedCommand { set; get; }
        public DelegateCommand DetectNoiseCommand { private set; get; }
        public DelegateCommand<Popup> SettingsCommand { private set; get; }
        public DelegateCommand<Popup> SoundSpeedCommand { private set; get; }
        public DelegateCommand<Popup> ShowApplicationInfoCommand { private set; get; }
        public DelegateCommand ImportDataCommand { private set; get; }
        public DelegateCommand SaveAudioCommand { private set; get; }
        public DelegateCommand ResetParamCommand { private set; get; }
        public DelegateCommand SnapShotCommand { private set; get; }
        public DelegateCommand StartCollectDataCommand { private set; get; }

        #endregion

        public MainWindowViewModel(IEventAggregator eventAggregator, IApplicationDataService dataService,
            IDialogService dialogService, ISerialPortService serialPortService)
        {
            _eventAggregator = eventAggregator;
            _soundSpeedDataService = dataService;
            _dialogService = dialogService;
            _serialPortService = serialPortService;

            RegisterMessage();

            TimerTick();

            _pipeMaterialsArray = new ObservableCollection<string>();
            var pipeMaterials = dataService.GetPipeMaterial();
            foreach (var material in pipeMaterials)
            {
                PipeMaterialsArray.Add(material.ChineseMaterial);
            }

            InitDelegateCommand();
        }

        /// <summary>
        /// 消息监听注册
        /// </summary>
        private void RegisterMessage()
        {
            _eventAggregator.GetEvent<RedSensorEvent>().Subscribe(delegate(DevStatus dev)
            {
                "MainWindowViewModel".WriteLog("Red Sensor收到消息：" + JsonConvert.SerializeObject(dev));

                //新协议不计算实际信号
                RedTransmitterBattery = Convert.ToInt32(dev.Cell);
                RedTransmitterSignal = 5;
                RedTransmitterState = true;
                RuntimeCache.RedSensorIsEnable = true;
            });

            _eventAggregator.GetEvent<BlueSensorEvent>().Subscribe(delegate(DevStatus dev)
            {
                "MainWindowViewModel".WriteLog("Blue Sensor收到消息：" + JsonConvert.SerializeObject(dev));

                //新协议不计算实际信号
                BlueTransmitterBattery = Convert.ToInt32(dev.Cell);
                BlueTransmitterSignal = 5;
                BlueTransmitterState = true;
                RuntimeCache.BlueSensorIsEnable = true;
            });

            //加速度计
            _eventAggregator.GetEvent<StartCalculateEvent>().Subscribe(StartCalculateData);

            //水听器
            _eventAggregator.GetEvent<ShowCheckResponseEvent>().Subscribe(delegate
            {
                _dialogService.Show("CheckResponseDialog", null, delegate(IDialogResult result)
                {
                    if (result.Result == ButtonResult.Cancel)
                    {
                        ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "数据未校验，无法进行计算");
                        return;
                    }

                    if (result.Result == ButtonResult.Abort)
                    {
                        ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "数据校验被终止，无法进行计算");
                        return;
                    }

                    if (result.Result == ButtonResult.OK)
                    {
                        //水听器数据采集完毕，开始计算
                        StartCalculateData();
                    }
                });
            });

            //数字键盘
            _eventAggregator.GetEvent<NumericKeypadEvent>().Subscribe(delegate(NumberStruct number)
            {
                if (number.TextBoxName.Equals(_mainWindow.PipeDiameterTextBox.Name))
                {
                    PipeDiameter = number.NumberValue;
                }
                else if (number.TextBoxName.Equals(_mainWindow.PipeLengthTextBox.Name))
                {
                    PipeLength = number.NumberValue;
                }
                else if (number.TextBoxName.Equals(_mainWindow.LowFrequencyTextBox.Name))
                {
                    LowFrequency = number.NumberValue;
                }
                else if (number.TextBoxName.Equals(_mainWindow.HighFrequencyTextBox.Name))
                {
                    HighFrequency = number.NumberValue;
                }
            });
        }

        private void StartCalculateData()
        {
            DialogHub.Get.ShowLoadingDialog(_mainWindow, "数据计算中，请稍后...");
            //开始计算就不收集收据了且不能点击开始按钮
            StartButtonEnabled = false;
            RuntimeCache.CanCollectData = false;
            if (!RuntimeCache.IsHydrophone)
            {
                //开始计算停止收集指令
                _accelerometerCommandTimer.Stop();
            }

            using (var manager = new DataBaseManager())
            {
                var today = DateTime.Now.ToString("yyyyMMdd");
                var configModel = manager.Table<CorrelatorConfigModel>()
                    .Where(x => x.Date == today)
                    .OrderBy(x => x.Date)
                    .LastOrDefault() ?? new CorrelatorConfigModel
                    { Date = today, Pipe = 1, LocateTimes = 1, ListenTimes = 1 };

                //如果配置里面的日期相同，则取配置里面的Pipe作为index，如果配置里面的日期不相同，则默认index=1
                var pipeIndex = configModel.Date.Equals(today) ? configModel.Pipe : 1;
                _locateDataDir = DirectoryManager.GetLocateDataDir(pipeIndex);
                _locateTimes = configModel.LocateTimes;
                //插入新纪录
                configModel.Pipe++;
                configModel.LocateTimes++;
                manager.Insert(configModel);
            }

            //计算
            new Thread(CalculateData).Start();
        }

        /// <summary>
        /// 算法计算
        /// </summary>
        private void CalculateData()
        {
            var dataModel = RuntimeCache.CorrelatorData;
            if (dataModel.LeftDeviceDataArray != null && dataModel.RightDeviceDataArray != null)
            {
                Console.WriteLine(@"MainWindowViewModel => 开始计算");
                var array = LazyCorrelator.Value.locating(
                    11,
                    (MWNumericArray)dataModel.LeftDeviceDataArray, (MWNumericArray)dataModel.RightDeviceDataArray,
                    RuntimeCache.AudioSampleRate,
                    int.Parse(_pipeLength), int.Parse(_soundSpeed),
                    0, 0,
                    0, 0,
                    _materialName,
                    int.Parse(_pipeDiameter), int.Parse(_pipeDiameter),
                    1, -1,
                    -1, -1,
                    int.Parse(_lowFrequency), int.Parse(_highFrequency)
                );
                Console.WriteLine(@"MainWindowViewModel => 计算结束");

                //数据绑定
                var snr = Convert.ToDouble(array[0].ToString()); //信噪比
                Snr = snr.ToString("0.0") + ":1";
                RedTransmitterDistance = Convert.ToDouble(array[1].ToString()); //距离A
                BlueTransmitterDistance = Convert.ToDouble(array[2].ToString()); //距离B

                var maxFreLowOut = Convert.ToInt32(array[6].ToString()); //低频
                var maxFreHighOut = Convert.ToInt32(array[7].ToString()); //高频

                FilterValue = maxFreLowOut + " ~ " + maxFreHighOut + "Hz";

                //设置噪声值
                CorrelatorData = dataModel;

                _eventAggregator.GetEvent<RenderOscillogramEvent>().Publish(array);

                var time = DateTime.Now.ToString("HHmmss");
                if (RuntimeCache.IsHydrophone)
                {
                    //保存参数
                    var paramConfigFile = $"{_locateDataDir}\\参数配置.{_locateTimes}.{time}.json";
                    File.AppendAllText(paramConfigFile, JsonConvert.SerializeObject(_paramConfig));
                }

                //保存数据
                var fileName = $"{_locateDataDir}\\测试数据.{_locateTimes}.{time}.txt";
                fileName.SaveLocateData(dataModel);
                "MainWindowViewModel".WriteLog("定位数据路径：" + fileName);

                //保存了数据之后3s再截图
                _snapShotPath = $"{_locateDataDir}\\快照.{_locateTimes}.{time}.png";
                _snapShotTimer.Start();

                _runningTimer.Stop();
                StartButtonEnabled = true;
                //清空缓存
                RuntimeCache.RedSensorOriginalResp.Clear();
                RuntimeCache.BlueSensorOriginalResp.Clear();
                RuntimeCache.RedSensorResponseTags.Clear();
                RuntimeCache.BlueSensorResponseTags.Clear();
                RuntimeCache.RedSensorIsEnable = false;
                RuntimeCache.BlueSensorIsEnable = false;

                DialogHub.Get.DismissLoadingDialog();
            }
        }

        /// <summary>
        /// 各种定时器
        /// </summary>
        private void TimerTick()
        {
            _checkSerialPortTimer.Tick += delegate
            {
                var ports = SerialPort.GetPortNames();
                foreach (var portName in ports)
                {
                    if (portName != "COM3" || _serialPortService.Sp.IsOpen) continue;
                    _serialPortService.Sp.PortName = portName; //串口名称
                    _serialPortService.Sp.BaudRate = 230400; //波特率57600和230400
                    _serialPortService.Sp.DataBits = 8; //数据位
                    _serialPortService.Sp.StopBits = (StopBits)1; //停止位
                    _serialPortService.Sp.Open(); //打开串口
                    Console.WriteLine(@"MainWindowViewModel => 打开串口");

                    break;
                }

                if (_serialPortService.Sp.IsOpen)
                {
                    //实时显示信号电量
                    if (!RuntimeCache.RedSensorIsEnable && !RuntimeCache.BlueSensorIsEnable)
                    {
                        _devId = (byte)(_devId == 0x02 ? 0x01 : 0x02);
                        _serialPortService.ShowSignal(_devId);
                    }
                    else
                    {
                        if (!RuntimeCache.RedSensorIsEnable)
                        {
                            _serialPortService.ShowSignal(0x01);
                        }

                        if (!RuntimeCache.BlueSensorIsEnable)
                        {
                            _serialPortService.ShowSignal(0x02);
                        }
                    }
                }
            };
            _checkSerialPortTimer.Start();

            //实时显示时间
            _timer.Tick += RealTime;
            _timer.Start();

            //获取电池电量
            var sysPower = new SystemConfig.SystemPowerStatus();
            GetSystemPowerStatus(ref sysPower);
            ComputerBattery = sysPower.BatteryPercent == 255 ? 100 : sysPower.BatteryPercent;

            _batteryTimer.Tick += delegate
            {
                GetSystemPowerStatus(ref sysPower);
                ComputerBattery = sysPower.BatteryPercent == 255 ? 100 : sysPower.BatteryPercent;
            };
            _batteryTimer.Start();

            //计算时间Timer
            _runningTimer.Tick += delegate
            {
                _runningSeconds++;
                ElapseTime = _runningSeconds.ToString();
            };

            //加速度计下发指令Timer
            _accelerometerCommandTimer.Tick += delegate
            {
                if (RuntimeCache.CanCollectData)
                {
                    RuntimeCache.IsDetectNoise = false;
                    CommandSender.SendCorrelatorWakeUpCmd(_serialPortService.Sp);
                }
            };

            //自动截屏Timer
            _snapShotTimer.Tick += delegate
            {
                _snapShotTimer.Stop();
                if (!string.IsNullOrEmpty(_snapShotPath))
                {
                    _snapShotPath.SnapShot();
                    "MainWindowViewModel".WriteLog("截屏路径：" + _snapShotPath);
                }
            };
        }

        /// <summary>
        /// 事件指令
        /// </summary>
        private void InitDelegateCommand()
        {
            //界面加载完成
            WindowLoadedCommand = new DelegateCommand<MainWindow>(it =>
            {
                _mainWindow = it;
                Console.WriteLine(@"MainWindowViewModel => 加载");
                it.AccelerationRadioButton.Checked += delegate
                {
                    RuntimeCache.IsHydrophone = false;
                    FrequencyInterval = "100 ~ 3000Hz";
                };

                it.HydrophonesRadioButton.Checked += delegate
                {
                    RuntimeCache.IsHydrophone = true;
                    FrequencyInterval = "10 ~ 300Hz";
                };
            });

            //退出应用
            CloseWindowCommand = new DelegateCommand(delegate
            {
                _dialogService.ShowDialog(
                    "AlertControlDialog",
                    new DialogParameters
                    {
                        { "AlertType", AlertType.Question }, { "Title", "温馨提示" }, { "Message", "是否确定退出应用？" }
                    },
                    delegate(IDialogResult dialogResult)
                    {
                        if (dialogResult.Result == ButtonResult.Cancel)
                        {
                            return;
                        }

                        //删除小于50K的音频
                        foreach (var file in RuntimeCache.SmallAudioFiles)
                        {
                            File.Delete(file);
                        }

                        RuntimeCache.SmallAudioFiles.Clear();
                        _mainWindow.Close();
                    }
                );
            });

            //打开图片、音频菜单
            OpenFolderCommand = new DelegateCommand<Popup>(delegate(Popup popup) { popup.IsOpen = true; });

            //查看图片列表
            OpenImageFileCommand = new DelegateCommand<Popup>(delegate(Popup popup)
            {
                _dialogService.Show("PictureFileView", null, delegate { });
                popup.IsOpen = false;
            });

            //查看音频列表
            OpenAudioFileCommand = new DelegateCommand<Popup>(delegate(Popup popup)
            {
                _dialogService.Show("AudioFileView", null, delegate { });
                popup.IsOpen = false;
            });

            //打开听音
            OpenListenAudioCommand = new DelegateCommand(delegate
            {
                if (!_serialPortService.Sp.IsOpen)
                {
                    ShowAlertMessageDialog(AlertType.Error, "操作错误", "串口状态异常，无法打开听音功能");
                    return;
                }

                _dialogService.Show("SimplyAuditionDialog", null, delegate { });
            });

            //噪声探测
            DetectNoiseCommand = new DelegateCommand(delegate
            {
                if (!_serialPortService.Sp.IsOpen)
                {
                    ShowAlertMessageDialog(AlertType.Error, "操作错误", "串口状态异常，无法打开探测功能");
                    return;
                }

                _dialogService.Show("DetectNoiseDialog", null, delegate { });
            });

            //设置
            SettingsCommand = new DelegateCommand<Popup>(delegate(Popup popup) { popup.IsOpen = true; });

            //声速
            SoundSpeedCommand = new DelegateCommand<Popup>(delegate(Popup popup)
            {
                if (string.IsNullOrEmpty(_materialName))
                {
                    ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "请选择管道材料");
                    return;
                }

                _dialogService.Show("SoundSpeedDialog", new DialogParameters
                    {
                        { "MaterialName", _materialName }
                    },
                    delegate { }
                );
                popup.IsOpen = false;
            });

            //查看软件、协议版本
            ShowApplicationInfoCommand = new DelegateCommand<Popup>(delegate(Popup popup)
            {
                _dialogService.Show("ApplicationInfoDialog", null, delegate { });
                popup.IsOpen = false;
            });

            //导入数据
            ImportDataCommand = new DelegateCommand(delegate
            {
                if (RuntimeCache.IsHydrophone)
                {
                    _dialogService.Show("ImportResponseDialog", null, delegate(IDialogResult result)
                    {
                        if (result.Result == ButtonResult.Cancel)
                        {
                            ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "用户取消导入数据");
                            return;
                        }

                        if (result.Result == ButtonResult.OK)
                        {
                            var configModel = result.Parameters.GetValue<ParamConfigModel>("ParamConfigModel");

                            MaterialName = configModel.PipeMaterial;
                            PipeDiameter = configModel.PipeDiameter;
                            PipeLength = configModel.PipeLength;
                            LowFrequency = configModel.MinFrequency;
                            HighFrequency = configModel.MaxFrequency;

                            //计算声速
                            var soundVelocity = _soundSpeedDataService.GetSoundVelocity(
                                _materialName, Convert.ToInt32(_pipeDiameter)
                            );
                            SoundSpeed = soundVelocity.ToString();
                        }

                        //导入数据完成，可以计算数据
                        StartCalculateData();
                    });
                }
                else
                {
                    ShowAlertMessageDialog(AlertType.Error, "操作错误", "仅支持水听器模式导入数据");
                }
            });

            //打开Matlab波形
            ShowWaveCommand = new DelegateCommand(delegate
            {
                if (RuntimeCache.CorrelatorData == null)
                {
                    ShowAlertMessageDialog(AlertType.Error, "温馨提示", "请先采集数据");
                    return;
                }

                _dialogService.ShowDialog("NoiseWaveView", null, delegate { });
            });

            //打开数字键盘
            OpenNumericKeypadCommand = new DelegateCommand(delegate
            {
                _dialogService.ShowDialog("NumericKeypadDialog", null, delegate { });
            });

            //管道材料选择
            PipeItemSelectedCommand = new DelegateCommand<ComboBox>(delegate(ComboBox box)
            {
                MaterialName = box.SelectedItem.ToString();
            });

            //将采集的数据转为音频并保存
            SaveAudioCommand = new DelegateCommand(delegate
            {
                if (RuntimeCache.CorrelatorData != null)
                {
                    var filePath = $"{DirectoryManager.GetAudioDir()}\\音频_{DateTime.Now:yyyyMMdd_HHmmss}.wav";
                    filePath.SaveWavFile(
                        RuntimeCache.CorrelatorData.LeftDeviceDataArray,
                        RuntimeCache.CorrelatorData.RightDeviceDataArray
                    );

                    Growl.Success("音频已保存");
                    //清空上次的缓存
                    RuntimeCache.CorrelatorData = null;
                }
                else
                {
                    ShowAlertMessageDialog(AlertType.Error, "操作错误", "还未开始采集数据，无法保存音频");
                }
            });

            //复位
            ResetParamCommand = new DelegateCommand(delegate
            {
                _isResetParam = true;
                ResetParam();
            });

            //截屏
            SnapShotCommand = new DelegateCommand(delegate
            {
                var filePath = $"{DirectoryManager.GetPictureDir()}\\快照_{DateTime.Now:yyyyMMddHHmmss}.png";
                filePath.SnapShot();
            });

            //开始采集数据
            StartCollectDataCommand = new DelegateCommand(delegate
            {
                if (!_serialPortService.Sp.IsOpen)
                {
                    ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "串口状态异常，无法操作");
                    return;
                }

                if (CheckParamLegitimacy())
                {
                    _isResetParam = false;

                    //每次计算之前都需要判断是否已经完成之前的计算，然后清空上一次的计算数据
                    ResetParam();

                    RuntimeCache.CanCollectData = true;
                    //开始数据采集
                    if (RuntimeCache.IsHydrophone)
                    {
                        CommandSender.SendHydrophoneWakeUpCmd(_serialPortService.Sp);
                    }
                    else
                    {
                        _accelerometerCommandTimer.Start();
                    }

                    //记录计算时间
                    _runningTimer.Start();
                }
            });
        }

        /// <summary>
        /// 重置参数
        /// </summary>
        private void ResetParam()
        {
            if (_isResetParam)
            {
                PipeDiameter = string.Empty;
                PipeLength = string.Empty;
                LowFrequency = string.Empty;

                HighFrequency = string.Empty;
                SoundSpeed = "0";

                //复位之后可以再次开始
                StartButtonEnabled = true;
            }

            InterferenceFrequency = "无";
            Snr = "无";
            FilterValue = " ~ Hz";
            RedTransmitterDistance = 0;
            ElapseTime = "0";
            BlueTransmitterDistance = 0;
            CorrelatorData = new CorrelatorDataModel();

            _runningSeconds = 0;
            _runningTimer.Stop();

            _eventAggregator.GetEvent<ClearOscillogramEvent>().Publish();

            if (!RuntimeCache.IsHydrophone)
            {
                _accelerometerCommandTimer.Stop();
            }

            RuntimeCache.CanCollectData = false;
        }

        /// <summary>
        /// 参数检查
        /// </summary>
        /// <returns></returns>
        private bool CheckParamLegitimacy()
        {
            if (string.IsNullOrEmpty(_materialName))
            {
                ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "请选择管道材料");
                return false;
            }

            if (string.IsNullOrEmpty(_pipeDiameter))
            {
                ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "请输入管道直径");
                return false;
            }

            if (string.IsNullOrEmpty(_pipeLength))
            {
                ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "请输入管道长度");
                return false;
            }

            if (string.IsNullOrEmpty(_lowFrequency) || string.IsNullOrEmpty(_highFrequency))
            {
                ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "请输入完整的计算频段");
                return false;
            }

            var low = Convert.ToInt32(_lowFrequency);
            var high = Convert.ToInt32(_highFrequency);

            if (RuntimeCache.IsHydrophone)
            {
                if (low < 10 || low > 300 || high < 10 || high > 300 || low >= high)
                {
                    ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "频段范围10 ~ 300Hz，请重新输入");
                    return false;
                }

                //缓存计算参数
                _paramConfig = new ParamConfigModel
                {
                    PipeMaterial = _materialName,
                    PipeDiameter = _pipeDiameter,
                    PipeLength = _pipeLength,
                    MinFrequency = _lowFrequency,
                    MaxFrequency = _highFrequency
                };
            }
            else
            {
                if (low < 100 || low > 3000 || high < 100 || high > 3000 || low >= high)
                {
                    ShowAlertMessageDialog(AlertType.Warning, "温馨提示", "频段范围100 ~ 3000Hz，请重新输入");
                    return false;
                }
            }


            //声速
            var soundVelocity = _soundSpeedDataService.GetSoundVelocity(_materialName, Convert.ToInt32(_pipeDiameter));
            SoundSpeed = soundVelocity.ToString();
            return true;
        }

        /// <summary>
        /// 实时显示时间，并监听串口状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void RealTime(object sender, EventArgs args)
        {
            var dateTime = DateTime.Now;
            var strDateTime = dateTime.ToString("yyyy年MM月dd日") +
                              dateTime.ToString("\0 \0 \0 dddd \0 \0 \0", new CultureInfo("zh-cn")) +
                              dateTime.ToString("HH:mm:ss");
            Application.Current.Dispatcher.Invoke(delegate
            {
                CurrentTime = strDateTime;

                //同时监听串口状态
                if (_serialPortService.Sp.IsOpen)
                {
                    ConnectColorBrush = "LimeGreen";
                }
                else
                {
                    ConnectColorBrush = "LightGray";

                    RedTransmitterBattery = 0;
                    RedTransmitterSignal = 0;
                    RedTransmitterState = false;

                    BlueTransmitterBattery = 0;
                    BlueTransmitterSignal = 0;
                    BlueTransmitterState = false;

                    RuntimeCache.RedSensorIsEnable = false;
                    RuntimeCache.BlueSensorIsEnable = false;
                }
            });
        }

        /// <summary>
        /// 显示普通提示对话框
        /// </summary>
        private void ShowAlertMessageDialog(AlertType type, string title, string message)
        {
            _dialogService.ShowDialog("AlertMessageDialog", new DialogParameters
                {
                    { "AlertType", type }, { "Title", title }, { "Message", message }
                },
                delegate { }
            );
        }
    }
}