///
/// Copyright (c) 2015 Sensus Metering Systems
///

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using Common;
using FluentNHibernate.Conventions;
using log4net;
using NHibernate.Criterion;
using Results.Entities;
using TBF.Resources;

namespace TBF.Rig.DataEntry.StandartCameraPurchaseOrder
{
    public partial class CycleBeginningForm : Form, GenericDevices.IHasCompleted
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(CycleBeginningForm));
        private static readonly ILog log_selected = LogManager.GetLogger("PurchaseOrderHistory");

        /// <summary> Number of water meters </summary>
        public readonly int WaterMetersCount;

        /// To be retrieved after the form is closed
        public string PurchaseOrder;

        private List<PurchaseOrder> purchaseOrderListExample;

        public string[] SNText;
        public bool[] Disabled;

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

        bool completed;

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

        Label[] labels;
        ComboBox[] comboBoxes;
        CheckBox[] checkBoxes;
        ComboBox[] comboNumbers;
        IList<ComboBox> enabledComboBoxes;
        IList<ComboBox> enabledComboBoxesN;


        /// <summary> Parameterless constructor for common functionality </summary>
        public CycleBeginningForm()
        {
            InitializeComponent();

            this.Icon = Properties.Resources.TBF_icon;

            ControlBox = false;

            textBoxesCount = 48;
            labels = new Label[]
            {
                label1, label2, label3, label4, label5, label6, label7, label8, label9, label10,
                label11, label12, label13, label14, label15, label16, label17, label18, label19, label20,
                label21, label22, label23, label24, label25, label26, label27, label28, label29, label30,
                label31, label32, label33, label34, label35, label36, label37, label38, label39, label40,
                label41, label42, label43, label44, label45, label46, label47, label48,
            };
            comboBoxes = new ComboBox[]
            {
                comboBox1, comboBox2, comboBox3, comboBox4, comboBox5, comboBox6, comboBox7, comboBox8, comboBox9,
                comboBox10,
                comboBox11, comboBox12, comboBox13, comboBox14, comboBox15, comboBox16, comboBox17, comboBox18,
                comboBox19, comboBox20,
                comboBox21, comboBox22, comboBox23, comboBox24, comboBox25, comboBox26, comboBox27, comboBox28,
                comboBox29, comboBox30,
                comboBox31, comboBox32, comboBox33, comboBox34, comboBox35, comboBox36, comboBox37, comboBox38,
                comboBox39, comboBox40,
                comboBox41, comboBox42, comboBox43, comboBox44, comboBox45, comboBox46, comboBox47, comboBox48,
            };
            checkBoxes = new CheckBox[]
            {
                checkBox1, checkBox2, checkBox3, checkBox4, checkBox5, checkBox6, checkBox7, checkBox8, checkBox9,
                checkBox10,
                checkBox11, checkBox12, checkBox13, checkBox14, checkBox15, checkBox16, checkBox17, checkBox18,
                checkBox19, checkBox20,
                checkBox21, checkBox22, checkBox23, checkBox24, checkBox25, checkBox26, checkBox27, checkBox28,
                checkBox29, checkBox30,
                checkBox31, checkBox32, checkBox33, checkBox34, checkBox35, checkBox36, checkBox37, checkBox38,
                checkBox39, checkBox40,
                checkBox41, checkBox42, checkBox43, checkBox44, checkBox45, checkBox46, checkBox47, checkBox48,
            };
            enabledComboBoxes = new List<ComboBox>();

            comboNumbers = new ComboBox[]
            {
                comboBoxN1, comboBoxN2, comboBoxN3, comboBoxN4, comboBoxN5, comboBoxN6, comboBoxN7, comboBoxN8,
                comboBoxN9,  comboBoxN10,
                comboBoxN11, comboBoxN12, comboBoxN13, comboBoxN14, comboBoxN15, comboBoxN16, comboBoxN17, comboBoxN18,
                comboBoxN19, comboBoxN20,
                comboBoxN21, comboBoxN22, comboBoxN23, comboBoxN24, comboBoxN25, comboBoxN26, comboBoxN27, comboBoxN28,
                comboBoxN29, comboBoxN30,
                comboBoxN31, comboBoxN32, comboBoxN33, comboBoxN34, comboBoxN35, comboBoxN36, comboBoxN37, comboBoxN38,
                comboBoxN39, comboBoxN40,
                comboBoxN41, comboBoxN42, comboBoxN43, comboBoxN44, comboBoxN45, comboBoxN46, comboBoxN47, comboBoxN48,
            };
            enabledComboBoxesN = new List<ComboBox>();


            completed = false;
            StartForceCloseHandler();
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="waterMetersCount">Number of text boxes for serial numbers</param>
        public CycleBeginningForm(int waterMetersCount, bool hideOrder)
            : this()
        {
            this.WaterMetersCount = waterMetersCount;
            SNText = new string[WaterMetersCount];
            Disabled = new bool[WaterMetersCount];

            int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : TBF.Data.LineSize;
            int MaxHight = this.Height;
            ShuffleTextBoxes(TBF.Data.WMsCount, lineSize, ref MaxHight);

            if (hideOrder) orderGroupBox.Visible = false;

            this.Height = Math.Max(MaxHight + 60, 400);
        }

        /// <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, ref int MaxHight)
        {
            MaxHight = 0;
            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];
                        comboBoxes[dest] = comboBoxes[l * lineSize + l * gap + i];
                        checkBoxes[dest] = checkBoxes[l * lineSize + l * gap + i];
                        comboNumbers[dest] = comboNumbers[l * lineSize + l * gap + i];
                        MaxHight = Math.Max(comboBoxes[dest].Location.Y, MaxHight);
                        dest++;
                    }
                }

                textBoxesCount = wmsCount;
            }
        }

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

            if (orderGroupBox.Visible)
            {
                LoadPurchaseOrderTables();
                LoadPurchaseOrder();
                //PrepareOrderCombo(orderComboBox);
            }

            for (int i = 0; i < textBoxesCount; i++)
            {
                if (Program.LocalSettings.LastSNTextsCount == textBoxesCount)
                {
                    comboBoxes[i].Items.Add((Program.LocalSettings.LastSNTexts[i] == null)
                        ? string.Empty
                        : Program.LocalSettings.LastSNTexts[i]);
                }

                InitialiseItemsForComboInRange(i, comboNumbers, textBoxesCount);
                labels[i].Visible = comboBoxes[i].Visible = checkBoxes[i].Visible = comboNumbers[i].Visible = true;
                enabledComboBoxes.Add(comboBoxes[i]);
                enabledComboBoxesN.Add(comboNumbers[i]);
            }

            foreach (ComboBox cbxN in enabledComboBoxesN)
            {
                cbxN.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.comboBoxNX_KeyPress);
            }
            
            AddEventListenerToEnabledComboBoxes();
        }

        private void InitialiseItemsForComboInRange(int i, ComboBox[] implementComboBoxes, int toMaxRange)
        {
            log.Debug($"Init combo number item: {i}");
            ComboBox comboBoxToFill = implementComboBoxes[i];
            comboBoxToFill.Items.Clear();
            for (int j = 0; j < toMaxRange; j++)
            {
                comboBoxToFill.Items.Add(j + 1);
            }

            comboBoxToFill.SelectedItem = i + 1;
            //comboBoxToFill.Text = (i+1).ToString();
        }

        void Localize()
        {
            Text = Strings.Data;
            orderGroupBox.Text = Strings.Project_number;
            for (int i = 0; i < textBoxesCount; i++)
            {
                labels[i].Text = Strings.Serial_number + " " + (i + 1).ToString();
            }

            okButton.Text = Strings.OkBtnText;
            clearButton.Text = Strings.ClearBtnText;
        }

        /// <summary>
        /// Load Purchase order combo box items from the LocalSettings PurchaseOrderHistory array
        /// </summary>
        /// <param name="orderComboBox">Puchase order ComboBox</param>
        void PrepareOrderCombo(ComboBox orderComboBox)
        {
            for (int i = 0; i < Program.LocalSettings.PurchaseOrderHistoryCount; i++)
            {
                orderComboBox.Items.Add(Program.LocalSettings.PurchaseOrderHistory[i]);
            }

            if (orderComboBox.Items.Count > 0)
            {
                orderComboBox.Text = orderComboBox.Items[0].ToString();
            }
        }

        private void okButton_Click(object sender, EventArgs e)
        {
            if (orderGroupBox.Visible)
            {
                PurchaseOrder = orderComboBox.Text;
                Program.LocalSettings.UpdateHistory(orderComboBox.Text,
                    ref Program.LocalSettings.PurchaseOrderHistory
#if FUZHOU_150 || FUZHOU_300
												, 20
#endif
                );
            }

            Program.LocalSettings.LastSNTexts = SNText;

            for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
            {
                SNText[i] = comboBoxes[i].Text;
                Disabled[i] = !checkBoxes[i].Checked;
            }

            //TODO create logger to log selected items and their order and Order number
            string snTextArrString = SNText != null ? string.Join(", ", SNText) : string.Empty;
            log_selected.DebugFormat("Purchase DLG - Selected Order: {0}, Last selected Box: {1}, All items: {2}", 
                orderComboBox.Text, purchaseBoxComboBox.Text,snTextArrString);
            
            completed = true;
            Close();
        }


        /// <summary>
        /// When one combo box is updated using drop-down menu, all combo boxes
        /// are updated by this function.
        /// </summary>
        private void UpdateAllCombos()
        {
            for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
            {
                //? for what is this last seteed into diaog
                //comboBoxes[i].Text = Program.LocalSettings.LastSNTexts[i];
                checkBoxes[i].Checked = !string.IsNullOrEmpty(comboBoxes[i].Text);
            }
        }

        private void clearButton_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
            {
                comboBoxes[i].Text = string.Empty;
                checkBoxes[i].Checked = false;
            }

            lastComboBoxSerialNo = 0;
            EnableOrderCheckBox(true);
        }


      
        #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);
            };
        }

        private void OnForceClose(object sender, EventArgs args)
        {
            DialogResult = DialogResult.Cancel;
            Close();
        }

        #endregion


        private void AddEventListenerToEnabledComboBoxes()
        {
            for (int i = 0; i < enabledComboBoxes.Count; i++)
            {
                ComboBox comboBox = enabledComboBoxes[i];
                if (comboBox!= null)
                {
                   comboBox.SelectedIndexChanged += new System.EventHandler(this.comboBoxX_SelectedIndexChanged);
                   comboBox.TextChanged += new System.EventHandler(this.comboBoxX_TextChanged);
                   comboBox.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.ProcKeyPressX);
                   comboBox.KeyDown += new System.Windows.Forms.KeyEventHandler(this.comboBoxX_KeyDown);
                }
            }
        }

        private void comboBoxX_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Up || e.KeyCode == Keys.Down)
            {
                ComboBox comboBox = sender as ComboBox;
                if (comboBox != null)
                {
                    e.Handled = true;
                    ProcessNextEnabledTextBoxFocus(comboBox, e.KeyCode == Keys.Up ? -1 : 1);
                }
            }
        }

        private void comboBoxX_TextChanged(object sender, EventArgs e)
        {
            ComboBox currentCombo = sender as ComboBox;
            if (currentCombo != null)
            {
                int? initialSelectedValue = ExtractNumberFromComboBoxes(currentCombo);
                if (initialSelectedValue.HasValue)
                {
                    this.checkBoxes[initialSelectedValue.Value].Checked =  !string.IsNullOrEmpty(comboBoxes[initialSelectedValue.Value].Text);    
                }
            }
            else
            {
                log.DebugFormat("DLG - comboBoxX_TextChanged - something Wrong ComboBox currentCombo is no combo!");
            }
        }
        
        private void comboBoxX_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
            {
                ComboBox currentCombo = sender as ComboBox;
                if (currentCombo != null)
                {
                    if (currentCombo.Text.Equals(currentCombo.Items[0])) UpdateAllCombos();    
                }
                else
                {
                    log.DebugFormat("DLG - comboBoxX_SelectedIndexChanged - something Wrong ComboBox currentCombo is no combo!");
                }
                
            }
        }
        
        private void ProcKeyPressX(object sender, KeyPressEventArgs e)
        {
            ComboBox currentCombo = sender as ComboBox;
            if (currentCombo != null)
            {
                ProcKeyPress(sender, e, currentCombo);
            }
            else
            {
                log.DebugFormat("DLG - ProcKeyPressX - something Wrong ComboBox currentCombo is no combo!");
            }
            
        }
        
        /// <summary>
        /// Process a key press within any enabled text boxe enabledComboBoxes
        /// </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, ComboBox currentFocusOwner)
        {
            if (e.KeyChar == '+')
            {
                /// Process '+' key ..... Form completed
                okButton_Click(sender, e);
            }

            if (e.KeyChar == '\r')
            {
                ProcessNextEnabledTextBoxFocus(currentFocusOwner);
            }
        }

        private void ProcessNextEnabledTextBoxFocus(ComboBox currentFocusOwner, int iter = 1)
        {
            /// Process <enter> key ..... Next text field
            if (enabledComboBoxes.Count < 2) return;

            int? extractNumberFromComboBoxes = ExtractNumberFromComboBoxes(currentFocusOwner);
            if(extractNumberFromComboBoxes.HasValue){
                if (extractNumberFromComboBoxes.Value == 0 && iter <= 0)
                {
                    return;
                }
                /// Change focus to the next enabled text box
                enabledComboBoxes[(extractNumberFromComboBoxes.Value + iter) % enabledComboBoxes.Count].Focus();
                return;
            }
            //if we are here - is something wrong
            log.DebugFormat("DLG - ProcKeyPress - something Wrong no currentFocuse occured!");
        }

     


        void PerformActionComboShuffle(ComboBox selComboBox)
        {
            if (selComboBox != null && selComboBox.Visible == true)
            {
                // Use helper method to extract number from comboBox's name
                int? initialSelectedValue = ExtractNumberFromComboBoxNumbers(selComboBox);
                if (!initialSelectedValue.HasValue)
                {
                    return;
                }

                string itemText = selComboBox.SelectedItem?.ToString();
                if (itemText == null)
                {
                    itemText = selComboBox.Text;
                }

                log.DebugFormat("Selected Combobox: {0} initialSelectedValue: {1} value: {2}", selComboBox.Name,
                    initialSelectedValue, itemText);


                if (int.TryParse(itemText, out int selectedNumber))
                {
                    if (selectedNumber == initialSelectedValue)
                    {
                        return;
                    }

                    // Substitute minNumber and maxNumber with actual values
                    int minNumber = 0, maxNumber = 50;

                    if (selectedNumber >= minNumber && selectedNumber <= maxNumber)
                    {
                        // Call changeSerialNo method if the number falls within the range
                        ChangeSerialNo(initialSelectedValue, selectedNumber);

                        // Reset the selection
                        selComboBox.SelectedItem = initialSelectedValue;
                    }
                }
                else
                {
                    Console.WriteLine(@"The selected item is not a number.");
                }
            }
        }

        private void ChangeSerialNo(int? thisComboBoxNumber, int destComboBoxNo)
        {
            // changeSerialNo implementation
            log.Debug($"Changed ComboBox this: {thisComboBoxNumber}");
            if (thisComboBoxNumber == null)
            {
                return;
            }

            int indexOfThisComboBox = (int)thisComboBoxNumber - 1;
            int indexDestComboBoxNo = destComboBoxNo - 1;

            ComboBox thisComboBox = null;
            if (indexOfThisComboBox >= 0 && indexOfThisComboBox < textBoxesCount)
            {
                thisComboBox = comboBoxes[indexOfThisComboBox];
            }

            ComboBox destComboBox = null;
            if (indexDestComboBoxNo >= 0 && indexDestComboBoxNo < textBoxesCount)
            {
                destComboBox = comboBoxes[indexDestComboBoxNo];
            }


            if (destComboBox != null && thisComboBox != null)
            {
                string thisComboBoxValue = thisComboBox.Text;
                string destComboBoxValue = destComboBox.Text;

                log.DebugFormat("ChangeSerialNo(thisComboBoxNumber:{0}, destComboBoxNo{1}) has shufle this:{2} to:{3}",
                    thisComboBoxNumber, destComboBoxNo, thisComboBoxValue, destComboBoxValue);
                if (thisComboBoxValue != null && destComboBoxValue != null)
                {
                    UpdateComboBox(thisComboBox, destComboBoxValue);
                    UpdateComboBox(destComboBox, thisComboBoxValue);
                }
            }
            else
            {
                log.Debug("Some of the sources are missing");
            }
        }

        private void UpdateComboBox(ComboBox comboBox, string comboBoxValue)
        {
            if (string.IsNullOrEmpty(comboBox.Text)) // Check if destComboBox text is empty
            {
                comboBox.SelectedItem = null; // Deselect any selected item
            }

            comboBox.Text = comboBoxValue; // Set the Text property

            // Update the SelectedIndex based on the new Text
            int index = comboBox.FindStringExact(comboBoxValue);
            comboBox.SelectedIndex = index; // Set the SelectedIndex to the found index, or -1 if not found
        }

        private int? ExtractNumberFromComboBoxes(ComboBox comboBox)
        {
           
            int counter = 0;
            foreach (ComboBox combo in enabledComboBoxes)
            {
                if (comboBox == combo)
                {
                    return counter;
                }
                else
                {
                    counter++;
                }
            }

            return null;
        }
        
        private int? ExtractNumberFromComboBoxNumbers(ComboBox comboBox)
        {
            // Extract number from comboBox's name
            /*var numberString = System.Text.RegularExpressions.Regex.Match(comboBox.Name, @"\d+").Value;
            if (int.TryParse(numberString, out int extractedNumber))
            {
                return extractedNumber;
            }
            else
            {
                Console.WriteLine("Failed to get number from comboBox name.");

                // Return null if it fails to parse the number
                return null;
            }*/

            int counter = 0;
            foreach (ComboBox combo in enabledComboBoxesN)
            {
                counter++;
                if (comboBox == combo)
                {
                    return counter;
                }
            }

            return null;
        }


        private void buttonChooseBox_Click(object sender, EventArgs e)
        {
            Choose();
            EnableOrderCheckBox(false);
        }

        private void EnableOrderCheckBox(bool enable)
        {
            if (orderComboBox.Text != null && !orderComboBox.Text.IsEmpty())
            {
                orderComboBox.Enabled = enable;
                //set Tooltip on
                toolTip.Active = !enable;
            }
            else if (orderComboBox.Text != null && orderComboBox.Text.IsEmpty())
            {
                orderComboBox.Enabled = true;
                toolTip.Active = false;
            }
        }


        private void LoadPurchaseOrderTables()
        {
            /// Load the list of components from the database

            using (var session = Results.DB.CreateSession())
            {
                /// Search for 'BenchInfo' component
                IList<PurchaseOrder> orders = session.QueryOver<PurchaseOrder>().List();

                if (orders != null)
                {
                    CopyPurchaseOrderList(ref purchaseOrderListExample, orders);
                }
            }
        }

        private void CopyPurchaseOrderList(ref List<PurchaseOrder> purchaseOrders, IList<PurchaseOrder> orders)
        {
            purchaseOrders?.Clear();
            if (purchaseOrders == null)
            {
                purchaseOrders = new List<PurchaseOrder>();
            }

            foreach (var order in orders)
            {
                PurchaseOrder orderCopy = new PurchaseOrder(order.Name);
                foreach (PurchaseBox box in order.PurchaseBoxList)
                {
                    PurchaseBox boxCopy = new PurchaseBox(box.BoxNo, box.PurchaseOrder);
                    foreach (PurchaseWaterMeterData waterMeter in box.PurchaseWaterMeterDataList)
                    {
                        PurchaseWaterMeterData waterMeterCopy =
                            new PurchaseWaterMeterData(waterMeter.SerialNo, boxCopy);

                        boxCopy.PurchaseWaterMeterDataList.Add(waterMeterCopy);
                    }


                    orderCopy.PurchaseBoxList.Add(boxCopy);
                }

                purchaseOrders.Add(orderCopy);
            }
        }


       
        private void LoadPurchaseOrder()
        {
            orderComboBox.Items.Clear();
            if (purchaseOrderListExample != null)
            {
                foreach (PurchaseOrder pOrder in purchaseOrderListExample)
                {
                    if (pOrder != null && !String.IsNullOrEmpty(pOrder.Name))
                    {
                        orderComboBox.Items.Add(pOrder.Name);
                    }
                }

                LoadPurchaseBox("");
            }
        }

        private void LoadPurchaseBox(String choosenOrder)
        {
            purchaseBoxComboBox.Items.Clear();
            if (choosenOrder.IsEmpty())
            {
                return;
            }

            var purchaseBoxes = purchaseOrderListExample
                .Where(pOrder => pOrder.Name == choosenOrder)
                .SelectMany(pOrder => pOrder.PurchaseBoxList)
                .Select(pBox => pBox.BoxNo);

            foreach (var boxNo in purchaseBoxes)
            {
                purchaseBoxComboBox.Items.Add(boxNo);
            }
        }

        private int lastComboBoxSerialNo = 0;
        private int countedFreeBoxes = 0;

        private void LoadChoosenSerialNumbers(String choosenOrder, String choosenBox)
        {
            if (choosenOrder == null || choosenOrder.IsEmpty() ||
                choosenBox == null || choosenBox.IsEmpty())
            {
                return;
            }

            log.Debug($"Selected order: {choosenOrder} box: {choosenBox}");

            IEnumerable<string> serialNumbers = purchaseOrderListExample
                .Where(pOrder => pOrder.Name == choosenOrder)
                .SelectMany(pOrder => pOrder.PurchaseBoxList)
                .Where(pBox => pBox.BoxNo == choosenBox)
                .SelectMany(pBox => pBox.PurchaseWaterMeterDataList)
                .Select(pWM => pWM.SerialNo);

            try
            {
                string[] iEnumerable = serialNumbers as string[] ?? serialNumbers.ToArray();
                log_selected.Debug(
                    $"Selected order: {choosenOrder} box: {choosenBox} possible serial numbers (form DB): {string.Join(", ", iEnumerable)}");
            }
            catch (Exception e)
            {
                log_selected.Error("Error loading serial numbers: " + e);
            }

            //enable behaviour type
            bool addOnEndOnly = false;

            int countOfFreeBoxes =
                addOnEndOnly ? (enabledComboBoxes.Count - (LastOccupiedBox() + 1)) : CountFreeBoxes();

            if (countOfFreeBoxes < serialNumbers.Count())
            {
                log_selected.Debug(">" + serialNumbers.Count() + " Serial Numbers in box as we have free positions!");
                MessageBox.Show(this, "We have more Serial Numbers in box as we have free positions!", "Warning",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            string noImplementedSerialNumbers = "";
            if (!addOnEndOnly)
            {
                lastComboBoxSerialNo = -1;
            }
            else
            {
                lastComboBoxSerialNo = (LastOccupiedBox() + 1);
            }

            //copy only serial numbers without repeat
            foreach (var serialNumber in serialNumbers)
            {
                bool canICopy = CanICopy(serialNumber);

                if (canICopy)
                {
                    if (addOnEndOnly)
                    {
                        if (lastComboBoxSerialNo >= 0 || lastComboBoxSerialNo < enabledComboBoxes.Count)
                        {
                            comboBoxes[lastComboBoxSerialNo].Text = serialNumber;
                            log_selected.Debug($"Added serial no: {serialNumber} to pos: {lastComboBoxSerialNo}");
                            lastComboBoxSerialNo++;
                        }
                    }
                    else
                    {
                        int iNextFreeNumber = NextFreeBox(lastComboBoxSerialNo);
                        if (iNextFreeNumber >= 0 || iNextFreeNumber < enabledComboBoxes.Count)
                        {
                            comboBoxes[iNextFreeNumber].Text = serialNumber;
                            log_selected.Debug($"Added serial no: {serialNumber} to pos: {iNextFreeNumber}");
                            lastComboBoxSerialNo = iNextFreeNumber;
                        }
                    }
                }
                else
                {
                    noImplementedSerialNumbers += (noImplementedSerialNumbers.IsEmpty() ? "" : ", ") + serialNumber;
                }
            }

            if (!noImplementedSerialNumbers.IsEmpty())
            {
                log_selected.Debug("No implemented serial numbers: " + noImplementedSerialNumbers);
                MessageBox.Show(this,
                    string.Format("The following serial numbers were not implemented: {0}", noImplementedSerialNumbers),
                    "Serial Numbers repeating!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        /// <summary>
        /// Experimental zoom method 
        /// </summary>
        /// <param name="scaleFactor"> number to multiply size (1.2 for 20%)</param>
        private void ApplyZoom(float scaleFactor)
        {
            // Resize the form
            this.Size = new Size((int)(this.Width * scaleFactor), (int)(this.Height * scaleFactor));

            // Resize and reposition all controls
            foreach (Control control in this.Controls)
            {
                if (control.Visible)
                {
                    control.Location = new Point((int)(control.Left * scaleFactor), (int)(control.Top * scaleFactor));
                    control.Size = new Size((int)(control.Width * scaleFactor), (int)(control.Height * scaleFactor));
                    control.Font = new Font(control.Font.FontFamily, control.Font.Size * scaleFactor);
                }
            }
        }

        private bool CanICopy(string serialNumber)
        {
            bool canICopy = true;
            for (int i = 0; i < comboBoxes.Length; i++)
            {
                string text = comboBoxes[i].Text;
                if (string.IsNullOrEmpty(text))
                {
                    continue;
                }
                else if (text == serialNumber)
                {
                    //OK I can copy 
                    canICopy = false;
                    break;
                }
            }

            return canICopy;
        }

        private int CountFreeBoxes()
        {
            int iAllFreeComboboxes = 0;
            for (int i = 0; i < enabledComboBoxes.Count; i++)
            {
                if (string.IsNullOrEmpty(enabledComboBoxes[i].Text))
                {
                    iAllFreeComboboxes++;
                }
            }

            return iAllFreeComboboxes;
        }

        private int LastOccupiedBox()
        {
            int iLastOccupiedBox = -1;
            for (int i = 0; i < enabledComboBoxes.Count; i++)
            {
                if (!string.IsNullOrEmpty(enabledComboBoxes[i].Text))
                {
                    iLastOccupiedBox = i;
                }
            }

            return iLastOccupiedBox;
        }

        private int NextFreeBox(int iLookingFromItem)
        {
            int iNextFreeItem = -1;
            for (int i = iLookingFromItem + 1; i < enabledComboBoxes.Count; i++)
            {
                if (i == iLookingFromItem + 1)
                {
                    iNextFreeItem = i;
                }

                if (string.IsNullOrEmpty(enabledComboBoxes[i].Text))
                {
                    iNextFreeItem = i;
                    break;
                }
            }

            if (iNextFreeItem < 0)
            {
                iNextFreeItem = 0;
            }

            return iNextFreeItem;
        }

        private void RemoveLoadSerialNumbers(IEnumerable<string> serialNumbers, string choosenOrder, string choosenBox)
        {
            IEnumerable<PurchaseBox> boxes = purchaseOrderListExample
                .Where(pOrder => pOrder.Name == choosenOrder)
                .SelectMany(pOrder => pOrder.PurchaseBoxList)
                .Where(pBox => pBox.BoxNo == choosenBox)
                .Select(pBox => pBox);

            foreach (var box in boxes)
            {
                //remove or mark added list to declare no give all again
                //box.PurchaseWaterMeterDataList.RemoveAll(pWM => serialNumbers.Contains(pWM.SerialNo));
            }
        }

        private void orderComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox orederComboBox = sender as ComboBox;
            if (orederComboBox != null && orederComboBox.SelectedItem != null)
            {
                string order = orederComboBox.SelectedItem.ToString();
                log.Debug($"Selected order: {order}");
                LoadPurchaseBox(order);
                purchaseBoxComboBox.SelectedItem = null;
                purchaseBoxComboBox.Text = "";
            }
        }

        private void purchaseBoxComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            buttonChooseBox.Enabled = (orderComboBox != null &&
                                       (orderComboBox.SelectedItem != null ||
                                        !string.IsNullOrEmpty(orderComboBox.Text)
                                       )
                );
            buttonChooseBox.Enabled = buttonChooseBox.Enabled && (purchaseBoxComboBox != null &&
                                                                  (purchaseBoxComboBox.SelectedItem != null ||
                                                                   !string.IsNullOrEmpty(purchaseBoxComboBox.Text)
                                                                  )
                );
        }

        private void Choose()
        {
            string boxStr = purchaseBoxComboBox?.SelectedItem?.ToString();
            string order = orderComboBox?.SelectedItem?.ToString();

            LoadChoosenSerialNumbers(order, boxStr);
        }

        /// <summary>
        /// Process a key press within any enabled text boxe enabledComboBoxesN
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ProcKeyPressComboNumbers(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                /// Process <enter> key ..... Next text field
                if (enabledComboBoxesN.Count < 2) return; /// There is just one enabled textbox

                ComboBox currentComboBox = (sender as ComboBox);
                for (int i = 0; i < enabledComboBoxesN.Count; i++)
                {
                    if (enabledComboBoxesN[i] == currentComboBox)
                    {
                        /// Change focus to the next enabled text box
                        enabledComboBoxesN[(i + 1) % enabledComboBoxesN.Count].Focus();
                        return;
                    }
                }
                log.Debug("DLG - ProcKeyPressComboNumbers - no found current focus item!");
            }
        }

        void PerformActionComboEscape(ComboBox selComboBox)
        {
            if (selComboBox != null && selComboBox.Visible == true)
            {
                // Use helper method to extract number from comboBox's name
                int? initialSelectedValue = ExtractNumberFromComboBoxNumbers(selComboBox);
                if (!initialSelectedValue.HasValue)
                {
                    return;
                }
                else
                {
                    selComboBox.SelectedItem = initialSelectedValue;
                    log.Debug("Escape key pressed, and initial value was selected!");
                }
            }
        }

        private void comboBoxN1_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN1_Leave(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN1_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void ProcessKeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                e.Handled = true;
                e.SuppressKeyPress = true; // To prevent the "ding" sound
                PerformActionComboShuffle(sender as ComboBox);
                ProcKeyPressComboNumbers(sender, e);
            }
            else if (e.KeyCode == Keys.Escape)
            {
                PerformActionComboEscape(sender as ComboBox);

                // Move to the next control in the tab order
                SelectNextControl((Control)sender, forward: true, tabStopOnly: true, nested: true, wrap: true);
            }
            else if (e.KeyCode == Keys.Up)
            {
                // Handle the Up arrow key press
                // Move to the next control in the tab order
                SelectNextControl((Control)sender, forward: false, tabStopOnly: true, nested: true, wrap: true);
            }
            else if (e.KeyCode == Keys.Down)
            {
                // Handle the Down arrow key press
                // Move to the next control in the tab order
                SelectNextControl((Control)sender, forward: true, tabStopOnly: true, nested: true, wrap: true);
            }
            // Handle '+' key
            else if (e.KeyCode == Keys.Add || (e.Shift && e.KeyCode == Keys.Oemplus))
            {
                PerformActionComboEscape(sender as ComboBox);
                SelectNextControl((Control)sender, forward: true, tabStopOnly: true, nested: true, wrap: true);
                e.Handled = true; // Mark the event as handled (optional)
            }

            // Handle '-' key
            else if (e.KeyCode == Keys.Subtract || e.KeyCode == Keys.OemMinus)
            {
                PerformActionComboEscape(sender as ComboBox);
                SelectNextControl((Control)sender, forward: false, tabStopOnly: true, nested: true, wrap: true);
                e.Handled = true; // Mark the event as handled (optional)
            }

            // Handle Left Arrow key
            else if (e.KeyCode == Keys.Left)
            {
            }

            // Handle Right Arrow key
            else if (e.KeyCode == Keys.Right)
            {
            }
        }


        private void comboBoxN1_TextUpdate(object sender, EventArgs e)
        {
            //PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN1_SelectionChangeCommitted(object sender, EventArgs e)
        {
            //PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN2_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN5_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN3_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN4_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN11_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN6_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN7_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN8_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN9_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN10_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN12_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN13_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN14_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN15_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN16_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN17_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN18_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN19_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN20_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN21_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN22_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN23_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN24_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN25_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN26_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN27_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN28_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN29_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN30_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN31_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN32_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN33_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN34_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN35_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN36_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN37_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN38_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN39_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN40_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN41_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN42_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN43_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN44_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN45_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN46_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN47_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN48_SelectedIndexChanged(object sender, EventArgs e)
        {
            PerformActionComboShuffle(sender as ComboBox);
        }

        private void comboBoxN48_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN47_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN46_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN45_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN44_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN43_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN42_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN40_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN41_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN39_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN38_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN37_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN36_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN35_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN34_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN33_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN32_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN31_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN30_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN29_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN28_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN27_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN26_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN25_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN24_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN23_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN22_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN21_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN20_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN19_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN18_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN17_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN16_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN15_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN14_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN13_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN12_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN11_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN10_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN9_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN8_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN7_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN6_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN5_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN4_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN3_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        private void comboBoxN2_KeyDown(object sender, KeyEventArgs e)
        {
            ProcessKeyDown(sender, e);
        }

        /// <summary>
        /// Handles the key down event for the ProcessKeyDownN method.
        /// Disables add characters '+', '-'  in text into combobox
        /// </summary>
        /// <param name="sender">The object that triggered the event.</param>
        /// <param name="e">The KeyPressEventArgs containing the event data.</param>
        private void ProcessKeyPressN(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '+' || e.KeyChar == '-')
            {
                e.Handled = true; // Mark the event as handled (optional)
            }
        }

        private void comboBoxN1_KeyPress(object sender, KeyPressEventArgs e)
        {
            ProcessKeyPressN(sender, e);
        }

        /// <summary>
        /// Process all KeyPress included in list of enabledComboBoxesN
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void comboBoxNX_KeyPress(object sender, KeyPressEventArgs e)
        {
            ProcessKeyPressN(sender, e);
        }

        private void ProcessKeyPressOrder(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '+')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Jump focus on Box
                purchaseBoxComboBox.Focus();
            }
            else if (e.KeyChar == '-')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Do nothing - highest element
            }
        }

        private void ProcessKeyPressBox(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '+')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Jump focus on Firs comboBoxN1 / buttonChooseBox if is visible
                if (buttonChooseBox.Enabled)
                {
                    buttonChooseBox.Focus();
                }
                else
                {
                    comboBoxN1.Focus();
                }
            }
            else if (e.KeyChar == '-')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Jump focus on Firs comboBoxN1
                orderComboBox.Focus();
            }
        }

        private void ProcessKeyPressButton(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '+')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Jump focus on Firs comboBoxN1
                comboBoxN1.Focus();
            }
            else if (e.KeyChar == '-')
            {
                e.Handled = true; // Mark the event as handled (optional)
                //Jump focus on Firs comboBoxN1
                purchaseBoxComboBox.Focus();
            }
        }

        private void orderComboBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            ProcessKeyPressOrder(sender, e);
        }

        private void purchaseBoxComboBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            ProcessKeyPressBox(sender, e);
        }

        private void buttonChooseBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            ProcessKeyPressButton(sender, e);
        }

        // Create a ToolTip object (this can also be done via the designer)
        private ToolTip toolTip = new ToolTip();

        private void CreateTooltipToInfoAboutLock()
        {
            // Set the ToolTip for the disabled CheckBox
            toolTip.SetToolTip(orderComboBox, " If is Locked by Order items! To unlock use button Clear, please!");

            toolTip.AutoPopDelay = 5000; // The time (in milliseconds) the tooltip stays visible
            toolTip.InitialDelay = 500; // The time (in milliseconds) before the tooltip appears
            toolTip.ReshowDelay = 500; // The time (in milliseconds) before subsequent tooltips appear
            toolTip.ShowAlways = true; // Ensures the tooltip shows even when the control is disabled
            toolTip.Active = true;
        }

        private void orderComboBox_Click(object sender, EventArgs e)
        {
            if (orderComboBox.Enabled == false && orderGroupBox.Enabled == true)
            {
                MessageBox.Show(this,
                    "To unlock use button Clear, please!",
                    "Locked by Order items!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void orderComboBox_MouseMove(object sender, MouseEventArgs e)
        {
            /*ComboBox comboBox = sender as ComboBox;
            if (comboBox != null && comboBox.Enabled == false)
            {
                toolTip.Show("To unlock use button Clear, please!", comboBox, 0, comboBox.Height);
            }*/
        }

        private void orderComboBox_MouseLeave(object sender, EventArgs e)
        {
           /* ComboBox comboBox = sender as ComboBox;
            if (comboBox != null && comboBox.Enabled == false)
            {
                toolTip.Hide(comboBox);
            }*/
        }

        private void orderGroupBox_MouseHover(object sender, EventArgs e)
        {
          /*  // Get the mouse position in screen coordinates
            Point mousePositionInScreen = Cursor.Position;
            // Check if the mouse is over the disabled ComboBox
            if (mousePositionInScreen != null && orderComboBox.Enabled == false &&
                orderComboBox.Bounds.Contains(mousePositionInScreen))
            {
                toolTip.Show("To unlock use button Clear, please!", orderComboBox, 0, orderComboBox.Height);
                //toolTip.Hide(comboBox);
            }
            else if (orderComboBox.Enabled == false)
            {
                toolTip.Hide(orderComboBox);
            }*/
        }
    }
}