///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.IO;
using System.Collections.Generic;
using System.IO.Ports;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;

namespace TBF.BenchControl.Hart.Nivotrack
{
    public class NivotrackCfg : ComponentCfgBase, Generic.IChildComponentCfg, Config.Entities.IParamsProvider, GenericDevices.ICalibInfoCfg
	{
		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(NivotrackCfg) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }

        static readonly int[] Par1Values = new int[] { 300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200 };
        static readonly int[] Par2Values = new int[] { 7, 8 };


        public IComponentCfgCtrl GetControl()
        {
			IList<string> parents = new List<string>();
			parents.Add("Hart");

			return new Configs.ParamsProvider.ComponentCfgCtrl(this, parents);
        }

		///
		/// Serialized parameters 
		///
		public int Address;
        public int Par1;
        public int Par2;


        /// Calibration info serialized parameters displayed in Metrology tab page
        string calibCertificateNr;
        DateTime calibDate;
        DateTime calibValidDate;
        public string CalibCertificateNr
        {
            get { return calibCertificateNr; }
            set { calibCertificateNr = value; }
        }
        public DateTime CalibDate
        {
            get { return calibDate; }
            set { calibDate = value; }
        }
        public DateTime CalibValidDate
        {
            get { return calibValidDate; }
            set { calibValidDate = value; }
        }


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

        public NivotrackCfg(string name, IComponentFactory factory)
            : this()
        {
            Name = name;
            Factory = factory;
            ParentName = "Hart";
            InitializeAll();
        }

        public string ComponentName { get { return Name; } }

        public void InitializeAll()
        {
            Address = 3;
            Par1 = 9600;
            Par2 = 8;
        }
        string[] paramNames = new string[]
		{
		    "HART address",
            "Parameter 1",
            "Parameter 2",
        };
        public string ParamName(int i) { return paramNames[i]; }
        public int ParamsCount() { return paramNames.Length; }

        public IList<string> ParamValues(int i)
        {
            IList<string> list = new List<string>();
            switch (i)
            {
                case 1: foreach (var v in Par1Values) list.Add(v.ToString()); break;
                case 2: foreach (var v in Par2Values) list.Add(v.ToString()); break;
                default: return null;
            }
            return list;
        }

		public string ToString(int i)
		{
            if (i == -1)
            {
                return string.Format("Address={0}", Address);
            }

            switch (i)
            {
                case 0: return Address.ToString();
                case 1: return Par1.ToString();
                case 2: return Par2.ToString();
                default: return string.Empty;
            }
        }


        public CfgUpdateFlags UpdateParam(int i, string strValue)
        {
            switch (i)
            {
                case 0:
                    if (Address != int.Parse(strValue))
                    {
                        Address = int.Parse(strValue);
                        return CfgUpdateFlags.RestartRqrd;
                    }
                    else
                    {
                        return CfgUpdateFlags.None;
                    }

                case 1:
                    foreach (var v in Par1Values)
                    {
                        if ((strValue == v.ToString()) && (Par1 != v))
                        {
                            Par1 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    return CfgUpdateFlags.None;

                case 2:
                    foreach (var v in Par2Values)
                    {
                        if ((strValue == v.ToString()) && (Par2 != v))
                        {
                            Par2 = v;
                            return CfgUpdateFlags.RestartRqrd;
                        }
                    }
                    return CfgUpdateFlags.None;

                default:
                    return CfgUpdateFlags.None;
            }
        }


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

            switch (i)
            {
                case 0:
                    int address;
                    if (int.TryParse(strValue, out address) && address >= 0 && address <= 15) return true;
                    break;
                case 1:
                    foreach (var v in Par1Values) if (strValue == v.ToString()) return true;
                    break;
                case 2:
                    foreach (var v in Par2Values) if (strValue == v.ToString()) return true;
                    break;         
         
                default:
                    message = "Invalid index";
                    return false;
            }

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

        void CopyContentTo(NivotrackCfg prms)
        {
            prms.ParentName = this.ParentName;
            prms.Address = this.Address;
            prms.Par1 = this.Par1;
            prms.Par2 = this.Par2;
        }


        public Config.Entities.IParamsProvider Clone()
        {
            NivotrackCfg pars = new NivotrackCfg();
            CopyContentTo(pars);
            return pars;
        }

        public void UpdateEmbeddedDbEntity()
        {
            /// Do nothing
        }
    }
}