///
/// Copyright (c) 2015 Sensus Metering Systems
/// Author: Milan Hanajík
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
using log4net;
using TBF.Resources;
using TBF.BenchControl.WaterMeters.iPerl;

namespace TBF.BenchControl.TestMethods.iPerlCommunication
{
    public enum CommErr
    {
        None = 0,
        Disabled,
        OpenPort,
        Read,
        Write,
        CmdActive,
        CmdTest,
        Verify,
    }


	public partial class iPerlCommunicationForm : Form, GenericDevices.IHasCompleted
    {
        const int CommTimeout = 1500;
        const int MaxCommRetries = 4;
        const int NrThreads = 2;            /// 1, 2 or 4 threads


        private static readonly ILog log = LogManager.GetLogger(typeof(iPerlCommunicationForm));
        protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData");

#region DLL_Interface

		[DllImport("libRfid1.dll", EntryPoint = "getDllVersion")]    static extern unsafe int getDllVersion1();
        [DllImport("libRfid1.dll", EntryPoint = "openPort")]         static extern unsafe int openPort1(int comPort);
        [DllImport("libRfid1.dll", EntryPoint = "closePort")]        static extern unsafe int closePort1();
        [DllImport("libRfid1.dll", EntryPoint = "readRequestPort")]  static extern unsafe int readRequestPort1(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);
        [DllImport("libRfid1.dll", EntryPoint = "writeRequestPort")] static extern unsafe int writeRequestPort1(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);

        [DllImport("libRfid2.dll", EntryPoint = "getDllVersion")]    public static extern unsafe int getDllVersion2();
        [DllImport("libRfid2.dll", EntryPoint = "openPort")]         static extern unsafe int openPort2(int comPort);
        [DllImport("libRfid2.dll", EntryPoint = "closePort")]        static extern unsafe int closePort2();
        [DllImport("libRfid2.dll", EntryPoint = "readRequestPort")]  static extern unsafe int readRequestPort2(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);
        [DllImport("libRfid2.dll", EntryPoint = "writeRequestPort")] static extern unsafe int writeRequestPort2(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);

        [DllImport("libRfid3.dll", EntryPoint = "getDllVersion")]    public static extern unsafe int getDllVersion3();
        [DllImport("libRfid3.dll", EntryPoint = "openPort")]         static extern unsafe int openPort3(int comPort);
        [DllImport("libRfid3.dll", EntryPoint = "closePort")]        static extern unsafe int closePort3();
        [DllImport("libRfid3.dll", EntryPoint = "readRequestPort")]  static extern unsafe int readRequestPort3(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);
        [DllImport("libRfid3.dll", EntryPoint = "writeRequestPort")] static extern unsafe int writeRequestPort3(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);

        [DllImport("libRfid4.dll", EntryPoint = "getDllVersion")]    public static extern unsafe int getDllVersion4();
        [DllImport("libRfid4.dll", EntryPoint = "openPort")]         static extern unsafe int openPort4(int comPort);
        [DllImport("libRfid4.dll", EntryPoint = "closePort")]        static extern unsafe int closePort4();
        [DllImport("libRfid4.dll", EntryPoint = "readRequestPort")]  static extern unsafe int readRequestPort4(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);
        [DllImport("libRfid4.dll", EntryPoint = "writeRequestPort")] static extern unsafe int writeRequestPort4(MessageID messageId, int offset, int lenght, byte* ptr, int timeout_ms);


        /// <summary>
        /// Wrapper function with safe interface and unsafe body
        /// </summary>
        /// <param name="boardNr">0..3</param>
        /// <param name="comPort">Com port number</param>
        /// <returns>Value returned by openPort(...)</returns>
        public static unsafe int OpenPort(int boardNr)
        {
            switch (boardNr)
            {
                default:
                case 0: return openPort1(cfg.RfidPortNrBoard1);
				case 1: return openPort2(cfg.RfidPortNrBoard2);
				case 2: return openPort3(cfg.RfidPortNrBoard3);
				case 3: return openPort4(cfg.RfidPortNrBoard4);
            }
        }

        /// <summary>
        /// Wrapper function with safe interface and unsafe body
        /// </summary>
        /// <param name="boardNr">0..3</param>
        /// <param name="comPort">Com port number</param>
        /// <returns>Value returned by openPort(...)</returns>
        public static unsafe int ClosePort(int boardNr)
        {
            switch (boardNr)
            {
                default:
                case 0: return closePort1();
                case 1: return closePort2();
                case 2: return closePort3();
                case 3: return closePort4();
            }
        }

        /// <summary>
		/// Wrapper function with safe interface and unsafe body
		/// </summary>
		/// <returns>Value returned by readRequestPort(...)</returns>
        public static unsafe int ReadRequestPort(int boardNr, MessageID messageID, int offset, int lenght, out byte[] buffer, int timeout)
		{
			byte[] buf = new byte[1000];
			int retv;

			fixed (byte* pBuf = buf)
			{
                switch (boardNr)
                {
                    default:
                    case 0: retv = readRequestPort1(messageID, offset, lenght, pBuf, timeout); break;
                    case 1: retv = readRequestPort2(messageID, offset, lenght, pBuf, timeout); break;
                    case 2: retv = readRequestPort3(messageID, offset, lenght, pBuf, timeout); break;
                    case 3: retv = readRequestPort4(messageID, offset, lenght, pBuf, timeout); break;
                }

                rfidDataLogger.InfoFormat("Group={0}, Board={1}, ReadRequestPort({2}, {3}, {4}, ...) returned {5} {6}", currentGroup, boardNr, messageID, offset, lenght, retv, (retv != 0) ? "!" : "");

				buffer = new byte[lenght];
				for (int i = 0; i < lenght; i++) buffer[i] = buf[i];
			}

			return retv;
		}

		/// <summary>
		/// Wrapper function with safe interface adn unsafe body
		/// </summary>
		/// <returns>Value returned by writeRequestPort(...)</returns>
        public static unsafe int WriteRequestPort(int boardNr, MessageID messageID, int offset, int lenght, byte[] buffer, int timeout)
		{
			int retv;
			fixed (byte* pBuf = buffer)
			{
                switch (boardNr)
                {
                    default:
                    case 0: retv = writeRequestPort1(messageID, offset, lenght, pBuf, timeout); break;
                    case 1: retv = writeRequestPort2(messageID, offset, lenght, pBuf, timeout); break;
                    case 2: retv = writeRequestPort3(messageID, offset, lenght, pBuf, timeout); break;
                    case 3: retv = writeRequestPort4(messageID, offset, lenght, pBuf, timeout); break;
                }

                if (lenght == 1)
                {
                    rfidDataLogger.InfoFormat("Group={0}, Board={1}, WriteRequestPort({3}, {4}, {5}, {6}) returned {2} {7}", currentGroup, boardNr, retv, messageID, offset, lenght, pBuf[0].ToString("X2"), (retv != 0) ? "!" : "");
                }
                else if (lenght == 2)
                {
                    rfidDataLogger.InfoFormat("Group={0}, Board={1}, WriteRequestPort({3}, {4}, {5}, {6} {7}) returned {2} {8}", currentGroup, boardNr, retv, messageID, offset, lenght, pBuf[0].ToString("X2"), pBuf[1].ToString("X2"), (retv != 0) ? "!" : "");
                }
                else
                {
                    rfidDataLogger.InfoFormat("Group={0}, Board={1}, WriteRequestPort({3}, {4}, {5}, {6} {7} ...) returned {2} {8}", currentGroup, boardNr, retv, messageID, offset, lenght, pBuf[0].ToString("X2"), pBuf[1].ToString("X2"), (retv != 0) ? "!" : "");
                }
            }
			return retv;
		}

#endregion DLL_Interface


        const string ReadConfigurationStr = "Read configuration";   /// Example: "Read configuration" or "Read configuration if enabled"
        const string SetTestModeStr = "Set Test mode";              /// Example: "Set Test mode" or "Set Test mode A0" (hexadecimal number is the required 'testModeConfig'
        const string SetActiveModeStr = "Set Active mode";
        const string ReadCalibrationStr = "Read calibration";
        const string WriteCalibrationFactorStr = "Write calibration factor";
        const string ResetQ2CorrectionStr = "Reset Q2 correction";
        const string WriteQ2CorrectionStr = "Write Q2 correction";


		// Set to 'true' when the form closes
		public bool Completed { get { return formCompleted; } }
		bool formCompleted;

		/// <summary> Number of text boxes for serial numbers </summary>
        public readonly int WaterMetersCount;

		readonly bool[] disabled;

		Entities.TestResult tr;

		int textBoxesCount;

		Label[] labels;
		TextBox[] messages;

		static TestMethodCfg cfg;
        static IList<WaterMeters.iPerl.WaterMeter> waterMeters;
        
        Modbus.QuidoRS.QuidoRS quido;


        ///
        /// RFID multiplexer PCB / RFID serial port and worker thread related variables
        ///
        static string activity;
        static int currentGroup;                    /// form -> worker thread (0 = none)
        static int lastGroup;
        static int completedCommCount;              /// Number of completed communication steps

        static IList<Thread> workerThreads;
        static IList<int> rfidPortNrs;
        static IList<bool> stopWorkerThreads;       /// form -> worker thread

		/// <summary> Parameterless constructor for 3 watermeters </summary>
		public iPerlCommunicationForm()
		{
			InitializeComponent();

			textBoxesCount = 48;

			labels = new Label[48]
				{
					wmLabel1, wmLabel2, wmLabel3, wmLabel4, wmLabel5,
					wmLabel6, wmLabel7, wmLabel8, wmLabel9, wmLabel10,
					wmLabel11, wmLabel12, wmLabel13, wmLabel14, wmLabel15,
					wmLabel16, wmLabel17, wmLabel18, wmLabel19, wmLabel20,
					wmLabel21, wmLabel22, wmLabel23, wmLabel24, wmLabel25,
					wmLabel26, wmLabel27, wmLabel28, wmLabel29, wmLabel30,
					wmLabel31, wmLabel32, wmLabel33, wmLabel34, wmLabel35,
					wmLabel36, wmLabel37, wmLabel38, wmLabel39, wmLabel40,
					wmLabel41, wmLabel42, wmLabel43, wmLabel44, wmLabel45,
					wmLabel46, wmLabel47, wmLabel48,
				};
			messages = new TextBox[48]
				{
					wmTextBox1, wmTextBox2, wmTextBox3, wmTextBox4, wmTextBox5,
					wmTextBox6, wmTextBox7, wmTextBox8, wmTextBox9, wmTextBox10,
					wmTextBox11, wmTextBox12, wmTextBox13, wmTextBox14, wmTextBox15,
					wmTextBox16, wmTextBox17, wmTextBox18, wmTextBox19, wmTextBox20,
					wmTextBox21, wmTextBox22, wmTextBox23, wmTextBox24, wmTextBox25,
					wmTextBox26, wmTextBox27, wmTextBox28, wmTextBox29, wmTextBox30,
					wmTextBox31, wmTextBox32, wmTextBox33, wmTextBox34, wmTextBox35,
					wmTextBox36, wmTextBox37, wmTextBox38, wmTextBox39, wmTextBox40,
					wmTextBox41, wmTextBox42, wmTextBox43, wmTextBox44, wmTextBox45,
					wmTextBox46, wmTextBox47, wmTextBox48,
				};

            currentGroup = 0;
            lastGroup = 0;      /// group numbers are >=1, lastGroup == 0 means no group
            completedCommCount = 0;

            workerThreads = new List<Thread>();
            rfidPortNrs = new List<int>();
            stopWorkerThreads = new List<bool>();

            formCompleted = false;
			tr = null;

            /// Find QuidoRS
            foreach (var comp in StateMachine.Components)
            {
                if (comp is Modbus.QuidoRS.QuidoRS)
                {
                    quido = comp as Modbus.QuidoRS.QuidoRS;
                    break;
	        	}
		    }

            /// Attach to 'CommCompleted' handler
            CommCompletedHandler += delegate(object sender, CommCompletedEventArgs args)
			{
				if (InvokeRequired)
				{
                    Invoke(new EventHandler<CommCompletedEventArgs>(DoOnCommCompleted), sender, args);
				}
                else DoOnCommCompleted(sender, args);
			};

            /// Attach to 'AllCompleted' handler
            AllCompletedHandler += delegate(object sender, AllCompletedEventArgs args)
            {
                if (InvokeRequired)
                {
                    Invoke(new EventHandler<AllCompletedEventArgs>(DoOnAllCompleted), sender, args);
                }
                else DoOnAllCompleted(sender, args);
            };
        }
		
		/// <summary>
        /// Constructor
        /// </summary>
        /// <param name="waterMetersCount">Number of text boxes for serial numbers</param>
		public iPerlCommunicationForm(TestMethodCfg cfg, IList<GenericDevices.IWaterMeter> waterMeters, string activity)
			: this()
        {
			iPerlCommunicationForm.cfg = cfg;
            iPerlCommunicationForm.activity = activity;
            this.WaterMetersCount = waterMeters.Count;
            iPerlCommunicationForm.waterMeters = new List<WaterMeters.iPerl.WaterMeter>();

#if DEFINE            
            foreach (var wm in waterMeters)
            {
                WaterMeters.iPerl.WaterMeter iPerlWM = wm as WaterMeters.iPerl.WaterMeter;
                iPerlCommunicationForm.waterMeters.Add(iPerlWM);
                if (iPerlWM.Group > lastGroup) lastGroup = iPerlWM.Group;
                if (!rfidPortNrs.Contains(iPerlWM.RfidComPortNr))
                {
                    int threadId = workerThreads.Count;
                    Thread thread = new Thread(iPerlCommunicationForm.Worker);
                    workerThreads.Add(thread);
                    rfidPortNrs.Add(iPerlWM.RfidComPortNr);
                    stopWorkerThreads.Add(false);
                    thread.Start(new Boxes.IntBox(threadId));
                }
            }
#else
            foreach (var wm in waterMeters)
            {
                WaterMeters.iPerl.WaterMeter iPerlWM = wm as WaterMeters.iPerl.WaterMeter;
                iPerlCommunicationForm.waterMeters.Add(iPerlWM);
                if (!rfidPortNrs.Contains(iPerlWM.MuxBoardNr))
                {
                    rfidPortNrs.Add(iPerlWM.MuxBoardNr);

                    int newThreadId = workerThreads.Count;
                    if (newThreadId < NrThreads)
                    {
                        Thread thread = new Thread(iPerlCommunicationForm.Worker);
                        workerThreads.Add(thread);
                        stopWorkerThreads.Add(false);
                        thread.Start(new Boxes.IntBox(newThreadId));
                    }
                }
                if (iPerlWM.Group > lastGroup) lastGroup = iPerlWM.Group;
            }
#endif
            activityLabel.Text = activity;

            ShuffleTextBoxes(this.WaterMetersCount, Program.LineSize);

            disabled = new bool[this.WaterMetersCount];
        }


		/// <summary>
		/// Make sure the layout of labels/text boxes on the screen
		/// corresponds to the layout of watermeters of the test bench.
		/// </summary>
		/// <param name="wmsCount">Number of watermeters</param>
		/// <param name="lineSize">Number of watermeters in one line</param>
		void ShuffleTextBoxes(int wmsCount, int lineSize)
		{
			if (wmsCount < textBoxesCount && lineSize > 0)
			{
				int nrLines = (wmsCount + lineSize - 1) / lineSize;
				int gap = (textBoxesCount - wmsCount) / nrLines;

				int dest = 0;
				for (int l = 0; l < nrLines; l++)
				{
					for (int i = 0; i < lineSize; i++)
					{
						labels[dest] = labels[l * lineSize + l * gap + i];
						messages[dest] = messages[l * lineSize + l * gap + i];
						dest++;
					}
				}
				textBoxesCount = wmsCount;
			}
		}


		void Localize()
        {
            Text = Strings.Water_Meter_States;
			for (int i = 0; i < textBoxesCount; i++)
			{
				labels[i].Text = string.Format("iPerl{0}", i + 1);
			}
        }

		private void iPerlCommunicationForm_Load(object sender, EventArgs e)
		{
            Localize();

            //Height = 50 + 90 * WaterMetersCount;

			for (int i = 0; i < textBoxesCount; i++)
			{
				if (disabled != null && i < disabled.Length && disabled[i])
				{
					labels[i].Visible = messages[i].Visible = false;
				}
                else
                {
                    labels[i].Visible = messages[i].Visible = true;
                    messages[i].Text = "---";
                }
            }

            ///
            /// Set QuidoRS outputs and start the whole communication process
            /// by incrementing 'currentGroup'.
            ///
            if (quido != null)
            {
                quido.SetOutputs((ushort)(16 - currentGroup - 1));
                Thread.Sleep(200);
            }
            currentGroup++;

            TBF.LocalSettings ls = Program.LocalSettings;
            Left = (ls.iPerlCommunicationsFormLeft != 0) ? ls.iPerlCommunicationsFormLeft : 150;
            Top = (ls.iPerlCommunicationsFormTop != 0) ? ls.iPerlCommunicationsFormTop : 150;
		}

		private void NormalClose()
		{
            CommCompletedHandler = null;
            AllCompletedHandler = null;

            formCompleted = true;
            Program.LocalSettings.iPerlCommunicationsFormLeft = Location.X;
            Program.LocalSettings.iPerlCommunicationsFormTop = Location.Y;
            Program.LocalSettings.Save();

			DialogResult = DialogResult.OK;
			Close();
		}

		void OnAdjustmentInProgress(object sender, UiBridge.AdjustmentInProgressEventArgs args)
		{
			tr = args.TestResult;
			Redraw();
		}

		void Redraw()
		{
			if (tr != null)
			{
				for (int i = 0; i < textBoxesCount; i++)
				{
					messages[i].Text = tr.Meters[i].VolumeErrorPct.ToString("F1");
				}
			}
		}

		private void WMErrorsForm_Paint(object sender, PaintEventArgs e)
		{
            //if (tr != null)
            //{
            //    System.Drawing.Graphics graphics = this.CreateGraphics();

            //    for (int i = 0; i < WaterMetersCount; i++)
            //    {
            //        PaintOne(graphics, rects[i], tr.Meters[i].VolumeErrorPct, tr.ErrLimLo, tr.ErrLimHi);
            //    }
            //}
		}

		#region Forced close handling

		public void StartForceCloseHandler()
		{
			UiBridge.Bridge.CloseModelessFormHandler += delegate(object sender, EventArgs args)
			{
				if (InvokeRequired) { Invoke(new EventHandler<EventArgs>(OnForceClose), sender, args); }
				else OnForceClose(sender, args);
			};
		}

		void OnForceClose(object sender, EventArgs args)
		{
            CommCompletedHandler = null;
            AllCompletedHandler = null;

            DialogResult = DialogResult.Cancel;
			Close();
		}

		#endregion


		/// <summary>
		/// Worker thread
		/// </summary>
		/// <param name="threadData">Thread ID (integer) wrapped into IntBox</param>
        static void Worker(object threadData)
        {
            int threadId = (threadData as Boxes.IntBox).Val;

            if (threadId == 0)
            {
                rfidDataLogger.InfoFormat("");                          /// Makes the log more readable when there is a lot of data
                rfidDataLogger.WarnFormat("Activity = {0}", activity);
                rfidDataLogger.InfoFormat("");                          /// Makes the log more readable when there is a lot of data
            }

            for (int group = 1; group <= lastGroup; group++)
            {
                while (currentGroup != group && !stopWorkerThreads[threadId]) Thread.Sleep(50);

                if (stopWorkerThreads[threadId]) break;

                for (int rfidPortIx = threadId; rfidPortIx < threadId + 4; rfidPortIx += NrThreads)
                {
                    int rfidPortNr = rfidPortNrs[rfidPortIx];
                    int wmNr = 0;
                    bool wmFound = false;
                    foreach (var wm in waterMeters)
                    {
                        if ((wm.MuxBoardNr == rfidPortNr) && (wm.Group == group))
                        {
                            wmFound = true;
                            if (wm.DebugLevel == Entities.DebugMode.Normal)
                            {
                                CommErr error;
                                string resultStr = string.Empty;

                                if (activity.ToLower().Contains(ReadConfigurationStr.ToLower())) error = ReadConfiguration(wm, ref resultStr);
                                else if (activity.ToLower().Contains(SetTestModeStr.ToLower())) error = SetTestMode(wm, ref resultStr);
                                else if (activity.ToLower().Equals(SetActiveModeStr.ToLower())) error = SetActiveMode(wm, ref resultStr);
                                else if (activity.ToLower().Equals(ReadCalibrationStr.ToLower())) error = ReadCalibration(wm, ref resultStr);
                                else if (activity.ToLower().Contains(WriteCalibrationFactorStr.ToLower())) error = WriteCalibrationFactor(wm, ref resultStr);
                                else if (activity.ToLower().Equals(ResetQ2CorrectionStr.ToLower())) error = ResetQ2Correction(wm, ref resultStr);
                                else if (activity.ToLower().Equals(WriteQ2CorrectionStr.ToLower())) error = WriteQ2Correction(wm, ref resultStr);
                                else
                                {
                                    error = CommErr.None;
                                    resultStr = "Invalid activity";
                                }

                                if (error == CommErr.None) OnCommCompleted(null, new CommCompletedEventArgs(threadId, wmNr, resultStr));
                                else if (wm.Disabled || error == CommErr.Disabled) OnCommCompleted(null, new CommCompletedEventArgs(threadId, wmNr, "Watermeter is disabled"));
                                else
                                {
                                    OnCommCompleted(null, new CommCompletedEventArgs(threadId, wmNr, string.Format("{0} failed ({1}) !!!", activity, error)));
									rfidDataLogger.ErrorFormat("Group={0}, Board={1}, {2} failed ({3}) !!!", currentGroup, wm.MuxBoardNr, activity, error);
                                    wm.Disabled = true;
                                }
                            }
                            else
                            {
                                OnCommCompleted(null, new CommCompletedEventArgs(threadId, wmNr, "Simulation"));
                            }
                            break;
                        }
                        wmNr++;
                    }

                    if (!wmFound) OnCommCompleted(null, new CommCompletedEventArgs(threadId, -1, string.Empty));    /// Send negative wmNr
                }
            }
        }


        /// <summary>
        /// Read a complete configuration structure of the watermeter
        /// </summary>
        /// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
		static CommErr ReadConfiguration(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            ///
            /// The activity is "Read configuration" (this enables the watermeter, resets error flag)
            /// or "Read configuration if enabled" (this keeps th error flag).
            /// 
            if (!activity.ToLower().Contains(" if enabled"))
			{
				wm.Disabled = false;
			}

            if (wm.Disabled) return CommErr.Disabled;

			if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;   /// Open RFID port

            CommErr error = CommErr.Read;

            /// Read configuration
		    byte[] config = null;
            for (int j = 0; j < MaxCommRetries; j++)
            {
                if (0 == ReadRequestPort(wm.MuxBoardNr, MessageID.Configuration, 0, ConfigStruct.Length, out config, CommTimeout))
				{
                    error = CommErr.None;
					wm.ConfigStruct = ConfigStruct.FromByteArray(config);
					resultStr = wm.ConfigStruct.ToString(1);
					break;
				}
            }

            ClosePort(wm.MuxBoardNr);   /// Close RFID port

			return error;
        }


        /// <summary>
        /// Set the watermeter to the test mode.
        /// If testModeConfig is specified as a hexadeximal number appended to "set test mode ", it is verified
        ///   whether the testModeConfig is correctly set, if necessary it is changed to the specified value.
        /// Read a part of configuration afterwards to verify the mode was set correctly.
        /// </summary>
        /// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
        static CommErr SetTestMode(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;
			
            Byte testModeConfig = 0xA0;                 /// Default value
            ///
            if (activity.Length > SetTestModeStr.Length)
            {
                string testModeConfigStr = activity.Substring(SetTestModeStr.Length + 1);
                UInt16 byteVal;
                if (UInt16.TryParse(testModeConfigStr, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out byteVal) && byteVal <= 255)
                {
                    testModeConfig = (Byte)byteVal;     /// Update with specified value
                }
            }

            if (wm.ConfigStruct.MeterState == MeterState.Test && wm.ConfigStruct.TestModeConfig == testModeConfig)
            {
                /// Already in the correct test mode
                resultStr = "Already " + wm.ConfigStruct.ToString(1);
                return CommErr.None;
            }

            /// Communication necessary
            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;   /// Open RFID port

            CommErr error = CommErr.None;

            if (error==CommErr.None && (wm.ConfigStruct.TestModeConfig != testModeConfig) && (wm.ConfigStruct.MeterState != MeterState.Active))
            {
                /// Switch to Active mode in order to change TestModeConfig
                error = CommErr.CmdActive;
                byte[] cmd = new byte[1] { (byte)6 };
                for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.Command, 0, 1, cmd, CommTimeout)) { error = CommErr.None; break; }
                }
            }

            if (error == CommErr.None && (wm.ConfigStruct.TestModeConfig != testModeConfig))
            {
                /// Change the TestModeConfig if necessary
                error = CommErr.Write;
                byte[] tstMdCfg = new byte[1] { testModeConfig };
                for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.Configuration, 21, 1, tstMdCfg, CommTimeout))
                    {
                        wm.ConfigStruct.Update(21, tstMdCfg);
                        error = CommErr.None;
                        break;
                    }
                }
            }

            if (error == CommErr.None)
            {
                /// Switch to test mode
                error = CommErr.CmdTest;
                byte[] cmd = new byte[1] { (byte)7 };
                for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.Command, 0, 1, cmd, CommTimeout)) { error = CommErr.None; break; }
                }
            }

            /// Now the meter should be in the Test mode ... verify
            if (error == CommErr.None)
            {
                /// Verify the configuration
                error = CommErr.Verify;
                byte[] cfg_0_3 = null;
                for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == ReadRequestPort(wm.MuxBoardNr, MessageID.Configuration, 0, 4, out cfg_0_3, CommTimeout))
                    {
                        wm.ConfigStruct.Update(0, cfg_0_3);
                        if (wm.ConfigStruct.MeterState == MeterState.Test)
                        {
                            error = CommErr.None;
                            resultStr = wm.ConfigStruct.ToString(1);
                            break;
                        }
                    }
                }
            }

			ClosePort(wm.MuxBoardNr);   /// Close RFID port

            return error;
        }


        /// <summary>
        /// Set the watermeter to the active mode.
        /// Read a part of configuration afterwards to verify the mode was set correctly.
        /// </summary>
        /// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
        static CommErr SetActiveMode(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;

            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;   /// Open RFID port

            CommErr error = CommErr.CmdActive;

            /// Switch to active mode
            byte[] cmd = new byte[1] { (byte)6 };
            for (int j = 0; j < MaxCommRetries; j++)
            {
				if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.Command, 0, 1, cmd, CommTimeout)) { error = CommErr.None; break; }
            }

            if (error == CommErr.None)
            {
                error = CommErr.Verify;

                /// Read configuration
                byte[] cfg_0_3 = null;
                for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == ReadRequestPort(wm.MuxBoardNr, MessageID.Configuration, 0, 4, out cfg_0_3, CommTimeout))
                    {
						wm.ConfigStruct.Update(0, cfg_0_3);
                        if (wm.ConfigStruct.MeterState == MeterState.Active)
                        {
                            error = CommErr.None;
                            resultStr = wm.ConfigStruct.ToString(1);
                            break;
                        }
                    }
                }
            }

			ClosePort(wm.MuxBoardNr);   /// Close RFID port

            return error;
        }


        /// <summary>
        /// Read a complete calibration structure from the watermeter
        /// </summary>
        /// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
        static CommErr ReadCalibration(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;

            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;   /// Open RFID port

            CommErr error = CommErr.Read;

            /// Read calibration
			byte[] calib = null;
			for (int j = 0; j < MaxCommRetries; j++)
            {
				if (0 == ReadRequestPort(wm.MuxBoardNr, MessageID.Calibration, 0, CalibrationStruct.Length, out calib, CommTimeout))
				{
                    error = CommErr.None;
					wm.CalibrationStruct = CalibrationStruct.FromByteArray(calib);
					resultStr = wm.CalibrationStruct.ToString();
					break;
				}
            }

			ClosePort(wm.MuxBoardNr);   /// Close RFID port

            return error;
        }


        /// <summary>
        /// Write the calculated calibration factor to the water meter.
        /// Read a part of CalibrationStruct afterwards to verify factor was written correctly.
        /// </summary>
        /// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
        static CommErr WriteCalibrationFactor(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;

            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;	/// Open RFID port

            CommErr error = CommErr.Write;

            UInt16 newCalibFactor = 3000;                 /// Default value
            ///
            if (activity.Length > WriteCalibrationFactorStr.Length)
            {
                string calibFactrorStr = activity.Substring(WriteCalibrationFactorStr.Length + 1);
                UInt16 val;
                if (UInt16.TryParse(calibFactrorStr, out val) && val > 0)
                {
                    newCalibFactor = val;     /// Update with specified value
                }
            }
            else
            {
            /// Write the calculated calibration factor
                newCalibFactor = wm.CalculateNewCalibFactor(wm.CalibrationFactor);
            }

            byte[] data = new byte[2] { (byte)(newCalibFactor & 0x00FF), (byte)((newCalibFactor >> 8) & 0x00FF) };
            for (int j = 0; j < MaxCommRetries; j++)
            {
				if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.Calibration, 2, 2, data, CommTimeout)) { error = CommErr.None; break; }
            }

            if (error == CommErr.None)
            {
                error = CommErr.Verify;

                /// Read calibration
				byte[] calib_2_3 = null;
				for (int j = 0; j < MaxCommRetries; j++)
                {
					if (0 == ReadRequestPort(wm.MuxBoardNr, MessageID.Calibration, 2, 2, out calib_2_3, CommTimeout))
					{
                        error = CommErr.None;
						wm.CalibrationStruct.Update(calib_2_3, 2);
						resultStr = wm.CalibrationStruct.ToString();
						break;
					}
                }
            }

			ClosePort(wm.MuxBoardNr);   /// Close RFID port

			return error;
		}


		const int Q2CorrFactorsAddr = 0x1878;	/// Used by ResetQ2Correction(...) and WriteQ2Correction(...)


		/// <summary>
		/// Reset both Q2 correction factors in the memory to 0.
		/// Read them back to verify factors were written correctly.
		/// </summary>
		/// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
		static CommErr ResetQ2Correction(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;

            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;	/// Open RFID port

            CommErr error = CommErr.Write;

			/// Write zero Q2 correction
            byte[] wrData = new byte[2] { 0, 0 };
            ///
			for (int j = 0; j < MaxCommRetries; j++)
			{
				if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, wrData, CommTimeout)) { error = CommErr.None; break; }
			}

            /// Verify the correction factors
            if (error == CommErr.None)
			{
                error = CommErr.Verify;

				/// Read calibration
				byte[] rdData = null;
				for (int j = 0; j < MaxCommRetries; j++)
				{
					if ((0 == ReadRequestPort(wm.MuxBoardNr, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, out rdData, CommTimeout)) &&
						(rdData != null) && (rdData.Length == 2) && (rdData[0] == 0) && (rdData[1] == 0))
					{
                        error = CommErr.None;
						resultStr = "Q2 correction factors reset to 0";
						break;
					}
				}
			}

			ClosePort(wm.MuxBoardNr);   /// Close RFID port

			return error;
		}


		/// <summary>
		/// Write the calculated Q2 correction factors to the memory.
		/// Read them back to verify factors were written correctly.
		/// </summary>
		/// <param name="wm">Water meter object</param>
		/// <param name="resultStr">String passed to caller</param>
		/// <returns>true on success</returns>
        static CommErr WriteQ2Correction(WaterMeters.iPerl.WaterMeter wm, ref string resultStr)
        {
            if (wm.Disabled) return CommErr.Disabled;

            if (OpenPort(wm.MuxBoardNr) != 0) return CommErr.OpenPort;	/// Open RFID port

            CommErr error = CommErr.Write;

			/// Write Q2 corrections
            double q2CorrectionFactor = wm.Q2CorrectionFactor();
            Byte q2CorrRFlow = (byte)((int)(q2CorrectionFactor / 2 + 0.5) & 0x000000FF);
            Byte q2CorrLFlow = (byte)((int)(q2CorrectionFactor + 0.5) & 0x000000FF);
            byte[] wrData = new byte[2] { q2CorrRFlow, q2CorrLFlow };
            ///
			for (int j = 0; j < MaxCommRetries; j++)
			{
				if (0 == WriteRequestPort(wm.MuxBoardNr, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, wrData, CommTimeout)) { error = CommErr.None; break; }
			}

            if (error == CommErr.None)
			{
                error = CommErr.Verify;

				/// Read calibration
				byte[] rdData = null;
				for (int j = 0; j < MaxCommRetries; j++)
				{
					if ((0 == ReadRequestPort(wm.MuxBoardNr, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, out rdData, CommTimeout)) &&
						(rdData != null) && (rdData.Length == 2) && (rdData[0] == q2CorrRFlow) && (rdData[1] == q2CorrRFlow))
					{
                        error = CommErr.None;
                        resultStr = string.Format("Group={0}, Board={1}, Q2 correction factors set: RightFlow = {2}, LeftFlow = {3}",
                                                  wm.Group, wm.MuxBoardNr, q2CorrRFlow, q2CorrRFlow);
                        rfidDataLogger.Warn(resultStr);
						break;
					}
				}
			}

			return error;
		}


        /// <summary>
        /// Called when communication with one watermeter is completed
        /// </summary>
        public static void OnCommCompleted(object sender, CommCompletedEventArgs data)
        {
            if (CommCompletedHandler == null) return;
            try { CommCompletedHandler(sender, data); }
            catch (Exception e) { log.Error("CommCompletedHandler(...) failed", e); }
        }
        public static event EventHandler<CommCompletedEventArgs> CommCompletedHandler;

        void DoOnCommCompleted(object sender, CommCompletedEventArgs data)
        {
            if (data.WMNr >= 0) messages[data.WMNr].Text = data.CommMessage;

            lock (this)
            {
                if (++completedCommCount < rfidPortNrs.Count) return;
                completedCommCount = 0;
            }

            if (currentGroup < lastGroup)
            {
                /// Go to the next step / next group
                if (quido != null)
                {
                    quido.SetOutputs((ushort)(16 - currentGroup - 1));
                    Thread.Sleep(100);
                }
                currentGroup++;
            }
            else
            {
                /// Wait until all threads are finished
                workerThreads[data.ThreadId].Join(2000);
                NormalClose();
            }
        }


        /// <summary>
        /// Called when communication with all watermeters is completed
        /// </summary>
        public static void OnAllCompleted(object sender, AllCompletedEventArgs data)
        {
            if (AllCompletedHandler == null) return;
            try { AllCompletedHandler(sender, data); }
            catch (Exception e) { log.Error("AllCompletedHandler(...) failed", e); }
        }
        public static event EventHandler<AllCompletedEventArgs> AllCompletedHandler;

        void DoOnAllCompleted(object sender, AllCompletedEventArgs data)
        {
            Text = data.CommMessage;
        }
    }
}