///
/// Copyright (c) 2020 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using log4net;
using Config.Entities;
using Results.Output;
using TBF.BenchControl.Generic;
using TBF.Resources;

namespace TBF.BenchControl.Output.DB.SensusOracle
{
	public class ProcedureParams : ProcedureParamsBase, IParamsProvider, IProcedureParams
	{
        private static readonly ILog log = LogManager.GetLogger(typeof(ProcedureParams));
        
        public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcedureParams) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }

        public DBUsed DBUsed;                               /// 0
        public WMKind WMKind;                               /// 1
        public int WMTypeId;                                /// 2
        public int YearOfManufacture;                       /// 3
        public bool SaveResults;                            /// 4
        public bool ReadStartInfo;                          /// 5
        public bool StartInfoIsRequired;                    /// 6
        public DesigMode DesigMode;                         /// 7
        public Results.Output.LogType DesigType;            /// 8
                                                            
		public override void InitializeAll()                
		{                                                   
            DBUsed = DBUsed.Production;                     /// 0
            WMKind = WMKind.iPERL;                          /// 1
            WMTypeId = 2;                                   /// 2
            YearOfManufacture = DateTime.Now.Year;          /// 3
#if TURA_SPECIAL                                            
            SaveResults = false;                            /// 4
#else                                                       
            SaveResults = true;                             /// 4
#endif                                                      
            ReadStartInfo = true;                           /// 5
            StartInfoIsRequired = false;                    /// 6
            DesigMode = DesigMode.Auto;                     /// 7
            DesigType = Results.Output.LogType.Just_Q3Q2Q1; /// 8
        }

		string[] paramNames = new string[]
		{
			"Database",                                     /// 0
            "Kind of WMs",                                  /// 1
            "WM type ID",                                   /// 2
            "Year of manufacture",                          /// 3
            "Save results",                                 /// 4
            "Read start info",                              /// 5
            "Start info is required",                       /// 6
			"Designation Mode",                             /// 7
            "Designation when mode is 'As_specified'",      /// 8
		};
		public override string ParamName(int i) { return paramNames[i]; }
		public override int ParamsCount() { return paramNames.Length; }

        public override ICollection<string> ParamValues(int i)
        {
            IList<string> retVal = new List<string>();

            switch (i)
            {
                case 0:
                    for (DBUsed db = 0; db < DBUsed.Count; db++) retVal.Add(db.ToString());
                    return retVal;

                case 1:
                    for (WMKind wm = 0; wm < WMKind.Count; wm++) retVal.Add(wm.ToString());
                    return retVal;

                case 2:
                default:
                    return null;

                case 3:
                    int year = DateTime.Now.Year;
                    return new string[] { year.ToString(), (year + 1).ToString() };
                case 4:
                case 5:
                case 6:
                    return new string[] { Strings.yes, Strings.no };
                case 7:
                    for (DesigMode md = 0; md < DesigMode.Count; md++) retVal.Add(md.ToString());
                    return retVal;

                case 8:
                    for (Results.Output.LogType wm = 0; wm < Results.Output.LogType.Count; wm++) retVal.Add(wm.ToString());
                    return retVal;
            }
        }

		public override string ToString(int i)
		{
			switch (i)
			{
                case 0: return DBUsed.ToString();
                case 1: return WMKind.ToString();
                case 2: return WMTypeId.ToString();
                case 3: return YearOfManufacture.ToString();
                case 4: return SaveResults ? Strings.yes : Strings.no;
                case 5: return ReadStartInfo ? Strings.yes : Strings.no;
                case 6: return StartInfoIsRequired ? Strings.yes : Strings.no;
                case 7: return DesigMode.ToString();
                case 8: return DesigType.ToString();
                default: return string.Empty;
			}
		}

		/// Retrieves parameters from UI controls
		public CfgUpdateFlags UpdateParam(int i, string strValue)
		{
			switch (i)
			{
                case 0:
                    for (DBUsed db = 0; db < DBUsed.Count; db++)
                    {
                        if (db.ToString() == strValue)
                        {
                            DBUsed = db;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;

                case 1:
                    for (WMKind wm = 0; wm < WMKind.Count; wm++)
                    {
                        if (wm.ToString() == strValue)
                        {
                            WMKind = wm;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;

                case 2: WMTypeId            = int.Parse(strValue);        return CfgUpdateFlags.None;
                case 3: YearOfManufacture   = int.Parse(strValue);        return CfgUpdateFlags.None;
                case 4: SaveResults         = (strValue == Strings.yes);  return CfgUpdateFlags.None;
                case 5: ReadStartInfo       = (strValue == Strings.yes);  return CfgUpdateFlags.None;
                case 6: StartInfoIsRequired = (strValue == Strings.yes);  return CfgUpdateFlags.None;

                case 7:
                    for (DesigMode db = 0; db < DesigMode.Count; db++)
                    {
                        if (db.ToString() == strValue)
                        {
                            DesigMode = db;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;

                case 8:
                    for (Results.Output.LogType wm = 0; wm < Results.Output.LogType.Count; wm++)
                    {
                        if (wm.ToString() == strValue)
                        {
                            DesigType = wm;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;
            }

            return CfgUpdateFlags.None;
        }

		/// Verifies whether strings in UI controls represent valid parameters
		public bool ValidateParam(int i, string strValue, out string message)
		{
			message = string.Empty;

            int idummy;
			switch (i)
			{
				case 0:
                    for (DBUsed db = 0; db < DBUsed.Count; db++)
                    {
                        if (db.ToString() == strValue) return true;
                    }
					break;

                case 1:
                    for (WMKind wm = 0; wm < WMKind.Count; wm++)
                    {
                        if (wm.ToString() == strValue) return true;
                    }
                    break;

                case 2:
                    if (int.TryParse(strValue, out idummy) && idummy >= 0)
                        return true;
                    break;

                case 3:
                    if (int.TryParse(strValue, out idummy) && idummy >= DateTime.Now.Year && idummy <= DateTime.Now.Year + 1)
                        return true;
                    break;

                case 4:
                case 5:
                case 6:
                    if (strValue == Strings.yes || strValue == Strings.no)
                        return true;
                    break;

                case 7:
                    for (DesigMode db = 0; db < DesigMode.Count; db++)
                    {
                        if (db.ToString() == strValue) return true;
                    }
                    break;

                case 8:
                    for (Results.Output.LogType wm = 0; wm < Results.Output.LogType.Count; wm++)
                    {
                        if (wm.ToString() == strValue) return true;
                    }
                    break;

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

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

		void CopyContentTo(ProcedureParams prms)
		{
			prms.DBUsed = this.DBUsed;
            prms.WMKind = this.WMKind;
            prms.WMTypeId = this.WMTypeId;
            prms.YearOfManufacture = this.YearOfManufacture;
            prms.SaveResults = this.SaveResults;
            prms.ReadStartInfo = this.ReadStartInfo;
            prms.StartInfoIsRequired = this.StartInfoIsRequired;
            prms.DesigMode = this.DesigMode;
            prms.DesigType = this.DesigType;
        }

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

		public override void UpdateFromDbEntity(ComponentProcedure dbEntity)
		{
			if (dbEntity == null) return;
			try
			{
				ProcedureParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as ProcedureParams;

				procedureParamsEntity = dbEntity;
				componentName = dbEntity.CmpntName;
				procedure = dbEntity.Procedure;

				if (tmp != null) tmp.CopyContentTo(this);
			}
			catch (Exception exc)
			{
                log.ErrorFormat("Failed to UpdateFromDbEntity({0}): {1}", dbEntity, exc.Message);
			}
		}
		

		public ProcedureParams()
		{
		}

		public ProcedureParams(bool initialize)
		{
			if (initialize) InitializeAll();
		}

		public ProcedureParams(ComponentProcedure procedureParamsEntity, string componentName, Procedure procedure)
		{
			this.procedureParamsEntity = procedureParamsEntity;
			this.componentName = componentName;
			this.procedure = procedure;
		}
	}
}