using VTB.Interfaces;
using VTB.Framework.ComponentDevelopment;
using SignalBackPlane;
using SwitchModel = SysEDA.Components.Natural.CoreModels.IdealSwitch;
using SnubberModel = SysEDA.Components.Natural.CoreModels.SeriesRCCoreModel;

namespace SysEDA.Components.Natural
{
    /// <summary>
    /// Summary
    /// </summary>
    [ComponentMetaData("SysEDA.Components.Natural.Electrical.PowerElectronics.Inverters.InverterControlled3Ph1L.vte")]
    public class InverterControlled : NaturalSignalEngine
    {
        #region Data Members
        private IInteractionPoint m_oPositiveDC;
        private IInteractionPoint m_oNegativeDC;
        private IInteractionPoint m_oA;
        private IInteractionPoint m_oB;
        private IInteractionPoint m_oC;
        private IInteractionPoint m_oGates;

        private IInteractionPoint m_oACPower;
        private IInteractionPoint m_oCurrentA;
        private IInteractionPoint m_oCurrentB;
        private IInteractionPoint m_oCurrentC;
        private IInteractionPoint m_oDCCurrent;
        private IInteractionPoint m_oDCVoltage;
        private IInteractionPoint m_oDCPower;
        private IInteractionPoint m_oPowerA;
        private IInteractionPoint m_oPowerB;
        private IInteractionPoint m_oPowerC;
        private IInteractionPoint m_oVoltageA;
        private IInteractionPoint m_oVoltageB;
        private IInteractionPoint m_oVoltageC;

        private IInteractionPoint m_oSnubberResistance;
        private IInteractionPoint m_oSnubberCapacitance;

        private SwitchModel m_oS1;
        private SwitchModel m_oS2;
        private SwitchModel m_oS3;
        private SwitchModel m_oS4;
        private SwitchModel m_oS5;
        private SwitchModel m_oS6;

        private SnubberModel m_oSnub1;
        private SnubberModel m_oSnub2;
        private SnubberModel m_oSnub3;
        private SnubberModel m_oSnub4;
        private SnubberModel m_oSnub5;
        private SnubberModel m_oSnub6;


        private double[,] m_dGates;
        private bool[] m_bGates;

        private double m_dSnubberResistance;
        private double m_dSnubberCapacitance;

        #endregion

        #region Constructor
        public InverterControlled(IEntity oEntity)
            : base(oEntity, 2)
        {
            m_oPositiveDC = GetIP("PositiveDC");
            m_oNegativeDC = GetIP("NegativeDC");
            m_oA = GetIP("A");
            m_oB = GetIP("B");
            m_oC = GetIP("C");
            m_oGates = GetIP("Gates");

            m_oSnubberResistance = GetIP("SnubberResistance");
            m_oSnubberCapacitance = GetIP("SnubberCapacitance");

            m_oACPower = GetIP("ACPower");
            m_oCurrentA = GetIP("CurrentA");
            m_oCurrentB = GetIP("CurrentB");
            m_oCurrentC = GetIP("CurrentC");
            m_oDCCurrent = GetIP("DCCurrent");
            m_oDCVoltage = GetIP("DCVoltage");
            m_oDCPower = GetIP("DCPower");
            m_oPowerA = GetIP("PowerA");
            m_oPowerB = GetIP("PowerB");
            m_oPowerC = GetIP("PowerC");
            m_oVoltageA = GetIP("VoltageA");
            m_oVoltageB = GetIP("VoltageB");
            m_oVoltageC = GetIP("VoltageC");

            m_oS1 = new SwitchModel(m_oA, m_oPositiveDC);
            m_oS2 = new SwitchModel(m_oNegativeDC, m_oA);
            m_oS3 = new SwitchModel(m_oB, m_oPositiveDC);
            m_oS4 = new SwitchModel(m_oNegativeDC, m_oB);
            m_oS5 = new SwitchModel(m_oC, m_oPositiveDC);
            m_oS6 = new SwitchModel(m_oNegativeDC, m_oC);

            m_oSnub1 = new SnubberModel(m_oA, m_oPositiveDC);
            m_oSnub2 = new SnubberModel(m_oNegativeDC, m_oA);
            m_oSnub3 = new SnubberModel(m_oB, m_oPositiveDC);
            m_oSnub4 = new SnubberModel(m_oNegativeDC, m_oB);
            m_oSnub5 = new SnubberModel(m_oC, m_oPositiveDC);
            m_oSnub6 = new SnubberModel(m_oNegativeDC, m_oC);

            //AddCoreModel(m_oS1);
            //AddCoreModel(m_oS2);
            //AddCoreModel(m_oS3);
            //AddCoreModel(m_oS4);
            //AddCoreModel(m_oS5);
            //AddCoreModel(m_oS6);

            AddCoreModels(m_oS1, m_oS2, m_oS3, m_oS4, m_oS5, m_oS6);

            AddCoreModels(m_oSnub1, m_oSnub2, m_oSnub3, m_oSnub4, m_oSnub5, m_oSnub6);

            //AddCoreModels(m_oSnub1);
            //AddCoreModels(m_oSnub2);
            //AddCoreModels(m_oSnub3);
            //AddCoreModels(m_oSnub4);
            //AddCoreModels(m_oSnub5);
            //AddCoreModels(m_oSnub6);

            m_bGates = new bool[6];
        }
        #endregion

        #region Engine

        public override void OnSimulationStart()
        {
            base.OnSimulationStart();

            m_oS1.IsClosed = true;
            m_oS2.IsClosed = true;
            m_oS3.IsClosed = true;
            m_oS4.IsClosed = true;
            m_oS5.IsClosed = true;
            m_oS6.IsClosed = true;
        }

        public override void OnRunTimeChange(bool bParameterChanged)
        {
            base.OnRunTimeChange(bParameterChanged);

            if (bParameterChanged)
            {
                m_dSnubberCapacitance = GetIPValue(m_oSnubberCapacitance);
                m_dSnubberResistance = GetIPValue(m_oSnubberResistance);

                m_oSnub1.Resistance = m_dSnubberResistance;
                m_oSnub2.Resistance = m_dSnubberResistance;
                m_oSnub3.Resistance = m_dSnubberResistance;
                m_oSnub4.Resistance = m_dSnubberResistance;
                m_oSnub5.Resistance = m_dSnubberResistance;
                m_oSnub6.Resistance = m_dSnubberResistance;

                m_oSnub1.Capacitance = m_dSnubberCapacitance;
                m_oSnub2.Capacitance = m_dSnubberCapacitance;
                m_oSnub3.Capacitance = m_dSnubberCapacitance;
                m_oSnub4.Capacitance = m_dSnubberCapacitance;
                m_oSnub5.Capacitance = m_dSnubberCapacitance;
                m_oSnub6.Capacitance = m_dSnubberCapacitance;
            }
        }

        public override void SignalStep()
        {
            m_oGates.Primitive.GetData(out m_dGates);

            if (m_dGates.GetLength(0) > 1)
            {
                for (int i = 0; i < 6; i++)
                {
                    m_bGates[i] = false;
                    if(i < m_dGates.GetLength(0))
                    {
                        if (m_dGates[i, 0] > 0.0)
                        {
                            m_bGates[i] = true;
                        }
                    }
                }
            }
            else // try other dimension:
            {
                for (int i = 0; i < 6; i++)
                {
                    m_bGates[i] = false;
                    if (i < m_dGates.GetLength(1))
                    {
                        if (m_dGates[0, i] > 0.0)
                        {
                            m_bGates[i] = true;
                        }
                    }
                }
            }

            m_oS1.IsClosed = m_bGates[0];
            m_oS2.IsClosed = m_bGates[1];
            m_oS3.IsClosed = m_bGates[2];
            m_oS4.IsClosed = m_bGates[3];
            m_oS5.IsClosed = m_bGates[4];
            m_oS6.IsClosed = m_bGates[5];
        }


        public override void PostStep()
        {
            double dVoltageDC = GetAcrossDifference(m_oPositiveDC, m_oNegativeDC);
            double dCurrentDC = GetThrough(m_oPositiveDC);

            double dVoltageA = GetAcross(m_oA);
            double dVoltageB = GetAcross(m_oB);
            double dVoltageC = GetAcross(m_oC);
            double dCurrentA = -GetThrough(m_oA);
            double dCurrentB = -GetThrough(m_oB);
            double dCurrentC = -GetThrough(m_oC);

            double dPowerA = dVoltageA * dCurrentA;
            double dPowerB = dVoltageB * dCurrentB;
            double dPowerC = dVoltageC * dCurrentC;

            SetIPValue(m_oDCVoltage, dVoltageDC);
            SetIPValue(m_oDCCurrent, dCurrentDC);
            SetIPValue(m_oDCPower, dVoltageDC * dCurrentDC);

            SetIPValue(m_oVoltageA, dVoltageA);
            SetIPValue(m_oVoltageB, dVoltageB);
            SetIPValue(m_oVoltageC, dVoltageC);
            SetIPValue(m_oCurrentA, dCurrentA);
            SetIPValue(m_oCurrentB, dCurrentB);
            SetIPValue(m_oCurrentC, dCurrentC);
            SetIPValue(m_oPowerA, dPowerA);
            SetIPValue(m_oPowerB, dPowerB);
            SetIPValue(m_oPowerC, dPowerC);
            SetIPValue(m_oACPower, dPowerA + dPowerB + dPowerC);

        }
        #endregion

    }
}