///
/// Copyright (c) 2017 Sensus Metering Systems
///
using System;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;
using TBF.Resources;

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

		public float TargetQ;				/// Target=terminal flow durning detection when increasing or decreasing the flow
		public float RateOfChange;			/// Each step is calculated as (TargetQfrom - Qfrom) * RateOfChange, text form is displayed in % (*100)
		public float DetectionThreshold;	/// Drop of frequency for the detection, text form is displayed in % (*100)
        public bool  SupressTrills;			/// Main meter readings are ignored during test (suitable for small flows)

		public override void InitializeAll()
		{
			TargetQ = 3.0f;
			RateOfChange = 0.05f;
			DetectionThreshold = 0.25f;
			SupressTrills = false;
		}
		

		string[] paramNames = new string[]
		{
			Strings.TargetQ,
			Strings.RateOfChangePct,
			Strings.DetectionThresholdPct,
			Strings.SupressWMTrills,
		};
		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 TargetQ.ToString();
				case 1: return (100.0f * RateOfChange).ToString();
				case 2: return (100.0f * DetectionThreshold).ToString();
                case 3: return (SupressTrills ? Strings.yes : Strings.no);
				default: return string.Empty;
			}
		}

		public void UpdateParam(int i, string strValue)
		{
			switch (i)
			{
				case 0: TargetQ = Utils.ParseUFloat(strValue); return;
				case 1: RateOfChange = Utils.ParseUFloat(strValue) / 100.0f; return;
				case 2: DetectionThreshold = Utils.ParseUFloat(strValue) / 100.0f; return;
                case 3: SupressTrills = strValue.Equals(Strings.yes); return;
				default: return;
			}
		}

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

			float dummy;
			switch (i)
			{
				case 0:
				case 1:
				case 2:
					if (Utils.TryParseUFloat(strValue, out dummy)) return true;
					break;
                case 3:
					if (strValue.Equals(Strings.yes) || strValue.Equals(Strings.no)) return true;
                    break;
				default:
					message = "Invalid index";
					return false;
			}

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

		void CopyContentTo(SensitivityTestParams prms)
		{
			prms.TargetQ = this.TargetQ;
			prms.RateOfChange = this.RateOfChange;
			prms.DetectionThreshold = this.DetectionThreshold;
			prms.SupressTrills = this.SupressTrills;
		}

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

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

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

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

		/// <summary>
		/// Parameterless constructor initializes the parameters
		/// </summary>
		public SensitivityTestParams()
		{
		}

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

		public SensitivityTestParams(ComponentTest testParamsEntity, string componentName, Test test)
		{
			this.testParamsEntity = testParamsEntity;
			this.componentName = componentName;
			this.test = test;
		}
	}
}