using Aurora.Api;
using AuroraDeviceCommon;
using Hermes;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace AuroraLaser.Amplitude
{
    public enum eLaserTrigger : int
    {
        INTERNAL,
        EXTERNAL,
    }

    public enum eLaserGate : int
    {
        INTERNAL,
        EXTERNAL,
    }

    public enum eLaserAlignment : int
    {
        NO,
        YES,
    }


    public enum eLaserTransmission : int
    {
        Software,
        AnalogInput,
    }

    public enum eLaserPowerTransmission : int
    {
        RF_POWER,
        LASER_POWER_TRANS,
        LASER_POWER,
    }

    public class LaserSatsumaDisplay : ModbusDevice
    {
        Logger Log = new Logger("SatsumaDisplay");

        public enum e_COIL_INPUT
        {
            e_SYSTEM_STOP,
            e_LASER_ON_STANDBY,
            e_PULSE_PICKER_TRIGGER_SYNC,
            e_EXTERNAL_MODULATOR_TRIGGER_SYNC,
            e_EXTERNAL_MODULATOR_GATE_SYNC,
            e_PULSE_PICKER_ALIGNMENT_SYNC,
            e_EXTERNAL_MODULATOR_ALIGNMENT_SYNC,
            e_EXTERNAL_MODULATOR_EFFICIENCY_MODE,
            e_COMPRESSOR_MODE,
            e_MAX,
        }

        public enum e_DISCRETE_INPUT
        {
            e_OSCILLATOR_READY,
            e_INTERLOCK,
            e_KEY,
            e_MODE_LOCK,
            e_FRONT_END_READY,
            e_SHUTTER,
            e_MAX,
        }

        public enum e_HOLDING_REGISTER
        {
            e_RESET,
            e_AMPLIFIER_LD_SET_CURRENT,
            e_BURST_MODE,
            e_PULSE_PICKER_FREQUENCY_SET,
            e_EXTERNAL_MODULATOR_WIDTH,
            e_EXTERNAL_MODULATOR_DELAY,
            e_EXTERNAL_MODULATOR_FREQUENCY_SET,
            e_EXTERNAL_MODULATOR_EFFICIENCY,

            e_MAX = 11,
        }

        public enum e_INPUT_REGISTER
        {
            e_DIODE_AMPLIFIER_RUNTIME,
            e_OSCILLATOR_LD_CURRENT,
            e_OSCILLATOR_LD_TEMP,
            e_OSCILLATOR_LD_POWER,

            e_PREAMP1_LD_CURRENT,
            e_PREAMP1_LD_TEMP,
            e_PREAMP1_LD_POWER,

            e_AMPLIFIER_LD_CURRENT,
            e_AMPLIFIER_LD_POWER,
            e_AMPLIFIER_LD_TEMP,

            e_PULSE_PICKER_FREQUENCY,
            e_EXTERNAL_MODULATOR_FREQUENCY,

            e_OUTPUPT_POWER = 12,

            e_MAX = 19,
        }

        bool[] m_bCoilInputs = new bool[(int)e_COIL_INPUT.e_MAX];
        int[] m_bCoilInputs_For_Write = new int[(int)e_COIL_INPUT.e_MAX] { -1, -1, -1, -1, -1, -1, -1, -1, -1 };


        bool[] m_bDiscreteInputs = new bool[(int)e_DISCRETE_INPUT.e_MAX];
        ushort[] m_usHoldingRegisteres = new ushort[(int)e_HOLDING_REGISTER.e_MAX];
        short[] m_usHoldingRegisteres_For_Write = new short[(int)e_HOLDING_REGISTER.e_MAX] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
        ushort[] m_usInputRegisteres = new ushort[(int)e_INPUT_REGISTER.e_MAX];

        public bool[] CoilInputs {
            get { return m_bCoilInputs; }
            set { m_bCoilInputs = value; }
        }

        public int[] CoilInputs_For_Write {
            get { return m_bCoilInputs_For_Write; }
            set { m_bCoilInputs_For_Write = value; }
        }

        public bool[] DiscreteInputs {
            get { return m_bDiscreteInputs; }
            set { m_bDiscreteInputs = value; }
        }

        public ushort[] HoldingRegisteres {
            get { return m_usHoldingRegisteres; }
            set { m_usHoldingRegisteres = value; }
        }

        public short[] HoldingRegisteres_For_Write {
            get { return m_usHoldingRegisteres_For_Write; }
            set { m_usHoldingRegisteres_For_Write = value; }
        }

        public ushort[] InputRegisteres {
            get { return m_usInputRegisteres; }
            set { m_usInputRegisteres = value; }
        }

        private bool IsRunning = false;
        public int RetryCount = 0;
        private object m_SyncLock = new object();
        private int MaxCount;

        public LaserSatsumaDisplay(bool isSimul) : base(isSimul)
        {
            IsSimul = isSimul;
            CommType = CommunicationType.ModbusTCP;
        }

        protected override int DoActivate(IDeviceConfig config)
        {
            if (IsActivated) {
                return E1.OK;
            }

            var satsumaConfig = (config as LaserSatsumaConfig);
            MaxCount = satsumaConfig.RetryCount;

            if (IsSimul) {
                return E1.OK;
            }

            var res = base.DoActivate(config);
            if (res == E1.OK) {
                RunMonitor(satsumaConfig.ScanIntervalMS);
            } else {
                IsCommError = true;
            }

            return res;
        }

        protected override int DoDeactivate()
        {
            IsRunning = false;

            if (!IsActivated || IsSimul) {
                return E1.OK;
            }

            return base.DoDeactivate();
        }

        public void StopMonitor()
        {
            IsRunning = false;
        }

        public void RunMonitor(int scanIntervalMS)
        {
            IsRunning = true;
            // 실시간 update
            Task.Run(() => {

                while (IsActivated && IsRunning && !IsCommError) {
                    int res = E1.OK;

                    res |= ModbusTcpMasterRead();
                    res |= ModbusTcpMasterWrite();

                    if (res != E1.OK) {
                        RetryCount++;
                    } else {
                        RetryCount = 0;
                    }

                    CheckRetryCount();
                    Thread.Sleep(scanIntervalMS);
                }
            });
        }

        private void CheckRetryCount()
        {
            if (MaxCount < RetryCount) {
                IsCommError = true;
            } else {
                IsCommError = false;
            }
        }

        private int ModbusTcpMasterRead()
        {
            int res = E1.OK;

            // Read Coil
            var bCoilInput = ReadBitBlock(0, (int)e_COIL_INPUT.e_MAX);
            lock (m_SyncLock) {
                Buffer.BlockCopy(bCoilInput.bits, 0, m_bCoilInputs, 0, (int)e_COIL_INPUT.e_MAX);
            }
            res |= bCoilInput.err;

            // Read Discrete Input
            var bDiscreteInput = ReadInputBitBlock(0, (int)e_DISCRETE_INPUT.e_MAX);
            if (bDiscreteInput.err == E1.OK) {
                Buffer.BlockCopy(bDiscreteInput.bits, 0, m_bDiscreteInputs, 0, (int)e_DISCRETE_INPUT.e_MAX);
            }
            res |= bDiscreteInput.err;

            // Read Holding Register
            var usHoldingRegister = ReadWordBlock(0, (int)e_HOLDING_REGISTER.e_MAX);
            lock (m_SyncLock) {
                Buffer.BlockCopy(usHoldingRegister.words, 0, m_usHoldingRegisteres, 0, (int)e_HOLDING_REGISTER.e_MAX * 2);
            }
            res |= usHoldingRegister.err;

            // Read Input Register
            var usInputRegister = ReadInputWordBlock(0, (int)e_INPUT_REGISTER.e_MAX);
            lock (m_SyncLock) {
                Buffer.BlockCopy(usInputRegister.words, 0, m_usInputRegisteres, 0, (int)e_INPUT_REGISTER.e_MAX * 2);
            }
            res |= usHoldingRegister.err;

            return res;
        }

        private int ModbusTcpMasterWrite()
        {
            int res = E1.OK;
            for (int i = 0; i < (int)e_COIL_INPUT.e_MAX; i++) {
                if (CoilInputs_For_Write[i] != -1) {
                    if (CoilInputs_For_Write[i] == 0) {
                        res |= WriteBit((ushort)i, CoilInputs_For_Write[i] == 1);
                    }
                    CoilInputs_For_Write[i] = -1;
                }
            }

            for (int i = 0; i < (int)e_HOLDING_REGISTER.e_MAX; i++) {
                if (m_usHoldingRegisteres_For_Write[i] != -1) {
                    res |= WriteWord((ushort)i, m_usHoldingRegisteres_For_Write[i]);
                    m_usHoldingRegisteres_For_Write[i] = -1;
                }
            }

            return res;
        }

        public void SetPulsePickerAlignment(eLaserAlignment eAlignment)
        {
            if (eAlignment == eLaserAlignment.NO) {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_PULSE_PICKER_ALIGNMENT_SYNC] = 0;
            } else {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_PULSE_PICKER_ALIGNMENT_SYNC] = 1;
            }
        }

        public void SetTrigger(eLaserTrigger eTrigger)
        {
            if (eTrigger == eLaserTrigger.EXTERNAL) {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_TRIGGER_SYNC] = 0;
            } else {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_TRIGGER_SYNC] = 1;
            }
        }

        public void SetPulsePickerTrigger(eLaserTrigger eTrigger)
        {
            if (eTrigger == eLaserTrigger.EXTERNAL) {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_PULSE_PICKER_TRIGGER_SYNC] = 0;
            } else {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_PULSE_PICKER_TRIGGER_SYNC] = 1;
            }
        }

        public void SetGate(eLaserGate eGate)
        {
            if (eGate == eLaserGate.EXTERNAL) {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_GATE_SYNC] = 0;
            } else {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_GATE_SYNC] = 1;
            }
        }

        public void SetAlignment(eLaserAlignment eAlignment)
        {
            if (eAlignment == eLaserAlignment.NO) {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_ALIGNMENT_SYNC] = 0;
            } else {
                CoilInputs_For_Write[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_ALIGNMENT_SYNC] = 1;
            }
        }

        public int SetWidth(short usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_WIDTH] = usValue;

            return 1;
        }

        public int SetDelay(short usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_DELAY] = usValue;

            return 1;
        }

        public int SetFrequency(short usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_FREQUENCY_SET] = usValue;

            return 1;
        }

        public int SetPulsePickerFrequencyMin(ushort usValue)
        {
            //HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_FREQUENCY_SET] = usValue;

            return 1;
        }

        public int SetTransmissionPercent(ushort usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_EFFICIENCY] = (short)usValue;

            return 1;
        }

        public int SetPulsePickerFrequency(short usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_PULSE_PICKER_FREQUENCY_SET] = usValue;

            return 1;
        }

        public int SetBurstMode(short usValue)
        {
            HoldingRegisteres_For_Write[(int)e_HOLDING_REGISTER.e_BURST_MODE] = usValue;

            return 1;
        }

        public ushort GetPulsePickerFrequency()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_PULSE_PICKER_FREQUENCY_SET];
        }

        public bool GetPulsePickerTrigger()
        {
            return CoilInputs[(int)e_COIL_INPUT.e_PULSE_PICKER_TRIGGER_SYNC];
        }

        public bool GetPulsePickerAlignment()
        {
            return CoilInputs[(int)e_COIL_INPUT.e_PULSE_PICKER_ALIGNMENT_SYNC];
        }

        public ushort GetBurstMode()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_BURST_MODE];
        }

        public ushort GetWidth()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_WIDTH];
        }

        public ushort GetDelay()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_DELAY];
        }

        public ushort GetFrequency()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_FREQUENCY_SET];
        }

        public bool GetTrigger()
        {
            return CoilInputs[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_TRIGGER_SYNC];
        }

        public bool GetGate()
        {
            return CoilInputs[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_GATE_SYNC];
        }

        public bool GetAlignment()
        {
            return CoilInputs[(int)e_COIL_INPUT.e_EXTERNAL_MODULATOR_ALIGNMENT_SYNC];
        }

        public ushort GetTransmissionPercent()
        {
            return HoldingRegisteres[(int)e_HOLDING_REGISTER.e_EXTERNAL_MODULATOR_EFFICIENCY];
        }
    }
}