using Config.Entities;
///
/// Copyright (c) 2020-2021 Sensus Slovensko a.s.
///
using System.Collections.Generic;
using System.Linq;
using System.Xml.Serialization;
using Common;
using TBF.Rig.Generic;

namespace TBF.Rig.ControlBoard.Papouch
{
    public enum QuidoVariant
    {
        None,
        QuidoRS_4_4,
        QuidoRS_8_8,
        QuidoRS_2_16,
        QuidoRS_2_32,
        Count
    }

    public class PapouchCBCfg : ComponentCfgBase, Generic.IChildComponentCfg, IParamsProvider
    {
        public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(PapouchCBCfg) })[0];
        public override XmlSerializer GetSerializer() { return Serializer; }

        public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities)
        {
            var parents = cmpntEntities.Where(x => x.ClassName == "Modbus.Common");
            return new Configs.ParamsProvider.ComponentCfgCtrl(this, parents);
        }

        ///
        /// Serialized parameters 
        ///
        public QuidoVariant Variant1;       /// None, QuidoRS_4_4, QuidoRS_8_8, QuidoRS_2_16 or QuidoRS_2_32
        public int ModbusAddress1;		    /// 1 .. 254
        public int OffsetOutputs1;          /// 0 .. (128 - output bits count)
        public int OffsetInputs1;           /// 0 .. (128 - input bits count)

        public QuidoVariant Variant2;       /// None, QuidoRS_4_4, QuidoRS_8_8, QuidoRS_2_16 or QuidoRS_2_32
        public int ModbusAddress2;		    /// 1 .. 254
        public int OffsetOutputs2;          /// 0 .. (128 - output bits count)
        public int OffsetInputs2;           /// 0 .. (128 - input bits count)

        public QuidoVariant Variant3;       /// None, QuidoRS_4_4, QuidoRS_8_8, QuidoRS_2_16 or QuidoRS_2_32
        public int ModbusAddress3;		    /// 1 .. 254
        public int OffsetOutputs3;          /// 0 .. (128 - output bits count)
        public int OffsetInputs3;           /// 0 .. (128 - input bits count)

        public QuidoVariant Variant4;       /// None, QuidoRS_4_4, QuidoRS_8_8, QuidoRS_2_16 or QuidoRS_2_32
        public int ModbusAddress4;		    /// 1 .. 254
        public int OffsetOutputs4;          /// 0 .. (128 - output bits count)
        public int OffsetInputs4;           /// 0 .. (128 - input bits count)

        /// Private parameterless constructor invoked by all other (public) constructors
        PapouchCBCfg() { }

        public PapouchCBCfg(IComponentFactory factory)
            : this()
        {
            Name = "CB";
            ParentName = "Modbus";
            InitializeAll();
        }

        public string ComponentName { get { return Name; } }

        public void InitializeAll()
        {
            Variant1 = QuidoVariant.QuidoRS_8_8;
            ModbusAddress1 = 1;
            OffsetOutputs1 = 0;
            OffsetInputs1 = 64;

            Variant2 = QuidoVariant.None;
            ModbusAddress2 = 0;
            OffsetOutputs2 = 0;
            OffsetInputs2 = 0;

            Variant3 = QuidoVariant.None;
            ModbusAddress3 = 0;
            OffsetOutputs3 = 0;
            OffsetInputs3 = 0;

            Variant4 = QuidoVariant.None;
            ModbusAddress4 = 0;
            OffsetOutputs4 = 0;
            OffsetInputs4 = 0;
        }

        string[] paramNames = new string[]
        {
            "Board 1: Variant",            /// 0
            "Board 1: Modbus address",     /// 1
            "Board 1: Offset outputs",     /// 2
            "Board 1: Offset inputs",      /// 3
            "Board 2: Variant",            /// 4
            "Board 2: Modbus address",     /// 5
            "Board 2: Offset outputs",     /// 6
            "Board 2: Offset inputs",      /// 7
            "Board 3: Variant",            /// 8
            "Board 3: Modbus address",     /// 9
            "Board 3: Offset outputs",     /// 10
            "Board 3: Offset inputs",      /// 11
            "Board 4: Variant",            /// 12
            "Board 4: Modbus address",     /// 13
            "Board 4: Offset outputs",     /// 14
            "Board 4: Offset inputs",      /// 15
        };
        public string ParamName(int i) { return paramNames[i]; }
        public int ParamsCount() { return paramNames.Length; }

        public ICollection<string> ParamValues(int i)
        {
            switch (i)
            {
                case 0:
                case 4:
                case 8:
                case 12:
                    return new string[] { QuidoVariant.None.ToString(),
                                          QuidoVariant.QuidoRS_4_4.ToString(),
                                          QuidoVariant.QuidoRS_8_8.ToString(),
                                          QuidoVariant.QuidoRS_2_16.ToString(),
                                          QuidoVariant.QuidoRS_2_32.ToString() };
                default:
                    return null;
            }
        }

        public string ToString(int i)
        {
            switch (i)
            {
                case 0: return Variant1.ToString();
                case 1: return ModbusAddress1.ToString();
                case 2: return OffsetOutputs1.ToString();
                case 3: return OffsetInputs1.ToString();

                case 4: return Variant2.ToString();
                case 5: return ModbusAddress2.ToString();
                case 6: return OffsetOutputs2.ToString();
                case 7: return OffsetInputs2.ToString();

                case 8: return Variant3.ToString();
                case 9: return ModbusAddress3.ToString();
                case 10: return OffsetOutputs3.ToString();
                case 11: return OffsetInputs3.ToString();

                case 12: return Variant4.ToString();
                case 13: return ModbusAddress4.ToString();
                case 14: return OffsetOutputs4.ToString();
                case 15: return OffsetInputs4.ToString();

                default:
                    return string.Format("name={0}({1}) {2}/a{3}/o{4}/i{5}  {6}/a{7}/o{8}/i{9}  {10}/a{11}/o{12}/i{13}  {14}/a{15}/o{16}/i{17}",
                                          Name, (string.IsNullOrEmpty(ParentName) ? "-" : ParentName),
                                          Variant1, ModbusAddress1, OffsetOutputs1, OffsetInputs1,
                                          Variant2, ModbusAddress2, OffsetOutputs2, OffsetInputs2,
                                          Variant3, ModbusAddress3, OffsetOutputs3, OffsetInputs3,
                                          Variant4, ModbusAddress4, OffsetOutputs4, OffsetInputs4);
            }
        }

        public CfgUpdateFlags UpdateParam(int i, string str)
        {
            switch (i)
            {
                case 0:
                    foreach (var v in new QuidoVariant[] { QuidoVariant.QuidoRS_4_4, QuidoVariant.QuidoRS_8_8, QuidoVariant.QuidoRS_2_16, QuidoVariant.QuidoRS_2_32 })
                    {
                        if (str == v.ToString())
                        {
                            Variant1 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    Variant1 = QuidoVariant.None;
                    return CfgUpdateFlags.None;

                case 1: ModbusAddress1 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 2: OffsetOutputs1 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 3: OffsetInputs1 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;

                case 4:
                    foreach (var v in new QuidoVariant[] { QuidoVariant.QuidoRS_4_4, QuidoVariant.QuidoRS_8_8, QuidoVariant.QuidoRS_2_16, QuidoVariant.QuidoRS_2_32 })
                    {
                        if (str == v.ToString())
                        {
                            Variant2 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    Variant2 = QuidoVariant.None;
                    return CfgUpdateFlags.None;

                case 5: ModbusAddress2 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 6: OffsetOutputs2 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 7: OffsetInputs2 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                
                case 8:
                    foreach (var v in new QuidoVariant[] { QuidoVariant.QuidoRS_4_4, QuidoVariant.QuidoRS_8_8, QuidoVariant.QuidoRS_2_16, QuidoVariant.QuidoRS_2_32 })
                    {
                        if (str == v.ToString())
                        {
                            Variant3 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    Variant3 = QuidoVariant.None;
                    return CfgUpdateFlags.None;

                case 9: ModbusAddress3 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 10: OffsetOutputs3 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 11: OffsetInputs3 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                
                case 12:
                    foreach (var v in new QuidoVariant[] { QuidoVariant.QuidoRS_4_4, QuidoVariant.QuidoRS_8_8, QuidoVariant.QuidoRS_2_16, QuidoVariant.QuidoRS_2_32 })
                    {
                        if (str == v.ToString())
                        {
                            Variant4 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    Variant4 = QuidoVariant.None;
                    return CfgUpdateFlags.None;

                case 13: ModbusAddress4 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 14: OffsetOutputs4 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                case 15: OffsetInputs4 = (byte)int.Parse(str); return CfgUpdateFlags.RestartRqrd;
                default: return CfgUpdateFlags.None;
            }
        }

        public bool ValidateParam(int i, string str, out string message)
        {
            message = string.Empty;
            int idummy;

            switch (i)
            {
                case 0:
                case 4:
                case 8:
                case 12:
                    if (ParamValues(i).Contains(str)) return true;
                    break;

                case 1:
                case 5:
                case 9:
                case 13:
                    if (int.TryParse(str, out idummy) && idummy >= 1 && idummy <= 254) return true;
                    break;

                case 2:
                case 3:
                case 6:
                case 7:
                case 10:
                case 11:
                case 14:
                case 15:
                    if (int.TryParse(str, out idummy) && idummy >= 0 && idummy <= 127) return true;
                    break;

                default:
                    message = "Invalid index";
                    return false;
            }

            message = ParamName(i) + " is invalid";
            return false;
        }

        void CopyContentTo(PapouchCBCfg prms)
        {
            prms.ParentName = ParentName;
            prms.Variant1 = Variant1;
            prms.ModbusAddress1 = ModbusAddress1;
            prms.OffsetOutputs1 = OffsetOutputs1;
            prms.OffsetInputs1 = OffsetInputs1;
            prms.Variant2 = Variant2;
            prms.ModbusAddress2 = ModbusAddress2;
            prms.OffsetOutputs2 = OffsetOutputs2;
            prms.OffsetInputs2 = OffsetInputs2;
            prms.Variant3 = Variant3;
            prms.ModbusAddress3 = ModbusAddress3;
            prms.OffsetOutputs3 = OffsetOutputs3;
            prms.OffsetInputs3 = OffsetInputs3;
            prms.Variant4 = Variant4;
            prms.ModbusAddress4 = ModbusAddress4;
            prms.OffsetOutputs4 = OffsetOutputs4;
            prms.OffsetInputs4 = OffsetInputs4;
        }

        public IParamsProvider Clone()
        {
            PapouchCBCfg pars = new PapouchCBCfg();
            CopyContentTo(pars);
            return pars;
        }

        public bool UpdateEmbeddedDbEntity()
        {
            return true;    /// =OK, do nothing
        }
    }
}