using Aurora;
using Aurora.Api;
using Aurora.Api.Devices;
using Aurora.Api.Manager;
using Aurora.View;
using AuroraDeviceCommon.Views;
using AuroraMassFlowMeter;
using AuroraUIComponent.Chart;
using Hermes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Threading;

namespace AuroraMassFlowMeter.MFC
{
    public class UCMassFlowMeterDeviceViewModel : NotifyPropertyChangedBase
    {
        public ICommand CMD_WRITE_SET_POINT { get; }
        public ICommand CMD_READ_SET_POINT { get; }
        public ICommand CMD_READ_FLOW { get; }
        public ICommand CMD_READ_READING_ERROR { get; }
        public ICommand CMD_WRITE_READING_ERROR { get; }
        public ICommand CMD_READ_MFC_STATUS { get; }
        public ICommand CMD_WRITE_DEVICE_ID { get; }
        public ICommand CMD_READ_DEVICE_ID { get; }
        public ICommand CMD_READ_OPERATION_MODE { get; }
        public ICommand CMD_WRITE_OPERATION_MODE { get; }
        public ICommand CMD_READ_MODEL_NAME { get; }
        public ICommand CMD_READ_FIRMWARE_REVISION { get; }
        public ICommand CMD_READ_HARDWARE_REVISION { get; }
        public ICommand CMD_READ_SERIAL { get; }
        public ICommand CMD_READ_BAUD_RATE { get; }
        public ICommand CMD_WRITE_BAUD_RATE { get; }
        public ICommand CMD_READ_GAS_NAME { get; }
        public ICommand CMD_READ_FULL_SCALE { get; }
        public ICommand CMD_READ_FLOW_UNIT { get; }
        public ICommand CMD_READ_INTEGRATION { get; }
        public ICommand CMD_RESET_INTEGRATION { get; }
        public ICommand CMD_READ_INTEGRATION_ON { get; }
        public ICommand CMD_WRITE_INTEGRATION_ON { get; }
        public ICommand CMD_WRITE_RAMP_SET_POINT { get; }
        public ICommand CMD_ZERO_OFFSET { get; }


        public ICommand CMD_VisibleChanged { get; }


        private readonly DispatcherTimer MonitorTimer;

        private double _WriteSetPoint;
        public double WriteSetPoint { get => _WriteSetPoint; set => SetProperty(ref _WriteSetPoint, value); }

        private double _ReadSetPoint;
        public double ReadSetPoint { get => _ReadSetPoint; set => SetProperty(ref _ReadSetPoint, value); }

        private double _ReadFlow;
        public double ReadFlow { get => _ReadFlow; set => SetProperty(ref _ReadFlow, value); }

        private double _ReadReadingError;
        public double ReadReadingError { get => _ReadReadingError; set => SetProperty(ref _ReadReadingError, value); }

        private double _WriteReadingError;
        public double WriteReadingError { get => _WriteReadingError; set => SetProperty(ref _WriteReadingError, value); }

        private int _ReadMFCStatus;
        public int ReadMFCStatus { get => _ReadMFCStatus; set => SetProperty(ref _ReadMFCStatus, value); }

        private int _WriteDeviceID;
        public int WriteDeviceID { get => _WriteDeviceID; set => SetProperty(ref _WriteDeviceID, value); }

        private int _ReadDeviceID;
        public int ReadDeviceID { get => _ReadDeviceID; set => SetProperty(ref _ReadDeviceID, value); }

        private int _ReadOperationMode;
        public int ReadOperationMode { get => _ReadOperationMode; set => SetProperty(ref _ReadOperationMode, value); }

        private int _WriteOperationMode;
        public int WriteOperationMode { get => _WriteOperationMode; set => SetProperty(ref _WriteOperationMode, value); }

        private string _ReadModelName;
        public string ReadModelName { get => _ReadModelName; set => SetProperty(ref _ReadModelName, value); }

        private string _ReadFirmwareRevision;
        public string ReadFirmwareRevision { get => _ReadFirmwareRevision; set => SetProperty(ref _ReadFirmwareRevision, value); }

        private string _ReadHardwareRevision;
        public string ReadHardwareRevision { get => _ReadHardwareRevision; set => SetProperty(ref _ReadHardwareRevision, value); }

        private string _ReadSerial;
        public string ReadSerial { get => _ReadSerial; set => SetProperty(ref _ReadSerial, value); }

        private eBaudRate _SelectedBaudRate = eBaudRate.bps_38400;
        public eBaudRate SelectedBaudRate { get => _SelectedBaudRate; set => SetProperty(ref _SelectedBaudRate, value); }

        private int _WriteBaudRate;
        public int WriteBaudRate { get => _WriteBaudRate; set => SetProperty(ref _WriteBaudRate, value); }

        private string _ReadGasName;
        public string ReadGasName { get => _ReadGasName; set => SetProperty(ref _ReadGasName, value); }
    
        private double _ReadFullScale;
        public double ReadFullScale { get => _ReadFullScale; set => SetProperty(ref _ReadFullScale, value); }

        private eFlowUnit _SelectedFlowUnit = eFlowUnit.CCM;
        public eFlowUnit SelectedFlowUnit { get => _SelectedFlowUnit; set => SetProperty(ref _SelectedFlowUnit, value); }

        private double _ReadIntegration;
        public double ReadIntegration { get => _ReadIntegration; set => SetProperty(ref _ReadIntegration, value); }

        private double _ResetIntegration;
        public double ResetIntegration { get => _ResetIntegration; set => SetProperty(ref _ResetIntegration, value); }

        private int _ReadIntegrationOn;
        public int ReadIntegrationOn { get => _ReadIntegrationOn; set => SetProperty(ref _ReadIntegrationOn, value); }

        private int _WriteIntegrationOn;
        public int WriteIntegrationOn { get => _WriteIntegrationOn; set => SetProperty(ref _WriteIntegrationOn, value); }

        private double _RampTime;
        public double RampTime { get => _RampTime; set => SetProperty(ref _RampTime, value); }

        private double _RampSetPoint;
        public double RampSetPoint { get => _RampSetPoint; set => SetProperty(ref _RampSetPoint, value); }

        private readonly MassFlowMeter _Device = null;


        public UCMassFlowMeterDeviceViewModel(Device dev)
        {
            _Device = dev as MassFlowMeter;

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);

            CMD_WRITE_SET_POINT = new DelegateCommand(CmdWriteSetPoint);
            CMD_READ_SET_POINT = new DelegateCommand(CmdReadSetPoint);
            CMD_READ_FLOW = new DelegateCommand(CmdReadFlow);
            CMD_READ_READING_ERROR = new DelegateCommand(CmdReadReadingError);
            CMD_WRITE_READING_ERROR = new DelegateCommand(CmdWriteReadingError);
            CMD_READ_MFC_STATUS = new DelegateCommand(CmdReadMFCStatus);
            CMD_WRITE_DEVICE_ID = new DelegateCommand(CmdWriteDeviceID);
            CMD_READ_DEVICE_ID = new DelegateCommand(CmdReadDeviceID);
            CMD_READ_OPERATION_MODE = new DelegateCommand(CmdReadOperationMode);
            CMD_WRITE_OPERATION_MODE = new DelegateCommand(CmdWriteOperationMode);
            CMD_READ_MODEL_NAME = new DelegateCommand(CmdReadModelName);
            CMD_READ_FIRMWARE_REVISION = new DelegateCommand(CmdReadFirmwareRevision);
            CMD_READ_HARDWARE_REVISION = new DelegateCommand(CmdReadHardwareRevision);
            CMD_READ_SERIAL = new DelegateCommand(CmdReadSerial);
            CMD_READ_BAUD_RATE = new DelegateCommand(CmdReadBaudRate);
            CMD_WRITE_BAUD_RATE = new DelegateCommand(CmdWriteBaudRate);
            CMD_READ_GAS_NAME = new DelegateCommand(CmdReadGasName);
            CMD_READ_FULL_SCALE = new DelegateCommand(CmdReadFullScale);
            CMD_READ_FLOW_UNIT = new DelegateCommand(CmdReadFlowUnit);
            CMD_READ_INTEGRATION = new DelegateCommand(CmdReadIntegration);
            CMD_RESET_INTEGRATION = new DelegateCommand(CmdResetIntegration);
            CMD_READ_INTEGRATION_ON = new DelegateCommand(CmdReadIntegrationOn);
            CMD_WRITE_INTEGRATION_ON = new DelegateCommand(CmdWriteIntegrationOn);
            CMD_WRITE_RAMP_SET_POINT = new DelegateCommand(CmdWriteRampSetPoint);
            CMD_ZERO_OFFSET = new DelegateCommand(CmdZeroOffset);

            MonitorTimer = new DispatcherTimer();
            MonitorTimer.Tick += OnMonitoring;
            MonitorTimer.Interval = TimeSpan.FromMilliseconds(1000);

            // 파워미터가 두개라 디바이스 인덱스 같은걸로 받는 이벤트 등록 나눠야할듯. 아직 어떤 디바이스가 붙을지 몰라 보류.
            //aurora.EventObservable.AsObservable(MassFlowMeterEvent.EVENT_ID_MEASURE_RESULT)
            //    .Select(msg => (ValueTuple<string, double>)msg.Param)
            //    .Where(msg => msg.Item1 == powerMeter.DeviceId)
            //    .Subscribe(power => OnPowerMeasured(power.Item2));
        }

        private void CmdZeroOffset(object obj)
        {
            if (_Device.ZeroOffset() == E1.OK) {
            }
        }

        private void CmdWriteRampSetPoint(object obj)
        {
            if (_Device.WriteRampSetPoint(RampTime, RampSetPoint) == E1.OK) {
            }
        }

        private void CmdWriteIntegrationOn(object obj)
        {
            if (_Device.WriteIntegrationOn((eIntegrationOn)WriteIntegrationOn) == E1.OK) {
            }
        }

        //특주품 전용 커멘드
        private void CmdReadIntegrationOn(object obj)
        {
            eIntegrationOn integrationOn;
            if (_Device.ReadIntegrationOn(out integrationOn) == E1.OK) {
                ReadIntegrationOn = (int)integrationOn;
            }
        }
        //특주품 전용 커멘드
        private void CmdResetIntegration(object obj)
        {
            double tempdouble;
            if (_Device.ResetIntegration(out tempdouble) == E1.OK) {
                ResetIntegration = tempdouble;
            }
        }

        private void CmdReadIntegration(object obj)
        {
            double tempdouble;
            if (_Device.ReadIntegration(out tempdouble) == E1.OK) {
                ReadIntegration = tempdouble;
            }
        }

        private void CmdReadFlowUnit(object obj)
        {
            eFlowUnit Flowunit;
            if (_Device.ReadFlowUnit(out Flowunit) == E1.OK) {
                SelectedFlowUnit = Flowunit;
            }
        }

        private void CmdReadFullScale(object obj)
        {
            double tempdouble;
            if (_Device.ReadFullScale(out tempdouble) == E1.OK) {
                ReadFullScale = tempdouble;
            }
        }

        private void CmdReadGasName(object obj)
        {
            string tempString;
            if (_Device.ReadGasName(out tempString) == E1.OK) {
                ReadGasName = tempString;
            }
        }

        private void CmdWriteBaudRate(object obj)
        {
            if (_Device.WriteBaudRate((eBaudRate)WriteBaudRate) == E1.OK) {
            }
        }

        private void CmdReadBaudRate(object obj)
        {
            eBaudRate tempBaudRate;
            if (_Device.ReadBaudRate(out tempBaudRate) == E1.OK) {
                SelectedBaudRate = tempBaudRate;
            }
        }

        private void CmdReadSerial(object obj)
        {
            string tempString;
            if (_Device.ReadSerial(out tempString) == E1.OK) {
                ReadSerial = tempString;
            }
        }

        private void CmdReadHardwareRevision(object obj)
        {
            string tempString;
            if (_Device.ReadHardwareRevision(out tempString) == E1.OK) {
                ReadHardwareRevision = tempString;
            }
        }

        private void CmdReadFirmwareRevision(object obj)
        {
            string tempString;
            if (_Device.ReadFirmwareRevision(out tempString) == E1.OK) {
                ReadFirmwareRevision = tempString;
            }
        }

        private void CmdReadModelName(object obj)
        {
            string tempString;
            if (_Device.ReadModelName(out tempString) == E1.OK) {
                ReadModelName = tempString;
            }
        }

        private void CmdWriteOperationMode(object obj)
        {
            if (_Device.WriteOperationMode((eOperationMode)WriteOperationMode) == E1.OK) {
            }
        }

        private void CmdReadOperationMode(object obj)
        {
            eOperationMode tempOperationMode;
            if (_Device.ReadOperationMode(out tempOperationMode) == E1.OK) {
                ReadOperationMode = (int)tempOperationMode;
            }
        }

        private void CmdReadDeviceID(object obj)
        {
            int tempInt;
            if (_Device.ReadDeviceId(out tempInt) == E1.OK) {
                ReadDeviceID = tempInt;
            }
        }

        private void CmdWriteDeviceID(object obj)
        {
            if (_Device.WriteDeviceId(WriteDeviceID) == E1.OK) {
            }
        }

        private void CmdReadMFCStatus(object obj)
        {
            byte tempbyte;
            if (_Device.ReadMFCStatus(out tempbyte) == E1.OK) {

                // 상태표시를 위한 UI반영 필요
            }
        }

        private void CmdWriteReadingError(object obj)
        {
            if (_Device.WriteReadingError(WriteReadingError) == E1.OK) {
            }
        }

        private void CmdReadReadingError(object obj)
        {
            double tempdouble = double.NaN;
            if (_Device.ReadReadingError(out tempdouble) == E1.OK) {
                ReadReadingError = tempdouble;
            }
            ReadReadingError = tempdouble;
        }

        private void CmdReadFlow(object obj)
        {
            double tempdouble;
            if (_Device.ReadFlow(out tempdouble) == E1.OK) {
                ReadFlow = tempdouble;
            }
        }

        private void CmdReadSetPoint(object obj)
        {
            double tempdouble;
            if (_Device.ReadSetPoint(out tempdouble) == E1.OK) {
                ReadSetPoint = tempdouble;
            }
        }

        private void CmdWriteSetPoint(object obj)
        {
            if (_Device.WriteSetPoint( WriteSetPoint) == E1.OK) {
            }
        }

        protected void VisibleChanged(object obj)
        {
            bool visible = (bool)obj;
            if (visible)
            {
                MonitorTimer.Start();
            }
            else
            {
                MonitorTimer.Stop();
            }
        }

        private void OnMonitoring(object sender, EventArgs e)
        {
            if (_Device.IsActivated)
            {
                var N2Meter = _Device as MassFlowMeter;

                //CurrentPowerName = _Device.DeviceId;
                //var deviceConfig = Application.Current.AuroraEnv().DeviceManager.GetDeviceConfig(_Device.DeviceId) as MassFlowMeterConfig;
                //CurrentPortNumber = string.Format("{0}", (deviceConfig.ConnConfig as SerialConnConfig).PortNum);

                //if (ContinuesMeasure)
                //    CurrentState = "측정중";
                //else
                //    CurrentState = "대기중";
                //if (ContinuesMeasure)
                //    //GetMeasurePower(null);
                return;
            }
            //else
                //CurrentState = "연결안됨";
        }

        private void GetMeasurePower(object obj)
        {
            if (!_Device.IsActivated)
            {
                //ContinuesMeasure = false;
                return;
            }

            var powerMeter = _Device as MassFlowMeter;
            double power = 0.0;
            if (powerMeter.ReadSetPoint(out power) == E1.OK)
            {
                //CurrentPower = power;
                //PowerMeterChart.AddPoint(power);
            }
        }
    }
}