///
/// Copyright (c) 2021 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using log4net;
using NHibernate;
using Common;
using Config.Entities;
using SharedDatabase.Entities;
using TBF.Resources;
using TBF.Rig.Sequences;

namespace TBF.Rig.TestMethods.S640Communication
{
    public enum CommErr
    {
        None = 0,
        CommFailed,             /// 1
        HeadDisabledByUser,     /// 2
    }

    ///
    /// (Program.LocalSettings.OptoHeadsEnabled & (1L << ix))) == 0  . .  opto head is disabled in configuration
    /// optoheads[ix] == null  . . . . . . . . . . . . . . . . . . . . .  opto head is not part of the selected sensors path
    /// optoHeads[ix].Disabled == true   . . . . . . . . . . . . . . . .  opto head was disabled by the user
    /// 
	public partial class S640CommForm : Form, GenericDevices.IHasCompleted
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(S640CommForm));
        protected static readonly ILog sirtDataLogger = LogManager.GetLogger("SirtData");

        public const int UIBoxesCount = 20;

        public static Color DisabledColor = Color.DarkGray;
        public static Color OptoOKColor = Color.Green;
        public static Color OptoNokColor = Color.Red;
        public const string StartFileName = "Start.pro";
        public const string EndFileName = "Ende.pro";
        public const string ErrorFileName = "Error.dat";

        enum Step
        {
            /// Start
            ReadSNsFromTracing,
            WatchOptoHeads,
            SaveStartPro,
            EnterSNsAndAwaitResponseToStartPro,
            AwaitResponseToStartPro,

            ///  End
            EnterSNs,
            ConfirmSNsAndRadioAddresses,
            SaveEndePro,
            AwaitResponseToEndePro,
            ConfirmError,
            Idle,
        }

		DateTime startTime;
		int startTimeSec;


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

        bool forcedClose;       /// Set in the forced close handler


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


		int textBoxesCount;
        /// 
        bool[] enabledInConfiguration;
		Label[] labels;
        CheckBoxImage[] checkBoxes;
        PictureBox[] pictures;
		TextBox[] eRegisterNumbers;
        TextBox[] radioAddresses;
        TextBox[] serialNumbers;
        TextBox[] assignedSNs;
        TextBox[] assignedRadioAddresses;

        int[] ckbIndex;                 /// Initialized by ShuffleTextBoxes() ... to be used in the future in case of test benches with two lines


        RegisterReaders.S640Stream.S640Stream[] optoHeads;


        ///
        /// Parameters and current state of activities
        ///
        DebugMode debugLevel;
        int optoDataTimeout;
        string fileExchangePath;
        int fileExchangeTimeout;
        SerialNumbers serialNumbersMode;
        SerialNumbers assignedNumbersMode;
        bool skipBadMeters;
        ProcParams pPars;
        IList<Results.Entities.WaterMeter> waterMeters;
        ///
        IList<S640Activity> activities;
        IList<Test> tests;
        ///
        int currentActivityIx;
        ///
        Step step;
        DateTime savedTimestamp;
        bool isAnySNMissing;
        bool areValuesDisplayed;
        bool areNewSNsAndRadioAddressesAssigned;


        ///
        /// Production tracing support
        ///
        IList<ReferenceRecord> refRecords;
        IList<Record> records;



        System.Windows.Forms.Timer timer;

        ///
        /// Used in Step.WatchOptoHeads, initially all zeros
        ///
        int[] commOkLoopsCount;


		/// <summary>
        /// Parameterless constructor (without watermeters, threads)
        /// </summary>
		public S640CommForm()
		{
			InitializeComponent();

            labels = new Label[UIBoxesCount]
			{
				wmLabel1,  wmLabel2,  wmLabel3,  wmLabel4,  wmLabel5,  wmLabel6,  wmLabel7,
                wmLabel8, wmLabel9,  wmLabel10, wmLabel11, wmLabel12, wmLabel13, wmLabel14,
                wmLabel15, wmLabel16, wmLabel17, wmLabel18, wmLabel19, wmLabel20
			};
            checkBoxes = new CheckBoxImage[UIBoxesCount]
			{
                checkBoxImage1,  checkBoxImage2,  checkBoxImage3,  checkBoxImage4,  checkBoxImage5,
                checkBoxImage6,  checkBoxImage7,  checkBoxImage8,  checkBoxImage9,  checkBoxImage10,
                checkBoxImage11, checkBoxImage12, checkBoxImage13, checkBoxImage14, checkBoxImage15,
                checkBoxImage16, checkBoxImage17, checkBoxImage18, checkBoxImage19, checkBoxImage20,
			};
            pictures = new PictureBox[UIBoxesCount]
			{
				pictureBox1,  pictureBox2,  pictureBox3,  pictureBox4,  pictureBox5,  pictureBox6,  pictureBox7,
                pictureBox8,  pictureBox9,  pictureBox10, pictureBox11, pictureBox12, pictureBox13, pictureBox14,
                pictureBox15, pictureBox16, pictureBox17, pictureBox18, pictureBox19, pictureBox20,
			};
            eRegisterNumbers = new TextBox[UIBoxesCount]
			{
				fromOptoTextBox1,  fromOptoTextBox2,  fromOptoTextBox3,  fromOptoTextBox4,  fromOptoTextBox5,
                fromOptoTextBox6,  fromOptoTextBox7,  fromOptoTextBox8,  fromOptoTextBox9,  fromOptoTextBox10,
                fromOptoTextBox11, fromOptoTextBox12, fromOptoTextBox13, fromOptoTextBox14, fromOptoTextBox15,
                fromOptoTextBox16, fromOptoTextBox17, fromOptoTextBox18, fromOptoTextBox19, fromOptoTextBox20,
			};
            radioAddresses = new TextBox[UIBoxesCount]
            {
                radioAddressTB1, radioAddressTB2, radioAddressTB3, radioAddressTB4, radioAddressTB5,
                radioAddressTB6, radioAddressTB7, radioAddressTB8, radioAddressTB9, radioAddressTB10,
                radioAddressTB11, radioAddressTB12, radioAddressTB13, radioAddressTB14, radioAddressTB15,
                radioAddressTB16, radioAddressTB17, radioAddressTB18, radioAddressTB19, radioAddressTB20,
            };
            serialNumbers = new TextBox[UIBoxesCount]
			{
				serialNrTB1,  serialNrTB2,  serialNrTB3,  serialNrTB4,  serialNrTB5,  serialNrTB6,  serialNrTB7,
                serialNrTB8,  serialNrTB9,  serialNrTB10, serialNrTB11, serialNrTB12, serialNrTB13, serialNrTB14,
                serialNrTB15, serialNrTB16, serialNrTB17, serialNrTB18, serialNrTB19, serialNrTB20, 
			};
            assignedSNs = new TextBox[UIBoxesCount]
            {
                assignedSnTB1,  assignedSnTB2,  assignedSnTB3,  assignedSnTB4,  assignedSnTB5,
                assignedSnTB6,  assignedSnTB7,  assignedSnTB8,  assignedSnTB9,  assignedSnTB10,
                assignedSnTB11, assignedSnTB12, assignedSnTB13, assignedSnTB14, assignedSnTB15,
                assignedSnTB16, assignedSnTB17, assignedSnTB18, assignedSnTB19, assignedSnTB20,
            };
            assignedRadioAddresses = new TextBox[UIBoxesCount]
            {
                assignedRadAddrTB1,  assignedRadAddrTB2,  assignedRadAddrTB3,  assignedRadAddrTB4,  assignedRadAddrTB5,
                assignedRadAddrTB6,  assignedRadAddrTB7,  assignedRadAddrTB8,  assignedRadAddrTB9,  assignedRadAddrTB10,
                assignedRadAddrTB11, assignedRadAddrTB12, assignedRadAddrTB13, assignedRadAddrTB14, assignedRadAddrTB15,
                assignedRadAddrTB16, assignedRadAddrTB17, assignedRadAddrTB18, assignedRadAddrTB19, assignedRadAddrTB20,
            };

            ckbIndex = new int[UIBoxesCount];   /// Initialized by ShuffleTextBoxes() ... to be used in the future in case of test benches with two lines
            refRecords = new List<ReferenceRecord>();
            records = new List<Record>();
        }

		/// <summary>
        /// Constructor for one S640Communication test
        /// </summary>
        /// <param name="waterMetersCount">Number of text boxes for serial numbers</param>
        public S640CommForm(S640Activity activity, I640Cfg cfg, Generic.IProcedureParams procParams, Test test, IList<Results.Entities.WaterMeter> waterMeters)
            : this(new List<S640Activity> { activity }, cfg, procParams, new List<Test> { test }, waterMeters)
        {
        }

		/// <summary>
		/// Constructor for multiple S640Communication tests
		/// </summary>
		/// <param name="waterMetersCount">Number of text boxes for serial numbers</param>
        public S640CommForm(IList<S640Activity> activities, I640Cfg cfg, Generic.IProcedureParams procParams, IList<Test> tests, IList<Results.Entities.WaterMeter> waterMeters)
			: this()
		{
            this.activities = activities;
            debugLevel = cfg.DebugLevel;
            optoDataTimeout = cfg.OptoDataTimeout;
            fileExchangePath = string.IsNullOrEmpty(cfg.FileExchangePath) ? string.Empty : cfg.FileExchangePath;
            fileExchangeTimeout = cfg.FileExchangeTimeout;
            serialNumbersMode = cfg.SerialNumbers;
            assignedNumbersMode = cfg.AssignedNumbers;
            skipBadMeters = cfg.SkipBadMeters;
			this.tests = tests;
            this.pPars = procParams as ProcParams;
            this.waterMeters = waterMeters;

            if (activities.Count != tests.Count)
            {
                throw new Exception("Something strange: activities.Count != tests.Count");
            }

            if (ProcessData.RegisterReaders.Length != ProcessData.BatchRslts.Batch.WaterMeters.Count)
            {
                throw new Exception("Something strange: RegisterReaders.Length != WaterMeters.Count");
            }

            if (activities.Count > 0)
			{
				ProcessData.RegisterReaders = StateMachine.GetMetersPath(tests[0]).RegisterReaders;
			}

            optoHeads = new RegisterReaders.S640Stream.S640Stream[ProcessData.RegisterReaders.Length];
            ///
            for (int wmPos = 0; wmPos < ProcessData.RegisterReaders.Length; wmPos++)
            {
                optoHeads[wmPos] = ProcessData.RegisterReaders[wmPos] as RegisterReaders.S640Stream.S640Stream;
            }

            WaterMetersCount = ProcessData.RegisterReaders.Length;
            ShuffleTextBoxes(WaterMetersCount, ProcessData.LineSize);

            enabledInConfiguration = new bool[textBoxesCount];
            for (int i = 0; i < textBoxesCount; i++)
            {
                enabledInConfiguration[i] = (optoHeads[i] != null) && ((Program.LocalSettings.OptoHeadsEnabled & (1L << i)) != 0L);
            }

            isAnySNMissing = false;
            areValuesDisplayed = false;
            areNewSNsAndRadioAddressesAssigned = false;
            formCompleted = false;
            StartForceCloseHandler();
        }


		/// <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)
		{
            textBoxesCount = UIBoxesCount;
            ///
            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];
                        checkBoxes[dest] = checkBoxes[l * lineSize + l * gap + i];
                        pictures[dest] = pictures[l * lineSize + l * gap + i];
						eRegisterNumbers[dest] = eRegisterNumbers[l * lineSize + l * gap + i];
                        radioAddresses[dest] = radioAddresses[l * lineSize + l * gap + i];
                        serialNumbers[dest] = serialNumbers[l * lineSize + l * gap + i];
                        assignedSNs[dest] = assignedSNs[l * lineSize + l * gap + i];
                        assignedRadioAddresses[dest] = assignedRadioAddresses[l * lineSize + l * gap + i];
                        ckbIndex[l * lineSize + l * gap + i] = dest;
                        dest++;
					}
				}

				textBoxesCount = wmsCount;
			}

            for (int i = 0; i < textBoxesCount; i++)
            {
                labels[i].Visible = checkBoxes[i].Visible = pictures[i].Visible
                    = eRegisterNumbers[i].Visible = radioAddresses[i].Visible = true;

                if (optoHeads[i] != null) labels[i].Text = (i + 1).ToString();
            }

            ///
            /// Resize this form to fit enabled controls
            ///
            //int xMax = 0;
            //int yMax = 0;
            //for (int i = 0; i < textBoxesCount; i++)
            //{
            //    if (messages[i].Left + messages[i].Width > xMax) xMax = messages[i].Left + messages[i].Width;
            //    if (messages[i].Top + messages[i].Height > yMax) yMax = messages[i].Top + messages[i].Height;
            //}
            /////Width = xMax + 30;
            //Height = yMax + 50;
		}


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

            ///
            /// Set location and checkbox states to values stored in local settings
            ///
            TBF.LocalSettings ls = Program.LocalSettings;
            Left = (ls.S640CommFormLeft != 0) ? ls.S640CommFormLeft : 150;
            Top = (ls.S640CommFormTop != 0) ? ls.S640CommFormTop : 150;

            ///
            /// Set checkbox states accroding to optoHeads[i].Disabled states
            ///
            for (int i = 0; i < textBoxesCount; i++)
            {
                if (!enabledInConfiguration[i])
                {
                    /// Opto head is disabled in configuration
                    checkBoxes[i].Checked = false;
                    checkBoxes[i].Enabled = false;
                    pictures[i].BackColor = DisabledColor;
                    eRegisterNumbers[i].Visible = false;
                    radioAddresses[i].Visible = false;
                    serialNumbers[i].Visible = false;
                }
                else if ((i >= waterMeters.Count) || waterMeters[i] == null || waterMeters[i].Disabled)
                {
                    /// Opto head was disabled by an operator
                    checkBoxes[i].Checked = false;
                    checkBoxes[i].Enabled = false;
                    pictures[i].BackColor = DisabledColor;
                    eRegisterNumbers[i].Text = "xxx";
                    radioAddresses[i].Text = "xxx";
                }
                else
                {
                    /// Opto head is enabled
                    checkBoxes[i].Checked = true;
                    checkBoxes[i].Enabled = true;
                    eRegisterNumbers[i].Text = "---";
                    radioAddresses[i].Text = "---";
                }

                /// Reset opto-data indication
                pictures[i].BackColor = OptoNokColor;

                eRegisterNumbers[i].Enabled = false;
                eRegisterNumbers[i].Enabled = false;

                serialNumbers[i].Visible = enabledInConfiguration[i] && (serialNumbersMode != SerialNumbers.None);
                serialNumbers[i].Enabled = (serialNumbersMode == SerialNumbers.EnterManually);

                if (activities.Contains(S640Activity.End))
                {
                    assignedSNs[i].Visible = enabledInConfiguration[i] && (serialNumbersMode != SerialNumbers.None);
                    assignedSNs[i].Enabled = (serialNumbersMode == SerialNumbers.EnterManually);

                    assignedRadioAddresses[i].Visible = enabledInConfiguration[i] && (serialNumbersMode != SerialNumbers.None);
                    assignedRadioAddresses[i].Enabled = (serialNumbersMode == SerialNumbers.EnterManually);
                }
            }

            startTimeSec = StateMachine.Time;

            StartActivity(0);

            timer = new System.Windows.Forms.Timer();
            timer.Interval = 300; // ms
            timer.Tick += new EventHandler(timer_Tick);
            timer.Start();
        }


        void Localize()
        {
            /// Close/Continue button is localized in other code
            Text = Strings.Water_Meter_States;
            retryButton.Text = Strings.RetryBtnText;
            sampleLabel1.Text = Strings.Optical_head_is_placed_correctly;
            sampleLabel2.Text = Strings.Missing_opto_pulses;
            samplePictureBox1.BackColor = OptoOKColor;
            samplePictureBox2.BackColor = OptoNokColor;
        }


        void StartActivity(int acIx)
        {
            startTime = DateTime.Now;
            activityLabel.Text = activities[acIx].ToString();
            currentActivityIx = acIx;
            if (activities[acIx] == S640Activity.Start)
            {
                step = serialNumbersMode == SerialNumbers.FromProductionTracing ? Step.ReadSNsFromTracing : Step.WatchOptoHeads;
            }
            else
            {
                step = serialNumbersMode == SerialNumbers.EnterManually ? Step.EnterSNs : Step.ConfirmSNsAndRadioAddresses;
            }

            closeButton.Visible = false;
            retryButton.Visible = false;
            responseTextBox.Text = string.Empty;

            if (step == Step.ReadSNsFromTracing || step == Step.WatchOptoHeads)
            {
                /// Start watching optical heads --> reset OK loop counters
                if (commOkLoopsCount == null || commOkLoopsCount.Length != textBoxesCount)
                {
                    commOkLoopsCount = new int[textBoxesCount];
                }
                for (int i = 0; i < textBoxesCount; i++) commOkLoopsCount[i] = 0;

                progressBar1.Visible = (optoDataTimeout != 0);
                progressBar1.Minimum = 0;
                progressBar1.Maximum = Math.Max(optoDataTimeout, 1);
                progressBar1.Value = 0;
            }

            TBF.UiBridge.TestProgressEventArgs.SetEstimatedTimes(new int[] { 0, 0, 10, 0, 140, 0, 0, 0 });
            TBF.UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[acIx], Progress.JustStarted));

            sirtDataLogger.InfoFormat("");                          /// Makes the log more readable when there is a lot of data
            sirtDataLogger.WarnFormat("Activity = {0}", activities[acIx]);
            sirtDataLogger.InfoFormat("");                          /// Makes the log more readable when there is a lot of data
        }


		/// <summary>
		/// Invoked every 0.5 sec.
		/// </summary>
        void timer_Tick(object sender, EventArgs args)
        {
            ///--------------------------------------------------------------------------
            if (step == Step.ReadSNsFromTracing)
            {
                if (ProcessData.TracingDB != null && ProcessData.OrderInfo is OrderInfo)
                {
                    ISession session = ProcessData.TracingDB.SessionFactory.OpenSession();
                    refRecords = ProcessData.TracingDB.ReadRefRecords(session, ProcessData.OrderInfo as OrderInfo);
                    records = ProcessData.TracingDB.ReadRecords(session, ProcessData.OrderInfo as OrderInfo);
                    session.Close();
                }

                step = Step.WatchOptoHeads;
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.WatchOptoHeads)
            {
                activityLabel.Text = "Heads are sensing opto-data";

                bool allOK = true;
                for (int i = 0; i < textBoxesCount; i++)
                {
                    if (enabledInConfiguration[i])
                    {
                        if (!checkBoxes[i].Checked)
                        {
                            /// Disabled by the user
                            pictures[i].BackColor = DisabledColor;
                            eRegisterNumbers[i].Text = "xxx";
                            radioAddresses[i].Text = "xxx";
                            serialNumbers[i].Text = string.Empty;
                        }
                        else
                        {
                            /// Opto head is enabled

                            if (optoHeads[i].PcbNumber == 0)
                            {
                                /// Communication is NOK right now
                                pictures[i].BackColor = OptoNokColor;
                                eRegisterNumbers[i].Text = "---";
                                radioAddresses[i].Text = "---";
                                serialNumbers[i].Text = string.Empty;
                                commOkLoopsCount[i] = 0;
                                allOK = false;
                            }
                            else
                            {
                                /// Communication is OK right now
                                string pcbNumber = optoHeads[i].PcbNumber.ToString();
                                eRegisterNumbers[i].Text = pcbNumber;
                                radioAddresses[i].Text = optoHeads[i].RadioAddress.ToString();

                                Record rec;
                                ReferenceRecord refRec;
                                if ((rec = records.FirstOrDefault(x => x.Code == pcbNumber)) != null &&
                                    (refRec = refRecords.FirstOrDefault(x => x.Id == rec.ReferenceRecord.Id)) != null)
                                {
                                    serialNumbers[i].Text = refRec.Code;
                                }
                                else
                                {
                                    serialNumbers[i].Text = string.Empty;
                                }

                                pictures[i].BackColor = OptoOKColor;

                                /// increment commOkLoopsCount[i] and check its value, considered OK just after 5 repeats
                                commOkLoopsCount[i] = commOkLoopsCount[i] + 1;
                                if (commOkLoopsCount[i] < 5) allOK = false;
                            }
                        }
                    }
                }

                isAnySNMissing = false;
                if (allOK)
                {
                    log.WarnFormat("allOk");

                    /// Update water meter properties
                    for (int i = 0; i < textBoxesCount; i++)
                    {
                        if (i < waterMeters.Count && waterMeters[i] != null && !waterMeters[i].Disabled)
                        {
                            if (enabledInConfiguration[i] && checkBoxes[i].Checked)
                            {
                                /// Save PCB Number of the water meter
                                waterMeters[i].SerialNrAux = optoHeads[i].PcbNumber.ToString();         /// PCB number (640)
                                waterMeters[i].OriRadioAddress = optoHeads[i].RadioAddress.ToString();  /// New radio address (640)
                                waterMeters[i].RadioAddress = optoHeads[i].RadioAddress.ToString();     /// New radio address (640)

                                if (string.IsNullOrEmpty(serialNumbers[i].Text)) isAnySNMissing = true;
                            }
                            else
                            {
                                /// Disable the water meter
                                waterMeters[i].Disabled = true;
                            }
                        }

                        checkBoxes[i].Enabled = false;
                    }

                    step = Step.SaveStartPro;
                }
                else if (optoDataTimeout != 0 && DateTime.Now - startTime > new TimeSpan(0, 0, optoDataTimeout))
                {
                    /// Opto-data timeout occured

                    activityLabel.Text = String.Format("{0}: {1} {2}", Strings.Start, Strings.Optical_heads, Strings.Timeout);
                    log.Error("Start: Optical heads timeout");
                    step = Step.ConfirmError;
                }
                else if (optoDataTimeout != 0)
                {
                    /// Count down
                    progressBar1.Value = (int)Math.Round((DateTime.Now - startTime).TotalSeconds);
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.SaveStartPro)
            {
                int count = 0;
                for (int i = 0; i < textBoxesCount; i++)
                {
                    if (optoHeads[i] != null && optoHeads[i].PcbNumber != 0 && ProcessData.BatchRslts.Batch.WaterMeters[i] != null) count++;
                }

                log.DebugFormat("Saving '{0}' file: {1} water meters found", StartFileName, count);
                if (debugLevel == DebugMode.Normal)
                {
                    SaveProFile(Path.Combine(fileExchangePath, StartFileName), S640Activity.Start, optoHeads);
                }
                SaveProFile(Path.Combine(Constants.SirtLogDir,
                                         string.Format("{0:yyMMdd-HHmmss}-b{1}-{2}", DateTime.Now, ProcessData.BatchRslts.Batch.BatchNr, StartFileName)),
                            S640Activity.Start, optoHeads);

                savedTimestamp = DateTime.Now;

                progressBar1.Visible = (fileExchangeTimeout != 0);
                progressBar1.Minimum = 0;
                progressBar1.Maximum = Math.Max(fileExchangeTimeout, 1);
                progressBar1.Value = 0;

                for (int i = 0; i < textBoxesCount; i++) { eRegisterNumbers[i].Enabled = false; }

                bool focused = false;
                if (serialNumbersMode == SerialNumbers.EnterManually || isAnySNMissing)
                {
                    for (int i = 0; i < textBoxesCount; i++)
                    {
                        if (serialNumbers[i].Visible && string.IsNullOrEmpty(serialNumbers[i].Text))
                        {
                            serialNumbers[i].Enabled = true;
                            if (!focused)
                            {
                                serialNumbers[i].Focus();
                                focused = true;
                            }
                        }
                    }
                    
                    closeButton.Visible = true;
                    closeButton.Enabled = true;
                    closeButton.Text = Strings.Continue;
                    step = Step.EnterSNsAndAwaitResponseToStartPro;
                }
                else
                {
                    /// Update water meter properties
                    UpdateAndDisableSerialNumbers();
                    step = Step.AwaitResponseToStartPro;
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.EnterSNsAndAwaitResponseToStartPro)
            {
                activityLabel.Text = "Enter or scan housing S/N-s";

                /// Don't do anything, move to the next step in closeButton_Click(...)
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.AwaitResponseToStartPro)
            {
                activityLabel.Text = "SIRT communication in progress";

                if (debugLevel == DebugMode.Simulate)
                {
                    /// Simulation: After 'Next' button click a similar action as when Start.pro file disappears

                    closeButton.Text = "Next";
                    closeButton.Visible = true;
                    retryButton.Visible = false;
                }
                else if (!File.Exists(Path.Combine(fileExchangePath, StartFileName)))
                {
                    /// Normal flow of actions ... Start.pro file disappeared in time

                    /// Updatetest results
                    UpdateFirstTestResult(tests);
                    UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[currentActivityIx], Progress.Completed));

                    step = Step.Idle;
                    NormalClose();
                }
                else if (File.Exists(Path.Combine(fileExchangePath, ErrorFileName)))
                {
                    /// Error file detected

                    string destination = Path.Combine(Constants.SirtLogDir,
                        string.Format("{0:yyMMdd-HHmmss}-b{1}-{2}", DateTime.Now, ProcessData.BatchRslts.Batch.BatchNr, ErrorFileName));
                    File.Move(Path.Combine(fileExchangePath, ErrorFileName), destination);
                    ParseFileAndDisplayErrors(destination);
                    File.Delete(Path.Combine(fileExchangePath, StartFileName));
                    activityLabel.Text = String.Format("{0}: SIRT {1}", Strings.Start, Strings.Error);
                    step = Step.ConfirmError;
                }
                else if (fileExchangeTimeout != 0 && DateTime.Now - savedTimestamp > new TimeSpan(0, 0, fileExchangeTimeout))
                {
                    /// Timeout

                    activityLabel.Text = String.Format("{0}: SIRT {1}", Strings.Start, Strings.Timeout);
                    log.Error("Start: SIRT timeout");
                    step = Step.ConfirmError;
                }
                else if (fileExchangeTimeout != 0)
                {
                    /// Nothing special, timeout is counting down

                    progressBar1.Value = (int)Math.Round((DateTime.Now - savedTimestamp).TotalSeconds);
                }
                else
                {
                    /// Nothing special, there is no timeout, Close adn Retry buttons are visible

                    progressBar1.Visible = false;
                    closeButton.Text = Strings.CloseBtnText;
                    closeButton.Visible = true;
                    retryButton.Visible = true;
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.EnterSNs)
            {
                /// Don't do anything just display values, move to the next step in closeButton_Click(...)

                if (!areValuesDisplayed)
                {
                    DisplayValues();
                    areValuesDisplayed = true;
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.ConfirmSNsAndRadioAddresses)
            {
                activityLabel.Text = "Confirm new S/N-s and radio addresses";

                if (!areValuesDisplayed)
                {
                    DisplayValues();
                    areValuesDisplayed = true;
                }

                if (!areNewSNsAndRadioAddressesAssigned)
                {
                    AssignNewSNsAndRadioAddresses(waterMeters, optoHeads);
                    closeButton.Visible = true;
                    closeButton.Text = Strings.Continue;
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.SaveEndePro)
            {
                activityLabel.Text = "SIRT communication in progress";

                log.DebugFormat("Saving '{0}' file", EndFileName);
                if (debugLevel == DebugMode.Normal)
                {
                    SaveProFile(Path.Combine(fileExchangePath, EndFileName), S640Activity.End, optoHeads);
                }
                SaveProFile(Path.Combine(Constants.SirtLogDir,
                                         string.Format("{0:yyMMdd-HHmmss}-b{1}-{2}", DateTime.Now, ProcessData.BatchRslts.Batch.BatchNr, EndFileName)),
                            S640Activity.Start, optoHeads);

                savedTimestamp = DateTime.Now;

                progressBar1.Visible = (fileExchangeTimeout != 0);
                progressBar1.Minimum = 0;
                progressBar1.Maximum = Math.Max(fileExchangeTimeout, 1);
                progressBar1.Value = 0;

                if (ProcessData.OracleDB != null && ProcessData.OrderInfo is TBF.Rig.Output.DB.SensusOracle.OrderDetails)
                {
                    int updatedCount = ProcessData.OracleDB
                        .UpdateOrderDetails(ProcessData.OrderInfo as TBF.Rig.Output.DB.SensusOracle.OrderDetails);
                }

                step = Step.AwaitResponseToEndePro;
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.AwaitResponseToEndePro)
            {
                if (debugLevel == DebugMode.Simulate)
                {
                    /// Simulation: After 'Next' button click a similar action as when Ende.pro file disappears

                    closeButton.Text = "Next";
                    closeButton.Visible = true;
                    retryButton.Visible = false;
                }
                else if (!File.Exists(Path.Combine(fileExchangePath, EndFileName)))
                {
                    /// Normal flow of actions ... Ende.pro file disappeared in time
                    
                    /// Update test results
                    UpdateFirstTestResult(tests);
                    UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[currentActivityIx], Progress.Completed));
                    step = Step.Idle;
                    NormalClose();
                }
                else if (File.Exists(Path.Combine(fileExchangePath, ErrorFileName)))
                {
                    /// Error.dat file detected
                    string destination = Path.Combine(Constants.SirtLogDir,
                        string.Format("{0:yyMMdd-HHmmss}-b{1}-{2}", DateTime.Now, ProcessData.BatchRslts.Batch.BatchNr, ErrorFileName));
                    File.Move(Path.Combine(fileExchangePath, ErrorFileName), destination);
                    ParseFileAndDisplayErrors(destination);
                    File.Delete(Path.Combine(fileExchangePath, EndFileName));
                    activityLabel.Text = String.Format("{0}: SIRT {1}", Strings.End, Strings.Error);
                    step = Step.ConfirmError;
                }
                else if (fileExchangeTimeout != 0 && DateTime.Now - savedTimestamp > new TimeSpan(0, 0, fileExchangeTimeout))
                {
                    activityLabel.Text = String.Format("{0}: SIRT {1}", Strings.End, Strings.Timeout);
                    log.Error("End: SIRT timeout");
                    step = Step.ConfirmError;
                }
                else if (fileExchangeTimeout != 0)
                {
                    progressBar1.Value = (int)Math.Round((DateTime.Now - savedTimestamp).TotalSeconds);
                }
                else
                {
                    progressBar1.Visible = false;
                    closeButton.Text = Strings.CloseBtnText;
                    closeButton.Visible = true;
                    retryButton.Visible = true;
                }
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.ConfirmError)
            {
                progressBar1.Visible = false;
                retryButton.Visible = true;
                closeButton.Visible = true;
                closeButton.Enabled = true;
                closeButton.Text = Strings.CloseBtnText;
            }
            ///--------------------------------------------------------------------------
            else if (step == Step.Idle)
            {
                /// Just wait until this form is closed
            }
            else
            {
                /// Invalid step
                log.ErrorFormat("Unexpected step: activity = {0} step = {1}", activities[currentActivityIx], step);
            }
        }

        private void closeButton_Click(object sender, EventArgs e)
        {
            if (step == Step.EnterSNsAndAwaitResponseToStartPro)
            {
                UpdateAndDisableSerialNumbers();
                step = Step.AwaitResponseToStartPro;
                closeButton.Visible = false;
            }
            else if (debugLevel == DebugMode.Simulate && step == Step.AwaitResponseToStartPro)
            {
                UpdateFirstTestResult(tests);
                UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[currentActivityIx], Progress.Completed));
                NormalClose();
            }
            else if (step == Step.EnterSNs)
            {
                UpdateAndDisableSerialNumbers();
                step = Step.ConfirmSNsAndRadioAddresses;
                closeButton.Visible = false;
            }
            else if (step == Step.ConfirmSNsAndRadioAddresses)
            {
                step = Step.SaveEndePro;
                closeButton.Visible = false;
            }
            else if (debugLevel == DebugMode.Simulate && step == Step.AwaitResponseToEndePro)
            {
                UpdateFirstTestResult(tests);
                UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[currentActivityIx], Progress.Completed));
                NormalClose();
            }
            else
            {
                log.Error("User is closing this form, communication failed");
                UpdateFirstTestResult(tests, true);
                UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[currentActivityIx], Progress.Aborted));
                NormalClose();
            }
        }


        /// <summary>
        /// Updates SerialNr of all enabled water meters from respective visible TextBoxes.
        /// </summary>
        void UpdateAndDisableSerialNumbers()
        {
            /// Update water meter properties
            for (int i = 0; i < textBoxesCount; i++)
            {
                if (serialNumbers[i].Visible)
                {
                    if (i < waterMeters.Count && waterMeters[i] != null && !waterMeters[i].Disabled &&
                        enabledInConfiguration[i] && checkBoxes[i].Checked)
                    {
                        /// Save brass water meter body serial number
                        waterMeters[i].SerialNr = serialNumbers[i].Text;
                    }

                    serialNumbers[i].Enabled = false;
                }
            }
        }


        void DisplayValues()
        {
            for (int i = 0; i < textBoxesCount; i++)
            {
                if (i < waterMeters.Count && waterMeters[i] != null && !waterMeters[i].Disabled &&
                    enabledInConfiguration[i] && checkBoxes[i].Checked)
                {
                    /// Save PCB Number of the water meter
                    eRegisterNumbers[i].Text = waterMeters[i].SerialNrAux;      /// PCB number (640)
                    radioAddresses[i].Text = waterMeters[i].OriRadioAddress;    /// New radio address (640)
                    serialNumbers[i].Text = waterMeters[i].SerialNr;            /// Serial unmber (housing number
                }
            }
        }


        bool AssignNewSNsAndRadioAddresses(IList<Results.Entities.WaterMeter> waterMeters, RegisterReaders.S640Stream.S640Stream[] optoHeads)
        {
            var order = ProcessData.OrderInfo;
            var oraOrder = order as TBF.Rig.Output.DB.SensusOracle.OrderDetails;
            ///
            if (oraOrder != null && (ProcessData.OracleDB == null || !ProcessData.OracleDB.ReadOrderDetails(ref oraOrder)))
            {
                return false;
            }

            if (order.CurrentSN < order.SNFirst)
            {
                order.CurrentSN = order.SNFirst - 1;
            }

            for (int i = 0; i < optoHeads.Length; i++)
            {
                int currentSerialNr = (order.CurrentSN < order.SNFirst)
                                    ? order.SNFirst
                                    : order.CurrentSN + 1;

                int currentRadioAddress = (order.CurrentRA < order.RAFirst)
                                        ? order.RAFirst
                                        : order.CurrentRA + 1;

                Results.Entities.WaterMeter wm = ProcessData.BatchRslts.Batch.WaterMeters[i];
                if (optoHeads[i] != null && optoHeads[i].PcbNumber != 0 && wm != null && !wm.Disabled)
                {
                    if (!wm.PassedFromTests())
                    {
                        /// Red background
                        eRegisterNumbers[i].BackColor = Color.Pink;
                        wm.AssignedSerialNr = -1;
                        wm.Prefix = order.SNPrefix;
                        wm.Suffix = order.SNSuffix;
                        wm.CompleteSerialNr = string.Empty;

                        assignedSNs[i].Text = wm.CompleteSerialNr;
                        assignedRadioAddresses[i].Text = wm.RadioAddress;
                    }
                    else if (order.CurrentPcsCount >= order.PiecesCount)
                    {
                        /// Disable the water meter to prevent sealing
                        wm.Disabled = true;
                    }
                    else
                    {
                        /// Assign numbers
                        wm.AssignedSerialNr = currentSerialNr;
                        wm.Prefix = order.SNPrefix;
                        wm.Suffix = order.SNSuffix;
                        wm.CompleteSerialNr = string.Format("{0}{1}{2}",
                                                            order.SNPrefix,
                                                            currentSerialNr.ToString(string.Format("D{0}", order.SNDigitsCount)),
                                                            order.SNSuffix);
                        assignedSNs[i].Text = wm.CompleteSerialNr;

                        wm.RadioAddress = string.Format("{0}{1}{2}",
                                                        order.RAPrefix,
                                                        currentRadioAddress.ToString("D9"),
                                                        order.RASuffix);
                        assignedRadioAddresses[i].Text = wm.RadioAddress;

                        order.CurrentSN = currentSerialNr;
                        order.CurrentRA = currentRadioAddress;
                        order.CurrentPcsCount++;
                    }
                }
            }

            areNewSNsAndRadioAddressesAssigned = true;
            return true;
        }


        void SaveProFile(string filename, S640Activity activity, RegisterReaders.S640Stream.S640Stream[] optoHeads)
        {
            /// Variant: 1.from OrderDetails, 2.from Procedure.WatermetersStr, 3.empty
            string variant = (ProcessData.OrderInfo != null && !string.IsNullOrEmpty(ProcessData.OrderInfo.VariantCode))
                           ? ProcessData.OrderInfo.VariantCode             /// 1
                           : !string.IsNullOrEmpty(ProcessData.BatchRslts.Batch.WatermetersStr)
                           ? ProcessData.BatchRslts.Batch.WatermetersStr        /// 2
                           : string.Empty;                                      /// 3

            /// Module parameter
            string moduleParam = (pPars.ModuleParameter.ToLower().Contains("vt_auftrag_pd") && ProcessData.OrderInfo != null)
                               ? ProcessData.OrderInfo.ModuleParam
                               : pPars.ModuleParameter;

            /// Purchase order and water meters count
            int count = 0;
            string purchaseOrder = null;
            for (int i = 0; i < optoHeads.Length; i++)
            {
                if (optoHeads[i] != null && optoHeads[i].PcbNumber != 0 &&
                    waterMeters[i] != null && !waterMeters[i].Disabled &&
                    (activity == S640Activity.Start || waterMeters[i].PassedFromTests()))
                {
                    count++;

                    if (purchaseOrder == null && !string.IsNullOrEmpty(ProcessData.BatchRslts.Batch.WaterMeters[i].PurchaseOrder))
                    {
                        purchaseOrder = ProcessData.BatchRslts.Batch.WaterMeters[i].PurchaseOrder;
                    }
                }
            }
            if (ProcessData.OrderInfo != null)
            {
                purchaseOrder = ProcessData.OrderInfo.POName;
            }

            using (StreamWriter file = new StreamWriter(filename))
            {
                file.WriteLine("<?xml version=\"1.0\" ?>");
                file.WriteLine("<Batch xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">");
                file.WriteLine(string.Format("  <TimeStamp>{0}</TimeStamp>", DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffzzz")));
                file.WriteLine(string.Format("  <Bench Mode=\"{0}\" Count=\"{1}\" TestBenchID=\"{2}\" TestBenchName=\"{3}\" EncyptionKeyMode=\"{4}\" />",
                    (activity == S640Activity.Start) ? "Start" : "End",
                    count,
                    ProcessData.BenchInfo.TestBenchId,
                    ProcessData.BenchInfo.TestBenchName,
                    "SensusKey"));

                file.WriteLine(string.Format("  <OrderData Variantencode=\"{0}\" OrderNo=\"{1}\" ModulParameter=\"{2}\" />",
                                             variant, (purchaseOrder != null) ? purchaseOrder : string.Empty, moduleParam));
                file.WriteLine("  <Meters>");
                for (int i = 0; i < optoHeads.Length; i++)
                {
                    if (optoHeads[i] != null &&
                        optoHeads[i].PcbNumber != 0 &&
                        ProcessData.BatchRslts.Batch.WaterMeters[i] != null &&
                        !ProcessData.BatchRslts.Batch.WaterMeters[i].Disabled &&
                        (activity == S640Activity.Start || ProcessData.BatchRslts.Batch.WaterMeters[i].PassedFromTests()))
                    {
                        Results.Entities.WaterMeter wm = ProcessData.BatchRslts.Batch.WaterMeters[i];

                        if (activity == S640Activity.Start)
                        {
                            file.WriteLine(string.Format("    <Meter RadioAddress=\"{0}\" MeterNumber=\"{0}\" CustomerText=\"\" NewRadioAddress=\"{0}\" PCBNumber=\"{1}\" EncyptionKey=\"\" />",
                                                         wm.RadioAddress,
                                                         wm.SerialNrAux));
                        }
                        else if (activity == S640Activity.End)
                        {
#if ORACLE_DB
                            file.WriteLine(string.Format("    <Meter RadioAddress=\"{0}\" MeterNumber=\"{1}\" CustomerText=\"{2}\" NewRadioAddress=\"{3}\" PCBNumber=\"{4}\" EncyptionKey=\"\" />",
                                                         wm.OriRadioAddress,
                                                         wm.AssignedSerialNr.ToString(),
                                                         wm.AssignedSerialNr.ToString(),
                                                         wm.RadioAddress,
                                                         wm.SerialNrAux));
#endif
                        }
                    }
                }
                file.WriteLine("  </Meters>");
                file.WriteLine(string.Format("  <Metro Enable=\"{0}\" PulseRatePiston=\"{1}\" PulseRateLED=\"{2}\" OffsetFactor=\"{3}\" FactoryCalibration=\"{4}\" Units=\"{5}\" MeterSize=\"{6}\" OffsetTime=\"{7}\" />",
                    B2S(pPars.MetroEnable),
                    pPars.PulseRatePiston.ToString("F3", CultureInfo.InvariantCulture),
                    pPars.PulseRateLed.ToString(CultureInfo.InvariantCulture),
                    pPars.OffsetFactor.ToString(CultureInfo.InvariantCulture),
                    pPars.FactoryCalibration,
                    pPars.Units,
                    pPars.MeterSize,
                    pPars.OffsetTime));
                file.WriteLine(string.Format("  <NewRead Enable=\"{0}\" NewRead=\"{1}\" />", B2S(pPars.NewReadEnable), pPars.NewRead));
                file.WriteLine(string.Format("  <TransInterval Enable=\"{0}\" Interval=\"{1}\" />", B2S(pPars.TransIntervalEnable), pPars.TransInterval));
                file.WriteLine(string.Format("  <LatInterval Enable=\"{0}\" Interval=\"{1}\" />", B2S(pPars.LatIntervalEnable), pPars.LatInterval));
                file.WriteLine(string.Format("  <ResetAlarm Enable=\"{0}\" />", B2S(pPars.ResetAlarmEnable)));
                file.WriteLine(string.Format("  <MetrologyTestMode Enable=\"{0}\" Hours=\"{1}\" />", B2S(pPars.MetrologyTestModeEnable), pPars.MetrologyTestModeHours));
                file.WriteLine(string.Format("  <OpticalTeleg Enable=\"{0}\" Minutes=\"{1}\" />", B2S(pPars.OpticalTelegramEnable), pPars.OpticalTelegramMinutes));
                file.WriteLine(string.Format("  <ChangeRadio Enable=\"{0}\" />", B2S(pPars.ChangeRadioEnable)));
                file.WriteLine(string.Format("  <ChangeMeterID Enable=\"{0}\" />", B2S(pPars.ChangeMeterIDEnable)));
                file.WriteLine(string.Format("  <SoftSeal Enable=\"{0}\" />", B2S(pPars.SoftSealEnable)));
                file.WriteLine(string.Format("  <GoToSleep Enable=\"{0}\" />", B2S(pPars.GoToSleepEnable)));
                file.WriteLine(string.Format("  <SaveDB Enable=\"{0}\" />", B2S(pPars.SaveDBEnable)));
                file.WriteLine("</Batch>");
            }
        }

        /// <summary>
        /// Boolean to lowercase string
        /// </summary>
        string B2S(bool b)
        {
            return b ? "true" : "false";
        }

        void ParseFileAndDisplayErrors(string fileName)
        {
            log.ErrorFormat("ParseFileAndDisplayErrors(\"{0}\")", fileName);
            string message = File.ReadAllText(fileName);
            responseTextBox.Text = message;
        }


        /// <summary>
        /// Update test result representing RFID communication success/failure
        /// </summary>
        /// <param name="test"></param>
        void UpdateFirstTestResult(IList<Config.Entities.Test> tests, bool commFailed = false)
        {
			DateTime endTime = DateTime.Now;
			int testTime = StateMachine.Time - startTimeSec;

			if (!tests.Contains(StateMachine.TestInstances[0].Test))
			{
                tests.Insert(0, StateMachine.TestInstances[0].Test);	/// Add RFID test as the 1st item
			}

			foreach (var test in tests)
			{
				Results.Entities.TestRslt tstRslt = ProcessData.BatchRslts.GetTestRslt(test.Name, test.Part);

                if (tstRslt != null)
                {
                    Results.Utils.GetCounterStates(tstRslt, Program.LocalSettings.Counters);

				    /// Auxiliary results ... not required

				    /// Main results
                    tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
                    tstRslt.TestDone    = true;
                    tstRslt.StartTime   = tstRslt.Batch.StartTime;
				    tstRslt.EndTime     = endTime;
				    tstRslt.FlowSetTime = 0;
                    tstRslt.MassOfEvapWater = 0;
                    tstRslt.TestTime   += testTime;             /// [s] total communication time of all tests

					for (int i = 0; i < textBoxesCount; i++)
					{
						Results.Entities.MeterTestRslt meterRslt =
							ProcessData.BatchRslts.GetMeterTestRslt(test.Name, i, Common.CompoundMeterId.Single);

						if (meterRslt != null && (i < ProcessData.BatchRslts.Batch.WaterMeters.Count) &&
                            ProcessData.BatchRslts.Batch.WaterMeters[i] != null &&
                            !ProcessData.BatchRslts.Batch.WaterMeters[i].Disabled)
						{
                            if (enabledInConfiguration[i] && !commFailed)
                            {
                                meterRslt.TestDone = true;
                                meterRslt.Passed = true;
                            }
                            else
                            {
                                meterRslt.TestDone = true;
                                meterRslt.Passed = false;
                            }
                        }
					}
                }
			}
        }

        private void NormalClose()
        {
            if (Program.LocalSettings.S640CommFormLeft != Location.X ||
                Program.LocalSettings.S640CommFormTop != Location.Y)
            {
                /// Update local settings
                Program.LocalSettings.S640CommFormLeft = Location.X;
                Program.LocalSettings.S640CommFormTop = Location.Y;
                Program.LocalSettings.Save();
            }

            formCompleted = true;

            DialogResult = DialogResult.OK;
            Close();
        }

        #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)
        {
            forcedClose = true;
            DialogResult = DialogResult.Cancel;
            Close();
        }

        #endregion

        private void S640CommForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!forcedClose && !formCompleted)
            {
                e.Cancel = true;
            }
        }

        private void retryButton_Click(object sender, EventArgs e)
        {
            if (step == Step.ConfirmError)
            {
                StartActivity(0);
            }
        }

        private void textBox1_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB1); }
        private void textBox2_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB2); }
        private void textBox3_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB3); }
        private void textBox4_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB4); }
        private void textBox5_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB5); }
        private void textBox6_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB6); }
        private void textBox7_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB7); }
        private void textBox8_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB8); }
        private void textBox9_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB9); }
        private void textBox10_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB10); }
        private void textBox11_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB11); }
        private void textBox12_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB12); }
        private void textBox13_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB13); }
        private void textBox14_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB14); }
        private void textBox15_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB15); }
        private void textBox16_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB16); }
        private void textBox17_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB17); }
        private void textBox18_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB18); }
        private void textBox19_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB19); }
        private void textBox20_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, serialNrTB20); }
        private void textBox21_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox21); }
        private void textBox22_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox22); }
        private void textBox23_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox23); }
        private void textBox24_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox24); }
        private void textBox25_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox25); }
        private void textBox26_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox26); }
        private void textBox27_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox27); }
        private void textBox28_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox28); }
        private void textBox29_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox29); }
        private void textBox30_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox30); }
        private void textBox31_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox31); }
        private void textBox32_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox32); }
        private void textBox33_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox33); }
        private void textBox34_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox34); }
        private void textBox35_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox35); }
        private void textBox36_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox36); }
        private void textBox37_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox37); }
        private void textBox38_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox38); }
        private void textBox39_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox39); }
        private void textBox40_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, textBox40); }

        /// <summary>
        /// Process a key press within any enabled text boxe
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <param name="currentFocusOwner">TextBox control which received the event</param>
        private void ProcKeyPress(object sender, KeyPressEventArgs e, TextBox currentFocusOwner)
        {
            if (e.KeyChar == '\r')
            {
                /// Process <enter> key ..... Next text field
                if (textBoxesCount < 2) return;		        /// There is just one enabled textBox

                for (int i = 0; i < textBoxesCount; i++)
                {
                    if (serialNumbers[i] == currentFocusOwner)
                    {
                        int nextIx = i;
                        do
                        {
                            nextIx = (++nextIx) % textBoxesCount;
                        }
                        while (!serialNumbers[nextIx].Visible);

                        /// Change focus to the next enabled text box
                        serialNumbers[nextIx].Focus();
                        return;
                    }
                }
            }
        }

        private void checkBoxImage1_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage1, fromOptoTextBox1, radioAddressTB1, serialNrTB1); }
        private void checkBoxImage2_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage2, fromOptoTextBox2, radioAddressTB2, serialNrTB2); }
        private void checkBoxImage3_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage3, fromOptoTextBox3, radioAddressTB3, serialNrTB3); }
        private void checkBoxImage4_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage4, fromOptoTextBox4, radioAddressTB4, serialNrTB4); }
        private void checkBoxImage5_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage5, fromOptoTextBox5, radioAddressTB5, serialNrTB5); }
        private void checkBoxImage6_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage6, fromOptoTextBox6, radioAddressTB6, serialNrTB6); }
        private void checkBoxImage7_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage7, fromOptoTextBox7, radioAddressTB7, serialNrTB7); }
        private void checkBoxImage8_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage8, fromOptoTextBox8, radioAddressTB8, serialNrTB8); }
        private void checkBoxImage9_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage9, fromOptoTextBox9, radioAddressTB9, serialNrTB9); }
        private void checkBoxImage10_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage10, fromOptoTextBox10, radioAddressTB10, serialNrTB10); }
        private void checkBoxImage11_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage11, fromOptoTextBox11, radioAddressTB11, serialNrTB11); }
        private void checkBoxImage12_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage12, fromOptoTextBox12, radioAddressTB12, serialNrTB12); }
        private void checkBoxImage13_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage13, fromOptoTextBox13, radioAddressTB13, serialNrTB13); }
        private void checkBoxImage14_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage14, fromOptoTextBox14, radioAddressTB14, serialNrTB14); }
        private void checkBoxImage15_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage15, fromOptoTextBox15, radioAddressTB15, serialNrTB15); }
        private void checkBoxImage16_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage16, fromOptoTextBox16, radioAddressTB16, serialNrTB16); }
        private void checkBoxImage17_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage17, fromOptoTextBox17, radioAddressTB17, serialNrTB17); }
        private void checkBoxImage18_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage18, fromOptoTextBox18, radioAddressTB18, serialNrTB18); }
        private void checkBoxImage19_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage19, fromOptoTextBox19, radioAddressTB19, serialNrTB19); }
        private void checkBoxImage20_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage20, fromOptoTextBox20, radioAddressTB20, serialNrTB20); }
        private void checkBoxImage21_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage21, fromOptoTextBox21, radioAddressTB21, textBox21); }
        private void checkBoxImage22_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage22, fromOptoTextBox22, radioAddressTB22, textBox22); }
        private void checkBoxImage23_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage23, fromOptoTextBox23, radioAddressTB23, textBox23); }
        private void checkBoxImage24_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage24, fromOptoTextBox24, radioAddressTB24, textBox24); }
        private void checkBoxImage25_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage25, fromOptoTextBox25, radioAddressTB25, textBox25); }
        private void checkBoxImage26_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage26, fromOptoTextBox26, radioAddressTB26, textBox26); }
        private void checkBoxImage27_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage27, fromOptoTextBox27, radioAddressTB27, textBox27); }
        private void checkBoxImage28_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage28, fromOptoTextBox28, radioAddressTB28, textBox28); }
        private void checkBoxImage29_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage29, fromOptoTextBox29, radioAddressTB29, textBox29); }
        private void checkBoxImage30_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage30, fromOptoTextBox30, radioAddressTB30, textBox30); }
        private void checkBoxImage31_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage31, fromOptoTextBox31, radioAddressTB31, textBox31); }
        private void checkBoxImage32_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage32, fromOptoTextBox32, radioAddressTB32, textBox32); }
        private void checkBoxImage33_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage33, fromOptoTextBox33, radioAddressTB33, textBox33); }
        private void checkBoxImage34_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage34, fromOptoTextBox34, radioAddressTB34, textBox34); }
        private void checkBoxImage35_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage35, fromOptoTextBox35, radioAddressTB35, textBox35); }
        private void checkBoxImage36_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage36, fromOptoTextBox36, radioAddressTB36, textBox36); }
        private void checkBoxImage37_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage37, fromOptoTextBox37, radioAddressTB37, textBox37); }
        private void checkBoxImage38_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage38, fromOptoTextBox38, radioAddressTB38, textBox38); }
        private void checkBoxImage39_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage39, fromOptoTextBox39, radioAddressTB39, textBox39); }
        private void checkBoxImage40_Click(object sender, EventArgs e) { ProcessClick(checkBoxImage40, fromOptoTextBox40, radioAddressTB40, textBox40); }

        void ProcessClick(CheckBoxImage checkBox, TextBox eRegisterNrTB, TextBox radioAddrTB, TextBox snTextBox)
        {
            if (checkBox.Checked)
            {
                eRegisterNrTB.Text = radioAddrTB.Text = string.Empty;
            }
            else
            {
                eRegisterNrTB.Text = radioAddrTB.Text = "xxx";
            }
            
            if (skipBadMeters)
            {
                snTextBox.Visible = checkBox.Checked;
            }
        }
    }
}