///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;
using log4net;
using Config;
using Config.Entities;

namespace TBF.BenchControl.Output.FileWriters.IperlLogger
{
	public enum Retv
	{
		OK,
		Error,
	}

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


        WriterCfg writerCfg;

        enum CurrentOp
        {
            None,
            WriteResults,
        }
        CurrentOp currentOp;
        bool opCompleted;
        bool anyError;


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


		public Writer() {}

		public Writer(Generic.IComponentCfg cfg)
            : base(cfg)
		{
			writerCfg = cfg as WriterCfg;
            currentOp = CurrentOp.None;

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


		/// <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 = writerCfg.DestinationPath;		/// Ends with "\\";
			Directory.CreateDirectory(directory);

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

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

			if (writerCfg.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)
		{
            if (currentOp != CurrentOp.None)
            {
                throw new Exception("Sequence error");
            }

            this.batch = batch;
            currentOp = CurrentOp.WriteResults;

			try
			{
                fileName = GetLogFileName(batch.StartTime);
			}
			catch
			{
                fileName = string.Empty;
				log.Error("Unable to create IperlLogger file name");
			}

            return this;
		}

		/// <summary>Start this operation</summary>
		public void Start()
		{
            opCompleted = false;
            anyError = false;
        }

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

                if (!opCompleted && !string.IsNullOrEmpty(fileName))
                {
                    log.WarnFormat("{0} : Going to write Iperl Log to file {1}", Name, fileName);

                    using (TextWriter logger = new StreamWriter(System.IO.File.Create(fileName)))
                    {
                        try
                        {
                            WriteLogsToDisk(logger, batch);
                            logger.Flush();
                            logger.Close();
                            log.WarnFormat("{0} : Batch {1} written OK", Name, batch.BatchNr);
                        }
                        catch
                        {
                            anyError = true;
                            log.WarnFormat("{0} : Failed to write batch {1}", Name, batch.BatchNr);
                        }
                    }

                    opCompleted = true;
                }

                if (anyError)
                    return Event.ResultsNotWritten;
                else
                    return Event.ResultsWritten;
            }
            else
            {
                return Event.None;
            }
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
            currentOp = CurrentOp.None;
		}


		public Retv WriteLogsToDisk(TextWriter logger, Results.Entities.Batch batch)
        {
#if TURA_IPERL || TURA_SPECIAL

            /// Obtain one representative water meter data
            Results.Entities.WaterMeter wm0 = null;
            foreach (var m in batch.WaterMeters)
            {
                if (m != null)
                {
                    wm0 = m;
                    break;
                }
            }
            if (wm0 == null)
            {
                return Retv.Error;          /// Not a single watermeter in the batch
            }


            SensusTestInfo[] testInfos = wm0.CompleteTestInfos as SensusTestInfo[];
            if (testInfos == null)
            {
                return Retv.Error;          /// No test infos
            }


            Results.Entities.WaterMeterData wmData = wm0.WaterMeterData;

            Results.Entities.MeterTestRslt[] wm0trs = new Results.Entities.MeterTestRslt[testInfos.Length];
            double totalTestTime = 0;
            int maxPruefungsNr = 0;
            for (int j = 0; j < testInfos.Length; j++)
            {
                if (testInfos[j].PruefungsNrLog != 0)
                {
                    if (Math.Abs(testInfos[j].PruefungsNrLog) > maxPruefungsNr) maxPruefungsNr = Math.Abs(testInfos[j].PruefungsNrLog);

                    wm0trs[j] = wm0.GetMeterTestRslt(testInfos[j].TestName);

                    if (wm0trs[j] != null)
                    {
                        totalTestTime += wm0trs[j].TargetTime();
                    }
                    else
                    {
                        return Retv.Error;      /// Missing test result for one of specified tests
                    }
                }
            }


			try
			{
				logger.WriteLine("[Wasserzähler-Daten]");
                logger.WriteLine(string.Format("PruefPunkte={0}",       (maxPruefungsNr > 15) ? 20 : ((maxPruefungsNr > 10) ? 15 : ((maxPruefungsNr > 5) ? 10 : 5))));
				logger.WriteLine(string.Format("Typ={0}",               batch.ProcedureName));	        /// iP 020 Q3_4 R160 A XXXX       
				logger.WriteLine(string.Format("MetroKlasse={0}",       wmData.MetrologicalClass));
				logger.WriteLine(string.Format("Zulassungszeichen={0}", wmData.ApprovalInfo));
                logger.WriteLine(string.Format("Qn={0}",                wmData.Q3_Qn.ToString("F1", Program.AltCulture)));
                logger.WriteLine(string.Format("Impulsrate=1"));
				logger.WriteLine(string.Format("WZid={0}",              wmData.WMTypeId));
                logger.WriteLine(string.Format("RevWzTyp={0}",          wm0.WMTypeRevision));
				logger.WriteLine(string.Format("RevPruefstandWzTyp=2"));

                for (int j = 0; j < testInfos.Length; j++)
                {
                    if (testInfos[j].PruefungsNrLog != 0)
                    {
                        string fId = testInfos[j].PruefungsNrLog.ToString("D2");
                        string qBz = testInfos[j].QBezeichnungLog;
                        Results.Entities.MeterTestRslt wm0r = wm0trs[j];
                        bool pb_100_110 = (testInfos[j].Range == Range.R100_110);

                        if (wm0r != null)
                        {
                            /// An existing test
                            logger.WriteLine(string.Format("Durchfluss{0}={1}", fId, Units.ConvertTo(Unit.lph, (wm0r.Qfrom() + wm0r.Qto()) / 2).ToString("F1", Program.AltCulture)));
                            logger.WriteLine(string.Format("Prüfzeit{0}={1}", fId, wm0r.TargetTime().ToString("F0")));
                            logger.WriteLine(string.Format("Prüfbereich100_110{0}={1}", fId, (pb_100_110 ? 1 : 0)));
                            logger.WriteLine(string.Format("PrüfbereichMin{0}={1}", fId, (pb_100_110 ? 100 : 90)));
                            logger.WriteLine(string.Format("PrüfbereichMax{0}={1}", fId, (pb_100_110 ? 110 : 100)));
                            logger.WriteLine(string.Format("QBezeichnung{0}={1}", fId, qBz));
                            if (testInfos[j].PruefungsNrLog > 0)
                            {
                                /// Test is not an adjustment
                                logger.WriteLine(string.Format("PosFehlergrenze{0}={1}", fId, (wm0r.ErrLimHi() - wm0r.Uncertainty()).ToString("F1", Program.AltCulture)));
                                logger.WriteLine(string.Format("NegFehlergrenze{0}={1}", fId, (wm0r.ErrLimLo() + wm0r.Uncertainty()).ToString("F1", Program.AltCulture)));
                                logger.WriteLine(string.Format("PosFehlergrenzeWarm{0}=0,0", fId));
                                logger.WriteLine(string.Format("NegFehlergrenzeWarm{0}=0,0", fId));
                            }
                        }
                        else
                        {
                            logger.WriteLine(string.Format("Durchfluss{0}=0,0", fId));
                            logger.WriteLine(string.Format("Prüfzeit{0}=0", fId));
                            logger.WriteLine(string.Format("Prüfbereich100_110{0}=0", fId));
                            logger.WriteLine(string.Format("PrüfbereichMin{0}=0", fId));
                            logger.WriteLine(string.Format("PrüfbereichMax{0}=0", fId));
                            logger.WriteLine(string.Format("QBezeichnung{0}=", fId));
                        }
                    }
                }

				logger.WriteLine(string.Format("GetriebeImpulse=2,000"));			/// 2,000
				logger.WriteLine(string.Format("OptikAufsetzen=0"));				/// 0
				logger.WriteLine(string.Format("Warm_Kalt=0"));						/// 0
				logger.WriteLine(string.Format("Füllzeit=0"));						/// 0
				logger.WriteLine(string.Format("EvakVorneZeit=0"));					/// 0
				logger.WriteLine(string.Format("EvakHintenZeit={0}", 0));			/// 90
				logger.WriteLine(string.Format("Spüllzeit={0}", 0));				/// 60
				logger.WriteLine(string.Format("Spüldurchfluss={0}", 0));			/// 5000,0
				logger.WriteLine(string.Format("Abpresszeit={0}", 0));				/// 60
				logger.WriteLine(string.Format("Abpressdruck={0}", 0));				/// 0,0
				logger.WriteLine(string.Format("Entwässerzeit={0}", 0));			/// 10
				logger.WriteLine(string.Format("DinA4_Format={0}", 0));				/// 0
				logger.WriteLine(string.Format("Netzwerk_Format={0}", 0));			/// 0
				logger.WriteLine(string.Format("Zählernr_Format={0}", 0));			/// 1
				logger.WriteLine(string.Format("WZ_Gruppe=24"));					/// 24 - iPerl
				logger.WriteLine(string.Format("MittelwertTiefe={0}", 0));			/// 1
				logger.WriteLine(string.Format("EndKriterium={0}", 0));				/// 0
				logger.WriteLine(string.Format("Justieren={0}", 1));				/// 1
				logger.WriteLine(string.Format("Bemerkung="));						///                     
                logger.WriteLine(string.Format("Gesamtprüfzeit={0}", totalTestTime.ToString("F0")));
				logger.WriteLine(string.Format("Gegenprüfung={0}", 0));				/// 0
				logger.WriteLine(string.Format("Geändert_von={0}", 6));				/// 4459
				logger.WriteLine(string.Format("Geändert_am={0:dd.MM.yyyy HH:mm:ss}", DateTime.Now));	/// 29.05.2015 13:46:17

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

                    if ((wMtr != null) && (wMtr.ErrorFlags & ((int)ErrorFlagMask.E25 | (int)ErrorFlagMask.E26 | (int)ErrorFlagMask.E27 | (int)ErrorFlagMask.E28)) == 0)
                    {
                        bool testRsltIsMissing = false;
                        Results.Entities.MeterTestRslt[] wmtrs = new Results.Entities.MeterTestRslt[testInfos.Length];
                        for (int j = 0; j < testInfos.Length; j++)
                        {
                            if (testInfos[j].PruefungsNrLog != 0)
                            {
                                wmtrs[j] = wMtr.GetMeterTestRslt(testInfos[j].TestName);
                                if (wmtrs[j] == null) testRsltIsMissing = true;   /// Missing test result for one of specified tests
                            }
                        }

					    logger.WriteLine();
                        logger.WriteLine(string.Format("[Zählerdaten_{0}]", wMtr.WMPosition));

                        if (testRsltIsMissing)
					    {
						    logger.WriteLine("geprüft=0");
					    }
					    else
					    {
						    logger.WriteLine("geprüft=1");
						    logger.WriteLine(string.Format("Zählernummer="));
						    logger.WriteLine(string.Format("FertigsNr={0}", wMtr.SerialNr));
						    logger.WriteLine(string.Format("bestanden={0}", wMtr.Passed ? 1 : 0));	/// 1
						    logger.WriteLine(string.Format("Prüfflag={0}", wMtr.HydrPruefung));	    /// 96
						    logger.WriteLine(string.Format("FestWertWZ=0"));					    /// 0
						    logger.WriteLine(string.Format("Dicht={0}", 1));					    /// 1
						    logger.WriteLine(string.Format("PrüfIndex={0}", wMtr.Pruefindex));	    /// 7301
						    logger.WriteLine(string.Format("GeprüftIndex=1"));					    /// 1

                            for (int j = 0; j < testInfos.Length; j++)
                            {
                                if (testInfos[j].PruefungsNrLog != 0)
                                {
                                    Results.Entities.MeterTestRslt mtr = wmtrs[j];
                                    string flID = testInfos[j].PruefungsNrLog.ToString("D2");

                                    if (mtr != null)
                                    {
                                        logger.WriteLine(string.Format("Q{0}bestanden={1}", flID, 1));
                                        logger.WriteLine(string.Format("Durchfluss{0}={1}", flID, Utils.DoubleToStr(Units.ConvertTo(Unit.lph, mtr.FlowVolume()), 5, true)));
                                        logger.WriteLine(string.Format("Fehler{0}={1}", flID, mtr.Error.ToString(Program.AltCulture)));
                                        logger.WriteLine(string.Format("ZeitImpulse{0}={1}", flID, mtr.TestTime.ToString(Program.AltCulture)));
                                        logger.WriteLine(string.Format("Impulse{0}={1}", flID, 0));
                                        logger.WriteLine(string.Format("Volumen{0}={1}", flID, mtr.VolumeMeter.ToString(Program.AltCulture)));
                                        logger.WriteLine(string.Format("KorrFehler{0}={1}", flID, ((testInfos[j].TestName == "Q2") && mtr.WaterMeter.Q2CorrectionDone) ? mtr.WaterMeter.Q2ErrWOCorrection.ToString(Program.AltCulture)
                                                                                                                                                                : mtr.Error.ToString(Program.AltCulture)));
                                        logger.WriteLine(string.Format("KorrDurchfluss{0}={1}", flID, 0));
                                        logger.WriteLine(string.Format("Q{0}KorrBestanden={1}", flID, 0));
                                        logger.WriteLine(string.Format("Anfangsstand{0}={1}", flID, 0));		    /// TODO
                                        logger.WriteLine(string.Format("Endstand{0}={1}", flID, 0));			    /// TODO
                                        logger.WriteLine(string.Format("QMittelwert{0}={1}", flID, Utils.DoubleToStr(Units.ConvertTo(Unit.lph, mtr.FlowVolume()), 5, true)));
                                        logger.WriteLine(string.Format("QStandardAbweichung{0}={1}", flID, 0));
                                        logger.WriteLine(string.Format("ImpedanzMittelwert{0}={1}", flID, "0,00000"));
                                        logger.WriteLine(string.Format("AusfallGrund{0}={1}", flID, 0));
                                    }
                                }
                            }

						    logger.WriteLine(string.Format("AusfallGrundGesamt={0}", 0));
						    logger.WriteLine(string.Format("AuftragNum={0}",            wMtr.PurchaseOrder));
						    logger.WriteLine(string.Format("MaterialNum={0}",           38140500));
						    logger.WriteLine(string.Format("Prefix={0}", "8SEN01"));
						    logger.WriteLine(string.Format("Suffix="));
						    logger.WriteLine(string.Format("Palette={0}", 0));
						    logger.WriteLine(string.Format("Umkarton={0}", 0));
						    logger.WriteLine(string.Format("ZNr_komplett="));
						    logger.WriteLine(string.Format("OptikBewertung=0,00000"));
						    logger.WriteLine(string.Format("IdProduziert={0}", 0));
						    logger.WriteLine(string.Format("Calibration_alt={0}",       wMtr.OrigCalibFactor));
						    logger.WriteLine(string.Format("Calibration={0}",           wMtr.CalibFactor));
						    logger.WriteLine(string.Format("Firmware={0}",              wMtr.FWVersion));	/// 5.066
						    logger.WriteLine(string.Format("FlexFlowFehler={0}",        0));			    /// 0
						    logger.WriteLine(string.Format("FlexFlowAuftrag={0}",       0));			    /// 4248189
						    logger.WriteLine(string.Format("JustierWert=0,2"));					            /// 0,2
						    logger.WriteLine(string.Format("Corrected2Hz={0}",          wMtr.Hz2CorrectionDone ? 1 : 0));
						    logger.WriteLine(string.Format("Q2Corrected={0}",           wMtr.Q2CorrectionDone ? 1 : 0));
						    logger.WriteLine(string.Format("Q2CorrectionRight={0}",     wMtr.Q2CorrLR));
						    logger.WriteLine(string.Format("Q2CorrectionLeft={0}",      wMtr.Q2CorrRL));
						    logger.WriteLine(string.Format("Q2CorrectionFlowRight={0}", wMtr.Q2CorrFlowRight));
						    logger.WriteLine(string.Format("FlowDirectionRight={0}",    wMtr.Q2CorrFlowRight));
						    logger.WriteLine(string.Format("Position={0}",              wMtr.WMPosition));
					    }
				    }
                }

				logger.WriteLine();
				logger.WriteLine("[Prüfdaten]");
                ///
				logger.WriteLine(string.Format("Startzeit={0}", batch.StartTime.ToString("HH:mm:ss")));
				logger.WriteLine(string.Format("Endezeit={0}", batch.EndTime.ToString("HH:mm:ss")));
				logger.WriteLine(string.Format("Datum={0}", batch.StartTime.ToString("dd.MM.yyyy")));
				logger.WriteLine(string.Format("GesamtDauer={0}", batch.EndTime.Subtract(batch.StartTime).TotalSeconds));
				logger.WriteLine(string.Format("Dichtprüfung={0}", 0));							/// 1


				foreach (var cti in testInfos)
				{
                    if (cti.PruefungsNrLog != 0)
                    {
                        string pNrStr = cti.PruefungsNrLog.ToString("D2");
                        Results.Entities.TestRslt tr = wm0.GetTestRslt(cti.TestName);

                        if (tr != null)
                        {
                            logger.WriteLine(string.Format("Q{0}_geprüft=1", pNrStr));
                            WriteOneToDisk(logger, pNrStr, tr);
                        }
                        else
                        {
                            logger.WriteLine(string.Format("Q{0}_geprüft=0", pNrStr));
                        }
                    }
				}

				logger.WriteLine(string.Format("FüllenDruck={0}", 0));							/// 0,00
				logger.WriteLine(string.Format("EvakVorneDruck={0}", 0));						/// 0,00
				logger.WriteLine(string.Format("EvakHintenDruck={0}", 0));						/// -1,00
				logger.WriteLine(string.Format("Spüldurchfluss={0}", 0));						/// 4722,00
				logger.WriteLine(string.Format("AbpressDruck={0}", 0));							/// 20,13
				logger.WriteLine(string.Format("AbpressDruckVorne={0}", 0));					/// 20,16
				logger.WriteLine(string.Format("AbpressDruckBeginn={0}", 0));					/// 0,00
				logger.WriteLine(string.Format("EntwässernDruck={0}", 0));						/// -1,00
				logger.WriteLine(string.Format("ZaehlwerktestAnfang={0}", 0));					/// 0,00000
				logger.WriteLine(string.Format("ZaehlwerktestEnde={0}", 0));					/// 0,00000
				logger.WriteLine(string.Format("ZaehlwerktestImpulse={0}", 0));					/// 0
				logger.WriteLine(string.Format("MeldungZaehler={0}", 0));						/// 0


				logger.WriteLine();
				logger.WriteLine("[allgemein]");
                ///
				logger.WriteLine(string.Format("Prüfer={0}", batch.UserName));
				logger.WriteLine(string.Format("PrüferID={0}", batch.UserNumber));
				logger.WriteLine(string.Format("AuftragKompakt={0}", 0));							/// 4248189
				logger.WriteLine(string.Format("VariantenCode={0}", "IP"));							/// IPRO04CMECAZDKAMMXB1AA2011201101AEUAA1XX314NM1XXXLX
				logger.WriteLine(string.Format("SollStückzahl={0}", 3));							/// 1000
				logger.WriteLine(string.Format("IstStückzahl={0}", 3));								/// 61
				logger.WriteLine(string.Format("Bemerkung=§"));										/// §
				logger.WriteLine(string.Format("BetriebsArt={0}", 3));								/// C
				logger.WriteLine(string.Format("BuchstabenVorEtikett=8SEN01"));						/// 8SEN01
				logger.WriteLine(string.Format("BuchstabenNachEtikett="));							/// 
				logger.WriteLine(string.Format("StehenderStartStop={0}", 0));						/// 0
				logger.WriteLine(string.Format("ID_WzPruefreihe={0}", batch.BatchNr));				/// 2583
				logger.WriteLine(string.Format("ID_Pruefstand={0}", 18000 + batch.TestBenchId));	/// 18004
				logger.WriteLine(string.Format("DichteKorrektur=0,00000"));							/// 0,00000
				logger.WriteLine(string.Format("LuftauftriebsKorrekturfaktor=1,00000"));			/// 1,00100
				logger.WriteLine(string.Format("ProgrammVersion={0}", Program.Version));
				logger.WriteLine(string.Format("LetzteAenderung={0}", Program.BuildDateTime.ToShortDateString()));
				logger.WriteLine(string.Format("QuarzTakt={0}", 0));								/// 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
		}


		void WriteOneToDisk(TextWriter logger, string id, Results.Entities.TestRslt tr)
		{
            logger.WriteLine(string.Format("Prüfvolumen{0}={1}", id, Config.Units.ConvertTo(Unit.l, tr.TestData.TargetVolume).ToString(Program.AltCulture)));
			logger.WriteLine(string.Format("Prüfmasse{0}={1}", id, 0));							/// 3,72610
			logger.WriteLine(string.Format("Temp1_P{0}={1}", id, 0));							/// 20,0
			logger.WriteLine(string.Format("Temp2_P{0}={1}", id, 0));							/// 20,0
			logger.WriteLine(string.Format("Temp3_P{0}={1}", id, 0));							/// 20,0
			logger.WriteLine(string.Format("Temp4_P{0}={1}", id, 0));	    					/// 20,0
			logger.WriteLine(string.Format("Temp5_P{0}={1}", id, 0));		    				/// 20,0
			logger.WriteLine(string.Format("Temp6_P{0}={1}", id, 0));			    			/// 20,0
			logger.WriteLine(string.Format("Temp7_P{0}={1}", id, 0));				    		/// 0,0
			logger.WriteLine(string.Format("Temp8_P{0}={1}", id, 0));					    	/// 0,0
			logger.WriteLine(string.Format("Druck1_P{0}={1}", id, Config.Units.ConvertTo(Unit.bar, tr.PressUpMean).ToString(Program.AltCulture)));
			logger.WriteLine(string.Format("Druck2_P{0}={1}", id, Config.Units.ConvertTo(Unit.bar, tr.PressDownMean).ToString(Program.AltCulture)));
			logger.WriteLine(string.Format("K-Faktor{0}={1}", id, 0));							/// 0,99820080
			logger.WriteLine(string.Format("Q_Waage{0}={1}", id, 0));						    /// 26,89887
			logger.WriteLine(string.Format("Q_Vergleich{0}={1}", id, 0));						/// 26,83427
			logger.WriteLine(string.Format("Fehler_Vergleich{0}={1}", id, 0));					/// -0,24014
			logger.WriteLine(string.Format("VZ_ZeitImpulse{0}={1}", id, 0));					/// 500,07962
			logger.WriteLine(string.Format("VZ_Impulse{0}={1}", id, 0));						/// 4473091
			logger.WriteLine(string.Format("ZeitImpulse_VZ{0}={1}", id, 0));					/// 976718
			logger.WriteLine(string.Format("VorwahlZähler{0}={1}", id, 0));						/// 0,00000
			logger.WriteLine(string.Format("VZ_Nummer{0}={1}", id, 0));							/// 3
			logger.WriteLine(string.Format("Anfangsgewicht{0}={1}", id, 0));					/// 4,66535
			logger.WriteLine(string.Format("Endgewicht{0}={1}", id, 0));						/// 8,39145
            logger.WriteLine(string.Format("MinDurchfluss{0}={1}", id, Config.Units.ConvertTo(Unit.lph, tr.FlowMin).ToString(Program.AltCulture)));
            logger.WriteLine(string.Format("MaxDurchfluss{0}={1}", id, Config.Units.ConvertTo(Unit.lph, tr.FlowMax).ToString(Program.AltCulture)));
			logger.WriteLine(string.Format("Q_Einstellzeit{0}={1}", id, 0));					/// 4,17
			logger.WriteLine(string.Format("Pumpennummer{0}={1}", id, 0));						/// 3
			logger.WriteLine(string.Format("Drehzahl{0}={1}", id, 0));							/// 1743
			logger.WriteLine(string.Format("DAW_Wert{0}={1}", id, 0));							/// 2700
			logger.WriteLine(string.Format("Leitfähigkeit{0}={1}", id, 0));						/// 543,10
			logger.WriteLine(string.Format("LuftDruck{0}={1}", id, 0));							/// 0,0
			logger.WriteLine(string.Format("LuftFeuchtigkeit{0}={1}", id, 0));					/// 0,0
			logger.WriteLine(string.Format("HyDruck{0}={1}", id, 0));					    	/// 6,2
			logger.WriteLine(string.Format("VorratsDruckHy{0}={1}", id, 0));					/// 6,3
			logger.WriteLine(string.Format("Anfangsgewicht2_{0}={1}", id, 0));					/// 37,94400
			logger.WriteLine(string.Format("Endgewicht2_{0}={1}", id, 0));						/// 37,94200
			logger.WriteLine(string.Format("Prüfmasse2_{0}={1}", id, 0));						/// -0,00200
			logger.WriteLine(string.Format("GegenWaage{0}={1}", id, 0));						/// 1
		}
	}
}