using System;
using System.Collections;
using System.Text.RegularExpressions;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using VirgoCommon;
using VirgoRT.Modules;

namespace VirgoRT.Devices
{
    class RevtechGenerator : RfPowerBase
    {
        // ----------------------------Fields--------------------------
        //
        private int QUERY_INTERVAL = 5000;
        private const string INFO_PATTERN = @"(\d{7})\s(\d{5})\s(\d{5})\s(\d{5})\s(\d{5})";
        private double _total;
        private double _fromLast;
        private bool _cmdRFPowerOn = false;
        private readonly AsyncSerialPort _serial;
        private readonly DeviceTimer _timerQueryStatus = new DeviceTimer();
        private readonly DeviceTimer _timerTotal = new DeviceTimer();
        private readonly DeviceTimer _timerFromLast = new DeviceTimer();
        private readonly DeviceTimer _timerRFTurnOn = new DeviceTimer();
        private DateTime _powerOnStartTime;
        private TimeSpan _powerOnElapsedTime;
        private readonly RD_TRIG _rfOnTrigger = new RD_TRIG();
        private readonly R_TRIG _ErrTrigger = new R_TRIG();
        private readonly R_TRIG _trigPMNeeded = new R_TRIG();
        private readonly RD_TRIG _trigOnOff = new RD_TRIG();
        private ToleranceChecker _checkerPower;
        private ToleranceChecker _checkerReflectPower;
        private readonly double _scPowerAlarmTime;
        private readonly double _scPowerAlarmRange;
        private readonly double _scPowerWarningTime;
        private readonly double _scPowerWarningRange;
        private readonly double _scReflectPowerAlarmTime;
        private readonly double _scReflectPowerAlarmRange;
        private readonly double _scPowerRange;
        private readonly DIAccessor _diIntlk;
        private StatsDataItemRFAndPump _statRFOnTime;
        private object _lockerCmdPowerOn = new object();

        private string _title = "Revtech TEC";

        // --------------------------Properties------------------------
        //
        public bool ConnectedStatus { get; set; }
        public override float ScalePower => (float)_scPowerRange;

        public GeneratorStatus Status { get; set; }

        public string LastPMTime
        {
            get
            {
                return _statRFOnTime != null ? _statRFOnTime.LastPMTime.ToString() : "";
            }
        }

        public double DaysFromLastPM
        {
            get
            {
                return _statRFOnTime == null ? 0 : _statRFOnTime.fromLastPM;
            }
            set
            {
                if (_statRFOnTime != null)
                    _statRFOnTime.fromLastPM = value;
            }
        }

        public double TotalDays
        {
            get
            {
                return _statRFOnTime != null ? _statRFOnTime.Total : 0;
            }
            set
            {
                if (_statRFOnTime != null)
                    _statRFOnTime.Total = value;
            }
        }

        public double PMIntervalDays
        {
            get
            {
                return _statRFOnTime != null ? _statRFOnTime.PMInterval : 0;
            }
        }

        public bool IsPMNeeded
        {
            get
            {
                return DaysFromLastPM > PMIntervalDays;
            }
        }

        public bool EnableAlarm
        {
            get
            {
                return _statRFOnTime == null || _statRFOnTime.AlarmEnable;
            }
        }

        public override bool IsPowerOn
        {
            get => Status == GeneratorStatus.ON;
            set { }
        }

        public override bool IsError
        {
            get => Status == GeneratorStatus.ERROR;
            set { }
        }

        [Subscription("PowerOnTime")]
        public string PowerOnTime
        {
            get
            {
                if (_cmdRFPowerOn)
                    _powerOnElapsedTime = DateTime.Now - _powerOnStartTime;

                return $"{(int)_powerOnElapsedTime.TotalHours:00}:{_powerOnElapsedTime.Minutes:00}:{(_powerOnElapsedTime.Seconds > 0 ? (_powerOnElapsedTime.Seconds + 1) : 0):00}";
            }
        }

        public bool RFInterlock => _diIntlk == null || _diIntlk.Value;

        private float _forwardPower;
        public override float ForwardPower
        {
            get
            {
                return _forwardPower;
            }
            set
            {
                _forwardPower = CalibrationData(value, false);
            }
        }

        public new AITRfData DeviceData =>
            new AITRfData
            {
                Module = Module,
                DeviceName = Name,
                ScalePower = ScalePower,
                ForwardPower = ForwardPower,
                ReflectPower = ReflectPower,
                IsRfOn = IsPowerOn,
                PowerSetPoint = PowerSetPoint,
                PowerOnElapsedTime = PowerOnTime,
                IsInterlockOk = RFInterlock,
                WorkMode = (int)RfMode.ContinuousWaveMode,
                DisplayName = "Source RF",
            };

        // --------------------------Constructor-----------------------
        //
        public RevtechGenerator(ModuleName mod, string name) : base(mod.ToString(), name)
        {
            var portNum = SC.GetStringValue($"{mod}.{name}.Port");
            this.Status = GeneratorStatus.Unknown;

            _serial = new AsyncSerialPort(portNum, 9600, 8, System.IO.Ports.Parity.None, System.IO.Ports.StopBits.One, "\r\r");

            _scPowerAlarmTime = SC.GetValue<double>($"{Module}.{Name}.PowerAlarmTime");
            _scPowerAlarmRange = SC.GetValue<double>($"{Module}.{Name}.PowerAlarmRange");

            _scPowerWarningTime = SC.GetValue<double>($"{Module}.{Name}.PowerWarningTime");
            _scPowerWarningRange = SC.GetValue<double>($"{Module}.{Name}.PowerWarningRange");

            _scReflectPowerAlarmTime = SC.GetValue<double>($"{Module}.{Name}.ReflectPowerAlarmTime");
            _scReflectPowerAlarmRange = SC.GetValue<double>($"{Module}.{Name}.ReflectPowerAlarmRange");
            _scPowerRange = SC.GetValue<double>($"{Module}.{Name}.PowerRange");
            _scEnableCalibration = SC.GetConfigItem($"{Module}.{Name}.EnableCalibration");
            _scCalibrationTable = SC.GetConfigItem($"{Module}.{Name}.CalibrationTable");
            _scRFPhysicalMaxPower = SC.GetConfigItem($"{Module}.{Name}.RFPhysicalMaxPower");
            _scCurrentRFMaxPower = SC.GetConfigItem($"{Module}.{Name}.CurrentRFMaxPower");

            _diIntlk = IO.DI[$"{Module}.DI_Generator_Hardware_Interlock"];
        }

        ~RevtechGenerator()
        {
            _serial?.Close();
        }

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

            DATA.Subscribe($"{Module}.{Name}.DeviceData", () => DeviceData);
            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetPowerOnOff}", (out string reason, int time, object[] param) =>
            {
                SetPowerOnOff(Convert.ToBoolean((string)param[0]), out reason);
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetPower}", (out string reason, int time, object[] param) =>
            {
                reason = "";
                ushort val = Convert.ToUInt16(param[0]);
                SetPower(val);
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetContinuousPower}", (out string reason, int time, object[] param) =>
            {
                reason = "";
                ushort val = Convert.ToUInt16(param[0]);
                SetPower(val);
                return true;
            });

            if (_serial.Open())
            {
                this.ConnectedStatus = true;
                _serial.OnDataChanged += SerialPortDataReceived;
                _serial.OnErrorHappened += SerialPortErrorOccurred;
            }
            else
            {
                this.ConnectedStatus = false;
                EV.PostAlarmLog(this.Module, $"{_title} 射频发生器串口无法打开");
                return false;
            }

            _statRFOnTime = StatsDataManager.Instance.GetItemRFAndPump($"{Module}.RfOnTime");

            _timerQueryStatus.Start(QUERY_INTERVAL);

            _checkerPower = new ToleranceChecker(_scPowerAlarmTime);
            _checkerReflectPower = new ToleranceChecker(_scReflectPowerAlarmTime);

            SetCommunicationMode(1);
            return true;
        }

        public override void Monitor()
        {
            // 状态查询
            if (_timerQueryStatus.IsTimeout())
            {
                this.SendCmd(AdTecRfMessage.QUERY);
                _timerQueryStatus.Start(QUERY_INTERVAL);
            }

            // power on triggered
            _rfOnTrigger.CLK = IsPowerOn;
            if (_rfOnTrigger.R)
            {
                _total = TotalDays;
                _fromLast = DaysFromLastPM;
                _timerTotal.Start(0);
                _timerFromLast.Start(0);
                _powerOnStartTime = DateTime.Now;
                _checkerPower.Reset(_scPowerAlarmTime);
                _checkerReflectPower.Reset(_scReflectPowerAlarmTime);
                _alarmChecker.Reset(_scPowerAlarmTime);
                _warningChecker.Reset(_scPowerWarningTime);
            }

            if (_rfOnTrigger.M)
            {
                TotalDays = _total + _timerTotal.GetElapseTime() / 1000 / 60 / 60;
                DaysFromLastPM = _fromLast + _timerFromLast.GetElapseTime() / 1000 / 60 / 60;

                //_checkerPower.Monitor(ForwardPower, PowerSetPoint - _scPowerAlarmRange, PowerSetPoint + _scPowerAlarmRange, _scPowerAlarmTime);

                //if (_checkerPower.Trig)
                //{
                //    EV.PostAlarmLog($"{Module}",
                //        $"{Display} Forward power {ForwardPower:0} out of range[{PowerSetPoint - _scPowerAlarmRange:0},{PowerSetPoint + _scPowerAlarmRange:0}] in {_scPowerAlarmTime:0} seconds");

                //    SetPowerOnOff(false, out _);
                //}





                if (_recipeAlarmRange > 0 && _recipeAlarmRange / 100.0 * PowerSetPoint < _scPowerAlarmRange)
                {
                    if (_recipeIgnoreTimer.GetElapseTime() > _recipeIgnoreTimeMS)
                    {
                        _recipeAlarmChecker.Monitor(ForwardPower, PowerSetPoint - Math.Abs(_recipeAlarmRange / 100.0 * PowerSetPoint), PowerSetPoint + Math.Abs(_recipeAlarmRange / 100.0 * PowerSetPoint), _scPowerAlarmTime);
                        if (_recipeAlarmChecker.Trig)
                        {
                            EV.PostAlarmLog(Module, Display + $" out of tolerance in {_scPowerAlarmTime:0} seconds");

                            SetPowerOnOff(false, out _);
                        }
                    }
                }
                else
                {
                    _alarmChecker.Monitor(ForwardPower, PowerSetPoint - Math.Abs(_scPowerAlarmRange), PowerSetPoint + Math.Abs(_scPowerAlarmRange), _scPowerAlarmTime);
                    if (_alarmChecker.Trig)
                    {
                        EV.PostAlarmLog(Module, Display + $" out of tolerance in {_scPowerAlarmTime:0} seconds");
                    }
                }


                if (_recipeWarningRange > 0 && _recipeWarningRange / 100.0 * PowerSetPoint < _scPowerWarningRange)
                {
                    if (_recipeIgnoreTimer.GetElapseTime() > _recipeIgnoreTimeMS)
                    {
                        _recipeWarningChecker.Monitor(ForwardPower, PowerSetPoint - Math.Abs(_recipeWarningRange / 100.0 * PowerSetPoint), PowerSetPoint + Math.Abs(_recipeWarningRange / 100.0 * PowerSetPoint), _scPowerWarningTime);
                        if (_recipeWarningChecker.Trig)
                        {
                            EV.PostWarningLog(Module, Display + $" out of tolerance in {_scPowerWarningTime:0} seconds");
                        }
                    }
                }
                else
                {
                    _warningChecker.Monitor(ForwardPower, PowerSetPoint - Math.Abs(_scPowerWarningRange), PowerSetPoint + Math.Abs(_scPowerWarningRange), _scPowerWarningTime);
                    if (_warningChecker.Trig)
                    {
                        EV.PostWarningLog(Module, Display + $" out of tolerance in {_scPowerWarningTime:0} seconds");
                    }
                }




                _checkerReflectPower.Monitor(ReflectPower, double.MinValue, _scReflectPowerAlarmRange, _scReflectPowerAlarmTime);

                if (_checkerReflectPower.Trig)
                {
                    EV.PostAlarmLog($"{Module}",
                        $"{Display} Reflect power {ReflectPower:0} out of range[0,{_scReflectPowerAlarmRange:0}] in {_scReflectPowerAlarmTime:0} seconds");

                    SetPowerOnOff(false, out _);
                }
            }

            if (PMIntervalDays > 0)
            {
                _trigPMNeeded.CLK = IsPMNeeded;

                if (_trigPMNeeded.Q)
                {
                    if (EnableAlarm)
                    {
                        EV.PostAlarmLog($"{Module}", "rf on time value larger than setting interval days");
                    }
                }
            }

            if (_rfOnTrigger.T)
                StatsDataManager.Instance.Increase($"{Module}.RfOnTime", $"{Module} RfOnTime", DaysFromLastPM, TotalDays);

            if (!_rfOnTrigger.CLK)
            {
                ForwardPower = 0;
                ReflectPower = 0;
            }

            // 通信 checking, 2 second 一次
            //if (_timerComm.IsTimeout() && !_bQueryComm)
            //{
            //    this.SendCmd(AdTecRfMessage.CHK_COMM);
            //    _bQueryComm = true;
            //    _timerComm.Start(CHK_COMM_INTERVAL);
            //}

            // RF Turn On & Off Timeout Check
            lock (_lockerCmdPowerOn)
            {
                if (IsPowerOn)
                {
                    _timerRFTurnOn.Stop();
                }
                else
                {
                    if (_cmdRFPowerOn && _timerRFTurnOn.IsTimeout())
                    {
                        EV.PostAlarmLog($"{Module}", "RF Turn On Failed");
                        _timerRFTurnOn.Stop();
                    }
                }
            }

            base.Monitor();
        }

        public override void Terminate()
        {
            _serial?.Close();
        }

        public override void Reset()
        {
            _rfOnTrigger.RST = true;
            _ErrTrigger.RST = true;
            _trigPMNeeded.RST = true;
            this.SendCmd(AdTecRfMessage.RESET);
            this.Status = GeneratorStatus.OFF;
            _cmdRFPowerOn = false;

            base.Reset();
        }

        public void SetRfMode(RfMode mode)
        {
            throw new NotImplementedException();
        }

        public override void SetCommunicationMode(int mode)
        {
            CommunicationType t1 = (CommunicationType)mode;
            switch (t1)
            {
                case CommunicationType.Analogue:
                    this.SendCmd(AdTecRfMessage.ANALOG);
                    break;
                case CommunicationType.RS232:
                    this.SendCmd(AdTecRfMessage.RS232);
                    break;
                default:
                    throw new ArgumentOutOfRangeException("Communication mode error");
            }
        }

        public override void SetPower(float val)
        {
            if (!(this.ControlMode == EnumRfPowerControlMode.RS232Mode)) SetCommunicationMode(1);
            ushort a = !_scEnableCalibration.BoolValue ? (ushort)val : (ushort)CalibrationData(val, true);
            if (SendCmd($"{a:D4}{AdTecRfMessage.SET_POWER}"))
            {
                PowerSetPoint = val;
            }
        }

        public override bool SetPowerOnOff(bool on, out string str)
        {
            if (!(this.ControlMode == EnumRfPowerControlMode.RS232Mode)) SetCommunicationMode(1);
            str = "";
            if (on)
            {
                lock (_lockerCmdPowerOn)
                {
                    _cmdRFPowerOn = true;
                    _timerRFTurnOn.Start(SC.GetValue<int>($"{Module}.Rf.RFTurnOnTimeout") * 1000);
                }
                SendCmd(AdTecRfMessage.RF_ON);

                QUERY_INTERVAL = 500;
            }
            else
            {
                lock (_lockerCmdPowerOn)
                {
                    _cmdRFPowerOn = false;
                    _timerRFTurnOn.Stop();
                }
                SendCmd(AdTecRfMessage.RF_OFF);
                ForwardPower = 0;
                ReflectPower = 0;
                QUERY_INTERVAL = 500;
                _ErrTrigger.RST = true;
            }

            _timerQueryStatus.Start(QUERY_INTERVAL);
            return true;
        }

        //----------------------------------Private Method-------------------------------
        //
        private void SerialPortDataReceived(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                EV.PostAlarmLog(Module, $"{_title} RFG 无数据反馈");
                return;
            }

            string str2 = str.Trim('\r');
            if (str2 == AdTecRfMessage.ERR_RES)
            {
                EV.PostWarningLog(Module, $"{_title} 收到 [{str2}]");
                return;
            }

            try
            {
                //LOG.Info($"{Module} Generator rec [{str2}]");

                Match match1 = Regex.Match(str2, INFO_PATTERN);
                if (!match1.Success)
                {
                    //EV.PostWarningLog(Module, "AdTec 数据格式错误");

                    if (!SC.GetValue<bool>("System.IsSimulatorMode"))
                    {
                        LOG.Write($"{Module}, {_title} 数据格式错误");
                    }

                    return;
                }

                string[] str1 =
                {
                    match1.Groups[1].Value,
                    match1.Groups[2].Value,
                    match1.Groups[3].Value,
                    match1.Groups[4].Value,
                    match1.Groups[5].Value
                };

                this.ParseQueryData(str1);
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        private void ParseQueryData(string[] strInfo)
        {
            // Control mode
            string s2 = strInfo[0].Substring(0, 1);
            this.ControlMode = (EnumRfPowerControlMode)Convert.ToUInt16(s2);

            // output mode
            string s0 = strInfo[0].Substring(1, 1);
            this.WorkMode = (EnumRfPowerWorkMode)Convert.ToUInt16(s0);

            // ON/OFF
            char s1 = strInfo[0][2];
            if (s1 == '1')
            {
                Status = GeneratorStatus.ON;
            }
            else if (s1 == '0')
            {
                Status = GeneratorStatus.OFF;
            }

            string errCode = strInfo[0].Substring(5, 2);

            _ErrTrigger.CLK = errCode != "00";
            if (_ErrTrigger.Q)
            {
                string code = errCode == "88" ? "EEPROM or FPGA....  Error" :
                    errCode == "99" ? "ITLK Error" :
                    errCode == "26" ? "Humidity Alarm" :
                    errCode == "05" ? "High Temperature Alarm" :
                    errCode == "12" ? "Amplifier Unbalance" :
                    errCode == "17" ? "Abnormal Power" : $"Unkown error code:{errCode}";
                if (!string.IsNullOrWhiteSpace(code))
                {
                    if (errCode == "99")
                        EV.PostInfoLog(Module, "Source Generator " + code);
                    else
                        EV.PostAlarmLog(Module, "Source Generator " + code);
                }
            }

            // forward power
            this.ForwardPower = Convert.ToUInt64(strInfo[2]);

            // reflect power
            this.ReflectPower = Convert.ToUInt64(strInfo[3]);
        }

        private void SerialPortErrorOccurred(string obj)
        {
            Status = GeneratorStatus.ERROR;
            EV.PostAlarmLog(Module, $"{_title} RFG serial port error, [{obj}]");
        }

        private bool SendCmd(string str)
        {
            if (str != AdTecRfMessage.QUERY)
            {
                EV.PostInfoLog(Module, $"{_title} Generator send [{str}]");
            }
            return _serial.Write(str + "\r");
        }
    }
}