using Aurora;
using Aurora.Api;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;

namespace AuroraLaser.Amplitude
{
    public class WinLaserSettingViewModel : NotifyPropertyChangedBase
    {
        static readonly Logger LOG = new Logger("WinLaserSettingViewModel");

        bool IsActivated = false;

        IAuroraEnvironment m_AuroraEnv;
        private readonly LaserSatsumaDisplay m_LaserDevice = null;

        public LaserSatsumaDisplay LaserDevice {
            get { return m_LaserDevice; }
        }

        // Pulse Picker Frequence
        private short m_WritePulsePickerFrequency = 0;
        public short WritePulsePickerFrequency { get => m_WritePulsePickerFrequency; set => SetProperty(ref m_WritePulsePickerFrequency, value); }

        public ICommand CMD_SetPulsePickerFrequency { get; }



        // Transmission Percent
        private ushort m_WriteTransmissionPercent = 0;
        public ushort WritTransmissionPercent { get => m_WriteTransmissionPercent; set => SetProperty(ref m_WriteTransmissionPercent, value); }
        public ICommand CMD_SetTransmissionPercent { get; }



        // Pulse Picker Frequence Min
        private ushort m_WritePulsePickerFrequencyMin = 0;
        public ushort WritePulsePickerFrequencyMin { get => m_WritePulsePickerFrequencyMin; set => SetProperty(ref m_WritePulsePickerFrequencyMin, value); }

        public ICommand CMD_SetPulsePickerFrequencyMin { get; }


        // Width
        private short m_WriteWidth = 0;
        public short WriteWidth { get => m_WriteWidth; set => SetProperty(ref m_WriteWidth, value); }

        public ICommand CMD_SetWidth { get; }

        // Delay
        private short m_WriteDelay = 0;
        public short WriteDelay { get => m_WriteDelay; set => SetProperty(ref m_WriteDelay, value); }

        public ICommand CMD_SetDelay { get; }


        // Modulator Frequence
        private short m_WriteFrequency = 0;
        public short WriteFrequency { get => m_WriteFrequency; set => SetProperty(ref m_WriteFrequency, value); }

        public ICommand CMD_SetFrequency { get; }

        // Frequency Min
        private ushort m_WriteFrequencyMin = 0;
        public ushort WriteFrequencyMin { get => m_WriteFrequencyMin; set => SetProperty(ref m_WriteFrequencyMin, value); }

        public ICommand CMD_SetFrequencyMin { get; }



        // BurstMode
        private short m_WriteBurstMode = 0;
        public short WriteBurstMode { get => m_WriteBurstMode; set => SetProperty(ref m_WriteBurstMode, value); }

        public ICommand CMD_SetBurstMode { get; }



        // Pulse Picker Trigger
        public List<eLaserTrigger> PulsePickerTriggerList { get; set; }

        private eLaserTrigger m_eSelectedPulsePickerTrigger = eLaserTrigger.EXTERNAL;
        public eLaserTrigger SelectedPulsePickerTrigger {
            get => m_eSelectedPulsePickerTrigger;
            set {
                m_eSelectedPulsePickerTrigger = value;
                m_LaserDevice.SetPulsePickerTrigger(value);

                //SetProperty(ref m_eSelectedPulsePickerTrigger, value);
                // OnPropertyChanged("PulsePickerTrigger");
            }
        }

        // Pulse Picker Alignment
        public List<eLaserAlignment> PulsePickerAlignmentList { get; set; }

        private eLaserAlignment m_eSelectedPulsePickerAlignment = eLaserAlignment.NO;
        public eLaserAlignment SelectedPulsePickerAlignment {
            get => m_eSelectedPulsePickerAlignment;
            set {
                m_eSelectedPulsePickerAlignment = value;
                m_LaserDevice.SetPulsePickerAlignment(value);
                //SetProperty(ref m_eSelectedPulsePickerAlignment, value);
            }
        }


        // Trigger
        public List<eLaserTrigger> TriggerList { get; set; }

        private eLaserTrigger m_eSelectedTrigger = eLaserTrigger.EXTERNAL;
        public eLaserTrigger SelectedTrigger {
            get => m_eSelectedTrigger;
            set {
                if (m_eSelectedTrigger != value) {
                    // Laser에 Set하는 메소드...
                    m_eSelectedTrigger = value;
                    m_LaserDevice.SetTrigger(value);
                }
            }
        }


        // Gate
        public List<eLaserGate> GateList { get; set; }

        private eLaserGate m_eSelectedGate = eLaserGate.EXTERNAL;
        public eLaserGate SelectedGate {
            get => m_eSelectedGate;
            set {
                m_eSelectedGate = value;
                m_LaserDevice.SetGate(value);
                //SetProperty(ref m_eSelectedGate, value);
            }
        }


        // Alignment
        public List<eLaserAlignment> AlignmentList { get; set; }

        private eLaserAlignment m_eSelectedAlignment = eLaserAlignment.NO;
        public eLaserAlignment SelectedAlignment {
            get => m_eSelectedAlignment;
            set {
                m_eSelectedAlignment = value;
                m_LaserDevice.SetAlignment(value);
                //SetProperty(ref m_eSelectedAlignment, value);
            }
        }

        // Transmission
        public List<eLaserTransmission> TransmissionList { get; set; }

        private eLaserTransmission m_eSelectedTransmission = eLaserTransmission.Software;
        public eLaserTransmission SelectedTransmission {
            get => m_eSelectedTransmission;
            set {
                m_eSelectedTransmission = value;
                //m_LaserDevice.
                //SetProperty(ref m_eSelectedTransmission, value);
            }
        }

        // Laser Power Transmission
        public List<eLaserPowerTransmission> PowerTransmissionList { get; set; }

        private eLaserPowerTransmission m_eSelectedPowerTransmission = eLaserPowerTransmission.LASER_POWER;
        public eLaserPowerTransmission SelectedPowerTransmission {
            get => m_eSelectedPowerTransmission;
            set {
                m_eSelectedPowerTransmission = value;
                //=> SetProperty(ref m_eSelectedPowerTransmission, value);
            }
        }

        public WinLaserSettingViewModel(IAuroraEnvironment aurora, string deviceId)
        {
            m_AuroraEnv = aurora;
            m_LaserDevice = aurora.DeviceManager[deviceId] as LaserSatsumaDisplay;

            CMD_SetPulsePickerFrequency = new DelegateCommand(SetPulsePickerFrequency);
            CMD_SetPulsePickerFrequencyMin = new DelegateCommand(SetPulsePickerFrequencyMin);
            CMD_SetTransmissionPercent = new DelegateCommand(SetTransmissionPercent);
            CMD_SetWidth = new DelegateCommand(SetWidth);
            CMD_SetDelay = new DelegateCommand(SetDelay);


            CMD_SetFrequency = new DelegateCommand(SetFrequency);

            CMD_SetBurstMode = new DelegateCommand(SetBurstMode);

            Init_PulsePickerTriggerList();
            Init_PulsePickerAlignmentList();

            Init_TriggerList();
            Init_GateList();
            Init_AlignmentList();
            Init_TransmissionList();
            Init_PowerTransmissionList();

            Observable.Merge(
                aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_ACTIVATED),
                aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_DEACTIVATED)
            ).Select(msg => msg.Param as string
            ).Where(x => x == m_LaserDevice?.DeviceId
            ).ObserveOnDispatcher(
            ).Subscribe(
                x => OnDeviceActiveChanged()
            );

            OnDeviceActiveChanged();
        }

        private void OnDeviceActiveChanged()
        {
            IsActivated = m_LaserDevice.IsActivated;
            if (m_LaserDevice.IsActivated) {
                m_WritePulsePickerFrequency = (short)m_LaserDevice.GetPulsePickerFrequency();
                OnPropertyChanged("WritePulsePickerFrequency");

                if (m_LaserDevice.GetPulsePickerTrigger() == false) {
                    m_eSelectedPulsePickerTrigger = eLaserTrigger.EXTERNAL;
                } else {
                    m_eSelectedPulsePickerTrigger = eLaserTrigger.INTERNAL;
                }
                OnPropertyChanged("SelectedPulsePickerTrigger");

                if (m_LaserDevice.GetPulsePickerAlignment() == false) {
                    m_eSelectedPulsePickerAlignment = eLaserAlignment.NO;
                } else {
                    m_eSelectedPulsePickerAlignment = eLaserAlignment.YES;
                }
                OnPropertyChanged("SelectedPulsePickerAlignment");

                m_WriteBurstMode = (short)m_LaserDevice.GetBurstMode();
                OnPropertyChanged("WriteBurstMode");

                m_WriteWidth = (short)m_LaserDevice.GetWidth();
                OnPropertyChanged("WriteWidth");


                m_WriteDelay = (short)m_LaserDevice.GetDelay();
                OnPropertyChanged("WriteDelay");

                m_WriteFrequency = (short)m_LaserDevice.GetFrequency();
                OnPropertyChanged("WriteFrequency");

                if (m_LaserDevice.GetTrigger() == false) {
                    m_eSelectedTrigger = eLaserTrigger.EXTERNAL;
                } else {
                    m_eSelectedTrigger = eLaserTrigger.INTERNAL;
                }
                OnPropertyChanged("SelectedTrigger");

                if (m_LaserDevice.GetGate() == false) {
                    m_eSelectedGate = eLaserGate.INTERNAL;
                } else {
                    m_eSelectedGate = eLaserGate.EXTERNAL;
                }
                OnPropertyChanged("SelectedGate");

                if (m_LaserDevice.GetAlignment() == true) {
                    m_eSelectedAlignment = eLaserAlignment.YES;
                } else {
                    m_eSelectedAlignment = eLaserAlignment.NO;
                }
                OnPropertyChanged("SelectedAlignment");

                m_WriteTransmissionPercent = (ushort)(m_LaserDevice.GetTransmissionPercent() / 100);
                OnPropertyChanged("WriteTransmissionPercent");


            } else {

            }
        }


        protected void OnPropertyChanged(string propertyName)
        {
            if (propertyName == "Trigger") {
                ;
            }
        }

        private void SetWidth(object obj)
        {
            m_LaserDevice.SetWidth(WriteWidth);
        }

        private void SetDelay(object obj)
        {
            m_LaserDevice.SetDelay(WriteDelay);
        }


        private void SetFrequency(object obj)
        {
            m_LaserDevice.SetFrequency(WriteFrequency);
        }
        private void SetPulsePickerFrequency(object obj)
        {
            m_LaserDevice.SetPulsePickerFrequency(WritePulsePickerFrequency);
        }

        private void SetTransmissionPercent(object obj)
        {
            m_LaserDevice.SetTransmissionPercent((ushort)(WritTransmissionPercent * 100));
        }

        private void SetPulsePickerFrequencyMin(object obj)
        {
            m_LaserDevice.SetPulsePickerFrequencyMin((ushort)WriteFrequency);
        }

        private void SetFrequencyMin(object obj)
        {
            m_LaserDevice.SetPulsePickerFrequency(WriteFrequency);
        }

        private void SetBurstMode(object obj)
        {
            m_LaserDevice.SetBurstMode(WriteBurstMode);
        }

        private void Init_PulsePickerTriggerList()
        {
            PulsePickerTriggerList = Enum.GetValues(typeof(eLaserTrigger)).Cast<eLaserTrigger>().ToList();
        }

        private void Init_PulsePickerAlignmentList()
        {
            PulsePickerAlignmentList = Enum.GetValues(typeof(eLaserAlignment)).Cast<eLaserAlignment>().ToList();
        }

        private void Init_TriggerList()
        {
            TriggerList = Enum.GetValues(typeof(eLaserTrigger)).Cast<eLaserTrigger>().ToList();
        }

        private void Init_GateList()
        {
            GateList = Enum.GetValues(typeof(eLaserGate)).Cast<eLaserGate>().ToList();
        }

        private void Init_AlignmentList()
        {
            AlignmentList = Enum.GetValues(typeof(eLaserAlignment)).Cast<eLaserAlignment>().ToList();
        }

        private void Init_TransmissionList()
        {
            TransmissionList = Enum.GetValues(typeof(eLaserTransmission)).Cast<eLaserTransmission>().ToList();
        }

        private void Init_PowerTransmissionList()
        {
            PowerTransmissionList = Enum.GetValues(typeof(eLaserPowerTransmission)).Cast<eLaserPowerTransmission>().ToList();
        }

        //public int SetTrigger(eLaserTrigger eTrigger)
        //{
        //    m_LaserDevice.SetTrigger(eTrigger);
        //    return 1;
        //}

    }
}