using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Threading;
using Correlator.SensorHubTag;
using Correlator.Service;
using Correlator.Util;
using Correlator.View;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using HandyControl.Controls;
using Newtonsoft.Json;
using ComboBox = System.Windows.Controls.ComboBox;
using MessageBox = HandyControl.Controls.MessageBox;

namespace Correlator.ViewModel
{
    public class HomePageProViewModel : ViewModelBase
    {
        #region 变量

        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)
        };

        #endregion

        #region VM属性

        private string _currentTime;

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

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

        public int RedTransmitterSignalIntensity
        {
            get => _redTransmitterSignalIntensity;
            private set
            {
                _redTransmitterSignalIntensity = value;
                RaisePropertyChanged();
            }
        }

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

        public int BlueTransmitterSignalIntensity
        {
            get => _blueTransmitterSignalIntensity;
            private set
            {
                _blueTransmitterSignalIntensity = 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 = "无";

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

        /// <summary>
        /// 绑定管道值
        /// </summary>
        private string _pipeline = "无";

        public string PipeLine
        {
            get => _pipeline;
            private set
            {
                _pipeline = 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 double _redTransmitterBattery;

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

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

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

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

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

        private double _computerBattery;

        public double ComputerBattery
        {
            get => _computerBattery;
            set
            {
                _computerBattery = 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;
            private set
            {
                _pipeMaterialsArray = value;
                RaisePropertyChanged();
            }
        }

        private string _pipeName;

        public string PipeName
        {
            get => _pipeName;
            set
            {
                _pipeName = value;
                RaisePropertyChanged();
            }
        }

        private bool _comboBoxIsEnabled = true;

        public bool ComboBoxIsEnabled
        {
            get => _comboBoxIsEnabled;
            set
            {
                _comboBoxIsEnabled = value;
                RaisePropertyChanged();
            }
        }

        private string _pipeDiameter;

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

        private string _pipeLength;

        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;

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

        private string _highFrequency;

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

        #endregion

        #region PC电量状态

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

        #endregion

        #region RelayCommand

        public RelayCommand<HomePageProWindow> WindowLoadedCommand { set; get; }
        public RelayCommand<ComboBox> PipeItemSelectedCommand { set; get; }
        public RelayCommand SaveAudioCommand { private set; get; }
        public RelayCommand ResetParamCommand { private set; get; }
        public RelayCommand SnapShotCommand { private set; get; }
        public RelayCommand StartCalculateCommand { private set; get; }

        #endregion

        public HomePageProViewModel(IPipeMaterialDataService dataService)
        {
            RegisterMessage();
            
            TimerTick();

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

            InitRelayCommand();

            InitDefaultValue();
        }

        /// <summary>
        /// 消息监听注册
        /// </summary>
        private void RegisterMessage()
        {
            Messenger.Default.Register<DevStatus>(this, MessengerToken.RedSensorStatus, dev =>
            {
                "HomePageProViewModel".WriteLog("Red Sensor收到消息：" + JsonConvert.SerializeObject(dev));

                RedTransmitterBattery = Convert.ToDouble(dev.Cell);
                var signalIntensity = Convert.ToInt32(dev.Signal).ToIntensity();
                RedTransmitterSignalIntensity = signalIntensity;
                var sensorStatus = dev.Status == "1";
                RedTransmitterState = sensorStatus;
                //将信号A数据缓存到FlowStatus
                FlowStatus.SensorASignalIntensity = signalIntensity;
                FlowStatus.SensorAIsEnable = sensorStatus;
            });

            Messenger.Default.Register<DevStatus>(this, MessengerToken.BlueSensorStatus, dev =>
            {
                "HomePageProViewModel".WriteLog("Blue Sensor收到消息：" + JsonConvert.SerializeObject(dev));

                BlueTransmitterBattery = Convert.ToDouble(dev.Cell);
                var signalIntensity = Convert.ToInt32(dev.Signal).ToIntensity();
                BlueTransmitterSignalIntensity = signalIntensity;
                var sensorStatus = dev.Status == "1";
                BlueTransmitterState = sensorStatus;
                //将信号B数据缓存到FlowStatus
                FlowStatus.SensorBSignalIntensity = signalIntensity;
                FlowStatus.SensorBIsEnable = sensorStatus;
            });
        }
        
        /// <summary>
        /// 各种定时器
        /// </summary>
        private void TimerTick()
        {
            //实时显示时间
            _timer.Tick += delegate
            {
                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");
                CurrentTime = strDateTime;

                //同时监听串口状态
                ConnectColorBrush = SerialPortManager.Get.Sp.IsOpen ? "LimeGreen" : "LightGray";
            };
            _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();
                if (_runningSeconds >= 90)
                {
                    _runningTimer.Stop();
                    MessageBox.Show("接收不到数据，请点击复位并重新开始采集数据", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            };
        }

        /// <summary>
        /// 事件指令
        /// </summary>
        private void InitRelayCommand()
        {
            WindowLoadedCommand = new RelayCommand<HomePageProWindow>(it =>
            {
                Debug.WriteLine("HomePageProViewModel => 加载");
                it.AccelerationRadioButton.Checked += delegate
                {
                    FlowStatus.IsHydrophone = false;
                    FrequencyInterval = "100 ~ 3000Hz";
                };
                it.HydrophonesRadioButton.Checked += delegate
                {
                    FlowStatus.IsHydrophone = true;
                    FrequencyInterval = "10 ~ 300Hz";
                };
            });

            PipeItemSelectedCommand = new RelayCommand<ComboBox>(delegate(ComboBox box)
            {
                PipeName = box.SelectedItem.ToString();
            });

            SaveAudioCommand = new RelayCommand(delegate
            {
                if (FlowStatus.CorrelatorData != null)
                {
                    var wavFile = new WavFile();
                    var filePath = Constant.GetAudioDir() + "\\音频_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".wav";

                    var stream = wavFile.CreateEmpty(filePath);
                    wavFile.WriteFilestream(stream, FlowStatus.CorrelatorData.LeftDeviceDataArray,
                        FlowStatus.CorrelatorData.RightDeviceDataArray);

                    //重写头文件
                    wavFile.WriteHeader(stream, 7500, 2);
                    Growl.Success("音频已保存");
                    //清空上次的缓存
                    FlowStatus.CorrelatorData = null;
                }
                else
                {
                    MessageBox.Show("还未开始采集数据，无法保存音频", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            });
            
            ResetParamCommand = new RelayCommand(ResetParam);

            SnapShotCommand = new RelayCommand(delegate
            {
                var filePath = Constant.GetPictureDir() + "\\快照_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".png";
                filePath.SnapShot();
            });

            StartCalculateCommand = new RelayCommand(delegate
            {
                if (!SerialPortManager.Get.Sp.IsOpen)
                {
                    MessageBox.Show("串口状态异常，无法操作", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (string.IsNullOrEmpty(_pipeName))
                {
                    MessageBox.Show("请选择管道材料", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (string.IsNullOrEmpty(_pipeDiameter))
                {
                    MessageBox.Show("请输入管道直径", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (string.IsNullOrEmpty(_pipeLength))
                {
                    MessageBox.Show("请输入管道长度", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (string.IsNullOrEmpty(_lowFrequency) || string.IsNullOrEmpty(_highFrequency))
                {
                    MessageBox.Show("请输入完整的干扰频段", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (!(Regex.IsMatch(_lowFrequency, "^([1-9][0-9]*)$") &&
                      Regex.IsMatch(_highFrequency, "^([1-9][0-9]*)$")))
                {
                    MessageBox.Show("输入格式错误，请重新输入", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

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

                if (FlowStatus.IsHydrophone)
                {
                    if (low < 10 || low > 300 || high < 10 || high > 300 || low >= high)
                    {
                        MessageBox.Show("频段范围10 ~ 300Hz，请重新输入", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                }
                else
                {
                    if (low < 100 || low > 3000 || high < 100 || high > 3000 || low >= high)
                    {
                        MessageBox.Show("频段范围100 ~ 3000Hz，请重新输入", "温馨提示", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                }

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

                Debug.WriteLine("_pipeName => " + _pipeName);
                Debug.WriteLine("_pipeDiameter => " + _pipeDiameter);
                Debug.WriteLine("_pipeLength => " + _pipeLength);
                Debug.WriteLine("_lowFrequency => " + _lowFrequency);
                Debug.WriteLine("_highFrequency => " + _highFrequency);
            });
        }

        /// <summary>
        /// 设置默认值
        /// </summary>
        private void InitDefaultValue()
        {
        }

        /// <summary>
        /// 重置参数
        /// </summary>
        private void ResetParam()
        {
            InterferenceFrequency = "无";
            Snr = "无";
            FilterValue = "无";
            PipeLine = "无";
            SoundSpeed = "0";
            RedTransmitterDistance = 0;
            ElapseTime = "0";
            BlueTransmitterDistance = 0;

            _runningSeconds = 0;
            _runningTimer.Stop();

            Messenger.Default.Send("", MessengerToken.ClearOscillogram);

            // StartState = false;
            // FlowStatus.CanCollectData = false;
            // if (FlowStatus.IsHydrophone)
            // {
            //     _hydrophoneCommandTimer.Stop();
            // }
            // else
            // {
            //     _accelerometerCommandTimer.Stop();
            // }
        }
    }
}