using System;
using System.Collections.Generic;
using System.IO.Ports;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.Device.Bases;

namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.RFs.Mkss
{
    public class MksRfPower : RfPowerBase
    {
        public override bool IsError { get; set; }

        public override bool IsPowerOn
        {
            get { return _isOn; }
        }

        //public override EnumRfPowerRegulationMode RegulationMode
        //{
        //    get { return _regulationMode; }
        //}
        public bool Connect()
        {
            return _connection.Connect();
        }

        public bool Disconnect()
        {
            return _connection.Disconnect();
        }

        public override bool IsConnected => Connection != null && Connection.IsConnected && !_connection.IsCommunicationError;

        public override float ForwardPower
        {
            get { return _forwardPower; }
        }

        public override float ReflectPower
        {
            get { return _reflectPower; }
        }

        public override float Frequency { get; set; }
        public override float PulsingFrequency { get; set; }
        public override float PulsingDutyCycle { get; set; }

        public string ControlSource { get; set; }
        public string RegulationSource { get; set; }
        public string SetpointSource { get; set; }



        public override AITRfPowerData DeviceData
        {
            get
            {
                AITRfPowerData data = new AITRfPowerData()
                {
                    DeviceName = Name,
                    Module = Module,
                    DeviceSchematicId = DeviceID,
                    DisplayName = Display,
                    UnitPower = "W",

                    ForwardPower = _originalPowerSetPoint > 0 ? CalibrationData(ForwardPower, false) : 0,
                    ReflectPower = _originalPowerSetPoint > 0 ? ReflectPower : 0,
                    PowerSetPoint = _originalPowerSetPoint,
                    RegulationMode = RegulationMode,
                    ScalePower = PowerRange,

                    IsRfOn = IsPowerOn,
                    IsRfAlarm = IsError,
                    IsInterlockOk = true,

                    Frequency = Frequency,
                    PulsingFrequency = PulsingFrequency,
                    PulsingDutyCycle = PulsingDutyCycle,
                };

                return data;
            }
        }

        public MksRfPowerConnection Connection
        {
            get { return _connection; }
        }

        private MksRfPowerConnection _connection;

        private byte _deviceAddress;

        private float _powerSetPoint;
        private float _reflectPower;
        private bool _isOn;
        private float _forwardPower;
        private float _voltage;

        private RD_TRIG _trigRfOnOff = new RD_TRIG();


        private R_TRIG _trigError = new R_TRIG();

        private R_TRIG _trigWarningMessage = new R_TRIG();

        private R_TRIG _trigCommunicationError = new R_TRIG();
        private R_TRIG _trigRetryConnect = new R_TRIG();

        private PeriodicJob _thread;
        //private bool _isInterlockNotOK;
        private LinkedList<HandlerBase> _lstHandler = new LinkedList<HandlerBase>();
        private object _locker = new object();

        private bool _enableLog = true;
        private bool _isHaloInstalled;

        private string _scRoot;

        public MksRfPower(string module, string name, string scRoot) : base(module, name)
        {
            _scRoot = scRoot;
        }


        public bool Initialize(string portName, int baudRate = 9600, int dataBits = 8, Parity parity = Parity.None, StopBits stopBits = StopBits.One)
        {
            base.Initialize();
            _enableLog = true;
            _connection = new MksRfPowerConnection(portName, baudRate, dataBits, parity, stopBits);
            _connection.EnableLog(_enableLog);
            if (_connection.Connect())
            {
                EV.PostInfoLog(Module, $"{Module}.{Name} connected");
            }
            _thread = new PeriodicJob(100, OnTimer, $"{Module}.{Name} MonitorHandler", true);

            return true;
        }

        public override bool Initialize()
        {
            base.Initialize();

            string portName = SC.GetStringValue($"{_scRoot}.Address");
            int bautRate = SC.GetValue<int>($"{_scRoot}.BaudRate");
            int dataBits = SC.GetValue<int>($"{_scRoot}.DataBits");
            Enum.TryParse(SC.GetStringValue($"{_scRoot}.Parity"), out Parity parity);
            Enum.TryParse(SC.GetStringValue($"{_scRoot}.StopBits"), out StopBits stopBits);

            _deviceAddress = (byte)SC.GetValue<int>($"{_scRoot}.Address");
            _enableLog = SC.GetValue<bool>($"{_scRoot}.EnableLogMessage");
            _scPowerScale = SC.GetConfigItem($"{_scRoot}.PowerScale");

            _connection = new MksRfPowerConnection(portName, bautRate, dataBits, parity, stopBits);
            _connection.EnableLog(_enableLog);

            if (_connection.Connect())
            {
                EV.PostInfoLog(Module, $"{Module}.{Name} connected");
            }

            _thread = new PeriodicJob(100, OnTimer, $"{Module}.{Name} MonitorHandler", true);

            lock (_locker)
            {
                _lstHandler.AddLast(new MksRfPowerSetEchoOffHandler(this, false));
            }

            OP.Subscribe($"{Module}.{Name}.WaveModulation", (out string reason, int time, object[] args) =>
            {
                reason = "";

                //if (!Enum.TryParse((string)args[0], out EnumRpsControlMode mode))
                //{
                //    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not mode, {args[0]} is not a valid mode value");
                //    return false;
                //}

                if (!PerformWaveModulation(out reason, time, ""))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set mode to {args[0]}");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.PowerMode", (out string reason, int time, object[] args) =>
            {
                reason = "";

                string mode = (string)args[0];

                if (!PerformPowerMode(out reason, time, mode))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set mode to {mode}");
                return true;
            });


            OP.Subscribe($"{Module}.{Name}.SetHighPower", (out string reason, int time, object[] args) =>
            {
                reason = "";
                float value = Convert.ToSingle((string)args[0]);

                if (!PerformSetHighPower(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set high power to {value}");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.SetLowPower", (out string reason, int time, object[] args) =>
            {
                reason = "";
                float value = Convert.ToSingle((string)args[0]);

                if (!PerformSetLowPower(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set low power to {value}");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.PulseFreq", (out string reason, int time, object[] args) =>
            {
                reason = "";
                float value = Convert.ToSingle((string)args[0]);

                if (!PerformPulseFreq(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set pulse frequency to {value}");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.PulseDutyCycle", (out string reason, int time, object[] args) =>
            {
                reason = "";

                float value = Convert.ToSingle((string)args[0]);

                if (!PerformPulseDutyCycle(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set pulse duty cycle to {value}");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.RampMode", (out string reason, int time, object[] args) =>
            {
                reason = "";

                if (!PerformRampMode(out reason, time, ""))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set ramp mode to ");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.RampUp", (out string reason, int time, object[] args) =>
            {
                reason = "";


                if (!PerformRampUp(out reason, time, ""))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set ramp up");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.RampDown", (out string reason, int time, object[] args) =>
            {
                reason = "";

                if (!PerformRampDown(out reason, time, ""))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set ramp down");
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.WarningPower", (out string reason, int time, object[] args) =>
            {
                reason = "";

                float value = Convert.ToSingle((string)args[0]);

                if (!PerformWarningPower(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set warning power to {value}");
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.AlarmPower", (out string reason, int time, object[] args) =>
            {
                reason = "";

                float value = Convert.ToSingle((string)args[0]);

                if (!PerformAlarmPower(out reason, time, value))
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}");
                    return false;
                }

                EV.PostInfoLog(Module, $"{Module}.{Name} set alarm power to {value}");
                return true;
            });

            DATA.Subscribe($"{Module}.{Name}.IsConnected", () => IsConnected);
            DATA.Subscribe($"{Module}.{Name}.Address", () => SC.GetStringValue($"{_scRoot}.Address"));
            OP.Subscribe($"{Module}.{Name}.Reconnect", (string cmd, object[] args) =>
            {
                Disconnect();
                Reset();
                Connect();
                return true;
            });

            return true;
        }

        private bool PerformWaveModulation(out string reason, int time, string mode)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformAlarmPower(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformWarningPower(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformPowerMode(out string reason, int time, string mode)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformSetHighPower(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformSetLowPower(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformPulseFreq(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformPulseDutyCycle(out string reason, int time, float value)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformRampMode(out string reason, int time, string v)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformRampUp(out string reason, int time, string mode)
        {
            reason = string.Empty;
            return true;
        }

        private bool PerformRampDown(out string reason, int time, string mode)
        {
            reason = string.Empty;
            return true;
        }

        private bool OnTimer()
        {
            try
            {
                _connection.MonitorTimeout();

                if (!_connection.IsConnected || _connection.IsCommunicationError)
                {
                    lock (_locker)
                    {
                        _lstHandler.Clear();
                    }

                    _trigRetryConnect.CLK = !_connection.IsConnected;
                    if (_trigRetryConnect.Q)
                    {
                        _connection.SetPortAddress(SC.GetStringValue($"{ScBasePath}.{Name}.Address"));
                        if (!_connection.Connect())
                        {
                            EV.PostAlarmLog(Module, $"Can not connect with {_connection.Address}, {Module}.{Name}");
                        }
                        else
                        {

                        }
                    }
                    return true;
                }

                HandlerBase handler = null;
                if (!_connection.IsBusy)
                {
                    lock (_locker)
                    {
                        if (_lstHandler.Count == 0)
                        {

                            _lstHandler.AddLast(new MksRfPowerQueryStatusHandler(this));

                        }

                        if (_lstHandler.Count > 0)
                        {
                            handler = _lstHandler.First.Value;

                            _lstHandler.RemoveFirst();
                        }
                    }

                    if (handler != null)
                    {
                        _connection.Execute(handler);
                    }
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

            return true;
        }

        public override void Monitor()
        {
            try
            {
                _connection.EnableLog(_enableLog);

                _trigRfOnOff.CLK = _isOn;
                if (_trigRfOnOff.R)
                {
                    EV.PostInfoLog(Module, $"{Module}.{Name} is on");
                }

                if (_trigRfOnOff.T)
                {
                    EV.PostInfoLog(Module, $"{Module}.{Name} is off");
                }

                //_trigError.CLK = IsError;
                //if (_trigError.Q)
                //{
                //    EV.PostAlarmLog(Module, $"{Module}.{Name} is error, error code {_errorCode:D3}");
                //}

                _trigCommunicationError.CLK = _connection.IsCommunicationError;
                if (_trigCommunicationError.Q)
                {
                    EV.PostAlarmLog(Module, $"{Module}.{Name} communication error, {_connection.LastCommunicationError}");
                }

                base.Monitor();
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

        }

        public override void Reset()
        {
            _trigError.RST = true;
            _trigWarningMessage.RST = true;

            _connection.SetCommunicationError(false, "");
            _trigCommunicationError.RST = true;

            _enableLog = SC.GetValue<bool>($"{_scRoot}.EnableLogMessage");

            _trigRetryConnect.RST = true;

            base.Reset();
        }

        public override void CheckTolerance()
        {
            if (!EnableAlarm || PowerSetPoint == 0 || (RecipeIgnoreTime > 0 && _recipeIgnoreTimer.GetElapseTime() < RecipeIgnoreTime * 1000))
                return;

            _toleranceAlarmChecker.Monitor(ForwardPower, (PowerSetPoint * (1 - AlarmRange / 100)), (PowerSetPoint * (1 + AlarmRange / 100)), AlarmTime);

            _toleranceWarningChecker.Monitor(ForwardPower, (PowerSetPoint * (1 - WarningRange / 100)), (PowerSetPoint * (1 + WarningRange / 100)), WarningTime);

            if (_PrThreshold > 0)
                _prThresholdChecker.Monitor(ReflectPower, 0, _PrThreshold, PrThresholdMonitorTime);

            //if (_toleranceAlarmChecker.Trig)
            //{
            //    EV.PostMessage(Module, EventEnum.ToleranceAlarm, Module, Display,
            //                           String.Format("Out of range in {0} seconds", AlarmTime.ToString("0")));
            //}
            //else if (_toleranceWarningChecker.Trig)
            //{
            //    EV.PostMessage(Module, EventEnum.ToleranceWarning, Module, Display,
            //                           String.Format("Out of range in {0} seconds", WarningTime.ToString("0")));
            //}
        }

        public override void SetPower(float power)
        {
            PowerSetPoint = power;
            lock (_locker)
            {
                _lstHandler.AddLast(new MksRfPowerSetPowerHandler(this, (int)PowerSetPoint));
            }
        }

        public override bool SetPowerOnOff(bool isOn, out string reason)
        {
            _isOn = isOn;//有指令能读状态之后，根据读回的状态显示
            reason = "";
            lock (_locker)
            {
                _lstHandler.AddLast(new MksRfPowerSwitchOnOffHandler(this, isOn));
            }

            return true;
        }

        public override void SetRegulationMode(EnumRfPowerRegulationMode mode)
        {
            lock (_locker)
            {
                _lstHandler.AddLast(new MksRfPowerSetRegulationModeHandler(this, _deviceAddress, mode));
            }
        }

        public void QueryStatus()
        {
            lock (_locker)
            {
                _lstHandler.AddLast(new MksRfPowerQueryStatusHandler(this));
            }
        }

        internal void NoteError(string reason)
        {
            _trigWarningMessage.CLK = true;
            if (_trigWarningMessage.Q)
            {
                EV.PostWarningLog(Module, $"{Module}.{Name} error, {reason}");
            }
        }

        internal void NoteReflectPower(float data)
        {
            _reflectPower = data;
        }
        internal void NoteVoltage(float data)
        {
            _voltage = data;
        }
        internal void NoteFrequency(float data)
        {
            Frequency = data;
        }


        //internal void NoteRegulationModeSetPoint(EnumRfPowerRegulationMode regMode)
        //{
        //    _regulationMode = regMode;
        //}

        internal void NotePowerSetPoint(int power)
        {
            _powerSetPoint = power;
        }

        internal void NoteForwardPower(int power)
        {
            _forwardPower = power;
        }


    }



}