///
/// Copyright (c) 2023 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using Common;
using Config;
using Config.Entities;
using TBF.Resources;
using TBF.Rig.Generic;

namespace TBF.Rig.DataEntry.Uni
{
    public enum Sz
    {
        [Description("Small")]  S,
        [Description("Medium")] M,
        [Description("Large")]  L,
        Count,
    }

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

        public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities)
        {
            return new Configs.ParamsProvider.ComponentCfgCtrl(this, null);
        }

		///
		/// Serialized parameters
		///
        public bool     BgShowForm;             /// 0
        public string   BgTitle;                /// 1
        public Sz       BgSize;                 /// 2
        //     int      BgItemsCount;           /// 3
        //     int      BgColumnsCount;         /// 4
        public bool     BgIsLrOrder;            /// 5
        public bool     BgIsVertArrangement;    /// 6
        public string   BgFormCloseKeys;        /// 7
                        
        public bool     EnShowForm;             /// 8
        public string   EnTitle;                /// 9
        public Sz       EnSize;                 /// 10
        //     int      EnItemsCount;           /// 11
        //     int      EnColumnsCount;         /// 12
        public bool     EnIsLrOrder;            /// 13
        public bool     EnIsVertArrangement;    /// 14
        public string   EnFormCloseKeys;        /// 15
                        
        public bool     TestStartEndShowForm;   /// 16
        public string   TestTitle;              /// 17
        public Sz       TestSize;               /// 18
        //     int      TestColumnsCount;       /// 19
        public bool     TestStartBoxAlwaysEn;   /// 20
        public bool     TestIsLrOrder;          /// 21
        public bool     TestIsVertArrangement;  /// 22
        public string   TestFormCloseKeys;      /// 23

        public Ct[]     BgItemContent;          /// 24 + 4 * ix
        public string[] BgItemCaption;          /// 25 + 4 * ix
        public Ac[]     BgItemAction;           /// 26 + 4 * ix
        public int[]    BgItemWidth;            /// 27 + 4 * ix

        public Ct[]     BgColumnContent;        /// 24 + 4 * ix
        public string[] BgColumnCaption;        /// 25 + 4 * ix
        public Ac[]     BgColumnAction;         /// 26 + 4 * ix
        public int[]    BgColumnWidth;          /// 27 + 4 * ix

        public Ct[]     EnItemContent;          /// 24 + 4 * ix
        public string[] EnItemCaption;          /// 25 + 4 * ix
        public Ac[]     EnItemAction;           /// 26 + 4 * ix
        public int[]    EnItemWidth;            /// 27 + 4 * ix

        public Ct[]     EnColumnContent;        /// 24 + 4 * ix
        public string[] EnColumnCaption;        /// 25 + 4 * ix
        public Ac[]     EnColumnAction;         /// 26 + 4 * ix
        public int[]    EnColumnWidth;          /// 27 + 4 * ix

        public Ct[]     TestColumnContent;      /// 24 + 4 * ix
        public string[] TestColumnCaption;      /// 25 + 4 * ix
        public Ac[]     TestColumnAction;       /// 26 + 4 * ix
        public int[]    TestColumnWidth;        /// 27 + 4 * ix

        ///
        /// Not serialized
        ///
        int oriBgItemsCount = -1;
        int oriBgColumnsCount = -1;
        int oriEnItemsCount = -1;
        int oriEnColumnsCount = -1;
        int oriTestColumnsCount = -1;

        ///
        /// Wrappers
        ///
        public int GetBgItemsCount() { return (BgItemContent == null) ? 0 : BgItemContent.Length; }
        public int GetBgColumnsCount() { return (BgColumnContent == null) ? 0 : BgColumnContent.Length; }
        public int GetEnItemsCount() { return (EnItemContent == null) ? 0 : EnItemContent.Length; }
        public int GetEnColumnsCount() { return (EnColumnContent == null) ? 0 : EnColumnContent.Length; }
        public int GetTestColumnsCount() { return (TestColumnContent == null) ? 0 : TestColumnContent.Length; }
        /// 
        void SetBgItemsCount(int newCount)
        {
            if (oriBgItemsCount < 0) oriBgItemsCount = GetBgItemsCount();
            if (newCount == GetBgItemsCount()) return;

            int oldCount = (BgItemContent == null) ? 0 : BgItemContent.Length;
            var oldContent = BgItemContent;
            var oldCaption = BgItemCaption;
            var oldAction  = BgItemAction;
            var oldWidth   = BgItemWidth;

            BgItemContent = new Ct[newCount];
            BgItemCaption = new string[newCount];
            BgItemAction = new Ac[newCount];
            BgItemWidth = new int[newCount];

            for (int i = 0; i < newCount; i++)
            {
                if (i < oldCount)
                {
                    BgItemContent[i] = oldContent[i];
                    BgItemCaption[i] = oldCaption[i];
                    BgItemAction[i] = oldAction[i];
                    BgItemWidth[i] = oldWidth[i];
                }
                else
                {
                    BgItemContent[i] = Ct.None;
                    BgItemCaption[i] = string.Empty;
                    BgItemAction[i] = Ac.Clear;
                    BgItemWidth[i] = 0;
                }
            }
        }
        /// 
        void SetBgColumnsCount(int newCount)
        {
            if (oriBgColumnsCount < 0) oriBgColumnsCount = GetBgColumnsCount();
            if (newCount == GetBgColumnsCount()) return;

            int oldCount = (BgColumnContent == null) ? 0 : BgColumnContent.Length;
            var oldContent = BgColumnContent;
            var oldCaption = BgColumnCaption;
            var oldAction = BgColumnAction;
            var oldWidth = BgColumnWidth;

            BgColumnContent = new Ct[newCount];
            BgColumnCaption = new string[newCount];
            BgColumnAction = new Ac[newCount];
            BgColumnWidth = new int[newCount];

            for (int i = 0; i < newCount; i++)
            {
                if (i < oldCount)
                {
                    BgColumnContent[i] = oldContent[i];
                    BgColumnCaption[i] = oldCaption[i];
                    BgColumnAction[i] = oldAction[i];
                    BgColumnWidth[i] = oldWidth[i];
                }
                else
                {
                    BgColumnContent[i] = Ct.None;
                    BgColumnCaption[i] = string.Empty;
                    BgColumnAction[i] = Ac.Clear;
                    BgColumnWidth[i] = 0;
                }
            }
        }
        /// 
        void SetEnItemsCount(int newCount)
        {
            if (oriEnItemsCount < 0) oriEnItemsCount = GetEnItemsCount();
            if (newCount == GetEnItemsCount()) return;

            int oldCount = (EnItemContent == null) ? 0 : EnItemContent.Length;
            var oldContent = EnItemContent;
            var oldCaption = EnItemCaption;
            var oldAction = EnItemAction;
            var oldWidth = EnItemWidth;

            EnItemContent = new Ct[newCount];
            EnItemCaption = new string[newCount];
            EnItemAction = new Ac[newCount];
            EnItemWidth = new int[newCount];

            for (int i = 0; i < newCount; i++)
            {
                if (i < oldCount)
                {
                    EnItemContent[i] = oldContent[i];
                    EnItemCaption[i] = oldCaption[i];
                    EnItemAction[i] = oldAction[i];
                    EnItemWidth[i] = oldWidth[i];
                }
                else
                {
                    EnItemContent[i] = Ct.None;
                    EnItemCaption[i] = string.Empty;
                    EnItemAction[i] = Ac.Clear;
                    EnItemWidth[i] = 0;
                }
            }
        }
        /// 
        void SetEnColumnsCount(int newCount)
        {
            if (oriEnColumnsCount < 0) oriEnColumnsCount = GetEnColumnsCount();
            if (newCount == GetEnColumnsCount()) return;

            int oldCount = (EnColumnContent == null) ? 0 : EnColumnContent.Length;
            var oldContent = EnColumnContent;
            var oldCaption = EnColumnCaption;
            var oldAction = EnColumnAction;
            var oldWidth = EnColumnWidth;

            EnColumnContent = new Ct[newCount];
            EnColumnCaption = new string[newCount];
            EnColumnAction = new Ac[newCount];
            EnColumnWidth = new int[newCount];

            for (int i = 0; i < newCount; i++)
            {
                if (i < oldCount)
                {
                    EnColumnContent[i] = oldContent[i];
                    EnColumnCaption[i] = oldCaption[i];
                    EnColumnAction[i] = oldAction[i];
                    EnColumnWidth[i] = oldWidth[i];
                }
                else
                {
                    EnColumnContent[i] = Ct.None;
                    EnColumnCaption[i] = string.Empty;
                    EnColumnAction[i] = Ac.Clear;
                    EnColumnWidth[i] = 0;
                }
            }
        }
        /// 
        void SetTestColumnsCount(int newCount)
        {
            if (oriTestColumnsCount < 0) oriTestColumnsCount = GetTestColumnsCount();
            if (newCount == GetTestColumnsCount()) return;

            int oldCount = (TestColumnContent == null) ? 0 : TestColumnContent.Length;
            var oldContent = TestColumnContent;
            var oldCaption = TestColumnCaption;
            var oldAction = TestColumnAction;
            var oldWidth = TestColumnWidth;

            TestColumnContent = new Ct[newCount];
            TestColumnCaption = new string[newCount];
            TestColumnAction = new Ac[newCount];
            TestColumnWidth = new int[newCount];

            for (int i = 0; i < newCount; i++)
            {
                if (i < oldCount)
                {
                    TestColumnContent[i] = oldContent[i];
                    TestColumnCaption[i] = oldCaption[i];
                    TestColumnAction[i] = oldAction[i];
                    TestColumnWidth[i] = oldWidth[i];
                }
                else
                {
                    TestColumnContent[i] = Ct.None;
                    TestColumnCaption[i] = string.Empty;
                    TestColumnAction[i] = Ac.Clear;
                    TestColumnWidth[i] = 0;
                }
            }
        }
        /// 
        int GetOriBgItemsCount()
        {
            if (oriBgItemsCount < 0) oriBgItemsCount = GetBgItemsCount();
            return oriBgItemsCount;
        }
        int GetOriBgColumnsCount()
        {
            if (oriBgColumnsCount < 0) oriBgColumnsCount = GetBgColumnsCount();
            return oriBgColumnsCount;
        }
        int GetOriEnItemsCount()
        {
            if (oriEnItemsCount < 0) oriEnItemsCount = GetEnItemsCount();
            return oriEnItemsCount;
        }
        int GetOriEnColumnsCount()
        {
            if (oriEnColumnsCount < 0) oriEnColumnsCount = GetEnColumnsCount();
            return oriEnColumnsCount;
        }
        int GetOriTestColumnsCount()
        {
            if (oriTestColumnsCount < 0) oriTestColumnsCount = GetTestColumnsCount();
            return oriTestColumnsCount;
        }


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

        public EntryFormCfg(IComponentFactory factory, string name)
            : this()
        {
            this.Factory = factory;
            this.Name = name;
            ParentName = string.Empty;
            InitializeAll();
        }

        public string ComponentName { get { return Name; } }

        public void InitializeAll()
        {
            BgShowForm = true;
            BgTitle = "Enter water meter data";
            BgSize = Sz.M;
            BgIsLrOrder = false;
            BgIsVertArrangement = false;
            BgFormCloseKeys = string.Empty;

            EnShowForm = false;
            EnTitle = "Enter water meter data";
            EnSize = Sz.M;
            EnIsLrOrder = false;
            EnIsVertArrangement = false;
            EnFormCloseKeys = string.Empty;

            TestStartEndShowForm = true;
            TestTitle = "Enter states of water meters";
            TestSize = Sz.M;
            TestStartBoxAlwaysEn = false;
            TestIsLrOrder = false;
            TestIsVertArrangement = false;
            TestFormCloseKeys = string.Empty;

            BgItemContent = new Ct[1] { Ct.BatchAndWmOrder };
            BgItemCaption = new string[1] { "Order nr." };
            BgItemAction = new Ac[1] { Ac.Clear };
            BgItemWidth = new int[1] { 200 };

            BgColumnContent = new Ct[1] { Ct.SerialNr };
            BgColumnCaption = new string[1] { "S/N" };
            BgColumnAction = new Ac[1] { Ac.Clear };
            BgColumnWidth = new int[1] { 200 };

            EnItemContent = new Ct[2] { Ct.BatchAndWmOrder, Ct.BatchRemark };
            EnItemCaption = new string[2] { "Order nr.","Remark" };
            EnItemAction = new Ac[2] { Ac.LoadReadOnly, Ac.HistoryLast };
            EnItemWidth = new int[2] { 200, 200 };

            EnColumnContent = new Ct[2] { Ct.SerialNr, Ct.EndState };
            EnColumnCaption = new string[2] { "S/N", "End state" };
            EnColumnAction = new Ac[2] { Ac.LoadReadOnly, Ac.Clear };
            EnColumnWidth = new int[2] { 200, 200 };

            TestColumnContent = new Ct[3] { Ct.SerialNr, Ct.StartState, Ct.EndState };
            TestColumnCaption = new string[3] { "S/N", "Start state", "End state" };
            TestColumnAction = new Ac[3] { Ac.LoadReadOnly, Ac.Clear, Ac.Clear };
            TestColumnWidth = new int[3] { 200, 200, 200 };
        }

        string[] paramNames = new string[]
		{
            "Beginning: Show form",
            "Beginning: Form title",
            "Beginning: Font ize",
            "Beginning: Common items count",
            "Beginning: Columns count",
            "Beginning: Left-to-right order",
            "Beginning: Vertical arrangement",
            "Beginning: Keys to close the form",

            "End: Show form",
            "End: Form title",
            "End: Font size",
            "End: Common items count",
            "End: Columns count",
            "End: Left-to-right order",
            "End: Vertical arrangement",
            "End: Keys to close the form",
            
            "Test start/end: Show form",
            "Test start/end: Form title",
            "Test start/end: Font size",
            "Test start/end: Columns count",
            "Test start/end: Start text box always enabled",
            "Test start/end: Left-to-right order",
            "Test start/end: Vertical arrangement",
            "Test start/end: Keys to close the form",
        };
        public string ParamName(int i)
        {
            if (i < paramNames.Length) return paramNames[i];
            int ix = i - paramNames.Length;

            if (ix < 4 * GetOriBgItemsCount())
            {
                int j = ix / 4 + 1;
                switch (ix % 4)
                {
                    case 0: return string.Format("Beginning: Item {0} content", j);
                    case 1: return string.Format("Beginning: Item {0} caption", j);
                    case 2: return string.Format("Beginning: Item {0} action", j);
                    case 3: return string.Format("Beginning: Item {0} width", j);
                }
            }
            ix -= 4 * GetOriBgItemsCount();

            if (ix < 4 * GetOriBgColumnsCount())
            {
                char c = Convert.ToChar(ix / 4 + 65);
                switch (ix % 4)
                {
                    case 0: return string.Format("Beginning: Column {0} content", c);
                    case 1: return string.Format("Beginning: Column {0} caption", c);
                    case 2: return string.Format("Beginning: Column {0} action", c);
                    case 3: return string.Format("Beginning: Column {0} width", c);
                }
            }
            ix -= 4 * GetOriBgColumnsCount();

            if (ix < 4 * GetOriEnItemsCount())
            {
                int j = ix / 4 + 1;
                switch (ix % 4)
                {
                    case 0: return string.Format("End: Item {0} content", j);
                    case 1: return string.Format("End: Item {0} caption", j);
                    case 2: return string.Format("End: Item {0} action", j);
                    case 3: return string.Format("End: Item {0} width", j);
                }
            }
            ix -= 4 * GetOriEnItemsCount();

            if (ix < 4 * GetOriEnColumnsCount())
            {
                char c = Convert.ToChar(ix / 4 + 65);
                switch (ix % 4)
                {
                    case 0: return string.Format("End: Column {0} content", c);
                    case 1: return string.Format("End: Column {0} caption", c);
                    case 2: return string.Format("End: Column {0} action", c);
                    case 3: return string.Format("End: Column {0} width", c);
                }
            }
            ix -= 4 * GetOriEnColumnsCount();

            if (ix < 4 * GetOriTestColumnsCount())
            {
                char c = Convert.ToChar(ix / 4 + 65);
                switch (ix % 4)
                {
                    case 0: return string.Format("Test start/end: Column {0} content", c);
                    case 1: return string.Format("Test start/end: Column {0} caption", c);
                    case 2: return string.Format("Test start/end: Column {0} action", c);
                    case 3: return string.Format("Test start/end: Column {0} width", c);
                }
            }

            return string.Empty;
        }

        public int ParamsCount()
        {
            int itemsCount = GetOriBgItemsCount() + GetOriBgColumnsCount()
                           + GetOriEnItemsCount() + GetOriEnColumnsCount() + GetOriTestColumnsCount();
            return paramNames.Length + 4 * itemsCount;
        }

        public ICollection<string> ParamValues(int i)
        {
            var list = new List<string>();

            if (i < paramNames.Length)
            {
                switch (i)
                {
                    case 0:
                    case 5:
                    case 6:
                    case 8:
                    case 13:
                    case 14:
                    case 16:
                    case 20:
                    case 21:
                    case 22:
                        return new string[] { Strings.yes, Strings.no };
                    case 2:
                    case 10:
                    case 18:
                        for (Sz sz = 0; sz < Sz.Count; sz++) list.Add(sz.ToDescription());
                        return list;
                    default:
                        return null;
                }
            }

            i -= paramNames.Length;

            switch (i % 4)
            {
                case 0:
                    bool isCommon = (i < 4 * GetOriBgItemsCount())
                        || (i >= 4 * (GetOriBgItemsCount() + GetOriBgColumnsCount())
                          && i < 4 * (GetOriBgItemsCount() + GetOriBgColumnsCount() + GetOriEnItemsCount()));
                    if (isCommon)
                    {
                        return new string[]
                        {
                            Ct.None.ToDescription(),
                            Ct.YearOfCalibration.ToDescription(),
                            Ct.ArchivePath.ToDescription(),
                            Ct.BatchOrder.ToDescription(),
                            Ct.BatchAndWmOrder.ToDescription(),
                            Ct.BatchRemark.ToDescription(),
                            Ct.BatchAndWmRemark.ToDescription(),
                        };
                    }
                    else
                    {
                        return new string[]
                        {
                            Ct.None.ToDescription(),
                            Ct.SerialNr.ToDescription(),
                            Ct.SerialNrAux.ToDescription(),
                            Ct.RadioAddress.ToDescription(),
                            Ct.YearOfCalibration.ToDescription(),
                            Ct.StartState.ToDescription(),
                            Ct.StartStateAux.ToDescription(),
                            Ct.EndState.ToDescription(),
                            Ct.EndStateAux.ToDescription(),
                            Ct.ArchivePath.ToDescription(),
                            Ct.WmOrder.ToDescription(),
                            Ct.WmRemark.ToDescription(),
                            Ct.PrintLabel.ToDescription(),
                        };
                    }
                case 2:
                    for (Ac a = 0; a < Ac.Count; a++) list.Add(a.ToDescription());
                    return list;
                case 1:
                case 3:
                default:
                    return null;
            }
        }

        public string ToString(int i)
        {
            if (i < 0)
            {
                return string.Format("Name={0}, Show cycle beginning form={1}, Show cycle end form={2}",
                                     Name, BgShowForm, EnShowForm);
            }
            
            if (i < paramNames.Length)
            {
                switch (i)
                {
                    case 0: return BgShowForm ? Strings.yes : Strings.no;
                    case 1: return BgTitle;
                    case 2: return BgSize.ToDescription();
                    case 3: return GetBgItemsCount().ToString();
                    case 4: return GetBgColumnsCount().ToString();
                    case 5: return BgIsLrOrder ? Strings.yes : Strings.no;
                    case 6: return BgIsVertArrangement ? Strings.yes : Strings.no;
                    case 7: return BgFormCloseKeys;

                    case 8: return EnShowForm ? Strings.yes : Strings.no;
                    case 9: return EnTitle;
                    case 10: return EnSize.ToDescription();
                    case 11: return GetEnItemsCount().ToString();
                    case 12: return GetEnColumnsCount().ToString();
                    case 13: return EnIsLrOrder ? Strings.yes : Strings.no;
                    case 14: return EnIsVertArrangement ? Strings.yes : Strings.no;
                    case 15: return EnFormCloseKeys;

                    case 16: return TestStartEndShowForm ? Strings.yes : Strings.no;
                    case 17: return TestTitle;
                    case 18: return TestSize.ToDescription();
                    case 19: return GetTestColumnsCount().ToString();
                    case 20: return TestStartBoxAlwaysEn ? Strings.yes : Strings.no;
                    case 21: return TestIsLrOrder ? Strings.yes : Strings.no;
                    case 22: return TestIsVertArrangement ? Strings.yes : Strings.no;
                    case 23: return TestFormCloseKeys;

                    default: return string.Empty;
                }
            }

            int ix = i - paramNames.Length;

            if (ix < 4 * GetOriBgItemsCount())
            {
                int j = ix / 4;
                switch (ix % 4)
                {
                    case 0: return (j < GetBgItemsCount()) ? BgItemContent[j].ToDescription() : Ct.None.ToDescription();
                    case 1: return (j < GetBgItemsCount()) ? BgItemCaption[j] : string.Empty;
                    case 2: return (j < GetBgItemsCount()) ? BgItemAction[j].ToDescription() : Ac.Clear.ToDescription();
                    case 3: return (j < GetBgItemsCount()) ? BgItemWidth[j].ToString() : "0";
                }
            }
            ix -= 4 * GetOriBgItemsCount();

            if (ix < 4 * GetOriBgColumnsCount())
            {
                int j = ix / 4;
                switch (ix % 4)
                {
                    case 0: return (j < GetBgColumnsCount()) ? BgColumnContent[j].ToDescription() : Ct.None.ToDescription();
                    case 1: return (j < GetBgColumnsCount()) ? BgColumnCaption[j] : string.Empty;
                    case 2: return (j < GetBgColumnsCount()) ? BgColumnAction[j].ToDescription() : Ac.Clear.ToDescription();
                    case 3: return (j < GetBgColumnsCount()) ? BgColumnWidth[j].ToString() : "0";
                }
            }
            ix -= 4 * GetOriBgColumnsCount();

            if (ix < 4 * GetOriEnItemsCount())
            {
                int j = ix / 4;
                switch (ix % 4)
                {
                    case 0: return (j < GetEnItemsCount()) ? EnItemContent[j].ToDescription() : Ct.None.ToDescription();
                    case 1: return (j < GetEnItemsCount()) ? EnItemCaption[j] : string.Empty;
                    case 2: return (j < GetEnItemsCount()) ? EnItemAction[j].ToDescription() : Ac.Clear.ToDescription();
                    case 3: return (j < GetEnItemsCount()) ? EnItemWidth[j].ToString() : "0";
                }
            }
            ix -= 4 * GetOriEnItemsCount();

            if (ix < 4 * GetOriEnColumnsCount())
            {
                int j = ix / 4;
                switch (ix % 4)
                {
                    case 0: return (j < GetEnColumnsCount()) ? EnColumnContent[j].ToDescription() : Ct.None.ToDescription();
                    case 1: return (j < GetEnColumnsCount()) ? EnColumnCaption[j] : string.Empty;
                    case 2: return (j < GetEnColumnsCount()) ? EnColumnAction[j].ToDescription() : Ac.Clear.ToDescription();
                    case 3: return (j < GetEnColumnsCount()) ? EnColumnWidth[j].ToString() : "0";
                }
            }
            ix -= 4 * GetOriEnColumnsCount();

            if (ix < 4 * GetOriTestColumnsCount())
            {
                int j = ix / 4;
                switch (ix % 4)
                {
                    case 0: return (j < GetTestColumnsCount()) ? TestColumnContent[j].ToDescription() : Ct.None.ToDescription();
                    case 1: return (j < GetTestColumnsCount()) ? TestColumnCaption[j] : string.Empty;
                    case 2: return (j < GetTestColumnsCount()) ? TestColumnAction[j].ToDescription() : Ac.Clear.ToDescription();
                    case 3: return (j < GetTestColumnsCount()) ? TestColumnWidth[j].ToString() : "0";
                }
            }

            return string.Empty;
        }


        public CfgUpdateFlags UpdateParam(int i, string str)
        {
            if (i < paramNames.Length)
            {
                switch (i)
                {
                    case 0: BgShowForm = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 1: BgTitle = str; return CfgUpdateFlags.RestartRqrd;
                    case 2:
                        for (Sz sz = 0; sz < Sz.Count; sz++)
                        {
                            if (str == sz.ToDescription())
                            {
                                BgSize = sz;
                                return CfgUpdateFlags.RestartRqrd;
                            }
                        }
                        return CfgUpdateFlags.None;
                    case 3: SetBgItemsCount(int.Parse(str)); return CfgUpdateFlags.RestartRqrd;
                    case 4: SetBgColumnsCount(int.Parse(str)); return CfgUpdateFlags.RestartRqrd;
                    case 5: BgIsLrOrder = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 6: BgIsVertArrangement = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 7: BgFormCloseKeys = str; return CfgUpdateFlags.RestartRqrd;

                    case 8: EnShowForm = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 9: EnTitle = str; return CfgUpdateFlags.RestartRqrd;
                    case 10:
                        for (Sz sz = 0; sz < Sz.Count; sz++)
                        {
                            if (str == sz.ToDescription())
                            {
                                EnSize = sz;
                                return CfgUpdateFlags.RestartRqrd;
                            }
                        }
                        return CfgUpdateFlags.None;
                    case 11: SetEnItemsCount(int.Parse(str)); return CfgUpdateFlags.RestartRqrd;
                    case 12: SetEnColumnsCount(int.Parse(str)); return CfgUpdateFlags.RestartRqrd;
                    case 13: EnIsLrOrder = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 14: EnIsVertArrangement = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 15: EnFormCloseKeys = str; return CfgUpdateFlags.RestartRqrd;

                    case 16: TestStartEndShowForm = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 17: TestTitle = str; return CfgUpdateFlags.RestartRqrd;
                    case 18:
                        for (Sz sz = 0; sz < Sz.Count; sz++)
                        {
                            if (str == sz.ToDescription())
                            {
                                TestSize = sz;
                                return CfgUpdateFlags.RestartRqrd;
                            }
                        }
                        return CfgUpdateFlags.None;
                    case 19: SetTestColumnsCount(int.Parse(str)); return CfgUpdateFlags.RestartRqrd;
                    case 20: TestStartBoxAlwaysEn = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 21: TestIsLrOrder = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 22: TestIsVertArrangement = (str == Strings.yes); return CfgUpdateFlags.RestartRqrd;
                    case 23: TestFormCloseKeys = str; return CfgUpdateFlags.RestartRqrd;

                    default:
                        return CfgUpdateFlags.None;
                }
            }

            int ix = i - paramNames.Length;
            
            if (ix < 4 * GetOriBgItemsCount())
            {
                int j = ix / 4;
                if (j < GetBgItemsCount())
                {
                    switch (ix % 4)
                    {
                        case 0: BgItemContent[j] = Str2Content(str); return CfgUpdateFlags.RestartRqrd;
                        case 1: BgItemCaption[j] = str;              return CfgUpdateFlags.RestartRqrd;
                        case 2: BgItemAction[j] = Str2Action(str);   return CfgUpdateFlags.RestartRqrd;
                        case 3: BgItemWidth[j] = int.Parse(str);     return CfgUpdateFlags.RestartRqrd;
                    }
                }
            }
            ix -= 4 * GetOriBgItemsCount();

            if (ix < 4 * GetOriBgColumnsCount())
            {
                int j = ix / 4;
                if (j < GetBgColumnsCount())
                {
                    switch (ix % 4)
                    {
                        case 0: BgColumnContent[j] = Str2Content(str); return CfgUpdateFlags.RestartRqrd;
                        case 1: BgColumnCaption[j] = str;              return CfgUpdateFlags.RestartRqrd;
                        case 2: BgColumnAction[j] = Str2Action(str);   return CfgUpdateFlags.RestartRqrd;
                        case 3: BgColumnWidth[j] = int.Parse(str);     return CfgUpdateFlags.RestartRqrd;
                    }
                }
            }
            ix -= 4 * GetOriBgColumnsCount();

            if (ix < 4 * GetOriEnItemsCount())
            {
                int j = ix / 4;
                if (j < GetEnItemsCount())
                {
                    switch (ix % 4)
                    {
                        case 0: EnItemContent[j] = Str2Content(str); return CfgUpdateFlags.RestartRqrd;
                        case 1: EnItemCaption[j] = str;              return CfgUpdateFlags.RestartRqrd;
                        case 2: EnItemAction[j] = Str2Action(str);   return CfgUpdateFlags.RestartRqrd;
                        case 3: EnItemWidth[j] = int.Parse(str);     return CfgUpdateFlags.RestartRqrd;
                    }
                }
            }
            ix -= 4 * GetOriEnItemsCount();

            if (ix < 4 * GetOriEnColumnsCount())
            {
                int j = ix / 4;
                if (j < GetEnColumnsCount())
                {
                    switch (ix % 4)
                    {
                        case 0: EnColumnContent[j] = Str2Content(str); return CfgUpdateFlags.RestartRqrd;
                        case 1: EnColumnCaption[j] = str;              return CfgUpdateFlags.RestartRqrd;
                        case 2: EnColumnAction[j] = Str2Action(str);   return CfgUpdateFlags.RestartRqrd;
                        case 3: EnColumnWidth[j] = int.Parse(str);     return CfgUpdateFlags.RestartRqrd;
                    }
                }
            }
            ix -= 4 * GetOriEnColumnsCount();

            if (ix < 4 * GetOriTestColumnsCount())
            {
                int j = ix / 4;
                if (j < GetTestColumnsCount())
                {
                    switch (ix % 4)
                    {
                        case 0: TestColumnContent[j] = Str2Content(str); return CfgUpdateFlags.RestartRqrd;
                        case 1: TestColumnCaption[j] = str;              return CfgUpdateFlags.RestartRqrd;
                        case 2: TestColumnAction[j] = Str2Action(str);   return CfgUpdateFlags.RestartRqrd;
                        case 3: TestColumnWidth[j] = int.Parse(str);     return CfgUpdateFlags.RestartRqrd;
                    }
                }
            }

            return CfgUpdateFlags.RestartRqrd;
        }

        Ct Str2Content(string str)
        {
            for (Ct c = 0; c < Ct.Count; c++)
            {
                if (str == c.ToDescription()) return c;
            }
            return Ct.None;
        }

        Ac Str2Action(string str)
        {
            for (Ac a = 0; a < Ac.Count; a++)
            {
                if (str == a.ToDescription()) return a;
            }
            return Ac.Clear;
        }

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

            if (i < paramNames.Length)
            {
                switch (i)
                {
                    case 0:
                    case 2:
                    case 5:
                    case 6:
                    case 8:
                    case 10:
                    case 13:
                    case 14:
                    case 16:
                    case 18:
                    case 20:
                    case 21:
                    case 22:
                        message = string.Empty;
                        if (ParamValues(i).Contains(str)) return true;
                        break;
                    case 3:
                    case 4:
                    case 11:
                    case 12:
                    case 19:
                        message = string.Empty;
                        if (int.TryParse(str, out idummy)) return true;
                        break;
                    case 1:
                    case 7:
                    case 9:
                    case 15:
                    case 17:
                    case 23:
                        message = string.Empty;
                        return true;
                    default:
                        message = "Invalid index";
                        return false;
                }
            }

            if (i < ParamsCount())
            {
                switch ((i - paramNames.Length) % 4)
                {
                    case 0:
                    case 2:
                        message = string.Empty;
                        if (ParamValues(i).Contains(str)) return true;
                        break;
                    case 1:
                        message = string.Empty;
                        return true;
                    case 3:
                        message = string.Empty;
                        if (int.TryParse(str, out idummy)) return true;
                        break;
                    default:
                        message = "Invalid index";
                        return false;
                }
            }

            message = string.Format(Strings.Invalid_0, ParamName(i)) ;
            return false;
        }

        void CopyContentTo(EntryFormCfg prms)
        {
            prms.BgShowForm = BgShowForm;
            prms.BgTitle                = BgTitle;
            prms.BgSize                 = BgSize;
            prms.BgIsLrOrder            = BgIsLrOrder;
            prms.BgIsVertArrangement    = BgIsVertArrangement;
            prms.BgFormCloseKeys        = BgFormCloseKeys;
            
            prms.EnShowForm       = EnShowForm;
            prms.EnTitle                = EnTitle;
            prms.EnSize                 = EnSize;
            prms.EnIsLrOrder            = EnIsLrOrder;
            prms.EnIsVertArrangement    = EnIsVertArrangement;
            prms.EnFormCloseKeys        = EnFormCloseKeys;

            prms.TestStartEndShowForm   = TestStartEndShowForm;
            prms.TestTitle              = TestTitle;
            prms.TestSize               = TestSize;
            prms.TestStartBoxAlwaysEn   = TestStartBoxAlwaysEn;
            prms.TestIsLrOrder          = TestIsLrOrder;
            prms.TestIsVertArrangement  = TestIsVertArrangement;
            prms.TestFormCloseKeys      = TestFormCloseKeys;

            prms.BgItemContent = new Ct[GetBgItemsCount()];
            prms.BgItemCaption = new string[GetBgItemsCount()];
            prms.BgItemAction = new Ac[GetBgItemsCount()];
            prms.BgItemWidth = new int[GetBgItemsCount()];
            ///
            for (int ix = 0; ix < GetBgItemsCount(); ix++)
            {
                prms.BgItemContent[ix] = BgItemContent[ix];
                prms.BgItemCaption[ix] = BgItemCaption[ix];
                prms.BgItemAction[ix] = BgItemAction[ix];
                prms.BgItemWidth[ix] = BgItemWidth[ix];
            }

            prms.BgColumnContent = new Ct[GetBgColumnsCount()];
            prms.BgColumnCaption = new string[GetBgColumnsCount()];
            prms.BgColumnAction = new Ac[GetBgColumnsCount()];
            prms.BgColumnWidth = new int[GetBgColumnsCount()];
            ///
            for (int ix = 0; ix < GetBgColumnsCount(); ix++)
            {
                prms.BgColumnContent[ix] = BgColumnContent[ix];
                prms.BgColumnCaption[ix] = BgColumnCaption[ix];
                prms.BgColumnAction[ix] = BgColumnAction[ix];
                prms.BgColumnWidth[ix] = BgColumnWidth[ix];
            }

            prms.EnItemContent = new Ct[GetEnItemsCount()];
            prms.EnItemCaption = new string[GetEnItemsCount()];
            prms.EnItemAction = new Ac[GetEnItemsCount()];
            prms.EnItemWidth = new int[GetEnItemsCount()];
            ///
            for (int ix = 0; ix < GetEnItemsCount(); ix++)
            {
                prms.EnItemContent[ix] = EnItemContent[ix];
                prms.EnItemCaption[ix] = EnItemCaption[ix];
                prms.EnItemAction[ix] = EnItemAction[ix];
                prms.EnItemWidth[ix] = EnItemWidth[ix];
            }

            prms.EnColumnContent = new Ct[GetEnColumnsCount()];
            prms.EnColumnCaption = new string[GetEnColumnsCount()];
            prms.EnColumnAction = new Ac[GetEnColumnsCount()];
            prms.EnColumnWidth = new int[GetEnColumnsCount()];
            ///
            for (int ix = 0; ix < GetEnColumnsCount(); ix++)
            {
                prms.EnColumnContent[ix] = EnColumnContent[ix];
                prms.EnColumnCaption[ix] = EnColumnCaption[ix];
                prms.EnColumnAction[ix] = EnColumnAction[ix];
                prms.EnColumnWidth[ix] = EnColumnWidth[ix];
            }

            prms.TestColumnContent = new Ct[GetTestColumnsCount()];
            prms.TestColumnCaption = new string[GetTestColumnsCount()];
            prms.TestColumnAction = new Ac[GetTestColumnsCount()];
            prms.TestColumnWidth = new int[GetTestColumnsCount()];
            ///
            for (int ix = 0; ix < GetTestColumnsCount(); ix++)
            {
                prms.TestColumnContent[ix] = TestColumnContent[ix];
                prms.TestColumnCaption[ix] = TestColumnCaption[ix];
                prms.TestColumnAction[ix] = TestColumnAction[ix];
                prms.TestColumnWidth[ix] = TestColumnWidth[ix];
            }
        }

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

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