///
/// Copyright (c) 2019 Sensus Slovensko a.s.
///
using System;
using System.Drawing;
using System.Windows.Forms;
using log4net;
using Config.Entities;
using Results.Entities;
using TBF.BenchControl.Sequences;
using TBF.UiBridge;
using TBF.Resources;

#pragma warning disable 162     /// Disables 'Unreachable code detected' warning

namespace TBF.UI.Process
{
    public partial class ProcessTabPageExCtrl : UserControl
    {
		static readonly ILog log = LogManager.GetLogger(typeof(ProcessTabPageExCtrl));

        enum Columns
        {
            Meter = 0,
            Sensor,
            Pulses,
            RefPulses,
            Volume,
            Error,
            Result,
            Energy,
            EnergyError,
            HeatMeterResult,
        }

        MetersKind currentMetersKind;

        bool pumpOn = true;
        bool diverterToTank = true;

		/// <summary>
		/// Constructor, initializes anonymous event handlers
		/// </summary>
		public ProcessTabPageExCtrl()
        {
            currentMetersKind = MetersKind.Single;

            InitializeComponent();

#if HEAT_METERS
            tLoLabel.Visible = true;
            tLoCmpntLabel.Visible = true;
            tLoDataLabel.Visible = true;
            tHiLabel.Visible = true;
            tHiCmpntLabel.Visible = true;
            tHiDataLabel.Visible = true;
#endif

			Bridge.ProcedureSelectedHandler += delegate(object sndr, ProcedureSelectedEventArgs args)
			{
				try
				{
					if (InvokeRequired) Invoke(new EventHandler<ProcedureSelectedEventArgs>(OnProcedureSelected), sndr, args);
					else OnProcedureSelected(sndr, args);
				}
				catch (Exception e) { log.ErrorFormat("ProcessTabPage24.OnProcedureSelected() failed: {0}", e.Message); }
			};

			Bridge.TestSelectedHandler += delegate(object sender, TestSelectedEventArgs args)
			{
				try
				{
					if (InvokeRequired) Invoke(new EventHandler<TestSelectedEventArgs>(OnTestSelected), sender, args);
					else OnTestSelected(sender, args);
				}
				catch (Exception e) { log.ErrorFormat("ProcessTabPage24.OnTestSelected() failed: {0}", e.Message); }
			};

			Bridge.ProcessDataHandler += delegate(object sender, ProcessDataEventArgs args)
			{
				try
				{
					if (InvokeRequired) Invoke(new EventHandler<ProcessDataEventArgs>(OnProcessDataChanged), sender, args);
					else OnProcessDataChanged(sender, args);
				}
				catch (Exception e) { log.ErrorFormat("ProcessTabPage24.OnProcessDataChanged() failed: {0}", e.Message); }
			};

			Bridge.TestCompletedHandler += delegate(object sender, TestCompletedEventArgs args)
			{
				try
				{
					if (InvokeRequired) Invoke(new EventHandler<TestCompletedEventArgs>(OnTestCompleted), sender, args);
					else OnTestCompleted(sender, args);
				}
				catch (Exception e) { log.ErrorFormat("ProcessTabPage24.OnTestCompleted() failed: {0}", e.Message); }
			};

			Bridge.ProcedureCompletedHandler += delegate(object sender, ProcedureCompletedEventArgs args)
			{
				try
				{
					if (InvokeRequired) Invoke(new EventHandler<ProcedureCompletedEventArgs>(OnProcedureCompleted), sender, args);
					else OnProcedureCompleted(sender, args);
				}
				catch (Exception e) { log.ErrorFormat("ProcessTabPage24.OnProcedureCompleted() failed: {0}", e.Message); }
			};

            Timer timer = new Timer();
            timer.Tick += (s, e) => { OnTimerTick(); };
            timer.Interval = 5000;
            timer.Start();
		}

		private void ProcessTabPageCtrl_Load(object sender, EventArgs e)
		{
			Once();
			ResetLabelsAndTargetVals();
			ResetReadings();        /// Erase all results
            OnTimerTick();          /// Redraw measurements that are always available
            ProcessTabPageCtrl_Paint(this, null);
		}

		void Once()
		{
            UpdateCurrentMetersKind(MetersKind.Single, true);
        }

        /// <summary>
        /// Update 'currentMetersKind' variable and visibility of UI items.
        /// </summary>
        /// <param name="metersKind">New value</param>
        /// <param name="fromScratch">true = always update UI</param>
		void UpdateCurrentMetersKind(MetersKind metersKind, bool fromScratch = false)
		{
            if (currentMetersKind != metersKind || fromScratch)
            {
                currentMetersKind = metersKind;

                metersListView.Items.Clear();
                metersListView.Columns.Clear();

                metersListView.Columns.Add(Strings.Meter, 60);
                metersListView.Columns.Add(Strings.Sensor, 80);
                metersListView.Columns.Add(Strings.Pulses_count, 100);
                metersListView.Columns.Add(Strings.Ref_pulses_count, 120);
                metersListView.Columns.Add(Strings.Volume, 80);
                metersListView.Columns.Add(Strings.Error, 80);
                metersListView.Columns.Add(Strings.Result, 80);
                ///
                if (metersKind == MetersKind.HeatMeter)
                {
                    metersListView.Columns.Add(Strings.Energy, 80);
                    metersListView.Columns.Add(Strings.Error, 80);
                    metersListView.Columns.Add(Strings.Result, 80);
                }

                if ((metersKind == MetersKind.Single) || (metersKind == MetersKind.HeatMeter))
                {
                    for (int i = 0; i < Config.Data.WMsCount; i++)
                    {
                        ListViewItem lvi = new ListViewItem(new string[] { (i + 1).ToString(), "---", "---", "---", "---", "---", "---" });
                        if (metersKind == MetersKind.HeatMeter)
                        {
                            lvi.SubItems.Add("---");    /// energy
                            lvi.SubItems.Add("---");    /// energy error
                            lvi.SubItems.Add("---");    /// HeatMeter result
                        }
                        metersListView.Items.Add(lvi);
                    }
                }
                else if (metersKind == MetersKind.Combined)
                {
                    for (int z = 0; z < Config.Data.CompoundWMsCount; z++)
                    {
                        ListViewItem lvi = new ListViewItem(string.Format("{0} {1}", Strings.Compound_meter_0, z + 1));
                        lvi.SubItems.Add(string.Empty);     /// sensor
                        lvi.SubItems.Add(string.Empty);     /// pulses count
                        lvi.SubItems.Add("---");            /// ref. pulses count
                        lvi.SubItems.Add("---");            /// volume
                        lvi.SubItems.Add("---");            /// error
                        lvi.SubItems.Add("---");            /// result
                        metersListView.Items.Add(lvi);

                        ListViewItem iMain = new ListViewItem(Strings.Main);
                        iMain.SubItems.Add("---");          /// sensor
                        iMain.SubItems.Add("---");          /// pulses count
                        iMain.SubItems.Add(string.Empty);   /// ref. pulses count
                        iMain.SubItems.Add("---");          /// volume
                        iMain.SubItems.Add(string.Empty);   /// error
                        iMain.SubItems.Add(string.Empty);   /// result
                        metersListView.Items.Add(iMain);

                        ListViewItem iAux = new ListViewItem(Strings.Aux);
                        iAux.SubItems.Add("---");           /// sensor
                        iAux.SubItems.Add("---");           /// pulses count
                        iAux.SubItems.Add(string.Empty);    /// ref. pulses count
                        iAux.SubItems.Add("---");           /// volume
                        iAux.SubItems.Add(string.Empty);    /// error
                        iAux.SubItems.Add(string.Empty);    /// result
                        metersListView.Items.Add(iAux);
                    }
                }
            }
		}


		/// <summary>
		/// Called when a new procedure is selected
		/// </summary>
		void ResetLabelsAndTargetVals()
		{
			/// Target values
			targetFlowLowLabel.Text = "---";
			targetFlowHighLabel.Text = "---";
			targetVolumeLabel.Text = "---";
			targetRefCountLabel.Text = "---";
			estmtdTimeLabel.Text = "---";

            //
			refFlowCmpntLabel.Text = "---";
			regValveCmpntLabel.Text = "---";

			/// Water pressure
			prInCmpntLabel.Text = "---";
			prOutCmpntLabel.Text    = "---";

            /// Water temperature
            tInCmpntLabel.Text = "---";
            tOutCmpntLabel.Text = "---";
            tDivCmpntLabel.Text = "---";
            tHiCmpntLabel.Text = "---";
            tLoCmpntLabel.Text = "---";

            scaleCmpntLabel.Text = "---";

            if ((currentMetersKind == MetersKind.Single) || (currentMetersKind == MetersKind.HeatMeter))
            {
                for (int i = 0; i < metersListView.Items.Count; i++)
                {
                    metersListView.Items[i].SubItems[(int)Columns.Sensor].Text = "---";
                }
            }
            else if (currentMetersKind == MetersKind.Combined)
            {
                for (int z = 0; z < Math.Min(Config.Data.CompoundWMsCount, metersListView.Items.Count / 3); z++)
                {
                    metersListView.Items[3 * z + 1].SubItems[(int)Columns.Sensor].Text = "---";
                    metersListView.Items[3 * z + 2].SubItems[(int)Columns.Sensor].Text = "---";
                }
            }
        }


		/// <summary>
		/// Called when a new procedure or a new test procedure is selected
		/// </summary>
		void ResetReadings()
		{
			/// Top part
			refPulsesLabel.Text = "---";
			refFreqLabel.Text = "---";
			refFlowLabel.Text = "---";
			refVolumeLabel.Text = "---";

			regValvePosLabel.Text = "---";
			tDivLabel.Text = "---";

            tInLabel.Text = "---";
            prInLabel.Text = "---";

            tHiDataLabel.Text = "---";
            tLoDataLabel.Text = "---";

            tOutLabel.Text = "---";
            prOutLabel.Text = "---";

            massLabel.Text = "---";
            massDiffLabel.Text = "---";
            volumeCtvLabel.Text = "---";
            refErrorLabel.Text = "---";


            if (currentMetersKind == MetersKind.Single)
			{
				for (int i = 0; i < metersListView.Items.Count; i++)
				{
                    metersListView.Items[i].SubItems[(int)Columns.Pulses].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.RefPulses].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Volume].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Error].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Result].Text = "---";
				}
            }
            else if (currentMetersKind == MetersKind.HeatMeter)
            {
                for (int i = 0; i < metersListView.Items.Count; i++)
                {
                    metersListView.Items[i].SubItems[(int)Columns.Pulses].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.RefPulses].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Volume].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Error].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Result].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.Energy].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.EnergyError].Text = "---";
                    metersListView.Items[i].SubItems[(int)Columns.HeatMeterResult].Text = "---";
                }
            }
            else if (currentMetersKind == MetersKind.Combined)
            {
                for (int z = 0; z < Math.Min(Config.Data.CompoundWMsCount,  metersListView.Items.Count / 3); z++)
                {
                    /// Compound
                    metersListView.Items[3 * z].SubItems[(int)Columns.RefPulses].Text = "---";
                    metersListView.Items[3 * z].SubItems[(int)Columns.Volume].Text = "---";
                    metersListView.Items[3 * z].SubItems[(int)Columns.Error].Text = "---";
                    metersListView.Items[3 * z].SubItems[(int)Columns.Result].Text = "---";

                    /// Main
                    metersListView.Items[3 * z + 1].SubItems[(int)Columns.Pulses].Text = "---";
                    metersListView.Items[3 * z + 1].SubItems[(int)Columns.Volume].Text = "---";

                    /// Aux
                    metersListView.Items[3 * z + 2].SubItems[(int)Columns.Pulses].Text = "---";
                    metersListView.Items[3 * z + 2].SubItems[(int)Columns.Volume].Text = "---";
                }
            }
        }

        void OnTimerTick()
        {
            ///
            /// Always available
            ///
            airTempLabel.Text = ProcessData.AmbTemp.ToString();
            airPressLabel.Text = Config.Units.ConvertTo(Config.Unit.mbar, ProcessData.AmbPress.Val).ToString("F0");
            airHumiLabel.Text = ProcessData.AmbHumi.ToString();

            tInLabel.Text = ProcessData.TempUp.ToString();
            tOutLabel.Text = ProcessData.TempDown.ToString();
            tDivLabel.Text = ProcessData.TempDiv.ToString();

            prInLabel.Text = ProcessData.PressUp.ToString();
            prOutLabel.Text = ProcessData.PressDown.ToString();

            massLabel.Text = ProcessData.Mass.ToString();

#if HEAT_METERS
            tHiDataLabel.Text = (ProcessData.TempRefHi1.Valid && ProcessData.TempRefHi2.Valid) ? ((ProcessData.TempRefHi1.Val + ProcessData.TempRefHi2.Val) / 2).ToString("F2") : "---";
            tLoDataLabel.Text = (ProcessData.TempRefLo1.Valid && ProcessData.TempRefLo2.Valid) ? ((ProcessData.TempRefLo1.Val + ProcessData.TempRefLo2.Val) / 2).ToString("F2") : "---";
#endif
        }

		void OnProcedureSelected(object sender, ProcedureSelectedEventArgs args)
		{
			UpdateCurrentMetersKind(args.Procedure.MetersKind);
			ResetLabelsAndTargetVals();
			ResetReadings();
            OnTimerTick();          /// Redraw measurements that are always available
            Invalidate();
		}

		void OnTestSelected(object sender, TestSelectedEventArgs args)
		{
            /// Readings and target values
            ResetReadings();

            /// Target values
			targetFlowLowLabel.Text  = args.Test.Qfrom.ToString("F3");
			targetFlowHighLabel.Text = args.Test.Qto.ToString("F3");
			targetVolumeLabel.Text   = args.Test.Volume.ToString("F1");
			targetRefCountLabel.Text = args.TotalPulses.ToString();
			estmtdTimeLabel.Text     = args.Test.TstTime.ToString("F1");

			/// Names of virtual bench components
            if (args.OutputPath.FlowMeter != null) refFlowCmpntLabel.Text = args.OutputPath.FlowMeter.Name;
            if (args.OutputPath.RegulValve != null) regValveCmpntLabel.Text = args.OutputPath.RegulValve.Name;
            if (args.OutputPath.Scale != null) scaleCmpntLabel.Text = args.OutputPath.Scale.Name;
            if (args.BenchPath.PressMtrUp != null) prInCmpntLabel.Text = args.BenchPath.PressMtrUp.Name;
            if (args.BenchPath.PressMtrDown != null) prOutCmpntLabel.Text    = args.BenchPath.PressMtrDown.Name;
            if (args.BenchPath.TempMtrUp != null)    tInCmpntLabel.Text      = args.BenchPath.TempMtrUp.Name;
            if (args.BenchPath.TempMtrDown != null)  tOutCmpntLabel.Text     = args.BenchPath.TempMtrDown.Name;
            if (args.OutputPath.TempDiv != null)     tDivCmpntLabel.Text     = args.OutputPath.TempDiv.Name;
#if HEAT_METERS
            if (args.HeatMetersPath != null && args.HeatMetersPath.TMeterRefWarm1 != null) tHiCmpntLabel.Text = args.HeatMetersPath.TMeterRefWarm1.Name;
            if (args.HeatMetersPath != null && args.HeatMetersPath.TMeterRefCold1 != null) tLoCmpntLabel.Text = args.HeatMetersPath.TMeterRefCold1.Name;
#endif

            OnTimerTick();          /// Redraw measurements that are always available
            
            if ((currentMetersKind == MetersKind.Single) || (currentMetersKind == MetersKind.HeatMeter))
            {
                for (int i = 0; i < metersListView.Items.Count; i++)
                {
                    metersListView.Items[i].SubItems[(int)Columns.Sensor].Text = (args.MetersPath.RegisterReaders[i] != null)
                                                                               ? args.MetersPath.RegisterReaders[i].Cfg.Name
                                                                               : string.Empty;
                }
            }
            else if (currentMetersKind == MetersKind.Combined)
            {
                for (int z = 0; z < Math.Min(Config.Data.CompoundWMsCount, metersListView.Items.Count / 3); z++)
                {
                    metersListView.Items[3 * z + 1].SubItems[(int)Columns.Sensor].Text
                        = ((args.MetersPath.RegisterReaders != null) && (args.MetersPath.RegisterReaders.Length > 2 * z) && (args.MetersPath.RegisterReaders[2 * z] != null))
                        ? args.MetersPath.RegisterReaders[2 * z].Cfg.Name
                        : string.Empty;

                    metersListView.Items[3 * z + 2].SubItems[(int)Columns.Sensor].Text
                        = ((args.MetersPath.RegisterReaders != null) && (args.MetersPath.RegisterReaders.Length > 2 * z + 1) && (args.MetersPath.RegisterReaders[2 * z + 1] != null))
                        ? args.MetersPath.RegisterReaders[2 * z + 1].Cfg.Name
                        : string.Empty;
                }
            }

			if (args.FeedingPath != null && (args.FeedingPath.Pump is BenchControl.GenericDevices.IPumpFM))
			{
				pumpPctTextBox.Visible = true;
				pumpPctTextBox.Text = (args.FeedingPath.Pump as BenchControl.GenericDevices.IPumpFM).Power.ToString("F0") + " %";
			}
			else
			{
				pumpPctTextBox.Visible = false;
			}
        }

		void OnProcessDataChanged(object sender, ProcessDataEventArgs args)
		{
            /// Pressure may change faster then temperature, therefore it is updated also here
			prInLabel.Text = ProcessData.PressUp.ToString();
			prOutLabel.Text = ProcessData.PressDown.ToString();

			massLabel.Text = ProcessData.Mass.ToString();

			if (args.TestPhase == Config.Entities.Progress.FlowSetting ||
				args.TestPhase == Config.Entities.Progress.Test)
			{
				///
				/// Available when setting the flow and during a test
				///
				refFreqLabel.Text = ProcessData.RefFreq.ToString();
				refFlowLabel.Text = Utils.DoubleToStr(ProcessData.RefFlow.Val, 4);
			}

			if (args.TestPhase == Config.Entities.Progress.Test)
			{
				///
				/// Available only during a test
				///
				refPulsesLabel.Text = ProcessData.RefPulses.ToString();
				double refVolume = ProcessData.LtrPerRefPulse * (double)ProcessData.RefPulses;
				refVolumeLabel.Text = refVolume.ToString("F2");

				double massDiff = ProcessData.Mass.Val - ProcessData.StartMass.Val;
				massDiffLabel.Text = massDiff.ToString("F3");
                double volumeCtv = 1000 * Config.Formulas.Buoyancy() * massDiff
                    / Config.Formulas.WaterDensityFromTempPress((ProcessData.TempUp.Val + ProcessData.TempDown.Val) / 2,
                                                                (ProcessData.PressUp.Val + ProcessData.PressDown.Val) / 2);
                volumeCtvLabel.Text = volumeCtv.ToString("F2");
				double refError = Config.Formulas.ErrorFromVolumes(refVolume, volumeCtv);
				refErrorLabel.Text = refError.ToString("F3");

                if (currentMetersKind == MetersKind.Single || currentMetersKind == MetersKind.HeatMeter)
				{
					for (int i = 0; i < Math.Min(metersListView.Items.Count, ProcessData.RegisterReaders.Length); i++)
					{
                        ListViewItem lvi = metersListView.Items[i];
                        BenchControl.GenericDevices.IRegReader rr = ProcessData.RegisterReaders[i];
						if (rr != null)
						{
							lvi.SubItems[(int)Columns.Pulses].Text = rr.WMPulses.ToString();
							lvi.SubItems[(int)Columns.RefPulses].Text = rr.WMRefPulses.ToString();
							lvi.SubItems[(int)Columns.Volume].Text = rr.WMVolume.ToString("F1");
                            lvi.SubItems[(int)Columns.Error].Text = Config.Formulas.ErrorFromVolumes(rr.WMVolume, rr.WMRefPulses * ProcessData.LtrPerRefPulse).ToString("F1");
						}

                        if (currentMetersKind == MetersKind.HeatMeter)
                        {
                            /// TODO:
                            lvi.SubItems[(int)Columns.Energy].Text = ProcessData.Energy.Last.ToString("F1");
                            lvi.SubItems[(int)Columns.EnergyError].Text = Config.Formulas.ErrorFromVolumes(rr.WMVolume, rr.WMRefPulses * ProcessData.LtrPerRefPulse).ToString("F1");
                        }
					}
				}
				else if (currentMetersKind == MetersKind.Combined)
				{
                    for (int z = 0; z < Math.Min(Config.Data.CompoundWMsCount, metersListView.Items.Count / 3); z++)
					{
                        BenchControl.GenericDevices.IRegReader rrMain = (ProcessData.RegisterReaders.Length > 2 * z) ? ProcessData.RegisterReaders[2 * z] : null;
                        BenchControl.GenericDevices.IRegReader rrAux = (ProcessData.RegisterReaders.Length > 2 * z + 1) ? ProcessData.RegisterReaders[2 * z + 1] : null;

                        Double compoundVolume = 0;
                        if (rrMain != null) compoundVolume += rrMain.WMVolume;
                        if (rrAux != null) compoundVolume += rrAux.WMVolume;

                        /// Compound
                        metersListView.Items[3 * z].SubItems[(int)Columns.RefPulses].Text = ProcessData.RefPulses.ToString();
                        metersListView.Items[3 * z].SubItems[(int)Columns.Volume].Text = compoundVolume.ToString("F1");
                        metersListView.Items[3 * z].SubItems[(int)Columns.Error].Text = Config.Formulas.ErrorFromVolumes(compoundVolume, refVolume).ToString("F1"); ;
                                
                        /// Main
                        metersListView.Items[3 * z + 1].SubItems[(int)Columns.Pulses].Text = (rrMain != null) ? rrMain.WMPulses.ToString() : string.Empty;
                        metersListView.Items[3 * z + 1].SubItems[(int)Columns.Volume].Text = (rrMain != null) ? rrMain.WMVolume.ToString("F1") : string.Empty;

                        /// Aux
                        metersListView.Items[3 * z + 2].SubItems[(int)Columns.Pulses].Text = (rrAux != null) ? rrMain.WMPulses.ToString() : string.Empty;
                        metersListView.Items[3 * z + 2].SubItems[(int)Columns.Volume].Text = (rrAux != null) ? rrMain.WMVolume.ToString("F1") : string.Empty;
					}
				}
			}

			//if (pumpOn != args.PumpOn || diverterToTank != args.DivToTank)
			//{
			//    //if (pumpOn != args.PumpOn)
			//    //{
			//    //    if (pumpOn) pumpPictureBox.Image = System.Resources.
			//    //    else        pumpPictureBox.Image = System.Resources.
			//    //}
			//    pumpOn = args.PumpOn;
			//    diverterToTank = args.DivToTank;
			//    Invalidate();
			//}
		}

		void OnTestCompleted(object sender, TestCompletedEventArgs args)
		{
            if (args == null) return;

            TestRslt tRes = args.TestRslt;
            if (tRes == null) return;

            /// Pressure may change faster then temperature, therefore it is updated also here
            prInLabel.Text = ProcessData.PressUp.ToString();
            prOutLabel.Text = ProcessData.PressDown.ToString();

			massLabel.Text = ProcessData.Mass.ToString();
			massDiffLabel.Text = (tRes.MassEnd - tRes.MassStart).ToString("F3");

			refPulsesLabel.Text = tRes.PulsesMaster.ToString("F0");
			refFreqLabel.Text = "---";
			refFlowLabel.Text = Utils.DoubleToStr(tRes.FlowVolume, 4);

			refVolumeLabel.Text = tRes.VolumeCTV.ToString("F2");
			//regValvePosLabel.Text = tstRslt.

			volumeCtvLabel.Text = tRes.VolumeCTV.ToString("F1");
			refErrorLabel.Text = (tRes.ErrorMaster == 0) ? "---" : tRes.ErrorMaster.ToString("F3");

            if ((currentMetersKind == MetersKind.Single) && !tRes.Batch.Compound && !tRes.Batch.HeatMeter)
			{
                ///
                /// Test results for single meters
                ///
				for (int i = 0; i < Math.Min(metersListView.Items.Count, ProcessData.BatchRslts.Batch.WaterMeters.Count); i++)
				{
                    WaterMeter wm = ProcessData.BatchRslts.Batch.WaterMeters[i];
                    MeterTestRslt mtr = (wm != null && !wm.Disabled) ? wm.GetMeterTestRslt(args.TestName) : null;

					if (mtr != null)
					{
                        metersListView.Items[i].SubItems[(int)Columns.Pulses].Text    = mtr.PulsesMeter.ToString("F0");
                        metersListView.Items[i].SubItems[(int)Columns.RefPulses].Text = mtr.PulsesMaster.ToString("F0");
                        metersListView.Items[i].SubItems[(int)Columns.Volume].Text    = mtr.VolumeMeter.ToString("F2");
                        metersListView.Items[i].SubItems[(int)Columns.Error].Text     = mtr.Error.ToString("F2");
                        metersListView.Items[i].SubItems[(int)Columns.Result].Text = mtr.Passed ? Strings.Passed : Strings.Failed;
					}
				}
			}
            else if ((currentMetersKind == MetersKind.HeatMeter) && tRes.Batch.HeatMeter)
            {
                ///
                /// Test results for heat meters
                ///
                for (int i = 0; i < Math.Min(metersListView.Items.Count, ProcessData.BatchRslts.Batch.WaterMeters.Count); i++)
                {
                    WaterMeter wm = ProcessData.BatchRslts.Batch.WaterMeters[i];
                    if (wm == null || wm.Disabled) continue;

                    MeterTestRslt mtrVolume = wm.GetMeterTestRslt(args.TestName, CompoundMeterId.HeatMeterVolume);
                    MeterTestRslt mtrEnergy = wm.GetMeterTestRslt(args.TestName, CompoundMeterId.HeatMeterEnergy);

                    if (mtrVolume != null)
                    {
                        metersListView.Items[i].SubItems[(int)Columns.Pulses].Text = mtrVolume.PulsesMeter.ToString("F0");
                        metersListView.Items[i].SubItems[(int)Columns.RefPulses].Text = mtrVolume.PulsesMaster.ToString("F0");
                        metersListView.Items[i].SubItems[(int)Columns.Volume].Text = mtrVolume.VolumeMeter.ToString("F2");
                        metersListView.Items[i].SubItems[(int)Columns.Error].Text = mtrVolume.Error.ToString("F2");
                        metersListView.Items[i].SubItems[(int)Columns.Result].Text = mtrVolume.Passed ? Strings.Passed : Strings.Failed;
                    }

                    if (mtrEnergy != null)
                    {
                        metersListView.Items[i].SubItems[(int)Columns.Energy].Text = mtrEnergy.VolumeMeter.ToString("F1"); ;
                        metersListView.Items[i].SubItems[(int)Columns.EnergyError].Text = mtrEnergy.Error.ToString("F2");
                        metersListView.Items[i].SubItems[(int)Columns.HeatMeterResult].Text = mtrEnergy.Passed ? Strings.Passed : Strings.Failed;
                    }
                }
            }
            else if ((currentMetersKind == MetersKind.Combined) && tRes.Batch.Compound)
            {
                ///
                /// Test results for compond meters
                ///
                for (int z = 0; z < Math.Min(Config.Data.CompoundWMsCount, metersListView.Items.Count / 3); z++)
                {
                    WaterMeter wm = ProcessData.BatchRslts.Batch.WaterMeters[z];
                    if (wm == null && !wm.Disabled) continue;

                    MeterTestRslt mtrComp = wm.GetMeterTestRslt(args.TestName, CompoundMeterId.Compound);
                    MeterTestRslt mtrMain = wm.GetMeterTestRslt(args.TestName, CompoundMeterId.CompoundMain);
                    MeterTestRslt mtrAux = wm.GetMeterTestRslt(args.TestName, CompoundMeterId.CompoundAux);

                    if (mtrComp != null)
                    {
                        metersListView.Items[3 * z].SubItems[(int)Columns.RefPulses].Text = mtrMain.PulsesMaster.ToString("F0");
                        metersListView.Items[3 * z].SubItems[(int)Columns.Volume].Text = mtrComp.VolumeMeter.ToString("F2");
                        metersListView.Items[3 * z].SubItems[(int)Columns.Error].Text = mtrComp.Error.ToString("F2");
                        metersListView.Items[3 * z].SubItems[(int)Columns.Result].Text = mtrComp.Passed ? Strings.Passed : Strings.Failed;
                    }

                    if (mtrMain != null)
                    {
                        metersListView.Items[3 * z + 1].SubItems[(int)Columns.Pulses].Text = mtrMain.PulsesMeter.ToString("F0");
                        metersListView.Items[3 * z + 1].SubItems[(int)Columns.Volume].Text = mtrMain.VolumeMeter.ToString("F2");
                    }

                    if (mtrAux != null)
                    {
                        metersListView.Items[3 * z + 2].SubItems[(int)Columns.Pulses].Text = mtrAux.PulsesMeter.ToString("F0");
                        metersListView.Items[2 * z + 2].SubItems[(int)Columns.Volume].Text = mtrAux.VolumeMeter.ToString("F2");
                    }
                }
            }
            else
            {
                /// Mismatch between Batch.Compound, Batch.HeatMeter and currentMetersKind
            }
        }

		void OnProcedureCompleted(object sender, ProcedureCompletedEventArgs args)
		{
		}

        private void ProcessTabPageCtrl_Paint(object sender, PaintEventArgs e)
        {
            System.Drawing.Graphics formGraphics = this.CreateGraphics();

            System.Drawing.SolidBrush filledBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Blue);
            System.Drawing.SolidBrush emptyBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Gray);
            System.Drawing.SolidBrush benchBrush = (pumpOn ? filledBrush : emptyBrush);

            int diam = 14;          // pipe diameter (pixels)
            int left = 20;          // left-most pipe x-coordinate
            int top = 14;           // top-most pipe y-coordinate
            int topLeft = 876;
            int topRight = 966;
            int divTop = 40;
            int bottom = 504;       // bottom-most pipe y-coordinate
            int benchTop = 378;     // bench-pipe top y-coordinate
            int pumpLeft = 779;
            int pumpWdth = 38;

            /// Pipes
            formGraphics.FillRectangle(filledBrush,new Rectangle(pumpLeft+pumpWdth, bottom-diam, 65, diam));        // tank -> pump
            formGraphics.FillRectangle(benchBrush, new Rectangle(left, bottom-diam, pumpLeft-left, diam));          // pump ->bench horizontal 
            formGraphics.FillRectangle(benchBrush, new Rectangle(left, benchTop, diam, bottom-benchTop));           // ->bench vertical
            formGraphics.FillRectangle(benchBrush, new Rectangle(left + diam, benchTop, topLeft-left, diam));       // bench horizontal
            formGraphics.FillRectangle(benchBrush, new Rectangle(topLeft, top + diam, diam, benchTop-top-diam));    // bench -> top vertical
            formGraphics.FillRectangle(benchBrush, new Rectangle(topLeft, top, topRight-topLeft, diam));            // top horizontal
            formGraphics.FillRectangle(benchBrush, new Rectangle(topRight-diam, top+diam, diam, divTop-top-diam));  // top -> diverter vertical

            /// Diverter
            int displacement = diverterToTank ? 25 : -25;
            Point[] points = new Point[4];
            points[0].X = topRight - diam;
            points[0].Y = divTop;
            points[1].X = topRight;
            points[1].Y = divTop;
            points[2].X = topRight + displacement;
            points[2].Y = divTop + 50;
            points[3].X = topRight - diam + displacement;
            points[3].Y = divTop + 50;
            formGraphics.FillPolygon(benchBrush, points);

            /// Sink
            formGraphics.FillEllipse(emptyBrush, topRight - diam / 2 - 45, divTop + 50, 40, 30);
            formGraphics.DrawEllipse(Pens.Black, topRight - diam / 2 - 45, divTop + 50, 40, 30);
            
            /// Tank
            formGraphics.DrawRectangle(Pens.Black, topRight - diam / 2, divTop + 51, 60, 80);


            emptyBrush.Dispose();
            filledBrush.Dispose();
            formGraphics.Dispose();
        }

        private void PaintBypass(System.Drawing.Graphics formGraphics, System.Drawing.SolidBrush brush, int startX, int startY)
        {
            int w = 80;
            int h = 43;
            int diam = 10;          // pipe diameter (pixels)

            formGraphics.FillRectangle(brush, new Rectangle(startX, startY, diam, h - diam));
            formGraphics.FillRectangle(brush, new Rectangle(startX, startY + h - diam, w, diam));
            formGraphics.FillRectangle(brush, new Rectangle(startX + w - diam, startY, diam, h));
        }
	}
}