///
/// Copyright (c) 2017-2019 Sensus Slovensko a.s.
///
using System.IO;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;
using TBF.Resources;

namespace TBF.BenchControl.Various.ErrorFlags
{
	public class TestParams : TestParamsBase, IParamsProvider, ITestParams
	{
		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(TestParams) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }

        public sbyte E1;                    ///
        public sbyte E2;                    ///
        public sbyte E3;                    ///
        public sbyte E4;                    ///
        public sbyte E5;                    ///
        public sbyte E6;                    ///
        public sbyte E7;                    ///
        public sbyte E8;                    ///
        public sbyte E9;                    /// 0=off, 1=info, 2=evaluate
        public sbyte E10;                   ///
        public sbyte E11;                   ///
        public sbyte E12;                   ///
        public sbyte E13;                   ///
        public sbyte E14;                   ///
        public sbyte E15;                   ///
        public sbyte E16;                   ///
        public sbyte E21;                   ///

		public double Delta_Q_pct;			/// [%]  max deviation from the mean flow
        public double Delta_T;				/// [°C] max. T_up or T_down deviation from the mean temperature
        public double Delta_Tup_Tdn;			/// [°C] max. difference abs(T_up - T_down)
        public double TestTime_min;			/// [s]
        public double TestTime_max;			/// [s]
        public double AmbTemp_min;			/// [°C] min. ambient temperature
        public double AmbTemp_max;			/// [°C] max. ambient temperature
        public double Pressure_min;         /// [bar] min. water pressure                                            
        public double Pressure_max;         /// [bar] max. water pressure

        public double Coef_E9;				/// Coefficient used in E9, default 0.025
        public double Coef_E10;				/// Coefficient used in E10, default 0.04
        public double Coef_E11;				/// Coefficient used in E11, default 0.1
        public double Coef_E12;				/// Coefficient used in E12, default 1
        public double Offset_E9;            /// [s] default 0 (no offset)
        public double Offset_E12;           /// [s] default 0 (no offset)

#if IPERL
        public sbyte E25;                   /// MaxProefindex verification
        public sbyte E26;                   /// Q2 factors verification (saved from production == current)
        public sbyte E27;                   /// Direction verification
        public sbyte E28;                   /// Previous workflow step verification
#endif

		public override void InitializeAll()
		{
#if IPERL
            E1 = (sbyte)ErrorFlagsMode.Info;
			E2 = (sbyte)ErrorFlagsMode.Off;
			E3 = (sbyte)ErrorFlagsMode.Info;
            E4 = (sbyte)ErrorFlagsMode.Off;
            E5 = (sbyte)ErrorFlagsMode.Off;
            E6 = (sbyte)ErrorFlagsMode.Off;
            E7 = (sbyte)ErrorFlagsMode.Off;
            E8 = (sbyte)ErrorFlagsMode.Off;
            E9 = (sbyte)ErrorFlagsMode.Off;
            E10 = (sbyte)ErrorFlagsMode.Off;
            E11 = (sbyte)ErrorFlagsMode.Off;
            E12 = (sbyte)ErrorFlagsMode.Off;
            E13 = (sbyte)ErrorFlagsMode.Off;
            E14 = (sbyte)ErrorFlagsMode.Off;
            E15 = (sbyte)ErrorFlagsMode.Off;
            E16 = (sbyte)ErrorFlagsMode.Off;
            E21 = (sbyte)ErrorFlagsMode.Info;

            E25 = (sbyte)ErrorFlagsMode.Info;   /// MaxPruefindex verification
            E26 = (sbyte)ErrorFlagsMode.Off;    /// Q2 factors verification (saved from production == current)
            E27 = (sbyte)ErrorFlagsMode.Off;    /// Direction verification
            E28 = (sbyte)ErrorFlagsMode.Info;   /// Previous workflow step verification
#else
            E1 = (sbyte)ErrorFlagsMode.Info;
            E2 = (sbyte)ErrorFlagsMode.Info;
            E3 = (sbyte)ErrorFlagsMode.Info;
            E4 = (sbyte)ErrorFlagsMode.Info;
            E5 = (sbyte)ErrorFlagsMode.Info;
            E6 = (sbyte)ErrorFlagsMode.Info;
            E7 = (sbyte)ErrorFlagsMode.Info;
            E8 = (sbyte)ErrorFlagsMode.Info;
            E9 = (sbyte)ErrorFlagsMode.Info;
            E10 = (sbyte)ErrorFlagsMode.Info;
            E11 = (sbyte)ErrorFlagsMode.Info;
            E12 = (sbyte)ErrorFlagsMode.Info;
            E13 = (sbyte)ErrorFlagsMode.Info;
            E14 = (sbyte)ErrorFlagsMode.Info;
            E15 = (sbyte)ErrorFlagsMode.Info;
            E16 = (sbyte)ErrorFlagsMode.Info;
            E21 = (sbyte)ErrorFlagsMode.Info;
#endif
            Delta_Q_pct = 5.0;		/// [%]
			Delta_T = 10.0;		    /// [°C]
			Delta_Tup_Tdn = 10.0;	/// [°C]
			TestTime_min = 0;		/// [s]
			TestTime_max = 99999;	/// [s]
            AmbTemp_min = 5.0;	    /// [°C]
            AmbTemp_max = 95.0;	    /// [°C]
            Pressure_min = 0;	    /// [bar]
            Pressure_max = 16.0;	/// [bar]

			Coef_E9 = 0.025;
			Coef_E10 = 0.04;
			Coef_E11 = 0.1;
			Coef_E12 = 1.0;
            Offset_E9 = 0;          /// [s]
            Offset_E12 = 0;         /// [s]
        }

		string[] paramNames = new string[]
		{
			"E1",
			"E2",
			"E3",
			"E4",
			"E5",
			"E6",
			"E7",
			"E8",
			"E9",
			"E10",
			"E11",
			"E12",
			"E13",
			"E14",
			"E15",
			"E16",
            "E21",

			"Delta Q [%]",
			"Delta T [°C]",
			"max. Abs(Tup - Tdn) [°C]",
			string.Format("min. {0}", Strings.Test_time_s_chdr),
			string.Format("max. {0}", Strings.Test_time_s_chdr),
			string.Format("min. {0} [°C]", Strings.Air_temperature),
			string.Format("max. {0} [°C]", Strings.Air_temperature),
			string.Format("min. {0} [bar]", Strings.Pressure),
			string.Format("max. {0} [bar]", Strings.Pressure),

			"Coef.E9",
			"Coef.E10",
			"Coef.E11",
			"Coef.E12",
            "Offset E9 [s]",
            "Offset E12 [s]",
#if IPERL
            "E25",
            "E26",
            "E27",
            "E28",
#endif
		};
		public override string ParamName(int i) { return paramNames[i]; }
		public override int ParamsCount() { return paramNames.Length; }

		public override string ToString(int i)
		{
			switch (i)
			{
                case 0: return ((ErrorFlagsMode)E1).ToDescription();
                case 1: return ((ErrorFlagsMode)E2).ToDescription();
                case 2: return ((ErrorFlagsMode)E3).ToDescription();
                case 3: return ((ErrorFlagsMode)E4).ToDescription();
                case 4: return ((ErrorFlagsMode)E5).ToDescription();
                case 5: return ((ErrorFlagsMode)E6).ToDescription();
                case 6: return ((ErrorFlagsMode)E7).ToDescription();
                case 7: return ((ErrorFlagsMode)E8).ToDescription();
                case 8: return ((ErrorFlagsMode)E9).ToDescription();
                case 9: return ((ErrorFlagsMode)E10).ToDescription();
                case 10: return ((ErrorFlagsMode)E11).ToDescription();
                case 11: return ((ErrorFlagsMode)E12).ToDescription();
                case 12: return ((ErrorFlagsMode)E13).ToDescription();
                case 13: return ((ErrorFlagsMode)E14).ToDescription();
                case 14: return ((ErrorFlagsMode)E15).ToDescription();
                case 15: return ((ErrorFlagsMode)E16).ToDescription();
                case 16: return ((ErrorFlagsMode)E21).ToDescription();

				case 17: return Delta_Q_pct.ToString();
				case 18: return Delta_T.ToString();
				case 19: return Delta_Tup_Tdn.ToString();
				case 20: return TestTime_min.ToString();
				case 21: return TestTime_max.ToString();
                case 22: return AmbTemp_min.ToString();
                case 23: return AmbTemp_max.ToString();
                case 24: return Pressure_min.ToString();
                case 25: return Pressure_max.ToString();
                case 26: return Coef_E9.ToString();
				case 27: return Coef_E10.ToString();
				case 28: return Coef_E11.ToString();
				case 29: return Coef_E12.ToString();
                case 30: return Offset_E9.ToString();
                case 31: return Offset_E12.ToString();
#if IPERL
                case 32: return ((ErrorFlagsMode)E25).ToDescription();
                case 33: return ((ErrorFlagsMode)E26).ToDescription();
                case 34: return ((ErrorFlagsMode)E27).ToDescription();
                case 35: return ((ErrorFlagsMode)E28).ToDescription();
#endif
				default: return string.Empty;
			}
		}

		/// Retrieves parameters from UI controls
		public CfgUpdateFlags UpdateParam(int i, string sVal)
		{
			switch (i)
			{
                case 0: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E1 = (sbyte)m; break; }; break;
                case 1: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E2 = (sbyte)m; break; }; break;
                case 2: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E3 = (sbyte)m; break; }; break;
                case 3: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E4 = (sbyte)m; break; }; break;
                case 4: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E5 = (sbyte)m; break; }; break;
                case 5: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E6 = (sbyte)m; break; }; break;
                case 6: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E7 = (sbyte)m; break; }; break;
                case 7: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E8 = (sbyte)m; break; }; break;
                case 8: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E9 = (sbyte)m; break; }; break;
                case 9: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E10 = (sbyte)m; break; }; break;
                case 10: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E11 = (sbyte)m; break; }; break;
                case 11: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E12 = (sbyte)m; break; }; break;
                case 12: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E13 = (sbyte)m; break; }; break;
                case 13: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E14 = (sbyte)m; break; }; break;
                case 14: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E15 = (sbyte)m; break; }; break;
                case 15: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E16 = (sbyte)m; break; }; break;
                case 16: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E21 = (sbyte)m; break; }; break;

                case 17: Delta_Q_pct = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 18: Delta_T = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 19: Delta_Tup_Tdn = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 20: TestTime_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 21: TestTime_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 22: AmbTemp_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 23: AmbTemp_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 24: Pressure_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 25: Pressure_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 26: Coef_E9 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 27: Coef_E10 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 28: Coef_E11 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 29: Coef_E12 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 30: Offset_E9 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
                case 31: Offset_E12 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
#if IPERL
                case 32: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E25 = (sbyte)m; break; }; break;
                case 33: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E26 = (sbyte)m; break; }; break;
                case 34: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E27 = (sbyte)m; break; }; break;
                case 35: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E28 = (sbyte)m; break; }; break;
#endif
			}

            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;

			double dummy;
			switch (i)
			{
				case 0:
				case 1:
				case 2:
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
				case 8:
				case 9:
				case 10:
				case 11:
				case 12:
				case 13:
				case 14:
				case 15:
				case 16:
                case 32:
                case 33:
                case 34:
                case 35:
					for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++)
					{
						if (m.ToDescription() == strValue) return true;
					}
					break;

				case 17:
				case 18:
				case 19:
				case 20:
				case 21:
				case 22:
				case 23:
				case 24:
				case 25:
                case 26:
                case 27:
                case 28:
                case 29:
                case 30:
                case 31:
                    if (Utils.TryParseUDouble(strValue, out dummy)) return true;
					break;

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

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

		void CopyContentTo(TestParams prms)
		{
			prms.E1 = this.E1;
			prms.E2 = this.E2;
			prms.E3 = this.E3;
			prms.E4 = this.E4;
			prms.E5 = this.E5;
			prms.E6 = this.E6;
			prms.E7 = this.E7;
			prms.E8 = this.E8;
			prms.E9 = this.E9;
			prms.E10 = this.E10;
			prms.E11 = this.E11;
			prms.E12 = this.E12;
			prms.E13 = this.E13;
			prms.E14 = this.E14;
			prms.E15 = this.E15;
			prms.E16 = this.E16;
            prms.E21 = this.E21;

			prms.Delta_Q_pct = this.Delta_Q_pct;
			prms.Delta_T = this.Delta_T;
			prms.Delta_Tup_Tdn = this.Delta_Tup_Tdn;
			prms.TestTime_min = this.TestTime_min;
			prms.TestTime_max = this.TestTime_max;
            prms.AmbTemp_min = this.AmbTemp_min;
            prms.AmbTemp_max = this.AmbTemp_max;
            prms.Pressure_min = this.Pressure_min;
            prms.Pressure_max = this.Pressure_max;
			prms.Coef_E9 = this.Coef_E9;
			prms.Coef_E10 = this.Coef_E10;
			prms.Coef_E11 = this.Coef_E11;
			prms.Coef_E12 = this.Coef_E12;
            prms.Offset_E9 = this.Offset_E9;
            prms.Offset_E12 = this.Offset_E12;
#if IPERL
            prms.E25 = this.E25;
            prms.E26 = this.E26;
            prms.E27 = this.E27;
            prms.E28 = this.E28;
#endif
        }

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

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

				testParamsEntity = dbEntity;
				componentName = dbEntity.CmpntName;
				test = dbEntity.Test;

				if (tmp != null) tmp.CopyContentTo(this);
			}
			catch
			{
			}
		}

		public TestParams() { }

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

		public TestParams(ComponentProcedure procedureParamsEntity, string componentName, Test test)
		{
			this.testParamsEntity = testParamsEntity;
			this.componentName = componentName;
			this.test = test;
		}
	}
}