using Aurora;
using Aurora.Api;
using Aurora.Api.Manager;
using Aurora.View;
using System;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Reactive.Linq;
using System.Windows;
using System.Windows.Data;
using System.Windows.Input;
using static AuroraLaser.Ekspla.LaserDeviceNL202;
using DelegateCommand = Aurora.View.DelegateCommand;
using HislogSourceLogger = Aurora.View.HislogSourceLogger;
using HislogViewModel = Aurora.View.HislogViewModel;
using Logger = Aurora.Api.Logger;

namespace AuroraLaser.Ekspla
{

    public class LaserStateConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is int intValue) {
                //Idle, Running, Error, NotInitialized
                switch (intValue) {
                    case 0:
                        return "Idle";
                    case 1:
                        return "Running";
                    case 2: // FALL_THROUGH
                    default:
                        return "Not Initialized";
                }
            }
            return "Unknown";
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is string strValue) {
                //Idle, Running, Error, NotInitialized
                switch (strValue) {
                    case "Idle":
                        return 0;
                    case "Running":
                        return 1;
                    case "NotInitialized": // FALL_THROUGH
                        return 2;
                    default:
                        break;
                }
            }
            return -1;
        }
    }

    public class UCLaserMaintViewModel : NotifyPropertyChangedBase
    {
        // UCLaserMaint : IDD_DIALOG_REPAIR_SYSTEM_LASERSLIT_SETUP_64BIT

        protected readonly Logger LOG = new Logger("UCLaserMaintViewModel");
        Logger LaserLog = new Logger("Laser", "LaserMaint");

        public string SerialNumber { get; set; }

        //private NL202Status _setlaserStatus;
        public NL202Status SetLaserStatus { set; get; }
        //private NL202Status _getlaserStatus;
        //public NL202Status GetLaserStatus { get => _getlaserStatus; set => SetProperty(ref _getlaserStatus, value); }

        private int _getLaserStatusState;
        public int GetLaserStatusState { get => _getLaserStatusState; set { SetProperty(ref _getLaserStatusState, value); NotifyPropertyChanged("IsServoOn"); } }
        public bool IsServoOn { get => (_getLaserStatusState == 1); }
        private int _getLaserStatusEnergyLevel;
        public int GetLaserStatusEnergyLevel { get => _getLaserStatusEnergyLevel; set => SetProperty(ref _getLaserStatusEnergyLevel, value); }
        private double _getLaserStatusPumpLevel;
        public double GetLaserStatusPumpLevel { get => _getLaserStatusPumpLevel; set => SetProperty(ref _getLaserStatusPumpLevel, value); }
        private int _getLaserStatusQSWAdjustDelay;
        public int GetLaserStatusQSWAdjustDelay { get => _getLaserStatusQSWAdjustDelay; set => SetProperty(ref _getLaserStatusQSWAdjustDelay, value); }
        private int _getLaserStatusSyncMode;
        public int GetLaserStatusSyncMode { get => _getLaserStatusSyncMode; set => SetProperty(ref _getLaserStatusSyncMode, value); }
        private int _getLaserStatusBurstMode;
        public int GetLaserStatusBurstMode { get => _getLaserStatusBurstMode; set => SetProperty(ref _getLaserStatusBurstMode, value); }
        private int _getLaserStatusBurstCount;
        public int GetLaserStatusBurstCount { get => _getLaserStatusBurstCount; set => SetProperty(ref _getLaserStatusBurstCount, value); }
        private int _getLaserStatusRepetitionRate;
        public int GetLaserStatusRepetitionRate { get => _getLaserStatusRepetitionRate; set => SetProperty(ref _getLaserStatusRepetitionRate, value); }
        private double _getLaserStatusTemperature_TTec1;
        public double GetLaserStatusTemperature_TTec1 { get => _getLaserStatusTemperature_TTec1; set => SetProperty(ref _getLaserStatusTemperature_TTec1, value); }
        private double _getLaserStatusTemperature_SH1;
        public double GetLaserStatusTemperature_SH1 { get => _getLaserStatusTemperature_SH1; set => SetProperty(ref _getLaserStatusTemperature_SH1, value); }
        private int _getLaserStatusWaveLength;
        public int GetLaserStatusWaveLength { get => _getLaserStatusWaveLength; set => SetProperty(ref _getLaserStatusWaveLength, value); }
        private double _getLaserStatusAttenTrans;
        public double GetLaserStatusAttenTrans { get => _getLaserStatusAttenTrans; set => SetProperty(ref _getLaserStatusAttenTrans, value); }
        private int _getLaserStatusFaultCode;
        public int GetLaserStatusFaultCode { get => _getLaserStatusFaultCode; set => SetProperty(ref _getLaserStatusFaultCode, value); }
        private string _getLaserStatusFaultMsg;
        public string GetLaserStatusFaultMsg { get => _getLaserStatusFaultMsg; set => SetProperty(ref _getLaserStatusFaultMsg, value); }
        private int _getLaserStatusShotCount;
        public int GetLaserStatusShotCount { get => _getLaserStatusShotCount; set => SetProperty(ref _getLaserStatusShotCount, value); }
        public Aurora.View.HislogViewModel LaserLogViewModel { get; }

        public ICommand CMD_VisibleChanged { get; }
        public ICommand CMD_SaveConfigs { get; }
        public ICommand CMD_StartLaser { get; }
        public ICommand CMD_StopLaser { get; }
        public ICommand CMD_Communication { get; }
        public ICommand CMD_Control { get; }
        public ICommand CMD_Error { get; }
        public ICommand CMD_Log { get; }
        public ICommand CMD_ClearLog { get; }

        public double TempValue { get; set; } = 0;

        public LaserConfig Config { get; set; }
        protected readonly IDeviceManager _deviceManager;
        protected readonly string _deviceId;
        protected readonly NL202Laser _laser;
        public bool IsActivated { get => _laser.IsActivated; }

        public UCLaserMaintViewModel(IDeviceManager devMngr, string deviceId)
        {
            _deviceManager = devMngr;
            _deviceId = deviceId;

            Config = _deviceManager.GetDeviceConfig(deviceId) as LaserConfig;
            _laser = _deviceManager.GetDevice(_deviceId) as NL202Laser;

            laserSetupLog = new ObservableCollection<LogItem>();
            laserSetupLog.Add(new LogItem("Initialized"));

            //GetLaserStatus = new NL202Status();
            SetLaserStatus = new NL202Status();

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);
            CMD_SaveConfigs = new DelegateCommand(SaveConfigs);
            CMD_StartLaser = new DelegateCommand(StartLaser);
            CMD_StopLaser = new DelegateCommand(StopLaser);
            CMD_Communication = new DelegateCommand(DoCommunicationCommand);
            CMD_Control = new DelegateCommand(DoControlCommand);
            CMD_Error = new DelegateCommand(DoErrorCommand);
            CMD_Log = new DelegateCommand(DoLogCommand);
            CMD_ClearLog = new DelegateCommand(ClearLog);

            var logSourceA = new HislogSourceLogger("LaserMaint", 500);

            LaserLogViewModel = new HislogViewModel(logSourceA, 11);
            LaserLogViewModel.FilterVisibility = Visibility.Collapsed;
            LaserLogViewModel.AutoScrollVisibility = Visibility.Hidden;

            UpdateControlInfo();

            Observable.Merge(
                Application.Current.AuroraEnv().EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_ACTIVATED),
                Application.Current.AuroraEnv().EventObservable.AsObservable(AuroraSysEvent.SYS_DEVICE_DEACTIVATED)
            ).Select(msg => msg.Param as string
            ).Where(x => x == _laser.DeviceId
            ).ObserveOnDispatcher(
            ).Subscribe(
                x => NotifyPropertyChanged("IsActivated")
            );
        }

        private void ClearLog(object obj)
        {
            var cmd = LaserLogViewModel.GetType().GetProperty("CMD_Clear").GetValue(LaserLogViewModel) as ICommand;
            cmd.Execute(null);
        }

        protected virtual void HandleActivationChange(bool value)
        {
            if (value) {
                UpdateErrorInfo();
                UpdateControlInfo();
            }
        }

        protected void UpdateErrorInfo()
        {
            //LOG.V("UpdateErrorInfo");
            int tempErrorCode = 0;
            string tempErrorMsg = "";
            _laser.GetLastError(ref tempErrorCode, ref tempErrorMsg);
            GetLaserStatusFaultCode = tempErrorCode;
            GetLaserStatusFaultMsg = tempErrorMsg;
        }

        protected void UpdateControlInfo()
        {
            //LOG.V("UpdateControlInfo");

            GetLaserStatusState = _laser.GetState();
            GetLaserStatusEnergyLevel = _laser.GetEnergyLevel();
            GetLaserStatusPumpLevel = _laser.GetPumpLevel();
            GetLaserStatusQSWAdjustDelay = _laser.GetQSWadjDelay();
            GetLaserStatusSyncMode = _laser.GetSyncMode();
            GetLaserStatusBurstMode = _laser.GetBurstMode();
            GetLaserStatusBurstCount = _laser.GetBurstCount();
            GetLaserStatusRepetitionRate = _laser.GetRepetitionRate();
            GetLaserStatusTemperature_TTec1 = _laser.GetTemperature(0);
            GetLaserStatusTemperature_SH1 = _laser.GetTemperature(1);
            GetLaserStatusWaveLength = _laser.GetWaveLength();
            GetLaserStatusAttenTrans = _laser.GetAttTrans();
            GetLaserStatusShotCount = _laser.GetShotCnt();
        }

        private void VisibleChanged(object obj)
        {
            bool visible = (bool)obj;
            if (visible) {
                UpdateControlInfo();
                UpdateErrorInfo();
            } else {
                // TODO: Implement
            }
        }

        protected void SaveConfigs(object obj)
        {
            LOG.V("SaveConfigs");
            _deviceManager.SaveDeviceConfig(_deviceId);

            MessageUtil.ShowSaveSuccessDialog();
        }

        protected void StartLaser(object obj)
        {
            LOG.V("StartLaser");
            if (_laser != null && _laser.IsActivated) {
                _laser.RunLaser();
                GetLaserStatusState = _laser.GetState();
            }
        }

        protected void StopLaser(object obj)
        {
            LOG.V("StopLaser");
            if (_laser != null && _laser.IsActivated) {
                _laser.StopLaser();
            }
        }

        protected void AddLog(object obj)
        {
            if (obj != null) {
                LaserLog.I(obj.ToString());
                //LOG.I("LaserMaint Log : " + obj.ToString());
                //LaserSetupLog.Add(new LogItem(obj.ToString()));
                //LaserSetupLog.Insert(0, new LogItem(obj.ToString()));
            }
        }

        protected void DoErrorCommand(object obj)
        {
            if (obj is string) {
                switch (obj as string) {
                    case "Reset":
                        _laser.ResetFault();
                        break;
                    case "Set Error (Test)":
                        _laser.SetError(100, "test error");
                        UpdateErrorInfo();
                        break;
                    case "Clear Error (Test)":
                        _laser.SetError(0, "");
                        UpdateErrorInfo();
                        break;
                    default:
                        LOG.E("Unhandled : " + obj);
                        return;
                }
            }

            //UpdateControlInfo();
            UpdateErrorInfo();

            AddLog(obj);
        }

        protected void DoCommunicationCommand(object obj)
        {
            if (obj is string) {
                switch (obj as string) {
                    case "Connect":
                        _laser.Activate();
                        break;
                    case "Disconnect":
                        _laser.Deactivate();
                        break;
                    //case "Start Fire":
                    //    _laser.RunLaser();
                    //    break;
                    //case "Stop Fire":
                    //    _laser.StopLaser();
                    //    break;
                    default:
                        LOG.E("Unhandled : " + obj);
                        return;
                }
            }

            UpdateControlInfo();
            UpdateErrorInfo();

            AddLog(obj);
        }

        protected void DoLogCommand(object obj)
        {
            if (obj is string) {
                switch (obj as string) {
                    case "Clear Log":
                        LaserSetupLog.Clear();
                        break;
                    case "Add Log":
                        AddLog(obj);
                        break;
                    default:
                        LOG.E("Unhandled : " + obj);
                        return;
                }
            }
        }

        protected void DoControlCommand(object obj)
        {
            switch (obj as string) {
                case "Update All":
                    AddLog(obj);
                    //UpdateControlInfo();
                    break;
                case "Set All":
                    AddLog(obj);
                    DoControlCommand("SetLaserStatus.EnergyLevel");
                    DoControlCommand("SetLaserStatus.PumpLevel");
                    DoControlCommand("SetLaserStatus.SyncMode");
                    DoControlCommand("SetLaserStatus.BurstMode");
                    DoControlCommand("SetLaserStatus.BurstCount");
                    DoControlCommand("SetLaserStatus.RepetitionRate");
                    DoControlCommand("SetLaserStatus.WaveLength");
                    break;
                case "Start":
                    AddLog(obj);
                    _laser.RunLaser();
                    break;
                case "Stop":
                    AddLog(obj);
                    _laser.StopLaser();
                    break;
                case "SetLaserStatus.QSWAdjustDelay":
                    //_laser.SetQSWAdjustDelay(this.SetLaserStatus.QSWAdjustDelay);
                    //GetLaserStatusQSWAdjustDelay = _laser.GetQSWadjDelay();
                    break;
                case "SetLaserStatus.EnergyLevel":
                    _laser.SetEnergyLevel(SetLaserStatus.EnergyLevel);
                    //GetLaserStatusEnergyLevel = _laser.GetEnergyLevel();
                    AddLog(obj + " : " + SetLaserStatus.EnergyLevel);
                    break;
                case "SetLaserStatus.PumpLevel":
                    _laser.SetPumpLevel(SetLaserStatus.PumpLevel);
                    //GetLaserStatusPumpLevel = _laser.GetPumpLevel();
                    AddLog(obj + " : " + SetLaserStatus.PumpLevel);
                    break;
                case "SetLaserStatus.SyncMode":
                    _laser.SetSyncMode(SetLaserStatus.SyncMode);
                    //GetLaserStatusSyncMode = _laser.GetSyncMode();
                    AddLog(obj + " : " + SetLaserStatus.SyncMode);
                    break;
                case "SetLaserStatus.BurstMode":
                    _laser.SetBurstMode(SetLaserStatus.BurstMode);
                    //GetLaserStatusBurstMode = _laser.GetBurstMode();
                    AddLog(obj + " : " + SetLaserStatus.BurstMode);
                    break;
                case "SetLaserStatus.BurstCount":
                    _laser.SetBurstCount(SetLaserStatus.BurstCount);
                    //GetLaserStatusBurstCount = _laser.GetBurstCount();
                    AddLog(obj + " : " + SetLaserStatus.BurstCount);
                    break;
                case "SetLaserStatus.RepetitionRate":
                    _laser.SetRepetitionRate(SetLaserStatus.RepetitionRate);
                    //GetLaserStatusRepetitionRate = _laser.GetRepetitionRate();
                    AddLog(obj + " : " + SetLaserStatus.RepetitionRate);
                    break;
                case "SetLaserStatus.Temperature_TTec1":
                    //_laser.SetTemperature(0, SetLaserStatus.Temperature_TTec1);
                    //GetLaserStatusTemperature_TTec1 = _laser.GetTemperature(0);
                    break;
                case "SetLaserStatus.Temperature_SH1":
                    //_laser.SetTemperature(1, SetLaserStatus.Temperature_SH1);
                    //GetLaserStatusTemperature_SH1 = _laser.GetTemperature(1);
                    break;
                case "SetLaserStatus.WaveLength":
                    _laser.SetWaveLength(SetLaserStatus.WaveLength);
                    //GetLaserStatusWaveLength = _laser.GetWaveLength();
                    AddLog(obj + " : " + SetLaserStatus.WaveLength);
                    break;
                case "SetLaserState":
                    //_laser.SetLaserState(SetLaserState);
                    break;
                default:
                    LOG.E("Unhandled : " + obj);
                    return;
            }

            UpdateControlInfo();
            //UpdateErrorInfo();
        }

        public class LogItem
        {
            public DateTime Time { get; set; }
            public string Log { get; set; }

            public LogItem(string logString)
            {
                Time = DateTime.Now;
                Log = logString;
            }
        }

        private ObservableCollection<LogItem> laserSetupLog;

        public ObservableCollection<LogItem> LaserSetupLog { get => laserSetupLog; set => SetProperty(ref laserSetupLog, value); }
    }
}