///
/// Copyright (c) 2018-2022 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using log4net;
using Common;
using Config;
using Config.Entities;
using Results.Entities;
using Results.Output;
using Events.Entities;
using TBF.Rig.Sequences;

namespace TBF.Rig.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("{0}({1})", ClassName, 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;
		}

        public override void Initialize()
        {
            currentOp = CurrentOp.None;
            log.FatalFormat("{0} initialized: {1}", Name, this);
        }


		/// <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 ProcessResultsOp(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
                        {
                            anyError = anyError || (WriteLogsToDisk(logger, batch) != Retv.OK);
                            logger.Flush();
                            logger.Close();
                            log.WarnFormat("{0} : Batch #{1} written OK", Name, batch.BatchNr);
                        }
                        catch (Exception exc)
                        {
                            anyError = true;
                            log.WarnFormat("{0} : Failed to write batch #{1}: {2}", Name, batch.BatchNr, exc.Message);
                        }
                    }

                    opCompleted = true;
                }

                if (TBF.DB.EventsDBSessionFactory != null && anyError)
                {
                    NHibernate.ISession session = null;
                    try
                    {
                        session = TBF.DB.EventsDBSessionFactory.OpenSession();
                        Events.DB.LoadSubscribers(session);

                        TBF.UiBridge.Bridge.TriggerEvent(session, Name, EventClass.ComputerResources, Severity.Error,
                                                         string.Format("Nepodarilo sa uložiť logy pre WZ Datenbank: Číslo dávky={0}", batch.BatchNr),
                                                         string.Format("Nepodarilo sa uložiť logy pre WZ Datenbank\r\nČíslo dávky = {0}", batch.BatchNr),
                                                         SubscriberGroup.Metrology | SubscriberGroup.Maintenance | SubscriberGroup.Production);
                    }
                    catch (Exception exc)
                    {
                        log.ErrorFormat("Triggering event(s) failed: {0}", exc.Message);
                    }
                    finally
                    {
                        if (session != null && session.IsOpen) session.Close();
                    }
                }

                return anyError ? Event.ErrorProcessingResults: Event.ResultsWritten;
            }
            else
            {
                return Event.None;
            }
		}

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


		public Retv WriteLogsToDisk(TextWriter logger, Batch batch)
        {
#if ORACLE_DB

            ///
            /// Obtain data of one water meter
            ///
            WaterMeter firstWM = batch.WaterMeters.FirstOrDefault<WaterMeter>(x => (x != null && !x.Disabled && x.WaterMeterData != null));
            if (firstWM == null)
            {
                log.Error("Not a single watermeter in the batch");
                return Retv.Error;          /// Not a single watermeter in the batch
            }
            WaterMeterData wmData = firstWM.WaterMeterData;

            ///
            /// Select or create appropriate test infos
            ///
            IList<LUTestData> testsToSave = new List<LUTestData>();
            int maxPruefungsNr = 0;
            double totalTestTime = 0;
            foreach (var td in batch.Tests)
            {
                for (int repNr = 1; repNr <= td.Repeats; repNr++)
                {
                    int testId = td.OraId + (td.Repeats - repNr) * td.OraIdRepetMulti;
                    if (testId != 0)
                    {
                        testsToSave.Add(new LUTestData(td, repNr));
                        if (Math.Abs(testId) > maxPruefungsNr) maxPruefungsNr = Math.Abs(testId);
                        totalTestTime += td.TargetTime;
                    }
                }
            }
            LUTestData[] testsToSaveArr = testsToSave.ToArray();
            Array.Sort(testsToSaveArr, new LUTestDataComparer());

            /// Make a log
            foreach (var ltd in testsToSaveArr)
            {
                log.WarnFormat("   Test={0}  Repetition={1}  Id={2}  Designation={3}", ltd.TData.Name, ltd.RepNr, ltd.Id, ltd.Designation);
            }

            ///
            /// Check whether the test results are complete, quit on error
            ///
            MeterTestRslt[] firstWMTestRslts = new MeterTestRslt[testsToSaveArr.Length];
            foreach (var ltd in testsToSaveArr)
            {
                if (firstWM.GetMeterTestRslt(ltd.TestName) == null)
                {
                    log.ErrorFormat("Missing test result for test {0}", ltd.TestName);
                    return Retv.Error;          /// Missing test result for one of specified tests
                }
            }

            ///
            /// Save the log file
            ///
			logger.WriteLine("[Wasserzähler-Daten]");
            logger.WriteLine(string.Format("PruefPunkte={0}",       (maxPruefungsNr > 20) ? 99 : (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}",          firstWM.WMTypeRevision));
			logger.WriteLine(string.Format("RevPruefstandWzTyp=2"));

            foreach (var ltd in testsToSaveArr)
            {
                string fId = ltd.Id.ToString((ltd.Id > 0) ? "D2" : "D1");
                string qBz = ltd.Designation;
                var td = ltd.TData;
                bool pb_100_110 = (Math.Abs(td.Qtg - td.Qfrom) < Math.Abs(td.Qto - td.Qtg));

                logger.WriteLine(string.Format("Durchfluss{0}={1}", fId, Units.ConvertTo(Unit.lph, (td.Qfrom + td.Qto) / 2).ToString("F1", Program.AltCulture)));
                logger.WriteLine(string.Format("Prüfzeit{0}={1}", fId, td.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 (ltd.Id > 0)
                {
                    /// Test is not an adjustment
                    logger.WriteLine(string.Format("PosFehlergrenze{0}={1}", fId, (td.ErrLimHi - td.ErrLimMargin).ToString("F1", Program.AltCulture)));
                    logger.WriteLine(string.Format("NegFehlergrenze{0}={1}", fId, (td.ErrLimLo + td.ErrLimMargin).ToString("F1", Program.AltCulture)));
                    logger.WriteLine(string.Format("PosFehlergrenzeWarm{0}=0,0", fId));
                    logger.WriteLine(string.Format("NegFehlergrenzeWarm{0}=0,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.E26 | (int)ErrorFlagMask.E27 | (int)ErrorFlagMask.E28)) != 0)
                {
                    logger.WriteLine();
                    logger.WriteLine(string.Format("[Zählerdaten_{0}]", wMtr.WMPosition));
                    logger.WriteLine("geprüft=0");
                }
                else
                {
                    bool testRsltIsMissing = false;
                    Results.Entities.MeterTestRslt[] wmtrs = new Results.Entities.MeterTestRslt[testsToSaveArr.Length];
                    for (int j = 0; j < testsToSaveArr.Length; j++)
                    {
                        wmtrs[j] = wMtr.GetMeterTestRslt(testsToSaveArr[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 < testsToSaveArr.Length; j++)
                        {
                            if (testsToSaveArr[j].Id != 0)
                            {
                                Results.Entities.MeterTestRslt mtr = wmtrs[j];
                                string flID = testsToSaveArr[j].Id.ToString((testsToSaveArr[j].Id > 0) ? "D2" : "D1");

                                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)));
#if ORACLE_DB
                                    logger.WriteLine(string.Format("KorrFehler{0}={1}", flID, mtr.ErrorBC.ToString(Program.AltCulture)));
#else
                                    logger.WriteLine(string.Format("KorrFehler{0}={1}", flID, mtr.Error.ToString(Program.AltCulture)));
#endif
                                    logger.WriteLine(string.Format("KorrDurchfluss{0}={1}", flID, 0));
                                    logger.WriteLine(string.Format("Q{0}KorrBestanden={1}", flID, mtr.Passed ? 1 : 0));
                                    logger.WriteLine(string.Format("Anfangsstand{0}={1}", flID, mtr.VolumeStart).ToString(Program.AltCulture));
                                    logger.WriteLine(string.Format("Endstand{0}={1}", flID, mtr.VolumeEnd).ToString(Program.AltCulture));
                                    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));
#if ORACLE_DB
						logger.WriteLine(string.Format("Prefix={0}", wMtr.Prefix));
                        logger.WriteLine(string.Format("Suffix={0}", wMtr.Suffix));
#else
						logger.WriteLine(string.Format("Prefix={0}", "8SEN"));
                        logger.WriteLine(string.Format("Suffix="));
#endif
                        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.Q2CorrRL != 0) || (wMtr.Q2CorrLR != 0)) ? 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 ltd in testsToSaveArr)
			{
                string pNrStr = ltd.Id.ToString((ltd.Id > 0) ? "D2" : "D1");
                Results.Entities.TestRslt tr = firstWM.GetTestRslt(ltd.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
#endif
            return Retv.OK;	/// OK
		}


		void WriteOneToDisk(TextWriter logger, string id, Results.Entities.TestRslt tr)
		{
            logger.WriteLine(string.Format("Prüfvolumen{0}={1}", id, Common.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, Common.Units.ConvertTo(Unit.bar, tr.PressUpMean).ToString(Program.AltCulture)));
			logger.WriteLine(string.Format("Druck2_P{0}={1}", id, Common.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, Common.Units.ConvertTo(Unit.lph, tr.FlowMin).ToString(Program.AltCulture)));
            logger.WriteLine(string.Format("MaxDurchfluss{0}={1}", id, Common.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
		}
	}
}