using SA_LTT.Base;
using System;
using System.Threading;

namespace SA_LTT.Module
{
    public class Attenuator : ComPort
    {
        public enum MotorRunState
        {
            Stopped,
            Accelerating,
            Decelerating,
            Running,
        }

        public enum MicroSteppingResolution : int
        {
            /// <summary>
            /// 1 Motor is driven in full steps mode.Waveplate holder turns once in 15600 steps.
            /// </summary>
            FullStep = 1,
            /// <summary>
            /// 2 Half step mode.Waveplate holder turns once in 31200 steps.
            /// </summary>
            HalfStep = 2 ,
            /// <summary>
            /// 4 Quarter step mode.Waveplate holder turns once in 62400 steps.
            /// </summary>
            QuaterStep = 4,
            /// <summary>
            /// 8 Eight step mode.Waveplate holder turns once in 124800 steps.
            /// </summary>
            EightStep = 8,
            /// <summary>
            /// 16 Sixteen step mode.Waveplate holder turns once in 249600 steps.
            /// </summary>
            SixteenStep = 16,
        }

        private MotorRunState _motorState;
        private int _position;
        private int _speed;
        private int _accelerationValue;
        private int _decelerationValue;
        private MicroSteppingResolution _steppingResolution;
        private bool _motorEnable;

        private Equipment _equipment;
        private Thread t_statusUpdate;

        public double DegreePerSecondFromSpeed
        {
            get
            {
                return 14400000 / (78 * (int)SteppingResolution * (65535 - Speed));
            }
        }

        public int Position
        {
            get
            {
                return _position;
            }

            private set
            {
                _position = value;
            }
        }

        public double Degree
        {
            get
            {
                return Math.Round(Position * GetDegreefromSteppingResolution(), 3);
            }
        }

        public int Speed
        {
            get
            {
                return _speed;
            }

            private set
            {
                _speed = value;
            }
        }

        public int AccelerationValue
        {
            get
            {
                return _accelerationValue;
            }

            private set
            {
                _accelerationValue = value;
            }
        }

        public int DecelerationValue
        {
            get
            {
                return _decelerationValue;
            }

            private set
            {
                _decelerationValue = value;
            }
        }

        public MicroSteppingResolution SteppingResolution
        {
            get
            {
                return _steppingResolution;
            }

            private set
            {
                _steppingResolution = value;
            }
        }

        public bool MotorEnable
        {
            get
            {
                return _motorEnable;
            }

            private set
            {
                _motorEnable = value;
            }
        }

        public MotorRunState MotorState
        {
            get
            {
                return _motorState;
            }

            private set
            {
                _motorState = value;
            }
        }

        public Attenuator(Equipment equipment)
        {
            serialPort.PortName = "COM11";
            serialPort.BaudRate = 38400;
            serialPort.Parity = System.IO.Ports.Parity.None;
            serialPort.DataBits = 8;
            serialPort.StopBits = System.IO.Ports.StopBits.One;
            serialPort.ReadTimeout = 500;
            ReceiveWaitSeconds = 0.5;
            Terminator = "\n\r";

            _steppingResolution = MicroSteppingResolution.FullStep;

            _equipment = equipment;

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

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

                    if (IsOpen)
                    {
                        ReadSettings();
                        ReadStatus();
                    }
                    else
                    {
                        if (_equipment.alarmManager.OccurredAlarms.Exists(x => x.Code == AlarmCode.AL_0053_ATTENUATOR_DISCONNECTED))
                        {

                        }
                        else
                        {
                            if (Open() == false)
                            {
                                _equipment.alarmManager.Occur(AlarmCode.AL_0053_ATTENUATOR_DISCONNECTED);
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                }
            }
        }

        public void Home()
        {
            Write("zp");
        }
        
        public void Stop()
        {
            Write("st");
        }
        
        public void MoveAbsolute(float angle)
        {
            int position = (int)(angle / GetDegreefromSteppingResolution());

            Write($"g {position}");
        }

        public void MoveAbsolute(int position)
        {
            Write($"g {position}");
        }

        public void MoveRelative(double angle)
        {
            int position = (int)(angle / GetDegreefromSteppingResolution());

            Write($"m {position}");
        }

        public void MoveRelative(int position)
        {
            Write($"m {position}");
        }

        public void JogPositive()
        {
            Write($"m 2147483646");
        }

        public void JogNegative()
        {
            Write($"m -2147483646");
        }

        public bool IsAttenuatorAngleCorrect(float angle)
        {
            if (Position == (int)(angle / GetDegreefromSteppingResolution()))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void SetMicroSteppingResolution(MicroSteppingResolution steppingResolution)
        {
            if (steppingResolution == MicroSteppingResolution.SixteenStep)
            {
                Write($"r 6");
            }
            else
            {
                Write($"r {(int)steppingResolution}");
            }
        }
        
        public double GetDegreefromSteppingResolution()
        {
            double degree = 360.0 / (78 * (int)SteppingResolution * 200);
            
            return degree;
        }

        public double GetDegreePerSecondFromSpeed(int speed)
        {
            double degreePerSecond = 14400000 / (78 * (int)SteppingResolution * (65535 - speed));

            return degreePerSecond;
        }

        public int GetSpeedFromDegreePerSecond(double degreePerSecond)
        {
            int speed = (int)Math.Ceiling(65535 - 14400000 / (degreePerSecond * 78 * (int)SteppingResolution));

            return speed;
        }

        /// <summary>
        /// 0 is turn off.
        /// </summary>
        /// <param name="acceleration"></param>
        public void SetAcceleration(int acceleration)
        {
            if(acceleration > 255)
            {
                acceleration = 255;
            }
            else if (acceleration < 0)
            {
                acceleration = 0;
            }

            Write($"a {acceleration}");
        }

        /// <summary>
        /// 0 is turn off
        /// </summary>
        /// <param name="deceleration"></param>
        public void SetDeceleration(int deceleration)
        {
            if (deceleration > 255)
            {
                deceleration = 255;
            }
            else if (deceleration < 0)
            {
                deceleration = 0;
            }

            Write($"d {deceleration}");
        }

        public void SetSpeed(int speed)
        {
            if (speed > 65000)
            {
                speed = 65000;
            }
            else if (speed < 1)
            {
                speed = 1;
            }

            Write($"s {speed}");
        }

        public void SaveSetting()
        {
            Write("ss");
        }

        public void ReadStatus()
        {
            string receivedData;

            if (WriteRead("o", out receivedData))
            {
                string[] status = receivedData.Split(';');

                if (status.Length < 2) return;

                MotorState = (MotorRunState)Enum.Parse(typeof(MotorRunState), status[0]);
                int position;

                int.TryParse(status[1], out position);

                this.Position = position;
            }
            else
            {

            }
        }

        public void ReadSettings()
        {
            try
            {
                string receivedData;

                if (WriteRead("pc", out receivedData))
                {
                    string[] settings = receivedData.Split(';');

                    if (settings.Length < 25) return;

                    bool operatingMode = settings[0] == "1" ? true : false;
                    MotorState = (MotorRunState)Enum.Parse(typeof(MotorRunState), settings[1]);
                    AccelerationValue = int.Parse(settings[2]);
                    DecelerationValue = int.Parse(settings[3]);
                    Speed = int.Parse(settings[4]);
                    int motionCurrentValue = int.Parse(settings[5]);
                    int idleCurrentValue = int.Parse(settings[6]);
                    int stepDirCurrentvalue = int.Parse(settings[7]);

                    if (settings[8] == "6")
                    {
                        SteppingResolution = MicroSteppingResolution.SixteenStep;
                    }
                    else
                    {
                        SteppingResolution = (MicroSteppingResolution)Enum.Parse(typeof(MicroSteppingResolution), settings[8]);
                    }

                    MotorEnable = settings[9] == "1" ? true : false;
                    
                    // settings[11] 필요 없을듯.
                    // settings[12] 필요 없을듯. Zero position 올 때마다 zp:[integerValue] 리턴해 주는거. 굳이 ..?
                    // settings[13] Reserved
                    // settings[14] Reserved
                    // settings[15] Reserved
                    // settings[16] 필요 없을듯.

                    // settings[21] Reserved
                    // settings[22] Reserved
                    // settings[23] Reserved
                }
            }
            catch(Exception e)
            {
                EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
            }
        }
        
        public new bool Write(string command)
        {
            lock (this)
            {
                //base.Write(command + '\r');

                //return true;

                Terminator = null;
                string data = base.WriteRead(command + '\r');

                if (data.StartsWith(command.Split(' ')[0]))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public bool WriteRead(string command, out string receivedData)
        {
            lock (this)
            {
                Terminator = "\n\r";
                string data = base.WriteRead(command + '\r');

                if (data.StartsWith(command.Split(' ')[0]))
                {
                    receivedData = data.Remove(0, command.Split(' ')[0].Length).Replace("\n\r", "");
                    return true;
                }
                else
                {
                    receivedData = string.Empty;
                    return false;
                }
            }
        }
    }
}