///
/// Copyright (c) 2015 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.IO;
using log4net;
using Oracle.DataAccess.Client; // ODP.NET Oracle managed provider
using Oracle.DataAccess.Types;
using Config.Entities;
using TBF.BenchControl;
using TBF.Resources;

namespace TBF.BenchControl.DB.SensusOracle
{
	public enum Retv
	{
		OK,
		Error,
	}

	public class Database : ComponentBase, IOperation, GenericDevices.IResultsWriter, Generic.IDevice
	{
		private static readonly ILog log = LogManager.GetLogger(typeof(Database));
		public override string ToString() { return string.Format("Sensus-Oracle-Database({0})", Cfg.ToString(1)); }

        const int Anbid_StaraTura = 4;

		public static DatabaseCfg DBCfg;
		string separatorStr;

        /// <summary>
		/// Result items to print
		/// </summary>
		IList<Results.ItemSpec> rsltItems;

		/// <summary>
		/// Results to print
		/// </summary>
		Results.Entities.Batch batch;

		OracleConnection connection;    /// Oracle database connection
		StreamWriter writer;			/// Results to disk
		StreamWriter logger;			/// Logs specified by LU


		public Database() {}

		public Database(DatabaseCfg cfg)
            : base(cfg)
		{
			DBCfg = cfg;

			switch (cfg.Separator)
			{
				default:
				case Separator.None:		separatorStr = string.Empty;	break;
				case Separator.Space:		separatorStr = " ";				break;
				case Separator.Tabulator:	separatorStr = "\t";			break;
				case Separator.Comma:		separatorStr = ",";				break;
				case Separator.Semicolon:	separatorStr = ";";				break;
			}

			log.Debug(this.ToString());
		}

        public void Initialize()
        {
            connection = (DBCfg.DBUsed == DBUsed.Production)
                ? new OracleConnection("Data Source=STARA01.WORLD;User Id=deltachef;Password=deltachef;")
                : new OracleConnection("Data Source=STARA_TEST.WORLD;User Id=deltachef;Password=deltachef;");

			if (DBCfg.DebugLevel == DebugMode.Simulate) return;

            ///
            /// Do something with the database to see if the connection works well
            ///
            connection.Open();

            string rslt = "none";
            OracleCommand cmd = new OracleCommand("select Standort from ANBIETER_SD where ANBID = 4", connection);
            OracleDataReader dr = cmd.ExecuteReader();
            if (dr.Read()) rslt =  dr.GetString(0);
            dr.Close();

            connection.Close();
        }

        public void RunDeviceBefore() {}
        public void RunDeviceAfter() {}

        public void StopDevice()
        {
            if (connection != null) connection.Dispose();
        }

		/// <summary>
		/// Eliminate spaces conditionally, depesing on bool WriterCfg.EliminateSpaces
		/// </summary>
		/// <param name="item">Input string</param>
		/// <returns>Output string</returns>
		string ElSpaces(string item)
		{
			if (DBCfg.EliminateSpaces)
				return item.Replace(" ", string.Empty);
			else
				return item;
		}


		/// <summary>
		/// Returns a file name derived from a DateTime structure.
		/// Creates directories on this path as a side effect.
		/// </summary>
		/// <param name="time">Date and time</param>
		/// <returns>File name</returns>
		string GetFileName(DateTime time)
		{
			string directory = DBCfg.DestinationPath;		/// Ends with "\\";
			Directory.CreateDirectory(directory);

			if (DBCfg.YearFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Year.ToString());
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.MonthFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Month.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.DayFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Day.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			return string.Format("{0}{1}{2}{3}-{4}{5}.txt", directory, (time.Year % 100).ToString("D2"),
				time.Month.ToString("D2"), time.Day.ToString("D2"), time.Hour.ToString("D2"), time.Minute.ToString("D2"));
		}


		/// <summary>
		/// Returns a file name derived from a DateTime structure.
		/// Creates directories on this path as a side effect.
		/// </summary>
		/// <param name="time">Date and time</param>
		/// <returns>File name</returns>
		string GetLogFileName(DateTime time)
		{
			string directory = DBCfg.LogFolderPath;		/// Ends with "\\";
			Directory.CreateDirectory(directory);

			if (DBCfg.YearFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Year.ToString());
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.MonthFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Month.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.DayFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Day.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			return string.Format("{0}{1}_{2}.log", directory, time.Hour.ToString("D2"), time.Minute.ToString("D2"));
		}

		/// <summary>
		/// Writes the test cycle results into a file,  Events:  Event.ResultsWritten
		/// </summary>
		/// <param name="procedure">Procedure to print the results of</param>
		/// <param name="unsortedResults">Results to write into the file</param>
		/// <returns>Reference to the operation</returns>
		public IOperation WriteResultsOp(Results.Entities.Batch batch)
		{
			this.batch = batch;

			if (batch.WaterMeters.Count > 0 && !batch.WaterMeters[0].Compound())
			{
                rsltItems = Results.ItemSpec.FromStrArray(Program.LocalSettings.RsltItems_Disk_SingleWM);
			}
			else
			{
                rsltItems = Results.ItemSpec.FromStrArray(Program.LocalSettings.RsltItems_Disk_CombinedWM);
			}

			string fname = GetFileName(batch.EndTime);
            try { writer = new StreamWriter(System.IO.File.Create(fname)); }
            catch
			{
				writer = null;
				log.ErrorFormat("Was not able to open results file {0}", fname);
			}

			fname = GetLogFileName(batch.StartTime);
			try { logger = new StreamWriter(System.IO.File.Create(fname)); }
			catch
			{
				logger = null;
				log.ErrorFormat("Was not able to open LU log file {0}", fname);
			}

			return this;
		}

		/// <summary>Start this operation</summary>
		public void Start()
		{
		}

		/// <summary>Run this operation</summary>
		/// <returns>Event.ResultsWritten or Event.Error</returns>
		public Event Run()
		{
			if (batch.WaterMeters.Count == 0) return Event.ResultsWritten;

			bool anyError = false;
#if IPERLST
			if (DBCfg.DebugLevel != DebugMode.Simulate)
			{
				if (WriteResultsToDatabase(connection, batch) == Retv.Error) anyError = true;
			}
#endif

            WriteResultsToDisk(batch);
			WriteLogsToDisk(batch);           
            
            if (anyError)
			{
				return Event.ResultsNotWritten;
			}
			else
			{
				return Event.ResultsWritten;
			}
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
		}


		public Retv WriteResultsToDisk(Results.Entities.Batch batch)
		{
			if (writer == null) return Retv.Error;

			try
			{
				///----------
				///  Header
				///----------
				writer.WriteLine(batch.ProtocolTitle);
				writer.WriteLine(string.Empty);

				string[] leftColumn = new string[]
				{
					"Batch number: ",
					"Date and time: ",
					"Procedure:",
					Strings.User_,
					"Ambient temperature: ",
					"Ambient pressure: ",
					"Ambient humidity: ",
				};

				string[] rightColumn = new string[]
				{
					batch.BatchNr.ToString(),
					//batch.EndTime.ToShortDateString() + "  " + batch.EndTime.ToShortTimeString(),
					string.Format("{0}.{1}.{2}  {3}:{4}", batch.EndTime.Year.ToString("D4"),
														  batch.EndTime.Month.ToString("D2"),
														  batch.EndTime.Day.ToString("D2"),
														  batch.EndTime.Hour.ToString("D2"),
														  batch.EndTime.Minute.ToString("D2")),
					batch.ProcedureName,
					batch.UserName,
					batch.AmbientTempAve().ToString("F1") + " °C",
					batch.AmbientPressAve().ToString("F0") + " mbar",
					batch.AmbientHumiAve().ToString("F0") + " %",
				};

				/// Determine max. left column width in characters
				int maxLen = 0;
				foreach (var s in leftColumn) if (s.Length > maxLen) maxLen = s.Length;

				/// Write aligned columns
				for (int i = 0; i < Math.Min(leftColumn.Length, rightColumn.Length); i++)
				{
					writer.Write(leftColumn[i]);
					writer.Write(new string(' ', maxLen - leftColumn[i].Length + 3));
					writer.WriteLine(rightColumn[i]);
				}
				writer.WriteLine(string.Empty);


				///--------
				///  Body
				///--------
				foreach (var wMtr in batch.WaterMeters) WriteWM(wMtr);

				/// Close the file
				writer.Close();
				writer = null;
			}
			catch (Exception exc)
			{
				log.ErrorFormat("Results not saved to disk: {0}", exc.Message);
				return Retv.Error;
			}

			return Retv.OK;	/// OK
		}


		/// <summary>
		/// Write one water meter results
		/// </summary>
		/// <param name="wmNr">Water meter number (0-based)</param>
		void WriteWM(Results.Entities.WaterMeter wm)
		{
			/// Determine column widths
			int[] columnWidths = new int[rsltItems.Count];
			int totalWidth = 0;
			for (int i = 0; i < rsltItems.Count; i++)
			{
				columnWidths[i] = ElSpaces(rsltItems[i].ClmnHeaderText).Length;
				foreach (var mtr in wm.MeterTestRslts)
				{
					string itemText;

					if (!wm.Compound())
					{
						/// Single water meter
						itemText = rsltItems[i].Print(mtr);
					}
					else if (mtr.CompoundMeterId == (byte)CompoundMeterId.Compound)
					{
						Results.Entities.MeterTestRslt mainMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundMain);
						Results.Entities.MeterTestRslt auxMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundAux);
						itemText = rsltItems[i].PrintCombined(mainMtr, auxMtr, mtr);
					}
					else
					{
						continue;
					}

					/// Strip color information
					string[] texts = itemText.Split(new char[] { '|' });
					if (texts.Length == 2) { itemText = texts[0]; }

					int len = ElSpaces(itemText).Length;
					if (len > columnWidths[i]) columnWidths[i] = len;
				}
				totalWidth += columnWidths[i];
			}
			totalWidth += 3 * (rsltItems.Count - 1);
			if (totalWidth < 0) totalWidth = 0;


			/// Write water meter number and s/n
			writer.Write(string.Format("Water meter {0}", wm.WMPosition));
			if (!string.IsNullOrEmpty(wm.SerialNr)) writer.Write(string.Format("   s/n: {0}", wm.SerialNr));
			writer.WriteLine(string.Empty);


			writer.WriteLine(new String('-', totalWidth));		/// Horizontal line above the header


			/// Write column headers
			for (int i = 0; i < rsltItems.Count; i++)
			{
				writer.Write(ElSpaces(rsltItems[i].ClmnHeaderText));

				if (i < rsltItems.Count - 1)
				{
					if (!DBCfg.EliminateSpaces)
					{
						writer.Write(new string(' ', columnWidths[i] - rsltItems[i].ClmnHeaderText.Length + 3));
					}
					writer.Write(separatorStr);
				}
				else
				{
					writer.WriteLine(string.Empty);
				}
			}


			writer.WriteLine(new String('-', totalWidth));		/// Horizontal line between the header and the body


			/// Write table data
			foreach (var mtr in wm.MeterTestRslts)
			{
				if (mtr != null)
				{
					for (int i = 0; i < rsltItems.Count; i++)
					{
						string itemText;

						///
						/// Fetch an item
						/// 
						if (!wm.Compound())
						{
							/// Single water meter
							itemText = rsltItems[i].Print(mtr);
						}
						else if (mtr.CompoundMeterId == (byte)CompoundMeterId.Compound)
						{
							Results.Entities.MeterTestRslt mainMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundMain);
							Results.Entities.MeterTestRslt auxMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundAux);
							itemText = rsltItems[i].PrintCombined(mainMtr, auxMtr, mtr);
						}
						else
						{
							continue;
						}

						///
						/// Print the item
						///
						string[] texts = itemText.Split(new char[] { '|' });
						if (texts.Length == 2) { itemText = texts[0]; }		/// Strip color information

						writer.Write(ElSpaces(itemText));

						if (i < rsltItems.Count - 1)
						{
							if (!DBCfg.EliminateSpaces)
							{
								writer.Write(new string(' ', columnWidths[i] - itemText.Length + 3));
							}
							writer.Write(separatorStr);
						}
						else
						{
							writer.WriteLine(string.Empty);
						}
					}
				}
			}

			writer.WriteLine(new String('-', totalWidth));		/// Horizontal line below the body

			writer.WriteLine(string.Empty);
		}


		public Retv WriteLogsToDisk(Results.Entities.Batch batch)
		{
#if IPERLST
			if (logger == null) return Retv.Error;

			try
			{
				logger.WriteLine("[Wasserzähler-Daten]");
				logger.WriteLine(string.Format("PruefPunkte={0}", 3));
				logger.WriteLine(string.Format("Typ={0}", 3));					/// iP 020 Q3_4 R160 A XXXX       
				logger.WriteLine(string.Format("MetroKlasse={0}", batch.WaterMeters[0].WaterMeterData.MetrologicalClass));	/// R160
				logger.WriteLine(string.Format("Zulassungszeichen={0}", batch.WaterMeters[0].WaterMeterData.ApprovalInfo));	/// DE-12-MI001-PTB010
				logger.WriteLine(string.Format("Qn={0}", batch.WaterMeters[0].WaterMeterData.Qn));							/// 4,0
				logger.WriteLine(string.Format("Impulsrate={0}", 3));			/// 50,000
				logger.WriteLine(string.Format("WZid={0}", 3));					/// 1242
				logger.WriteLine(string.Format("RevWzTyp={0}", 3));				/// 1
				logger.WriteLine(string.Format("RevPruefstandWzTyp={0}", 3));	/// 2
				logger.WriteLine(string.Format("Durchfluss-5={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-5={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-5={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-5={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-5={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung-5={0}", 3));		/// 
				logger.WriteLine(string.Format("Durchfluss-4={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-4={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-4={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-4={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-4={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung-4={0}", 3));		/// 
				logger.WriteLine(string.Format("Durchfluss-3={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-3={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-3={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-3={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-3={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung-3={0}", 3));		/// 
				logger.WriteLine(string.Format("Durchfluss-2={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-2={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-2={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-2={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-2={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung-2={0}", 3));		/// 
				logger.WriteLine(string.Format("Durchfluss-1={0}", 3));			/// 4000,0
				logger.WriteLine(string.Format("Prüfzeit-1={0}", 3));			/// 500
				logger.WriteLine(string.Format("Prüfbereich100_110-1={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-1={0}", 3));		/// 90
				logger.WriteLine(string.Format("PrüfbereichMax-1={0}", 3));		/// 100
				logger.WriteLine(string.Format("QBezeichnung-1={0}", 3));		/// Just
				logger.WriteLine(string.Format("Durchfluss0={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit0={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_1100={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin0={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax0={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung0={0}", 3));		/// 
				logger.WriteLine(string.Format("Durchfluss1={0}", 3));			/// 25,0
				logger.WriteLine(string.Format("Prüfzeit1={0}", 3));			/// 500
				logger.WriteLine(string.Format("Prüfbereich100_1101={0}", 3));	/// 1
				logger.WriteLine(string.Format("PrüfbereichMin1={0}", 3));		/// 100
				logger.WriteLine(string.Format("PrüfbereichMax1={0}", 3));		/// 110
				logger.WriteLine(string.Format("QBezeichnung1={0}", 3));		/// Q1
				logger.WriteLine(string.Format("PosFehlergrenze1={0}", 3));		/// 5,0
				logger.WriteLine(string.Format("NegFehlergrenze1={0}", 3));		/// -5,0
				logger.WriteLine(string.Format("PosFehlergrenzeWarm1={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenzeWarm1={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("Durchfluss2={0}", 3));			/// 40,0
				logger.WriteLine(string.Format("Prüfzeit2={0}", 3));			/// 400
				logger.WriteLine(string.Format("Prüfbereich100_1102={0}", 3));	/// 1
				logger.WriteLine(string.Format("PrüfbereichMin2={0}", 3));		/// 100
				logger.WriteLine(string.Format("PrüfbereichMax2={0}", 3));		/// 110
				logger.WriteLine(string.Format("QBezeichnung2={0}", 3));		/// Q2
				logger.WriteLine(string.Format("PosFehlergrenze2={0}", 3));		/// 2,0
				logger.WriteLine(string.Format("NegFehlergrenze2={0}", 3));		/// -2,0
				logger.WriteLine(string.Format("PosFehlergrenzeWarm2={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenzeWarm2={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("Durchfluss3={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit3={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_1103={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin3={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax3={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung3={0}", 3));		/// 
				logger.WriteLine(string.Format("PosFehlergrenze3={0}", 3));		/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenze3={0}", 3));		/// 0,0
				logger.WriteLine(string.Format("PosFehlergrenzeWarm3={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenzeWarm3={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("Durchfluss4={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Prüfzeit4={0}", 3));			/// 0
				logger.WriteLine(string.Format("Prüfbereich100_1104={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin4={0}", 3));		/// 0
				logger.WriteLine(string.Format("PrüfbereichMax4={0}", 3));		/// 0
				logger.WriteLine(string.Format("QBezeichnung4={0}", 3));		/// 
				logger.WriteLine(string.Format("PosFehlergrenze4={0}", 3));		/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenze4={0}", 3));		/// 0,0
				logger.WriteLine(string.Format("PosFehlergrenzeWarm4={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenzeWarm4={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("Durchfluss5={0}", 3));			/// 4000,0
				logger.WriteLine(string.Format("Prüfzeit5={0}", 3));			/// 100
				logger.WriteLine(string.Format("Prüfbereich100_1105={0}", 3));	/// 0
				logger.WriteLine(string.Format("PrüfbereichMin5={0}", 3));		/// 90
				logger.WriteLine(string.Format("PrüfbereichMax5={0}", 3));		/// 100
				logger.WriteLine(string.Format("QBezeichnung5={0}", 3));		/// Q3
				logger.WriteLine(string.Format("PosFehlergrenze5={0}", 3));		/// 1,3
				logger.WriteLine(string.Format("NegFehlergrenze5={0}", 3));		/// -0,8
				logger.WriteLine(string.Format("PosFehlergrenzeWarm5={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("NegFehlergrenzeWarm5={0}", 3));	/// 0,0
				logger.WriteLine(string.Format("GetriebeImpulse={0}", 3));		/// 2,000
				logger.WriteLine(string.Format("OptikAufsetzen={0}", 3));		/// 0
				logger.WriteLine(string.Format("Warm_Kalt={0}", 3));			/// 0
				logger.WriteLine(string.Format("Füllzeit={0}", 3));				/// 0
				logger.WriteLine(string.Format("EvakVorneZeit={0}", 3));		/// 0
				logger.WriteLine(string.Format("EvakHintenZeit={0}", 3));		/// 90
				logger.WriteLine(string.Format("Spüllzeit={0}", 3));			/// 60
				logger.WriteLine(string.Format("Spüldurchfluss={0}", 3));		/// 5000,0
				logger.WriteLine(string.Format("Abpresszeit={0}", 3));			/// 60
				logger.WriteLine(string.Format("Abpressdruck={0}", 3));			/// 0,0
				logger.WriteLine(string.Format("Entwässerzeit={0}", 3));		/// 10
				logger.WriteLine(string.Format("DinA4_Format={0}", 3));			/// 0
				logger.WriteLine(string.Format("Netzwerk_Format={0}", 3));		/// 0
				logger.WriteLine(string.Format("Zählernr_Format={0}", 3));		/// 1
				logger.WriteLine(string.Format("WZ_Gruppe={0}", 3));			/// 24
				logger.WriteLine(string.Format("MittelwertTiefe={0}", 3));		/// 1
				logger.WriteLine(string.Format("EndKriterium={0}", 3));			/// 0
				logger.WriteLine(string.Format("Justieren={0}", 3));			/// 1
				logger.WriteLine(string.Format("Bemerkung={0}", 3));			///                     
				logger.WriteLine(string.Format("Gesamtprüfzeit={0}", 3));		/// 2042
				logger.WriteLine(string.Format("Gegenprüfung={0}", 3));			/// 0
				logger.WriteLine(string.Format("Geändert_von={0}", 3));			/// 4459
				logger.WriteLine(string.Format("Geändert_am={0}", 3));			/// 29.05.2015 13:46:17

				for (int i = 0; i < batch.WaterMeters.Count; i++)
				{
					Results.Entities.WaterMeter wMtr = batch.WaterMeters[i];

					logger.WriteLine(string.Empty);
					logger.WriteLine(string.Format("[Zählerdaten_{0}]", i + 1));
					logger.WriteLine(string.Format("geprüft={0}", 3));				/// 1
					logger.WriteLine(string.Format("Zählernummer={0}", wMtr.SerialNrEx));
					logger.WriteLine(string.Format("FertigsNr={0}", wMtr.SerialNr));
					logger.WriteLine(string.Format("bestanden={0}", 3));			/// 1
					logger.WriteLine(string.Format("Prüfflag={0}", 3));				/// 96
					logger.WriteLine(string.Format("FestWertWZ={0}", 3));			/// 0
					logger.WriteLine(string.Format("Dicht={0}", 3));				/// 1
					logger.WriteLine(string.Format("PrüfIndex={0}", 3));			/// 7301
					logger.WriteLine(string.Format("GeprüftIndex={0}", 3));			/// 1
					logger.WriteLine(string.Format("Q-1bestanden={0}", 3));			/// 1
					logger.WriteLine(string.Format("Durchfluss-1={0}", 3));			/// 3963,38404
					logger.WriteLine(string.Format("Fehler-1={0}", 3));				/// 2,12605
					logger.WriteLine(string.Format("ZeitImpulse-1={0}", 3));		/// 494,00012
					logger.WriteLine(string.Format("Impulse-1={0}", 3));			/// 0
					logger.WriteLine(string.Format("Volumen-1={0}", 3));			/// 543,86450
					logger.WriteLine(string.Format("KorrFehler-1={0}", 3));			/// 2,12605
					logger.WriteLine(string.Format("KorrDurchfluss-1={0}", 3));		/// 3963,38416
					logger.WriteLine(string.Format("Q-1KorrBestanden={0}", 3));		/// 0
					logger.WriteLine(string.Format("Anfangsstand-1={0}", 3));		/// 205,82450
					logger.WriteLine(string.Format("Endstand-1={0}", 3));			/// 749,68900
					logger.WriteLine(string.Format("QMittelwert-1={0}", 3));		/// 3963,38416
					logger.WriteLine(string.Format("QStandardAbweichung-1={0}", 3));	/// 23,80341
					logger.WriteLine(string.Format("ImpedanzMittelwert-1={0}", 3));	/// 0,00000
					logger.WriteLine(string.Format("AusfallGrund-1={0}", 3));		/// 0
					logger.WriteLine(string.Format("Q1bestanden={0}", 3));			/// 1
					logger.WriteLine(string.Format("Durchfluss1={0}", 3));			/// 26,91235
					logger.WriteLine(string.Format("Fehler1={0}", 3));				/// 0,05011
					logger.WriteLine(string.Format("ZeitImpulse1={0}", 3));			/// 501,12683
					logger.WriteLine(string.Format("Impulse1={0}", 3));				/// 0
					logger.WriteLine(string.Format("Volumen1={0}", 3));				/// 3,74625
					logger.WriteLine(string.Format("KorrFehler1={0}", 3));			/// 0,05223
					logger.WriteLine(string.Format("KorrDurchfluss1={0}", 3));		/// 26,91292
					logger.WriteLine(string.Format("Q1KorrBestanden={0}", 3));		/// 1
					logger.WriteLine(string.Format("Anfangsstand1={0}", 3));		/// 977,83375
					logger.WriteLine(string.Format("Endstand1={0}", 3));			/// 981,58000
					logger.WriteLine(string.Format("QMittelwert1={0}", 3));			/// 26,91292
					logger.WriteLine(string.Format("QStandardAbweichung1={0}", 3));	/// 3,61664
					logger.WriteLine(string.Format("ImpedanzMittelwert1={0}", 3));	/// 0,00000
					logger.WriteLine(string.Format("AusfallGrund1={0}", 3));		/// 0
					logger.WriteLine(string.Format("Q2bestanden={0}", 3));			/// 1
					logger.WriteLine(string.Format("Durchfluss2={0}", 3));			/// 42,06588
					logger.WriteLine(string.Format("Fehler2={0}", 3));				/// 0,52480
					logger.WriteLine(string.Format("ZeitImpulse2={0}", 3));			/// 400,75000
					logger.WriteLine(string.Format("Impulse2={0}", 3));				/// 0
					logger.WriteLine(string.Format("Volumen2={0}", 3));				/// 4,68275
					logger.WriteLine(string.Format("KorrFehler2={0}", 3));			/// 0,52028
					logger.WriteLine(string.Format("KorrDurchfluss2={0}", 3));		/// 42,06399
					logger.WriteLine(string.Format("Q2KorrBestanden={0}", 3));		/// 1
					logger.WriteLine(string.Format("Anfangsstand2={0}", 3));		/// 971,36300
					logger.WriteLine(string.Format("Endstand2={0}", 3));			/// 976,04575
					logger.WriteLine(string.Format("QMittelwert2={0}", 3));			/// 42,06399
					logger.WriteLine(string.Format("QStandardAbweichung2={0}", 3));	/// 3,52892
					logger.WriteLine(string.Format("ImpedanzMittelwert2={0}", 3));	/// 0,00000
					logger.WriteLine(string.Format("AusfallGrund2={0}", 3));		/// 0
					logger.WriteLine(string.Format("Q5bestanden={0}", 3));			/// 1
					logger.WriteLine(string.Format("Durchfluss5={0}", 3));			/// 3886,53959
					logger.WriteLine(string.Format("Fehler5={0}", 3));				/// 0,31667
					logger.WriteLine(string.Format("ZeitImpulse5={0}", 3));			/// 101,12317
					logger.WriteLine(string.Format("Impulse5={0}", 3));				/// 0
					logger.WriteLine(string.Format("Volumen5={0}", 3));				/// 109,17200
					logger.WriteLine(string.Format("KorrFehler5={0}", 3));			/// 0,31421
					logger.WriteLine(string.Format("KorrDurchfluss5={0}", 3));		/// 3886,44444
					logger.WriteLine(string.Format("Q5KorrBestanden={0}", 3));		/// 1
					logger.WriteLine(string.Format("Anfangsstand5={0}", 3));		/// 853,41800
					logger.WriteLine(string.Format("Endstand5={0}", 3));			/// 962,59000
					logger.WriteLine(string.Format("QMittelwert5={0}", 3));			/// 3886,44444
					logger.WriteLine(string.Format("QStandardAbweichung5={0}", 3));	/// 25,63481
					logger.WriteLine(string.Format("ImpedanzMittelwert5={0}", 3));	/// 0,00000
					logger.WriteLine(string.Format("AusfallGrund5={0}", 3));		/// 0
					logger.WriteLine(string.Format("AusfallGrundGesamt={0}", 3));	/// 0
					logger.WriteLine(string.Format("AuftragNum={0}", wMtr.PurchaseOrder));
					logger.WriteLine(string.Format("MaterialNum={0}", 3));			/// 38140500
					logger.WriteLine(string.Format("Prefix={0}", "8SEN01"));		/// 
					logger.WriteLine(string.Format("Suffix={0}", 3));				/// 
					logger.WriteLine(string.Format("Palette={0}", 0));				/// 0
					logger.WriteLine(string.Format("Umkarton={0}", 0));				/// 0
					logger.WriteLine(string.Format("ZNr_komplett={0}", 3));			/// 
					logger.WriteLine(string.Format("OptikBewertung={0}", "0,00000"));		/// 0,00000
					logger.WriteLine(string.Format("IdProduziert={0}", 3));			/// 61
					logger.WriteLine(string.Format("Calibration_alt={0}", 3));		/// 3746
					logger.WriteLine(string.Format("Calibration={0}", 3));			/// 3675
					logger.WriteLine(string.Format("Firmware={0}", 3));				/// 05.66
					logger.WriteLine(string.Format("FlexFlowFehler={0}", 3));		/// 0
					logger.WriteLine(string.Format("FlexFlowAuftrag={0}", 3));		/// 4248189
					logger.WriteLine(string.Format("JustierWert={0}", 3));			/// 0,2
					logger.WriteLine(string.Format("Corrected2Hz={0}", 0));								/// 0
					logger.WriteLine(string.Format("Q2Corrected={0}", wMtr.Q2CorrectionDone ? 1 : 0));	/// 0
					logger.WriteLine(string.Format("Q2CorrectionRight={0}", 3));						/// 0
					logger.WriteLine(string.Format("Q2CorrectionLeft={0}", 3));							/// 0
					logger.WriteLine(string.Format("Q2CorrectionFlowRight={0}", 3));	/// 0
					logger.WriteLine(string.Format("FlowDirectionRight={0}", 3));		/// 0
					logger.WriteLine(string.Format("Position={0}", wMtr.WMPosition));	/// 1
				}

				logger.WriteLine(string.Empty);
				logger.WriteLine(string.Format("[allgemein]"));					/// 
				logger.WriteLine(string.Format("Prüfer={0}", 6));				/// 1047
				logger.WriteLine(string.Format("PrüferID={0}", 6));				/// 246
				logger.WriteLine(string.Format("AuftragKompakt={0}", 3));		/// 4248189
				logger.WriteLine(string.Format("VariantenCode={0}", 3));		/// IPRO04CMECAZDKAMMXB1AA2011201101AEUAA1XX314NM1XXXLX
				logger.WriteLine(string.Format("SollStückzahl={0}", 3));		/// 1000
				logger.WriteLine(string.Format("IstStückzahl={0}", 3));			/// 61
				logger.WriteLine(string.Format("Bemerkung={0}", 3));			/// §
				logger.WriteLine(string.Format("BetriebsArt={0}", 3));			/// C
				logger.WriteLine(string.Format("BuchstabenVorEtikett={0}", 3));	/// 8SEN01
				logger.WriteLine(string.Format("BuchstabenNachEtikett={0}", 3));/// 
				logger.WriteLine(string.Format("StehenderStartStop={0}", 3));	/// 0
				logger.WriteLine(string.Format("ID_WzPruefreihe={0}", 3));		/// 2583
				logger.WriteLine(string.Format("ID_Pruefstand={0}", 3));		/// 18004
				logger.WriteLine(string.Format("DichteKorrektur={0}", 3));		/// 0,00000
				logger.WriteLine(string.Format("LuftauftriebsKorrekturfaktor={0}", 3));	/// 1,00100
				logger.WriteLine(string.Format("ProgrammVersion={0}", 3));		/// 2.18b
				logger.WriteLine(string.Format("LetzteAenderung={0}", 3));		/// 13.11.2015
				logger.WriteLine(string.Format("QuarzTakt={0}", 3));			/// 1953,125

				/// Close the file
				logger.Close();
				logger = null;
			}
			catch (Exception exc)
			{
				log.ErrorFormat("Results not saved to disk: {0}", exc.Message);
				return Retv.Error;
			}
#endif
			return Retv.OK;	/// OK
		}


#if IPERLST
		public static Retv WriteResultsToDatabase(OracleConnection conn, Results.Entities.Batch batch)
		{
            OracleTransaction transaction = null;

            try
            {
                conn.Open();	/// Open the Oracle database
                transaction = conn.BeginTransaction();

                SaveBatchData(conn, batch);

				foreach (var wMtr in batch.WaterMeters)
				{
					SaveSingleWM2DB(conn, wMtr);
				}

				transaction.Commit();
			}
			catch (Exception exc)
			{
				if (transaction != null) transaction.Rollback();

				log.ErrorFormat("Results of batch {0} not writen to ORACLE database: {1}",
								batch.BatchNr, exc.Message);

				conn.Close();
				return Retv.Error;
			}

			conn.Close();
			return Retv.OK;
		}


		/// <summary>
		/// Write one meter results into the database
		/// </summary>
		/// <param name="wmNr">0-based water meter number</param>
		/// <param name="results">Sorted list of results to save</param>
		static void SaveSingleWM2DB(OracleConnection conn, Results.Entities.WaterMeter wm)
		{
			if (string.IsNullOrEmpty(wm.SerialNr)) return;		/// No database activity possible w/o PCB number
            
			///
			/// Read a list of all prufindexes for a given PCB Number
			///
			IList<int> pruefindexes = new List<int>();
			{
				OracleParameter parm = new OracleParameter();
				parm.OracleDbType = OracleDbType.Varchar2;
				parm.Value = wm.SerialNr;

				OracleCommand cmd1 = new OracleCommand("SELECT MAX_Pruefindex FROM VT_ZAEHLER_PD WHERE VT_Fernum = :1 AND ANBID = 4", conn);
				cmd1.Parameters.Add(parm);

				OracleDataReader dr = cmd1.ExecuteReader();
                while (dr.Read()) { pruefindexes.Add(dr.GetInt32(0)); }
                dr.Close();
            }

			///
			/// Determine MAX_Pruefindex
			///
			int maxpruefindexLowPart = 0;
			foreach (var v in pruefindexes)
			{
				if ((v % 100) > maxpruefindexLowPart) maxpruefindexLowPart = (v % 100);
			}
			int MAX_Pruefindex = 100 * DBCfg.TestBenchId + maxpruefindexLowPart + 1;


			int Hydr_Pruefung;
			if (wm.Passed)
			{
				/// Passed
				if (maxpruefindexLowPart == 0)
					Hydr_Pruefung = 96;
				else
					Hydr_Pruefung = 224;
			}
			else
			{
				/// Failed
				Hydr_Pruefung = 97;     /// Hydr. test failed, Pressure test passed
			}

			SaveOrUpdateWM(conn, wm, MAX_Pruefindex, Hydr_Pruefung);
		}


		/// <summary>
		/// Save common batch data
		/// </summary>
		/// <param name="b">Batch</param>
		static int SaveBatchData(OracleConnection conn, Results.Entities.Batch b)
		{
			OracleCommand cmd = new OracleCommand("INSERT INTO VT_PRUEFREIHE_PD(" +
												  "ANBID, ID_Pruefstand, ID_WzPruefreihe, ID_WZTyp, Rev_WZTyp, Rev_Pruefstand_WZTyp, " +
												  "StartDatumZeit, EndDatumZeit, Betriebsart, QVzKontakt, " +
												  "FuellenBegDruck, DruckEvakVorne, DruckEvakHinten, DruckBeiAbpressen, " +
												  "Druckentwaessern, SpuelDurchflussIst, ProgrammVersion)" +
												  " VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, :14, :15, :16, :17)", conn);
			OracleParameter parm;
			parm = new OracleParameter("ANBID", OracleDbType.Int32);				parm.Value = Anbid_StaraTura;				            cmd.Parameters.Add(parm); ///:1
			parm = new OracleParameter("ID_Pruefstand", OracleDbType.Int32);		parm.Value = 18000 + b.TestBenchId;			            cmd.Parameters.Add(parm); ///:2
			parm = new OracleParameter("ID_WzPruefreihe", OracleDbType.Int32);		parm.Value = b.BatchNr;						            cmd.Parameters.Add(parm); ///:3
            parm = new OracleParameter("ID_WZTyp", OracleDbType.Int32);             parm.Value = b.WaterMeters[0].WaterMeterData.WMTypeId;  cmd.Parameters.Add(parm); ///:4
			parm = new OracleParameter("Rev_WZTyp", OracleDbType.Int32);			parm.Value = b.WaterMeters[0].WaterMeterData.WMTypeRev; cmd.Parameters.Add(parm); ///:5
			parm = new OracleParameter("Rev_Pruefstand_WZTyp", OracleDbType.Int32); parm.Value = 1;								            cmd.Parameters.Add(parm); ///:6
			parm = new OracleParameter("StartDatumZeit", OracleDbType.TimeStamp);	parm.Value = b.StartTime;				            	cmd.Parameters.Add(parm); ///:7
			parm = new OracleParameter("EndDatumZeit", OracleDbType.TimeStamp);		parm.Value = b.EndTime;					            	cmd.Parameters.Add(parm); ///:8
			parm = new OracleParameter("Betriebsart", OracleDbType.Varchar2);		parm.Value = "";						            	cmd.Parameters.Add(parm); ///:9
			parm = new OracleParameter("QVzKontakt", OracleDbType.Double);			parm.Value = 0;							            	cmd.Parameters.Add(parm); ///:10
			parm = new OracleParameter("FuellenBegDruck", OracleDbType.Double);		parm.Value = 0;							            	cmd.Parameters.Add(parm); ///:11
			parm = new OracleParameter("DruckEvakVorne", OracleDbType.Double);		parm.Value = 0;							            	cmd.Parameters.Add(parm); ///:12
			parm = new OracleParameter("DruckEvakHinten", OracleDbType.Double);		parm.Value = 0;							            	cmd.Parameters.Add(parm); ///:13
			parm = new OracleParameter("DruckBeiAbpressen", OracleDbType.Double);	parm.Value = 0;/*TODO*/					            	cmd.Parameters.Add(parm); ///:14
			parm = new OracleParameter("Druckentwaessern", OracleDbType.Double);	parm.Value = 0;							            	cmd.Parameters.Add(parm); ///:15
			parm = new OracleParameter("SpuelDurchflussIst", OracleDbType.Double);	parm.Value = 0;/*TODO*/						            cmd.Parameters.Add(parm); ///:16
			parm = new OracleParameter("ProgrammVersion", OracleDbType.Varchar2);	parm.Value = "TBF v." + b.ProgramVersion;	            cmd.Parameters.Add(parm); ///:17

			int retv = cmd.ExecuteNonQuery();	/// Returns nr. of updated rows
            log.InfoFormat("Batch data saved, batchNr={0}", b.BatchNr);
            return retv;
		}


		static void SaveOrUpdateWM(OracleConnection conn, Results.Entities.WaterMeter wm, int max_Pruefindex, int hydr_Pruefung)
		{
			int sekundaere_Adr = wm.Passed ? 1 : 0;

			if (max_Pruefindex % 100 == 1)
			{
				OracleCommand cmd = new OracleCommand("INSERT INTO VT_ZAEHLER_PD(Auftragsnummer, VT_Identnummer, VT_Fernum, Max_Pruefindex, Zaehlernummer, Sekundaere_Adr, Hydr_Pruefung, ID_Benutzer, ANBID, Baujahr) VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)", conn);

				OracleParameter parm;
				parm = new OracleParameter("Auftragsnummer", OracleDbType.Varchar2); parm.Value = wm.PurchaseOrder; cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Identnummer", OracleDbType.Varchar2); parm.Value = "IPBATMXX";		cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		 parm.Value = wm.SerialNr;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("Max_Pruefindex", OracleDbType.Int32);	 parm.Value = max_Pruefindex;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Zaehlernummer", OracleDbType.Int32);	 parm.Value = -1;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("Sekundaere_Adr", OracleDbType.Int32);	 parm.Value = sekundaere_Adr;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	 parm.Value = hydr_Pruefung;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		 parm.Value = 6;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			 parm.Value = Anbid_StaraTura;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Baujahr", OracleDbType.Int32);			 parm.Value = DBCfg.Baujahr;	cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PD inserted, PcbNr={0}, pos={1}, maxPruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex);
            }
			else
			{
				OracleCommand cmd = new OracleCommand("UPDATE VT_ZAEHLER_PD SET Auftragsnummer = :1, VT_Identnummer = :2, Max_Pruefindex = :3, Hydr_Pruefung= :4, ID_Benutzer= :5, Baujahr= :6 WHERE VT_Fernum = :7 and ANBID = :8", conn);

				OracleParameter parm;
				parm = new OracleParameter("Auftragsnummer", OracleDbType.Varchar2); parm.Value = wm.PurchaseOrder; cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Identnummer", OracleDbType.Varchar2); parm.Value = "IPBATMXX";		cmd.Parameters.Add(parm);
				parm = new OracleParameter("Max_Pruefindex", OracleDbType.Int32);	 parm.Value = max_Pruefindex;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	 parm.Value = hydr_Pruefung;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		 parm.Value = 6;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("Baujahr", OracleDbType.Int32);			 parm.Value = DBCfg.Baujahr;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		 parm.Value = wm.SerialNr;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			 parm.Value = Anbid_StaraTura;	cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PD updated, PcbNr={0}, pos={1}, maxPruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex);
            }

			{
				OracleCommand cmd = new OracleCommand("INSERT INTO VT_ZAEHLER_PINDEX_PD(" +
														"VT_Fernum, Pruefindex, ANBID, ID_Pruefstand, ID_WzPruefreihe, Hydr_Pruefung, " +
														"ReedKontakt, ReedKontaktOK, ReedKontaktZeit, KorrImprate, FestWertWZ, PtestOK, " +
														"Zaehlerstand, WT_Platz_NR, WZgut, ID_Benutzer, AnzahlPruefungen)" +
														" VALUES (:1, :2, :3, :4, :5, :6, 0, 0, 0, :7, 0, :8, 0, :9, :10, :11, :12)", conn);
				OracleParameter parm;
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		parm.Value = wm.SerialNr;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("Pruefindex", OracleDbType.Int32);		parm.Value = max_Pruefindex % 100;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			parm.Value = Anbid_StaraTura;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Pruefstand", OracleDbType.Int32);	parm.Value = 18000 + wm.Batch.TestBenchId; cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_WzPruefreihe", OracleDbType.Int32);	parm.Value = wm.Batch.BatchNr;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	parm.Value = hydr_Pruefung;				cmd.Parameters.Add(parm);
				// ReedKontakt
				// ReedKontaktOK
				// ReedKontaktZeit
				parm = new OracleParameter("KorrImprate", OracleDbType.Double);		parm.Value = wm.OrigCalibFactor;		cmd.Parameters.Add(parm);
				// FestWertWZ
				parm = new OracleParameter("PtestOK", OracleDbType.Int32);			parm.Value = 0;/*TODO*/					cmd.Parameters.Add(parm);
				// Zaehlerstand
				parm = new OracleParameter("WT_Platz_NR", OracleDbType.Int32);		parm.Value = wm.WMPosition;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("WZgut", OracleDbType.Int32);			parm.Value = wm.Passed ? 1 : 0;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		parm.Value = 6;							cmd.Parameters.Add(parm);
				parm = new OracleParameter("AnzahlPruefungen", OracleDbType.Int32); parm.Value = 3;							cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PINDEX_PD inserted, PcbNr={0}, pos={1}, pruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex % 100);
            }

			for (int q = 1; q <= 3; q++)
			{
				Results.Entities.MeterTestRslt mtr = wm.GetMeterTestRslt(string.Format("Q{0}", q));
				SaveMeterTestResult(conn, mtr, q, max_Pruefindex);
			}

			{
                double q2ErrWOCorrection = Math.Min(100.0, Math.Max(-100.0, wm.Q2ErrWOCorrection));

				OracleCommand cmd = new OracleCommand("INSERT INTO VT_IP_ZAEHLER_PINDEX_PD(" +
														"VT_Fernum, Pruefindex, ANBID, WITHCORRECTION2HZ, CORRECTION2HZ, DIFF2HZ8HZ, " +
														"WITHQ2CORRECTION, ERRQ2, Q2CORRECTIONFLOWRIGHT, Q2CORRECTIONLEFT, Q2CORRECTIONRIGHT)" +
														" VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11)", conn);
				OracleParameter parm;
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);			parm.Value = wm.SerialNr;							cmd.Parameters.Add(parm); ///:1
				parm = new OracleParameter("Pruefindex", OracleDbType.Int32);			parm.Value = max_Pruefindex;	    				cmd.Parameters.Add(parm); ///:2
				parm = new OracleParameter("ANBID", OracleDbType.Int32);				parm.Value = Anbid_StaraTura;						cmd.Parameters.Add(parm); ///:3
				parm = new OracleParameter("WITHCORRECTION2HZ", OracleDbType.Int32);	parm.Value = wm.Hz2CorrectionDone ? 1 : 0;			cmd.Parameters.Add(parm); ///:4
				parm = new OracleParameter("CORRECTION2HZ", OracleDbType.Double);		parm.Value = wm.Hz2Correction;						cmd.Parameters.Add(parm); ///:5
				parm = new OracleParameter("DIFF2HZ8HZ", OracleDbType.Double);			parm.Value = wm.Diff2Hz8Hz;							cmd.Parameters.Add(parm); ///:6
				parm = new OracleParameter("WITHQ2CORRECTION", OracleDbType.Int32);		parm.Value = wm.Q2CorrectionDone ? 1 : 0;			cmd.Parameters.Add(parm); ///:7
                parm = new OracleParameter("ERRQ2", OracleDbType.Double);               parm.Value = q2ErrWOCorrection;                     cmd.Parameters.Add(parm); ///:8
				parm = new OracleParameter("Q2CORRECTIONFLOWRIGHT", OracleDbType.Int32);parm.Value = wm.Q2CorrFlowRight;/*1=right to left*/	cmd.Parameters.Add(parm); ///:9
				parm = new OracleParameter("Q2CORRECTIONLEFT", OracleDbType.Int32);		parm.Value = (int)Math.Round(wm.Q2Correction);		cmd.Parameters.Add(parm); ///:10
				parm = new OracleParameter("Q2CORRECTIONRIGHT", OracleDbType.Int32);	parm.Value = (int)Math.Round(wm.Q2Correction / 2);	cmd.Parameters.Add(parm); ///:11

				int rowsUpdated = cmd.ExecuteNonQuery();
                log.InfoFormat("VT_IP_ZAEHLER_PINDEX_PD inserted, PcbNr={0}, pruefix={1}", wm.SerialNr, max_Pruefindex);
            }
		}


		/// <summary>
		/// Saves a water meter result of a single test
		/// </summary>
		/// <param name="q">q = 0, 1, 2 or 3 (Adj., Q1, Q2, Q3)</param>
		/// <returns>Nr. of rows updated</returns>
		static int SaveMeterTestResult(OracleConnection conn, Results.Entities.MeterTestRslt mtr, int q, int max_Pruefindex) /// 
		{
			double Q_wm = 3600.0 * mtr.VolumeMeter / mtr.TestTime;		/// in [l/hour]
			int qq = (q == 0) ? -1 : q;

			OracleCommand cmd = new OracleCommand("INSERT INTO VT_PRUEFREIHE_IST_PD(" +
												  "VT_Fernum, Pruefindex, PruefungsNr, ANBID, ID_WZTyp, Rev_WZTyp, Rev_WZPruefpunkt, " +
												  "Q_WZ, Q_Fehler, Q_Best, NIZ, AnfangZStand, EndZStand, " +
												  "KorrErrQok, KorrErrQ, KorrQWz, TIZ, Vol_WZ_US, TempMittel_US)" +
												  " VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, 0, 0, 0, :14, 0, 0)", conn);
			OracleParameter parm;
			parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		parm.Value = mtr.WaterMeter.SerialNr;	cmd.Parameters.Add(parm); ///:1
			parm = new OracleParameter("Pruefindex", OracleDbType.Int32);		parm.Value = max_Pruefindex % 100;		cmd.Parameters.Add(parm); ///:2
			parm = new OracleParameter("PruefungsNr", OracleDbType.Int32);		parm.Value = qq;						cmd.Parameters.Add(parm); ///:3
			parm = new OracleParameter("ANBID", OracleDbType.Int32);			parm.Value = Anbid_StaraTura;			cmd.Parameters.Add(parm); ///:4
			parm = new OracleParameter("ID_WZTyp", OracleDbType.Int32);			parm.Value = mtr.WaterMeter.WaterMeterData.WMTypeId; cmd.Parameters.Add(parm);	///:5
			parm = new OracleParameter("Rev_WZTyp", OracleDbType.Int32);		parm.Value = mtr.WaterMeter.WaterMeterData.WMTypeRev; cmd.Parameters.Add(parm); ///:6
			parm = new OracleParameter("Rev_WZPruefpunkt", OracleDbType.Int32); parm.Value = 1;							cmd.Parameters.Add(parm); ///:7
			parm = new OracleParameter("Q_WZ", OracleDbType.Double);			parm.Value = Q_wm;						cmd.Parameters.Add(parm); ///:8
			parm = new OracleParameter("Q_Fehler", OracleDbType.Double);		parm.Value = mtr.Error;					cmd.Parameters.Add(parm); ///:9
			parm = new OracleParameter("Q_Best", OracleDbType.Int32);			parm.Value = mtr.Passed ? 1 : 0;		cmd.Parameters.Add(parm); ///:10
			parm = new OracleParameter("NIZ", OracleDbType.Int32);				parm.Value = 0;							cmd.Parameters.Add(parm); ///:11
			parm = new OracleParameter("AnfangZStand", OracleDbType.Double);	parm.Value = 0;/*TODO*/					cmd.Parameters.Add(parm); ///:12
			parm = new OracleParameter("EndZStand", OracleDbType.Double);		parm.Value = 0;/*TODO*/					cmd.Parameters.Add(parm); ///:13
			/// KorrErrQok
			/// KorrErrQ
			/// KorrQWz
			parm = new OracleParameter("TIZ", OracleDbType.Double);		parm.Value = Math.Min(100000, mtr.TestTime);	cmd.Parameters.Add(parm);
			/// Vol_WZ_US
			/// TempMittel_US

			int retv = cmd.ExecuteNonQuery();
            log.DebugFormat("VT_PRUEFREIHE_IST_PD inserted, PcbNr={0}, q={1}, error={2}", mtr.WaterMeter.SerialNr, qq, mtr.Error);
            return retv;
        }
#endif
	}
}