using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SA_LTT.Module
{
    public delegate void EnergyMeasuredEvent(double energy);

    public class PowerMeter : ComPort
    {
        public enum MeasurementMode
        {
            QueryPresentMeasurementMode,
            Passive,
            Power,
            Energy,
            Exposure,
            PowerWithPosition,
            ReservedForFutureUse,
            LuxForPD300_CIESensors,
            DosageForPD300_RMSensors,
            HoldModeForBC20Sensors,
            ContinuousForBC20Sensors,
            ReservedForFutureUse2,
            PowerFromPulse,
        }

        private Equipment _equipment;
        private Thread t_statusUpdate;
        private bool _enable;
        private string _ErrorDescription;
        private bool _flag;
        private double _energy;
        private double _energyPerUnitArea;
        private MeasurementMode _currentMeasurementMode;
        private List<double> _measurementsEnergy;
        private List<double> _measurementsEnergyPerUnitArea;

        private DateTime _measurementChangedTime = DateTime.Now;
        private double _measurementChangedWaitTime = 3;
        public event EnergyMeasuredEvent EnergyMeasured;


        public string ErrorDescription
        {
            get
            {
                return _ErrorDescription;
            }

            private set
            {
                _ErrorDescription = value;
            }
        }

        public bool Flag
        {
            get
            {
                return _flag;
            }

            private set
            {
                _flag = value;
            }
        }
        
        public MeasurementMode CurrentMeasurementMode
        {
            get
            {
                return _currentMeasurementMode;
            }

            private set
            {
                _currentMeasurementMode = value;
            }
        }

        public double Energy
        {
            get
            {
                return _energy;
            }

            private set
            {
                _energy = value;
            }
        }

        public double MeasurementAverageEnergy
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergy.Count > 0)
                {
                    energy = MeasurementsEnergy.Average();
                    energy = double.Parse($"{energy:F7}");
                }

                return energy;
            }
        }

        public double MeasurementMaxEnergy
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergy.Count > 0)
                {
                    energy = MeasurementsEnergy.Max();
                    energy = double.Parse($"{energy:F7}");
                }

                return energy;
            }
        }

        public double MeasurementMinEnergy
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergy.Count > 0)
                {
                    energy = MeasurementsEnergy.Min();
                    energy = double.Parse($"{energy:F7}");
                }

                return energy;
            }
        }

        public List<double> MeasurementsEnergy
        {
            get
            {
                return _measurementsEnergy;
            }

            private set
            {
                _measurementsEnergy = value;
            }
        }

        public double EnergyPerUnitArea
        {
            get
            {
                return _energyPerUnitArea;
            }

            set
            {
                _energyPerUnitArea = value;
            }
        }

        public double MeasurementAverageEnergyPerUnitArea
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergyPerUnitArea.Count > 0)
                {
                    energy = MeasurementsEnergyPerUnitArea.Average();
                    energy = double.Parse($"{energy:F4}");
                }

                return energy;
            }
        }

        public double MeasurementMaxEnergyPerUnitArea
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergyPerUnitArea.Count > 0)
                {
                    energy = MeasurementsEnergyPerUnitArea.Max();
                    energy = double.Parse($"{energy:F4}");
                }

                return energy;
            }
        }

        public double MeasurementMinEnergyPerUnitArea
        {
            get
            {
                double energy = 0;

                if (MeasurementsEnergyPerUnitArea.Count > 0)
                {
                    energy = MeasurementsEnergyPerUnitArea.Min();
                    energy = double.Parse($"{energy:F4}");
                }

                return energy;
            }
        }

        public List<double> MeasurementsEnergyPerUnitArea
        {
            get
            {
                return _measurementsEnergyPerUnitArea;
            }

            set
            {
                _measurementsEnergyPerUnitArea = value;
            }
        }

        public bool Enable
        {
            get
            {
                return _enable;
            }

            private set
            {
                _enable = value;
            }
        }

        public PowerMeter(Equipment equipment)
        {
            serialPort.PortName = "COM3";
            serialPort.BaudRate = 115200;
            serialPort.Parity = System.IO.Ports.Parity.None;
            serialPort.DataBits = 8;
            serialPort.StopBits = System.IO.Ports.StopBits.One;
            serialPort.ReadTimeout = 1000;
            Terminator = "\r\n";

            _equipment = equipment;

            MeasurementsEnergy = new List<double>();
            MeasurementsEnergyPerUnitArea = new List<double>();

            t_statusUpdate = new Thread(statusUpdate);
            t_statusUpdate.Start();
        }

        public void statusUpdate()
        {
            while (_equipment.IsDisposed == false)
            {
                try
                {
                    Thread.Sleep(100);

                    if (IsOpen)
                    {
                        if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
                        {
                            Enable = false;
                            continue;
                        }
                        else
                        {
                            Enable = true;
                        }


                        GetMeasurementMode();

                        if (CurrentMeasurementMode == MeasurementMode.Energy)
                        {
                            if(_equipment.chamber.IsPowerMeterPosition)
                            {
                                ReadEnergy();
                            }
                        }
                    }
                    else
                    {
                        if (_equipment.alarmManager.OccurredAlarms.Exists(x => x.Code == AlarmCode.AL_0059_POWERMETER_DISCONNECTED))
                        {
                            Close();
                        }
                        else
                        {
                            if (Open() == false)
                            {
                                _equipment.alarmManager.Occur(AlarmCode.AL_0059_POWERMETER_DISCONNECTED);
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                }
            }
        }
        
        public double ReadEnergy()
        {
            try
            {
                double energy = 0;

                string flag = WriteRead("EF");

                if (flag.Contains("1"))
                {
                    Flag = true;
                    string energyData = WriteRead("SE");

                    if(double.TryParse(energyData, out energy))
                    {
                        Energy = energy;
                        EnergyPerUnitArea = Energy / (_equipment.settingParameterManager.SettingParameter.BeamHeight * _equipment.settingParameterManager.SettingParameter.BeamWidth);

                        Energy = double.Parse($"{Energy:F7}");
                        EnergyPerUnitArea = double.Parse($"{EnergyPerUnitArea * 100:F4}");

                        EquipmentLogManager.Instance.WriteEnergyMeterLog($"{energy}");
                        if (MeasurementsEnergy.Count >= int.MaxValue - 1000)
                        {
                            ResetMeasurementsEnergy();
                        }

                        MeasurementsEnergy.Add(Energy);
                        MeasurementsEnergyPerUnitArea.Add(EnergyPerUnitArea);

                        EnergyMeasured?.Invoke(EnergyPerUnitArea);

                        ErrorDescription = string.Empty;
                    }
                    else
                    {
                        Close();
                        Energy = energy;
                        ErrorDescription = energyData;
                    }
                }
                else
                {
                    Flag = false;
                    Energy = 0;
                    EnergyPerUnitArea = 0;
                }

                return energy;
            }
            catch (Exception ex)
            {
                EquipmentLogManager.Instance.WriteExceptionLog(ex.StackTrace + "\r\n" + ex.Message);
                return 0;
            }
        }
        
        public bool SetPowerMode()
        {
            if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
            {
                return false;
            }

            string result = WriteRead($"MM{MeasurementMode.Power:d}");

            if (result.Contains("2"))
            {
                _currentMeasurementMode = MeasurementMode.Power;
                Enable = false;
                _measurementChangedTime = DateTime.Now;
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool SetEnergyMode()
        {
            if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
            {
                return false;
            }

            string result = WriteRead($"MM{MeasurementMode.Energy:d}");

            if(result.Contains("3"))
            {
                _currentMeasurementMode = MeasurementMode.Energy;
                Enable = false;
                _measurementChangedTime = DateTime.Now;
                return true;
            }
            else
            {
                return false;
            }
        }

        public MeasurementMode GetMeasurementMode()
        {
            MeasurementMode measurementMode = MeasurementMode.QueryPresentMeasurementMode;

            string mode = WriteRead("MM");
            
            int modeNumber;
            
            if(int.TryParse(mode, out modeNumber))
            {
                measurementMode = (MeasurementMode)modeNumber;
                
                if(measurementMode != MeasurementMode.Energy)
                {
                    SetEnergyMode();
                }
            }

            CurrentMeasurementMode = measurementMode;

            return measurementMode;
        }
        
        public void ResetMeasurementsEnergy()
        {
            MeasurementsEnergy.Clear();
            MeasurementsEnergyPerUnitArea.Clear();
        }

        public bool ResetEnergyMeter()
        {
            return SetPowerMode();
        }

        private new string WriteRead(string command)
        {
            string data = base.WriteRead("$" + command + "\r");

            if(data == "")
            {
                return null;
            }
            else
            {
                return data.Replace("\r\n", "").Replace("*","");
            }
        }
    }
}